refactor: port to native ts

.changeset/cached-selector-with-types.md

@@ -0,0 +1,13 @@
+---
+'re-reselect': minor
+---
+
+Add `createCachedSelector.withTypes<State>()` to create a pre-typed selector creator, mirroring reselect's `createSelector.withTypes` API.
+
+This lets you set the `state` type once and reuse it across all `createCachedSelector` calls, removing the need to annotate `state` on every input selector:
+
+```ts
+const createAppCachedSelector = createCachedSelector.withTypes<RootState>();
+```
+
+Runtime behavior is unchanged: `withTypes` only refines the static types and returns the same creator.

.changeset/strict-selector-typings.md

@@ -0,0 +1,11 @@
+---
+'re-reselect': major
+---
+
+Stricter selector typings after migration to native TypeScript sources (reselect v5-style inference).
+
+Runtime behavior is unchanged; the following are type-level breaking changes that may surface as compile errors for strict-mode TypeScript consumers:
+
+- The cached selector's call signature is now a precise tuple inferred from the input selectors, instead of `(state, props, ...args: any[])`. Passing excess positional arguments is no longer accepted.
+- The cached selector's parameters must match the union of all input selectors' parameters. Under-supplying arguments declared by an input selector is no longer accepted.
+- `resetRecomputations()` is now typed as `() => void` (aligned with reselect v5) instead of `() => number`.

package.json

@@ -5,14 +5,14 @@
   "main": "dist/cjs/index.js",
   "module": "dist/es/index.js",
   "jsnext:main": "dist/es/index.js",
-  "browser": "dist/umd/index.js",
-  "types": "dist/types/index.d.ts",
+  "browser": "dist/umd/index.umd.js",
+  "types": "dist/es/index.d.ts",
   "sideEffects": false,
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "rimraf ./dist && rollup -c --bundleConfigAsCjs",
+    "build": "tsdown",
     "test": "vitest --config ./vitest.config.mts",
     "test:bundles": "npm run test:bundles:snapshot && npm run test:bundles:unit",
     "test:bundles:unit": "vitest run --config ./test-bundles/cjs.vitest.config.mts && vitest run --config ./test-bundles/es.vitest.config.mts && vitest run --config ./test-bundles/umd.vitest.config.mts",
@@ -45,21 +45,17 @@
     "reselect": "^5.0.0"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.24.6",
     "@changesets/changelog-github": "^0.7.0",
     "@changesets/cli": "^2.29.7",
-    "@rollup/plugin-babel": "^6.0.4",
     "@trivago/prettier-plugin-sort-imports": "^6.0.0",
-    "@vitest/coverage-v8": "^3.0.0",
+    "@vitest/coverage-v8": "^4.1.8",
     "expect-type": "^1.2.2",
     "prettier": "^3.2.5",
     "reselect": "^5.1.0",
-    "rimraf": "^6.0.1",
-    "rollup": "^4.17.2",
-    "rollup-plugin-copy": "^3.5.0",
     "simple-git-hooks": "^2.11.1",
+    "tsdown": "^0.22.1",
     "typescript": "^5.4.5",
