@modern-js/runtime-utils 0.0.0-nightly-20250424160335 → 0.0.0-nightly-20250428160307

package/dist/cjs/universal/cache.js

@@ -49,14 +49,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 = {
@@ -125,18 +125,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 } = 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 = (0, import_async_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 Promise.resolve(cacheConfig.unstable_shouldDisable({
+            request
+          }));
+        }
+        if (shouldDisableCaching) {
+          return fn(...args);
+        }
         let requestCache = requestCacheMap.get(request);
         if (!requestCache) {
           requestCache = /* @__PURE__ */ new Map();
@@ -162,30 +177,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 = 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 = (0, import_async_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 Promise.resolve(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) {
@@ -202,12 +248,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.");
@@ -227,17 +283,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();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/esm/universal/cache.js

@@ -26,14 +26,14 @@ var lruCache;
 var cacheConfig = {
   maxSize: CacheSize.GB
 };
-var tagFnMap = /* @__PURE__ */ new Map();
-function addTagFnRelation(tag, fn) {
-  var fns = tagFnMap.get(tag);
-  if (!fns) {
-    fns = /* @__PURE__ */ new Set();
-    tagFnMap.set(tag, fns);
+var tagKeyMap = /* @__PURE__ */ new Map();
+function addTagKeyRelation(tag, key) {
+  var keys = tagKeyMap.get(tag);
+  if (!keys) {
+    keys = /* @__PURE__ */ new Set();
+    tagKeyMap.set(tag, keys);
   }
-  fns.add(fn);
+  keys.add(key);
 }
 function configureCache(config) {
   cacheConfig = _object_spread({}, cacheConfig, config);
@@ -121,16 +121,20 @@ function generateKey(args) {
   });
 }
 function cache(fn, options) {
-  var _ref = options || {}, _ref_tag = _ref.tag, tag = _ref_tag === void 0 ? "default" : _ref_tag, _ref_maxAge = _ref.maxAge, maxAge = _ref_maxAge === void 0 ? CacheTime.MINUTE * 5 : _ref_maxAge, _ref_revalidate = _ref.revalidate, revalidate = _ref_revalidate === void 0 ? 0 : _ref_revalidate;
+  var _ref = options || {}, _ref_tag = _ref.tag, tag = _ref_tag === void 0 ? "default" : _ref_tag, _ref_maxAge = _ref.maxAge, maxAge = _ref_maxAge === void 0 ? CacheTime.MINUTE * 5 : _ref_maxAge, _ref_revalidate = _ref.revalidate, revalidate = _ref_revalidate === void 0 ? 0 : _ref_revalidate, customKey = _ref.customKey, onCache = _ref.onCache;
   var store = getLRUCache();
   var tags = Array.isArray(tag) ? tag : [
     tag
   ];
-  tags.forEach(function(t) {
-    return addTagFnRelation(t, fn);
-  });
+  var getCacheKey = function(args, generatedKey) {
+    return customKey ? customKey({
+      params: args,
+      fn,
+      generatedKey
+    }) : fn;
+  };
   return /* @__PURE__ */ _async_to_generator(function() {
-    var _len, args, _key, _storage_useContext, storage, request, requestCache, fnCache, key, promise, data, error, tagCache, key1, cached, now, age, data1;
+    var _len, args, _key, _storage_useContext, storage, request, shouldDisableCaching, requestCache, fnCache, key, promise, data, error, genKey, now, cacheKey, finalKey, cacheStore, storeKey, shouldDisableCaching1, _storage_useContext1, storage1, request1, cached, age, data1;
     var _arguments = arguments;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
@@ -141,15 +145,37 @@ function cache(fn, options) {
           if (!(isServer && typeof options === "undefined"))
             return [
               3,
-              5
+              7
             ];
           storage = getAsyncLocalStorage();
           request = storage === null || storage === void 0 ? void 0 : (_storage_useContext = storage.useContext()) === null || _storage_useContext === void 0 ? void 0 : _storage_useContext.request;
           if (!request)
             return [
               3,
-              4
+              6
+            ];
+          shouldDisableCaching = false;
+          if (!cacheConfig.unstable_shouldDisable)
+            return [
+              3,
+              2
             ];
+          return [
+            4,
+            Promise.resolve(cacheConfig.unstable_shouldDisable({
+              request
+            }))
+          ];
+        case 1:
+          shouldDisableCaching = _state.sent();
+          _state.label = 2;
+        case 2:
+          if (shouldDisableCaching) {
+            return [
+              2,
+              fn.apply(void 0, _to_consumable_array(args))
+            ];
+          }
           requestCache = requestCacheMap.get(request);
           if (!requestCache) {
             requestCache = /* @__PURE__ */ new Map();
@@ -169,55 +195,100 @@ function cache(fn, options) {
           }
           promise = fn.apply(void 0, _to_consumable_array(args));
           fnCache.set(key, promise);
-          _state.label = 1;
-        case 1:
+          _state.label = 3;
+        case 3:
           _state.trys.push([
-            1,
             3,
+            5,
             ,
-            4
+            6
           ]);
           return [
             4,
             promise
           ];
-        case 2:
+        case 4:
           data = _state.sent();
           return [
             2,
             data
           ];
-        case 3:
+        case 5:
           error = _state.sent();
           fnCache.delete(key);
           throw error;
-        case 4:
+        case 6:
           return [
             3,
-            8
+            12
           ];
-        case 5:
+        case 7:
           if (!(typeof options !== "undefined"))
             return [
               3,
-              7
+              11
             ];
-          tagCache = store.get(fn);
-          if (!tagCache) {
-            tagCache = /* @__PURE__ */ new Map();
-          }
-          key1 = generateKey(args);
-          cached = tagCache.get(key1);
+          genKey = generateKey(args);
           now = Date.now();
-          if (cached) {
+          cacheKey = getCacheKey(args, genKey);
+          finalKey = typeof cacheKey === "function" ? genKey : cacheKey;
+          tags.forEach(function(t) {
+            return addTagKeyRelation(t, cacheKey);
+          });
+          cacheStore = store.get(cacheKey);
+          if (!cacheStore) {
+            cacheStore = /* @__PURE__ */ new Map();
+          }
+          storeKey = customKey && (typeof cacheKey === "undefined" ? "undefined" : _type_of(cacheKey)) === "symbol" ? "symbol-key" : genKey;
+          shouldDisableCaching1 = false;
+          if (!(isServer && cacheConfig.unstable_shouldDisable))
+            return [
+              3,
+              9
+            ];
+          storage1 = getAsyncLocalStorage();
+          request1 = storage1 === null || storage1 === void 0 ? void 0 : (_storage_useContext1 = storage1.useContext()) === null || _storage_useContext1 === void 0 ? void 0 : _storage_useContext1.request;
+          if (!request1)
+            return [
+              3,
+              9
+            ];
+          return [
+            4,
+            Promise.resolve(cacheConfig.unstable_shouldDisable({
+              request: request1
+            }))
+          ];
+        case 8:
+          shouldDisableCaching1 = _state.sent();
+          _state.label = 9;
+        case 9:
+          cached = cacheStore.get(storeKey);
+          if (cached && !shouldDisableCaching1) {
             age = now - cached.timestamp;
             if (age < maxAge) {
+              if (onCache) {
+                onCache({
+                  status: "hit",
+                  key: finalKey,
+                  params: args,
+                  result: cached.data
+                });
+              }
               return [
                 2,
                 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(/* @__PURE__ */ _async_to_generator(function() {
@@ -237,12 +308,12 @@ function cache(fn, options) {
                         ];
                       case 1:
                         newData = _state2.sent();
-                        tagCache.set(key1, {
+                        cacheStore.set(storeKey, {
                           data: newData,
                           timestamp: Date.now(),
                           isRevalidating: false
                         });
-                        store.set(fn, tagCache);
+                        store.set(cacheKey, cacheStore);
                         return [
                           3,
                           3
@@ -279,25 +350,35 @@ function cache(fn, options) {
             4,
             fn.apply(void 0, _to_consumable_array(args))
           ];
-        case 6:
+        case 10:
           data1 = _state.sent();
-          tagCache.set(key1, {
-            data: data1,
-            timestamp: now,
-            isRevalidating: false
-          });
-          store.set(fn, tagCache);
+          if (!shouldDisableCaching1) {
+            cacheStore.set(storeKey, {
+              data: data1,
+              timestamp: now,
+              isRevalidating: false
+            });
+            store.set(cacheKey, cacheStore);
+          }
+          if (onCache) {
+            onCache({
+              status: "miss",
+              key: finalKey,
+              params: args,
+              result: data1
+            });
+          }
           return [
             2,
             data1
           ];
-        case 7:
+        case 11:
           console.warn("The cache function will not work because it runs on the browser and there are no options are provided.");
           return [
             2,
             fn.apply(void 0, _to_consumable_array(args))
           ];
-        case 8:
+        case 12:
           return [
             2
           ];
@@ -336,17 +417,17 @@ function withRequestCache(handler) {
   }();
 }
 function revalidateTag(tag) {
-  var fns = tagFnMap.get(tag);
-  if (fns) {
-    fns.forEach(function(fn) {
-      lruCache === null || lruCache === void 0 ? void 0 : lruCache.delete(fn);
+  var keys = tagKeyMap.get(tag);
+  if (keys) {
+    keys.forEach(function(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/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 = {
@@ -95,18 +95,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 } = 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 Promise.resolve(cacheConfig.unstable_shouldDisable({
+            request
+          }));
+        }
+        if (shouldDisableCaching) {
+          return fn(...args);
+        }
         let requestCache = requestCacheMap.get(request);
         if (!requestCache) {
           requestCache = /* @__PURE__ */ new Map();
@@ -132,30 +147,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 = 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 Promise.resolve(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 +218,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 +253,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/universal/cache.d.ts

@@ -11,13 +11,29 @@ 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;
+    customKey?: <Args extends any[]>(options: {
+        params: Args;
+        fn: (...args: Args) => any;
+        generatedKey: string;
+    }) => string | symbol;
+    onCache?: (info: CacheStatsInfo) => void;
 }
 interface CacheConfig {
     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": "0.0.0-nightly-20250424160335",
+  "version": "0.0.0-nightly-20250428160307",
   "_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": "0.0.0-nightly-20250424160335",
-    "@modern-js/utils": "0.0.0-nightly-20250424160335"
+    "@modern-js/types": "0.0.0-nightly-20250428160307",
+    "@modern-js/utils": "0.0.0-nightly-20250428160307"
   },
   "peerDependencies": {
     "react": ">=17.0.0",
@@ -168,8 +168,8 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "typescript": "^5",
-    "@scripts/build": "0.0.0-nightly-20250424160335",
-    "@scripts/jest-config": "0.0.0-nightly-20250424160335"
+    "@scripts/build": "0.0.0-nightly-20250428160307",
+    "@scripts/jest-config": "0.0.0-nightly-20250428160307"
   },
   "sideEffects": false,
   "scripts": {