@gera2ld/async-memo 1.0.0 → 2.0.0

package/README.md

@@ -18,7 +18,7 @@ const myApi = asyncMemo(myApiCall, {
 
 // Call from anywhere
 async function someAction() {
-  const response = await myApi(params);
+  const response = await myApi.call(params);
 }
 
 // Get the current value anytime
@@ -26,12 +26,13 @@ function getValueSync() {
   return myApi.get(params);
 }
 
-// Get context to avoid passing args around
+// Prepare a bound context to avoid passing args around
 function otherPlace() {
-  const ctx = myApi.context(params);
+  const ctx = myApi.prepare(params);
   ctx.get();        // sync get
   ctx.reload();     // refresh data
   ctx.isSettled();  // check loading state
+  ctx.set(value);   // override cache
 }
 ```
 
@@ -95,6 +96,7 @@ function createCache<T>() {
   return {
     get(cacheKey: string) { ... },
     set(cacheKey: string, data?: T) { ... },
+    keys(): IterableIterator<string> { ... },
     clear() { ... },
   };
 }
@@ -120,6 +122,9 @@ function createCache<T>() {
     set(cacheKey: string, data?: T) {
       target.value = { ...target.value, [cacheKey]: data };
     },
+    *keys() {
+      yield* Object.keys(target.value);
+    },
     clear() {
       target.value = {};
     },
@@ -144,6 +149,9 @@ function createCache<T>() {
     set(cacheKey: string, data?: T) {
       target.value = { ...target.value, [cacheKey]: data };
     },
+    *keys() {
+      yield* Object.keys(target.value);
+    },
     clear() {
       target.value = {};
     },

package/dist/index.d.ts

@@ -13,25 +13,6 @@ export interface CacheContext<U> {
     /** Whether the value returned by `get` is fresh. */
     isFresh(): boolean;
 }
-export interface CachedFunction<T extends unknown[], U, S extends CacheStorage> {
-    (...args: T): Promise<U>;
-    /** Return the currently cached value immediately. */
-    get(...args: T): U | undefined;
-    /** Delete the currently cached value. */
-    delete(...args: T): void;
-    /** Invalidate the current cached value and send a new request without deleting the old value. */
-    reload(...args: T): Promise<U>;
-    /** Whether the latest request is settled. */
-    isSettled(...args: T): boolean;
-    /** Whether the value returned by `get` is fresh. */
-    isFresh(...args: T): boolean;
-    /** Clear cache. */
-    clear(): void;
-    /** Get the cache context so we don't need to pass `args` around. */
-    context(...args: T): CacheContext<U>;
-    /** The cache storage, only used for testing purpose. */
-    cache: S;
-}
 type CachePrimitiveKey = string | number | undefined;
 export interface CacheOptions<T extends unknown[]> {
     /**
@@ -49,7 +30,7 @@ export interface CacheOptions<T extends unknown[]> {
      */
     mustRevalidate: boolean;
     /**
-     * Time to live, -1 for always. Default as `-1`.
+     * Time to live in ms, -1 for always. Default as `-1`.
      */
     ttl: number;
 }
@@ -63,9 +44,40 @@ export interface CacheData<U = unknown> {
 export interface CacheStorage<U = unknown> {
     get(cacheGroup: string): CacheData<U> | undefined;
     set(cacheGroup: string, data?: CacheData<U>): void;
+    keys(): IterableIterator<string>;
     clear(): void;
 }
 export declare function createAsyncMemoStorage(): Map<string, CacheData<unknown>>;
-export declare function createAsyncMemo<S extends CacheStorage = ReturnType<typeof createAsyncMemoStorage>>(cacheFactory?: () => S): <U, T extends unknown[]>(fn: (...args: T) => Promise<U>, options?: Partial<CacheOptions<T>>) => CachedFunction<T, U, S>;
-export declare const asyncMemo: <U, T extends unknown[]>(fn: (...args: T) => Promise<U>, options?: Partial<CacheOptions<T>> | undefined) => CachedFunction<T, U, Map<string, CacheData<unknown>>>;
+export declare class AsyncMemoContext<T extends unknown[], U, S extends CacheStorage = ReturnType<typeof createAsyncMemoStorage>> {
+    cache: S;
+    private fn;
+    private mustRevalidate;
+    private resolver;
+    private ttl;
+    constructor(fn: (...args: T) => Promise<U>, options?: Partial<CacheOptions<T>>, cacheFactory?: () => S);
+    private resolveKey;
+    private getCachedData;
+    private isSettledByKey;
+    private isFreshByKey;
+    private getByKey;
+    private computeExpiresAt;
+    private setByKey;
+    private removeByKey;
+    private createPendingEntry;
+    private onSettled;
+    private reloadByKey;
+    private callByKey;
+    isSettled(...args: T): boolean;
+    isFresh(...args: T): boolean;
+    get(...args: T): U | undefined;
+    remove(...args: T): void;
+    reload(...args: T): Promise<U>;
+    call(...args: T): Promise<U>;
+    getContext(...args: T): CacheContext<U>;
+    prepare(...args: T): CacheContext<U>;
+    clear(): void;
+    prune(): void;
+}
+export declare function createAsyncMemo<S extends CacheStorage = ReturnType<typeof createAsyncMemoStorage>>(cacheFactory?: () => S): <U, T extends unknown[]>(fn: (...args: T) => Promise<U>, options?: Partial<CacheOptions<T>>) => AsyncMemoContext<T, U, S>;
+export declare const asyncMemo: <U, T extends unknown[]>(fn: (...args: T) => Promise<U>, options?: Partial<CacheOptions<T>> | undefined) => AsyncMemoContext<T, U, Map<string, CacheData<unknown>>>;
 export {};

package/dist/index.js

@@ -1,104 +1,139 @@
-const K = {
-  mustRevalidate: !1,
-  resolver: () => "",
-  ttl: -1
+//#region src/index.ts
+var e = -1, t = {
+	mustRevalidate: !1,
+	resolver: () => "",
+	ttl: e
 };
-function O() {
-  return /* @__PURE__ */ new Map();
+function n() {
+	return /* @__PURE__ */ new Map();
 }
-function P(x) {
-  return (y, D) => {
-    const n = (x || O)(), { mustRevalidate: M, resolver: w, ttl: a } = {
-      ...K,
-      ...D
-    }, F = (...e) => {
-      const s = w(...e);
-      return (Array.isArray(s) ? s : [s, s]).map((r) => `${r ?? ""}`);
-    }, o = (e) => (...s) => {
-      const t = F(...s);
-      return e(t, s);
-    }, i = ([e, s]) => {
-      const t = n.get(e);
-      return t?.key === s && t.settled;
-    }, l = ([e, s]) => {
-      const t = n.get(e);
-      return t?.key === s && t.settled && (t.expiresAt < 0 || t.expiresAt > Date.now());
-    }, h = ([e, s]) => {
-      const t = n.get(e);
-      if (t && (!M || l([e, s])))
-        return t.value;
-    }, v = ([e, s], t, r = a) => {
-      const c = r < 0 ? r : Date.now() + r;
-      n.set(e, {
-        key: s,
-        ...n.get(e),
-        promise: t == null ? Promise.reject() : Promise.resolve(t),
-        value: t,
-        expiresAt: c,
-        settled: !0
-      });
-    }, f = ([e]) => {
-      n.set(e);
-    }, S = () => {
-      n.clear();
-    }, d = ([e, s], t) => {
-      const r = n.get(e), c = y(...t), u = {
-        ...r,
-        key: s,
-        promise: c,
-        // Set to -1 until the promise is either resolved or rejected
-        expiresAt: -1,
-        settled: !1
-      };
-      n.set(e, u);
-      const p = (m, C) => {
-        if (n.get(e) !== u)
-          return;
-        let g;
-        m ? g = 0 : g = a < 0 ? a : Date.now() + a, n.set(e, {
-          ...u,
-          value: C,
-          expiresAt: g,
-          settled: !0
-        });
-      };
-      return c.then(
-        (m) => {
-          p(!1, m);
-        },
-        () => {
-          p(!0);
-        }
-      ), c;
-    }, A = (e, s) => {
-      const [t, r] = e, c = n.get(t);
-      return c?.key === r && (l(e) || !i(e)) ? c.promise : d(e, s);
-    }, j = (e, s) => ({
-      call: () => A(e, s),
-      get: () => h(e),
-      set: (t, r = -1) => {
-        v(e, t, r);
-      },
-      delete: () => f(e),
-      reload: () => d(e, s),
-      isSettled: () => i(e),
-      isFresh: () => l(e)
-    });
-    return Object.assign(o(A), {
-      get: o(h),
-      delete: o(f),
-      reload: o(d),
-      isSettled: o(i),
-      isFresh: o(l),
-      context: o(j),
-      clear: S,
-      cache: n
-    });
-  };
-}
-const _ = P();
-export {
-  _ as asyncMemo,
-  P as createAsyncMemo,
-  O as createAsyncMemoStorage
+var r = class {
+	cache;
+	fn;
+	mustRevalidate;
+	resolver;
+	ttl;
+	constructor(e, r, i) {
+		this.fn = e, this.cache = (i || n)();
+		let a = {
+			...t,
+			...r
+		};
+		this.mustRevalidate = a.mustRevalidate, this.resolver = a.resolver, this.ttl = a.ttl;
+	}
+	resolveKey(...e) {
+		let t = this.resolver(...e);
+		return (Array.isArray(t) ? t : [t, t]).map((e) => `${e ?? ""}`);
+	}
+	getCachedData([e, t]) {
+		let n = this.cache.get(e);
+		return n?.key === t ? n : void 0;
+	}
+	isSettledByKey(e) {
+		return this.getCachedData(e)?.settled ?? !1;
+	}
+	isFreshByKey(e) {
+		let t = this.getCachedData(e);
+		return t?.settled ? t.expiresAt < 0 || t.expiresAt > Date.now() : !1;
+	}
+	getByKey(e) {
+		let t = this.getCachedData(e);
+		if (t && (!this.mustRevalidate || this.isFreshByKey(e))) return t.value;
+	}
+	computeExpiresAt(e) {
+		return e < 0 ? e : Date.now() + e;
+	}
+	setByKey([e, t], n, r) {
+		let i = r ?? this.ttl;
+		this.cache.set(e, {
+			key: t,
+			...this.cache.get(e),
+			promise: n == null ? Promise.reject() : Promise.resolve(n),
+			value: n,
+			expiresAt: this.computeExpiresAt(i),
+			settled: !0
+		});
+	}
+	removeByKey([e]) {
+		this.cache.set(e);
+	}
+	createPendingEntry([t, n], r, i) {
+		let a = {
+			...i,
+			key: n,
+			promise: r,
+			expiresAt: e,
+			settled: !1
+		};
+		return this.cache.set(t, a), a;
+	}
+	onSettled([e], t, n, r) {
+		this.cache.get(e) === t && this.cache.set(e, {
+			...t,
+			value: r,
+			expiresAt: n ? 0 : this.computeExpiresAt(this.ttl),
+			settled: !0
+		});
+	}
+	reloadByKey(e, t) {
+		let n = this.fn(...t), r = this.createPendingEntry(e, n, this.getCachedData(e));
+		return n.then((t) => this.onSettled(e, r, !1, t), () => this.onSettled(e, r, !0)), n;
+	}
+	callByKey(e, t) {
+		let n = this.getCachedData(e);
+		return n && (this.isFreshByKey(e) || !this.isSettledByKey(e)) ? n.promise : this.reloadByKey(e, t);
+	}
+	isSettled(...e) {
+		return this.isSettledByKey(this.resolveKey(...e));
+	}
+	isFresh(...e) {
+		return this.isFreshByKey(this.resolveKey(...e));
+	}
+	get(...e) {
+		return this.getByKey(this.resolveKey(...e));
+	}
+	remove(...e) {
+		this.removeByKey(this.resolveKey(...e));
+	}
+	reload(...e) {
+		let t = this.resolveKey(...e);
+		return this.reloadByKey(t, e);
+	}
+	call(...e) {
+		let t = this.resolveKey(...e);
+		return this.callByKey(t, e);
+	}
+	getContext(...t) {
+		let n = this.resolveKey(...t);
+		return {
+			call: () => this.callByKey(n, t),
+			get: () => this.getByKey(n),
+			set: (t, r = e) => {
+				this.setByKey(n, t, r);
+			},
+			delete: () => this.removeByKey(n),
+			reload: () => this.reloadByKey(n, t),
+			isSettled: () => this.isSettledByKey(n),
+			isFresh: () => this.isFreshByKey(n)
+		};
+	}
+	prepare(...e) {
+		return this.getContext(...e);
+	}
+	clear() {
+		this.cache.clear();
+	}
+	prune() {
+		let e = Date.now();
+		for (let t of this.cache.keys()) {
+			let n = this.cache.get(t);
+			n && n.settled && n.expiresAt > 0 && n.expiresAt < e && this.cache.set(t);
+		}
+	}
 };
+function i(e) {
+	return (t, n) => new r(t, n, e);
+}
+var a = i();
+//#endregion
+export { r as AsyncMemoContext, a as asyncMemo, i as createAsyncMemo, n as createAsyncMemoStorage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gera2ld/async-memo",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Cache asynchronous functions where they should be",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,6 +15,13 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "build:js": "vite build",
+    "build:types": "tsc",
+    "build": "pnpm run build:js && pnpm run build:types",
+    "test": "vitest --run",
+    "prepublishOnly": "pnpm run build"
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -31,14 +38,8 @@
     "url": "https://github.com/gera2ld/async-memo.git"
   },
   "devDependencies": {
-    "typescript": "^5.3.3",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.18"
-  },
-  "scripts": {
-    "build:js": "vite build",
-    "build:types": "tsc",
-    "build": "pnpm run /^build:/",
-    "test": "vitest --run"
+    "typescript": "^6.0.3",
+    "vite": "^8.1.0",
+    "vitest": "^4.1.9"
   }
-}
+}