@modern-js/runtime-utils 2.67.2 → 2.67.4

package/dist/esm-node/universal/cache.js

@@ -19,14 +19,14 @@ let lruCache;
 let cacheConfig = {
   maxSize: CacheSize.GB
 };
-const tagFnMap = /* @__PURE__ */ new Map();
-function addTagFnRelation(tag, fn) {
-  let fns = tagFnMap.get(tag);
-  if (!fns) {
-    fns = /* @__PURE__ */ new Set();
-    tagFnMap.set(tag, fns);
+const tagKeyMap = /* @__PURE__ */ new Map();
+function addTagKeyRelation(tag, key) {
+  let keys = tagKeyMap.get(tag);
+  if (!keys) {
+    keys = /* @__PURE__ */ new Set();
+    tagKeyMap.set(tag, keys);
   }
-  fns.add(fn);
+  keys.add(key);
 }
 function configureCache(config) {
   cacheConfig = {
@@ -36,8 +36,9 @@ function configureCache(config) {
 }
 function getLRUCache() {
   if (!lruCache) {
+    var _cacheConfig_maxSize;
     lruCache = new LRUCache({
-      maxSize: cacheConfig.maxSize,
+      maxSize: (_cacheConfig_maxSize = cacheConfig.maxSize) !== null && _cacheConfig_maxSize !== void 0 ? _cacheConfig_maxSize : CacheSize.GB,
       sizeCalculation: (value) => {
         if (!value.size) {
           return 1;
@@ -95,18 +96,33 @@ function generateKey(args) {
   });
 }
 function cache(fn, options) {
-  const { tag = "default", maxAge = CacheTime.MINUTE * 5, revalidate = 0 } = options || {};
+  const { tag = "default", maxAge = CacheTime.MINUTE * 5, revalidate = 0, customKey, onCache, getKey } = options || {};
   const store = getLRUCache();
   const tags = Array.isArray(tag) ? tag : [
     tag
   ];
-  tags.forEach((t) => addTagFnRelation(t, fn));
+  const getCacheKey = (args, generatedKey) => {
+    return customKey ? customKey({
+      params: args,
+      fn,
+      generatedKey
+    }) : fn;
+  };
   return async (...args) => {
     if (isServer && typeof options === "undefined") {
       var _storage_useContext;
       const storage = getAsyncLocalStorage();
       const request = storage === null || storage === void 0 ? void 0 : (_storage_useContext = storage.useContext()) === null || _storage_useContext === void 0 ? void 0 : _storage_useContext.request;
       if (request) {
+        let shouldDisableCaching = false;
+        if (cacheConfig.unstable_shouldDisable) {
+          shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
+            request
+          });
+        }
+        if (shouldDisableCaching) {
+          return fn(...args);
+        }
         let requestCache = requestCacheMap.get(request);
         if (!requestCache) {
           requestCache = /* @__PURE__ */ new Map();
@@ -132,30 +148,61 @@ function cache(fn, options) {
         }
       }
     } else if (typeof options !== "undefined") {
-      let tagCache = store.get(fn);
-      if (!tagCache) {
-        tagCache = /* @__PURE__ */ new Map();
-      }
-      const key = generateKey(args);
-      const cached = tagCache.get(key);
+      const genKey = getKey ? getKey(...args) : generateKey(args);
       const now = Date.now();
-      if (cached) {
+      const cacheKey = getCacheKey(args, genKey);
+      const finalKey = typeof cacheKey === "function" ? genKey : cacheKey;
+      tags.forEach((t) => addTagKeyRelation(t, cacheKey));
+      let cacheStore = store.get(cacheKey);
+      if (!cacheStore) {
+        cacheStore = /* @__PURE__ */ new Map();
+      }
+      const storeKey = customKey && typeof cacheKey === "symbol" ? "symbol-key" : genKey;
+      let shouldDisableCaching = false;
+      if (isServer && cacheConfig.unstable_shouldDisable) {
+        var _storage_useContext1;
+        const storage = getAsyncLocalStorage();
+        const request = storage === null || storage === void 0 ? void 0 : (_storage_useContext1 = storage.useContext()) === null || _storage_useContext1 === void 0 ? void 0 : _storage_useContext1.request;
+        if (request) {
+          shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
+            request
+          });
+        }
+      }
+      const cached = cacheStore.get(storeKey);
+      if (cached && !shouldDisableCaching) {
         const age = now - cached.timestamp;
         if (age < maxAge) {
+          if (onCache) {
+            onCache({
+              status: "hit",
+              key: finalKey,
+              params: args,
+              result: cached.data
+            });
+          }
           return cached.data;
         }
         if (revalidate > 0 && age < maxAge + revalidate) {
+          if (onCache) {
+            onCache({
+              status: "stale",
+              key: finalKey,
+              params: args,
+              result: cached.data
+            });
+          }
           if (!cached.isRevalidating) {
             cached.isRevalidating = true;
             Promise.resolve().then(async () => {
               try {
                 const newData = await fn(...args);
-                tagCache.set(key, {
+                cacheStore.set(storeKey, {
                   data: newData,
                   timestamp: Date.now(),
                   isRevalidating: false
                 });
-                store.set(fn, tagCache);
+                store.set(cacheKey, cacheStore);
               } catch (error) {
                 cached.isRevalidating = false;
                 if (isServer) {
@@ -172,12 +219,22 @@ function cache(fn, options) {
         }
       }
       const data = await fn(...args);
-      tagCache.set(key, {
-        data,
-        timestamp: now,
-        isRevalidating: false
-      });
-      store.set(fn, tagCache);
+      if (!shouldDisableCaching) {
+        cacheStore.set(storeKey, {
+          data,
+          timestamp: now,
+          isRevalidating: false
+        });
+        store.set(cacheKey, cacheStore);
+      }
+      if (onCache) {
+        onCache({
+          status: "miss",
+          key: finalKey,
+          params: args,
+          result: data
+        });
+      }
       return data;
     } else {
       console.warn("The cache function will not work because it runs on the browser and there are no options are provided.");
@@ -197,17 +254,17 @@ function withRequestCache(handler) {
   };
 }
 function revalidateTag(tag) {
-  const fns = tagFnMap.get(tag);
-  if (fns) {
-    fns.forEach((fn) => {
-      lruCache === null || lruCache === void 0 ? void 0 : lruCache.delete(fn);
+  const keys = tagKeyMap.get(tag);
+  if (keys) {
+    keys.forEach((key) => {
+      lruCache === null || lruCache === void 0 ? void 0 : lruCache.delete(key);
     });
   }
 }
 function clearStore() {
   lruCache === null || lruCache === void 0 ? void 0 : lruCache.clear();
   lruCache = void 0;
-  tagFnMap.clear();
+  tagKeyMap.clear();
 }
 export {
   CacheSize,

package/dist/types/browser/deferreds.d.ts

@@ -0,0 +1,31 @@
+export declare function invariant(value: boolean, message?: string): asserts value;
+export declare function invariant<T>(value: T | null | undefined, message?: string): asserts value is T;
+export declare class AbortedDeferredError extends Error {
+}
+export interface TrackedPromise extends Promise<any> {
+    _tracked?: boolean;
+    _data?: any;
+    _error?: any;
+}
+export declare class DeferredData {
+    private pendingKeysSet;
+    private controller;
+    private abortPromise;
+    private unlistenAbortSignal;
+    private subscribers;
+    __modern_deferred: boolean;
+    data: Record<string, unknown>;
+    init?: ResponseInit;
+    deferredKeys: string[];
+    constructor(data: Record<string, unknown>, responseInit?: ResponseInit);
+    private trackPromise;
+    private onSettle;
+    private emit;
+    subscribe(fn: (aborted: boolean, settledKey?: string) => void): () => boolean;
+    cancel(): void;
+    resolveData(signal: AbortSignal): Promise<boolean>;
+    get done(): boolean;
+    get unwrappedData(): {};
+    get pendingKeys(): string[];
+}
+export declare const activeDeferreds: Map<string, DeferredData>;

package/dist/types/browser/index.d.ts

@@ -1 +1,2 @@
 export * from './nestedRoutes';
+export * from './deferreds';

package/dist/types/universal/async_storage.server.d.ts

@@ -9,6 +9,7 @@ declare const storage: {
             headers: Record<string, string>;
             status: number;
         };
+        activeDeferreds?: Map<string, unknown>;
     }, cb: () => O | Promise<O>) => Promise<O>;
     useContext: () => {
         monitors?: Monitors;
@@ -18,6 +19,7 @@ declare const storage: {
             headers: Record<string, string>;
             status: number;
         };
+        activeDeferreds?: Map<string, unknown>;
     };
 };
 type Storage = typeof storage;

package/dist/types/universal/cache.d.ts

@@ -11,13 +11,30 @@ export declare const CacheTime: {
     readonly WEEK: number;
     readonly MONTH: number;
 };
+export type CacheStatus = 'hit' | 'stale' | 'miss';
+export interface CacheStatsInfo {
+    status: CacheStatus;
+    key: string | symbol;
+    params: any[];
+    result: any;
+}
 interface CacheOptions {
     tag?: string | string[];
     maxAge?: number;
     revalidate?: number;
+    getKey?: <Args extends any[]>(...args: Args) => string;
+    customKey?: <Args extends any[]>(options: {
+        params: Args;
+        fn: (...args: Args) => any;
+        generatedKey: string;
+    }) => string | symbol;
+    onCache?: (info: CacheStatsInfo) => void;
 }
 interface CacheConfig {
-    maxSize: number;
+    maxSize?: number;
+    unstable_shouldDisable?: ({ request, }: {
+        request: Request;
+    }) => boolean | Promise<boolean>;
 }
 export declare function configureCache(config: CacheConfig): void;
 export declare function generateKey(args: unknown[]): string;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.67.2",
+  "version": "2.67.4",
   "_comment": "Provide ESM and CJS exports, ESM is used by runtime package, for treeshaking",
   "exports": {
     "./router": {
@@ -145,8 +145,8 @@
     "lru-cache": "^10.4.3",
     "react-router-dom": "6.27.0",
     "serialize-javascript": "^6.0.0",
-    "@modern-js/types": "2.67.2",
-    "@modern-js/utils": "2.67.2"
+    "@modern-js/types": "2.67.4",
+    "@modern-js/utils": "2.67.4"
   },
   "peerDependencies": {
     "react": ">=17.0.0",