@modern-js/runtime-utils 2.68.0 → 2.68.2

package/dist/cjs/remixRouter.js

@@ -1,8 +1,14 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -12,11 +18,26 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var remixRouter_exports = {};
+__export(remixRouter_exports, {
+  DEFERRED_SYMBOL: () => DEFERRED_SYMBOL
+});
 module.exports = __toCommonJS(remixRouter_exports);
 __reExport(remixRouter_exports, require("@remix-run/router"), module.exports);
+var remixRouter = __toESM(require("@remix-run/router"));
+const symbolName = "UNSAFE_DEFERRED_SYMBOL";
+const DEFERRED_SYMBOL = symbolName in remixRouter ? remixRouter[symbolName] : Symbol("deferred");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFERRED_SYMBOL,
   ...require("@remix-run/router")
 });

package/dist/cjs/universal/cache.js

@@ -43,50 +43,6 @@ const CacheTime = {
   WEEK: 7 * 24 * 60 * 60 * 1e3,
   MONTH: 30 * 24 * 60 * 60 * 1e3
 };
-const isServer = typeof window === "undefined";
-const requestCacheMap = /* @__PURE__ */ new WeakMap();
-let lruCache;
-let cacheConfig = {
-  maxSize: CacheSize.GB
-};
-const tagKeyMap = /* @__PURE__ */ new Map();
-function addTagKeyRelation(tag, key) {
-  let keys = tagKeyMap.get(tag);
-  if (!keys) {
-    keys = /* @__PURE__ */ new Set();
-    tagKeyMap.set(tag, keys);
-  }
-  keys.add(key);
-}
-function configureCache(config) {
-  cacheConfig = {
-    ...cacheConfig,
-    ...config
-  };
-}
-function getLRUCache() {
-  if (!lruCache) {
-    var _cacheConfig_maxSize;
-    lruCache = new import_lru_cache.LRUCache({
-      maxSize: (_cacheConfig_maxSize = cacheConfig.maxSize) !== null && _cacheConfig_maxSize !== void 0 ? _cacheConfig_maxSize : CacheSize.GB,
-      sizeCalculation: (value) => {
-        if (!value.size) {
-          return 1;
-        }
-        let size = 0;
-        for (const [k, item] of value.entries()) {
-          size += k.length * 2;
-          size += estimateObjectSize(item.data);
-          size += 8;
-        }
-        return size;
-      },
-      updateAgeOnGet: true,
-      updateAgeOnHas: true
-    });
-  }
-  return lruCache;
-}
 function estimateObjectSize(data) {
   const type = typeof data;
   if (type === "number")
@@ -114,6 +70,67 @@ function estimateObjectSize(data) {
   }
   return 1;
 }