-    "vitest": "^3.0.0"
+    "vitest": "^4.1.8"
   },
   "simple-git-hooks": {
     "pre-commit": "npm run prepare"

src/cache/FifoMapCache.js → src/cache/FifoMapCache.ts

@@ -1,26 +1,33 @@
+import type { ICacheObject } from './types';
 import validateCacheSize from './util/validateCacheSize';
 
-export default class FifoMapCache {
-  constructor({ cacheSize } = {}) {
+export default class FifoMapCache implements ICacheObject {
+  private _cache: Map<any, any> = new Map();
+  private _cacheSize: number;
+
+  constructor({ cacheSize }: { cacheSize: number }) {
     validateCacheSize(cacheSize);
-    this._cache = new Map();
     this._cacheSize = cacheSize;
   }
-  set(key, selectorFn) {
+
+  set(key: any, selectorFn: any): void {
     this._cache.set(key, selectorFn);
 
     if (this._cache.size > this._cacheSize) {
       const earliest = this._cache.keys().next().value;
       this.remove(earliest);
     }
   }
-  get(key) {
+
+  get(key: any): any {
     return this._cache.get(key);
   }
-  remove(key) {
+
+  remove(key: any): void {
     this._cache.delete(key);
   }
-  clear() {
+
+  clear(): void {
     this._cache.clear();
   }
 }

src/cache/FifoObjectCache.js → src/cache/FifoObjectCache.ts

@@ -1,14 +1,18 @@
+import type { ICacheObject, ObjectCacheKey } from './types';
 import isStringOrNumber from './util/isStringOrNumber';
 import validateCacheSize from './util/validateCacheSize';
 
-export default class FifoObjectCache {
-  constructor({ cacheSize } = {}) {
+export default class FifoObjectCache implements ICacheObject {
+  private _cache: Record<string, any> = {};
+  private _cacheOrdering: ObjectCacheKey[] = [];
+  private _cacheSize: number;
+
+  constructor({ cacheSize }: { cacheSize: number }) {
     validateCacheSize(cacheSize);
-    this._cache = {};
-    this._cacheOrdering = [];
     this._cacheSize = cacheSize;
   }
-  set(key, selectorFn) {
+
+  set(key: ObjectCacheKey, selectorFn: any): void {
     this._cache[key] = selectorFn;
     this._cacheOrdering.push(key);
 
@@ -17,22 +21,26 @@ export default class FifoObjectCache {
       this.remove(earliest);
     }
   }
-  get(key) {
+
+  get(key: ObjectCacheKey): any {
     return this._cache[key];
   }
-  remove(key) {
+
+  remove(key: ObjectCacheKey): void {
     const index = this._cacheOrdering.indexOf(key);
 
     if (index > -1) {
       this._cacheOrdering.splice(index, 1);
     }
     delete this._cache[key];
   }
-  clear() {
+
+  clear(): void {
     this._cache = {};
     this._cacheOrdering = [];
   }
-  isValidCacheKey(cacheKey) {
+
+  isValidCacheKey(cacheKey: ObjectCacheKey): boolean {
     return isStringOrNumber(cacheKey);
   }
 }

src/cache/FlatMapCache.ts

@@ -0,0 +1,21 @@
+import type { ICacheObject } from './types';
+
+export default class FlatMapCache implements ICacheObject {
+  private _cache: Map<any, any> = new Map();
+
+  set(key: any, selectorFn: any): void {
+    this._cache.set(key, selectorFn);
+  }
+
+  get(key: any): any {
+    return this._cache.get(key);
+  }
+
+  remove(key: any): void {
+    this._cache.delete(key);
+  }
+
+  clear(): void {
+    this._cache.clear();
+  }
+}

src/cache/FlatObjectCache.ts

@@ -0,0 +1,26 @@
+import type { ICacheObject, ObjectCacheKey } from './types';
+import isStringOrNumber from './util/isStringOrNumber';
+
+export default class FlatObjectCache implements ICacheObject {
+  private _cache: Record<string, any> = {};
+
+  set(key: ObjectCacheKey, selectorFn: any): void {
+    this._cache[key] = selectorFn;
+  }
+
+  get(key: ObjectCacheKey): any {
+    return this._cache[key];
+  }
+
+  remove(key: ObjectCacheKey): void {
+    delete this._cache[key];
+  }
+
+  clear(): void {
+    this._cache = {};
+  }
+
+  isValidCacheKey(cacheKey: ObjectCacheKey): boolean {
+    return isStringOrNumber(cacheKey);
+  }
+}

src/cache/LruMapCache.js → src/cache/LruMapCache.ts

@@ -1,20 +1,25 @@
+import type { ICacheObject } from './types';
 import validateCacheSize from './util/validateCacheSize';
 
-export default class LruMapCache {
-  constructor({ cacheSize } = {}) {
+export default class LruMapCache implements ICacheObject {
+  private _cache: Map<any, any> = new Map();
+  private _cacheSize: number;
+
+  constructor({ cacheSize }: { cacheSize: number }) {
     validateCacheSize(cacheSize);
-    this._cache = new Map();
     this._cacheSize = cacheSize;
   }
-  set(key, selectorFn) {
+
+  set(key: any, selectorFn: any): void {
     this._cache.set(key, selectorFn);
 
     if (this._cache.size > this._cacheSize) {
       const earliest = this._cache.keys().next().value;
       this.remove(earliest);
     }
   }
-  get(key) {
+
+  get(key: any): any {
     const value = this._cache.get(key);
 
     // Register cache hit
@@ -24,10 +29,12 @@ export default class LruMapCache {
     }
     return value;
   }
-  remove(key) {
+
+  remove(key: any): void {
     this._cache.delete(key);
   }
-  clear() {
+
+  clear(): void {
     this._cache.clear();
   }
 }