+class MemoryContainer {
+  async get(key) {
+    return this.lru.get(key);
+  }
+  async set(key, value, options) {
+    if (options === null || options === void 0 ? void 0 : options.ttl) {
+      this.lru.set(key, value, {
+        ttl: options.ttl * 1e3
+      });
+    } else {
+      this.lru.set(key, value);
+    }
+  }
+  async has(key) {
+    return this.lru.has(key);
+  }
+  async delete(key) {
+    return this.lru.delete(key);
+  }
+  async clear() {
+    this.lru.clear();
+  }
+  constructor(options) {
+    var _options_maxSize;
+    this.lru = new import_lru_cache.LRUCache({
+      maxSize: (_options_maxSize = options === null || options === void 0 ? void 0 : options.maxSize) !== null && _options_maxSize !== void 0 ? _options_maxSize : CacheSize.GB,
+      sizeCalculation: estimateObjectSize,
+      updateAgeOnGet: true,
+      updateAgeOnHas: true
+    });
+  }
+}
+const isServer = typeof window === "undefined";
+const requestCacheMap = /* @__PURE__ */ new WeakMap();
+const TAG_PREFIX = "tag:";
+const CACHE_PREFIX = "modernjs_cache:";
+const ongoingRevalidations = /* @__PURE__ */ new Map();
+let storage;
+let cacheConfig = {
+  maxSize: CacheSize.GB
+};
+function getStorage() {
+  if (storage) {
+    return storage;
+  }
+  if (cacheConfig.container) {
+    storage = cacheConfig.container;
+  } else {
+    storage = new MemoryContainer({
+      maxSize: cacheConfig.maxSize
+    });
+  }
+  return storage;
+}
+function configureCache(config) {
+  cacheConfig = {
+    ...cacheConfig,
+    ...config
+  };
+  storage = void 0;
+}
 function generateKey(args) {
   return JSON.stringify(args, (_, value) => {
     if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -125,24 +142,22 @@ function generateKey(args) {
     return value;
   });
 }
+function generateStableFunctionId(fn) {
+  const fnString = fn.toString();
+  let hash = 0;
+  for (let i = 0; i < fnString.length; i++) {
+    const char = fnString.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `fn_${fn.name || "anonymous"}_${Math.abs(hash).toString(36)}`;
+}
 function cache(fn, options) {
-  const { tag = "default", maxAge = CacheTime.MINUTE * 5, revalidate = 0, customKey, onCache, getKey } = options || {};
-  const store = getLRUCache();
-  const tags = Array.isArray(tag) ? tag : [
-    tag
-  ];
-  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;
+      const storage2 = (0, import_async_storage.getAsyncLocalStorage)();
+      const request = storage2 === null || storage2 === void 0 ? void 0 : (_storage_useContext = storage2.useContext()) === null || _storage_useContext === void 0 ? void 0 : _storage_useContext.request;
       if (request) {
         let shouldDisableCaching = false;
         if (cacheConfig.unstable_shouldDisable) {
@@ -178,123 +193,231 @@ function cache(fn, options) {
         }
       }
     } else if (typeof options !== "undefined") {
-      const genKey = getKey ? getKey(...args) : generateKey(args);
-      const now = Date.now();
-      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 cacheConfig.unstable_shouldDisable({
-            request
+      try {
+        const { tag, maxAge = CacheTime.MINUTE * 5, revalidate = 0, customKey, onCache, getKey, unstable_shouldCache } = options;
+        let missReason;
+        const currentStorage = getStorage();
+        const now = Date.now();
+        const tags = tag ? Array.isArray(tag) ? tag : [
+          tag
+        ] : [];
+        const genKey = getKey ? getKey(...args) : generateKey(args);
+        let finalKey;
+        if (customKey) {
+          finalKey = customKey({
+            params: args,
+            fn,
+            generatedKey: genKey
           });
+        } else {
+          const functionId = generateStableFunctionId(fn);
+          finalKey = `${functionId}:${genKey}`;
         }
-      }
-      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
+        const storageKey = `${CACHE_PREFIX}${finalKey}`;
+        let shouldDisableCaching = false;
+        if (isServer && cacheConfig.unstable_shouldDisable) {
+          var _asyncStorage_useContext;
+          const asyncStorage = (0, import_async_storage.getAsyncLocalStorage)();
+          const request = asyncStorage === null || asyncStorage === void 0 ? void 0 : (_asyncStorage_useContext = asyncStorage.useContext()) === null || _asyncStorage_useContext === void 0 ? void 0 : _asyncStorage_useContext.request;
+          if (request) {
+            shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
+              request
             });
           }
-          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);
-                cacheStore.set(storeKey, {
-                  data: newData,
-                  timestamp: Date.now(),
-                  isRevalidating: false
+        if (!shouldDisableCaching) {
+          const cached = await currentStorage.get(storageKey);
+          if (cached) {
+            try {
+              const cacheItem = cached;
+              const age = now - cacheItem.timestamp;
+              if (age < maxAge) {
+                onCache === null || onCache === void 0 ? void 0 : onCache({
+                  status: "hit",
+                  key: finalKey,
+                  params: args,
+                  result: cacheItem.data
+                });
+                return cacheItem.data;
+              }
+              if (revalidate > 0 && age < maxAge + revalidate) {
+                onCache === null || onCache === void 0 ? void 0 : onCache({
+                  status: "stale",
+                  key: finalKey,
+                  params: args,
+                  result: cacheItem.data
                 });
-                store.set(cacheKey, cacheStore);
-              } catch (error) {
-                cached.isRevalidating = false;
-                if (isServer) {
-                  var _storage_useContext_monitors, _storage_useContext2;
-                  const storage = (0, import_async_storage.getAsyncLocalStorage)();
-                  storage === null || storage === void 0 ? void 0 : (_storage_useContext2 = storage.useContext()) === null || _storage_useContext2 === void 0 ? void 0 : (_storage_useContext_monitors = _storage_useContext2.monitors) === null || _storage_useContext_monitors === void 0 ? void 0 : _storage_useContext_monitors.error(error.message);
-                } else {
-                  console.error("Background revalidation failed:", error);
+                if (!ongoingRevalidations.has(storageKey)) {
+                  const revalidationPromise = (async () => {
+                    try {
+                      const newData = await fn(...args);
+                      let shouldCache = true;
+                      if (unstable_shouldCache) {
+                        shouldCache = await unstable_shouldCache({
+                          params: args,
+                          result: newData
+                        });
+                      }
+                      if (shouldCache) {
+                        await setCacheItem(currentStorage, storageKey, newData, tags, maxAge, revalidate);
+                      }
+                    } catch (error) {
+                      if (isServer) {
+                        var _asyncStorage_useContext_monitors, _asyncStorage_useContext2;
+                        const asyncStorage = (0, import_async_storage.getAsyncLocalStorage)();
+                        asyncStorage === null || asyncStorage === void 0 ? void 0 : (_asyncStorage_useContext2 = asyncStorage.useContext()) === null || _asyncStorage_useContext2 === void 0 ? void 0 : (_asyncStorage_useContext_monitors = _asyncStorage_useContext2.monitors) === null || _asyncStorage_useContext_monitors === void 0 ? void 0 : _asyncStorage_useContext_monitors.error(error.message);
+                      } else {
+                        console.error("Background revalidation failed:", error);
+                      }
+                    } finally {
+                      ongoingRevalidations.delete(storageKey);
+                    }
+                  })();
+                  ongoingRevalidations.set(storageKey, revalidationPromise);
                 }
+                return cacheItem.data;
               }
+              missReason = 3;
+            } catch (error) {
+              console.warn("Failed to parse cached data:", error);
+              missReason = 4;
+            }
+          } else {
+            missReason = 2;
+          }
+        } else {
+          missReason = 1;
+        }
+        const data = await fn(...args);
+        if (!shouldDisableCaching) {
+          let shouldCache = true;
+          if (unstable_shouldCache) {
+            shouldCache = await unstable_shouldCache({
+              params: args,
+              result: data
             });
           }
-          return cached.data;
+          if (shouldCache) {
+            await setCacheItem(currentStorage, storageKey, data, tags, maxAge, revalidate);
+          }
         }
-      }
-      const data = await fn(...args);
-      if (!shouldDisableCaching) {
-        cacheStore.set(storeKey, {
-          data,
-          timestamp: now,
-          isRevalidating: false
-        });
-        store.set(cacheKey, cacheStore);
-      }
-      if (onCache) {
-        onCache({
+        onCache === null || onCache === void 0 ? void 0 : onCache({
           status: "miss",
           key: finalKey,
           params: args,
-          result: data
+          result: data,
+          reason: missReason
         });
+        return data;
+      } catch (error) {
+        console.warn("Cache operation failed, falling back to direct execution:", error);
+        const data = await fn(...args);
+        const { onCache } = options;
+        try {
+          onCache === null || onCache === void 0 ? void 0 : onCache({
+            status: "miss",
+            key: "cache_failed",
+            params: args,
+            result: data,
+            reason: 5
+          });
+        } catch (callbackError) {
+          console.warn("Failed to call onCache callback:", callbackError);
+        }
+        return 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.");
       return fn(...args);
     }
   };
 }
+async function setCacheItem(storage2, storageKey, data, tags, maxAge, revalidate) {
+  const newItem = {
+    data,
+    timestamp: Date.now(),
+    tags: tags.length > 0 ? tags : void 0
+  };
+  const ttl = (maxAge + revalidate) / 1e3;
+  await storage2.set(storageKey, newItem, {
+    ttl: ttl > 0 ? ttl : void 0
+  });
+  await updateTagRelationships(storage2, storageKey, tags);
+}
+async function updateTagRelationships(storage2, storageKey, tags) {
+  for (const tag of tags) {
+    const tagStoreKey = `${TAG_PREFIX}${tag}`;
+    const keyList = await storage2.get(tagStoreKey);
+    const keyArray = keyList || [];
+    if (!keyArray.includes(storageKey)) {
+      keyArray.push(storageKey);
+    }
+    await storage2.set(tagStoreKey, keyArray);
+  }
+}
+async function removeKeyFromTags(storage2, storageKey, tags) {
+  for (const tag of tags) {
+    const tagStoreKey = `${TAG_PREFIX}${tag}`;
+    const keyList = await storage2.get(tagStoreKey);
+    if (keyList) {
+      try {
+        const keyArray = Array.isArray(keyList) ? keyList : [];
+        const updatedKeyList = keyArray.filter((key) => key !== storageKey);
+        if (updatedKeyList.length > 0) {
+          await storage2.set(tagStoreKey, updatedKeyList);
+        } else {
+          await storage2.delete(tagStoreKey);
+        }
+      } catch (error) {
+        console.warn(`Failed to process tag key list for tag ${tag}:`, error);
+      }
+    }
+  }
+}
 function withRequestCache(handler) {
   if (!isServer) {
     return handler;
   }
   return async (req, ...args) => {
-    const storage = (0, import_async_storage.getAsyncLocalStorage)();
-    return storage.run({
+    const storage2 = (0, import_async_storage.getAsyncLocalStorage)();
+    return storage2.run({
       request: req
     }, () => handler(req, ...args));
   };
 }
-function revalidateTag(tag) {
-  const keys = tagKeyMap.get(tag);
-  if (keys) {
-    keys.forEach((key) => {
-      lruCache === null || lruCache === void 0 ? void 0 : lruCache.delete(key);
-    });
+async function revalidateTag(tag) {
+  const currentStorage = getStorage();
+  const tagStoreKey = `${TAG_PREFIX}${tag}`;
+  const keyList = await currentStorage.get(tagStoreKey);
+  if (keyList) {
+    try {
+      const keyArray = Array.isArray(keyList) ? keyList : [];
+      for (const cacheKey of keyArray) {
+        const cached = await currentStorage.get(cacheKey);
+        if (cached) {
+          try {
+            const cacheItem = cached;
+            if (cacheItem.tags) {
+              const otherTags = cacheItem.tags.filter((t) => t !== tag);
+              await removeKeyFromTags(currentStorage, cacheKey, otherTags);
+            }
+          } catch (error) {
+            console.warn("Failed to parse cached data while revalidating:", error);
+          }
+        }
+        await currentStorage.delete(cacheKey);
+      }
+      await currentStorage.delete(tagStoreKey);
+    } catch (error) {
+      console.warn("Failed to process tag key list:", error);
+    }
   }
 }
-function clearStore() {
-  lruCache === null || lruCache === void 0 ? void 0 : lruCache.clear();
-  lruCache = void 0;
-  tagKeyMap.clear();
+async function clearStore() {
+  const currentStorage = getStorage();
+  await currentStorage.clear();
+  storage = void 0;
+  ongoingRevalidations.clear();
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/esm/remixRouter.js

@@ -1 +1,7 @@
 export * from "@remix-run/router";
+import * as remixRouter from "@remix-run/router";
+var symbolName = "UNSAFE_DEFERRED_SYMBOL";
+var DEFERRED_SYMBOL = symbolName in remixRouter ? remixRouter[symbolName] : Symbol("deferred");
+export {
+  DEFERRED_SYMBOL
+};