@modern-js/runtime-utils 2.67.3 → 2.67.5

package/dist/esm/browser/nestedRoutes.js

@@ -9,6 +9,10 @@ import { Suspense } from "react";
 import { Outlet, Route, createRoutesFromElements } from "react-router-dom";
 import { time } from "../time";
 import { getAsyncLocalStorage } from "../universal/async_storage";
+import { DeferredData, activeDeferreds as originalActiveDeferreds } from "./deferreds";
+var privateDefer = function(data) {
+  return new DeferredData(data);
+};
 var transformNestedRoutes = function(routes) {
   var routeElements = [];
   var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
@@ -102,12 +106,15 @@ var renderNestedRoute = function(nestedRoute) {
   }), id);
   return routeElement;
 };
+function isPlainObject(value) {
+  return value != null && (typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && Object.getPrototypeOf(value) === Object.prototype;
+}
 function createLoader(route) {
   var loader = route.loader;
   if (loader) {
     return function() {
       var _ref = _async_to_generator(function(args) {
-        var end, res, cost, _storage_useContext_monitors, storage;
+        var end, res, isRouterV7, activeDeferreds, _getAsyncLocalStorage_useContext, _getAsyncLocalStorage, deferredData, cost, _route_id, _storage_useContext_monitors, storage;
         return _ts_generator(this, function(_state) {
           switch (_state.label) {
             case 0:
@@ -121,11 +128,25 @@ function createLoader(route) {
               ];
             case 1:
               res = _state.sent();
+              isRouterV7 = process.env._MODERN_ROUTER_VERSION === "v7";
+              if (isRouterV7) {
+                activeDeferreds = null;
+                if (typeof document === "undefined") {
+                  ;
+                  activeDeferreds = (_getAsyncLocalStorage = getAsyncLocalStorage()) === null || _getAsyncLocalStorage === void 0 ? void 0 : (_getAsyncLocalStorage_useContext = _getAsyncLocalStorage.useContext()) === null || _getAsyncLocalStorage_useContext === void 0 ? void 0 : _getAsyncLocalStorage_useContext.activeDeferreds;
+                } else {
+                  activeDeferreds = originalActiveDeferreds;
+                }
+                if (isPlainObject(res)) {
+                  deferredData = privateDefer(res);
+                  activeDeferreds.set(route.id, deferredData);
+                }
+              }
               cost = end();
               if (typeof document === "undefined") {
                 ;
                 storage = getAsyncLocalStorage();
-                storage === null || storage === void 0 ? void 0 : (_storage_useContext_monitors = storage.useContext().monitors) === null || _storage_useContext_monitors === void 0 ? void 0 : _storage_useContext_monitors.timing("".concat(LOADER_REPORTER_NAME, "-").concat(route.id), cost);
+                storage === null || storage === void 0 ? void 0 : (_storage_useContext_monitors = storage.useContext().monitors) === null || _storage_useContext_monitors === void 0 ? void 0 : _storage_useContext_monitors.timing("".concat(LOADER_REPORTER_NAME, "-").concat((_route_id = route.id) === null || _route_id === void 0 ? void 0 : _route_id.replace(/\//g, "_")), cost);
               }
               return [
                 2,

package/dist/esm/universal/async_storage.js

@@ -1,6 +1,17 @@
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
 var getAsyncLocalStorage = function() {
-  console.error("You should not get async storage in browser");
-  return null;
+  if (isBrowser) {
+    console.error("You should not get async storage in browser");
+    return null;
+  } else {
+    try {
+      var serverStorage = require("./async_storage.server");
+      return serverStorage.getAsyncLocalStorage();
+    } catch (err) {
+      console.error("Failed to load server async storage", err);
+      return null;
+    }
+  }
 };
 export {
   getAsyncLocalStorage

package/dist/esm/universal/cache.js

@@ -26,22 +26,23 @@ 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);
 }
 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: function(value) {
         if (!value.size) {
           return 1;
@@ -121,16 +122,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, getKey = _ref.getKey;
   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 +146,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,
+            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 +196,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 = getKey ? getKey.apply(void 0, _to_consumable_array(args)) : 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,
+            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 +309,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 +351,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 +418,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/browser/deferreds.js

@@ -0,0 +1,138 @@
+function invariant(value, message) {
+  if (value === false || value === null || typeof value === "undefined") {
+    throw new Error(message);
+  }
+}
+class AbortedDeferredError extends Error {
+}
+function isTrackedPromise(value) {
+  return value instanceof Promise && value._tracked === true;
+}
+function unwrapTrackedPromise(value) {
+  if (!isTrackedPromise(value)) {
+    return value;
+  }
+  if (value._error) {
+    throw value._error;
+  }
+  return value._data;
+}
+class DeferredData {
+  trackPromise(key, value) {
+    if (!(value instanceof Promise)) {
+      return value;
+    }
+    this.deferredKeys.push(key);
+    this.pendingKeysSet.add(key);
+    const promise = Promise.race([
+      value,
+      this.abortPromise
+    ]).then((data) => this.onSettle(promise, key, void 0, data), (error) => this.onSettle(promise, key, error));
+    promise.catch(() => {
+    });
+    Object.defineProperty(promise, "_tracked", {
+      get: () => true
+    });
+    return promise;
+  }
+  onSettle(promise, key, error, data) {
+    if (this.controller.signal.aborted && error instanceof AbortedDeferredError) {
+      this.unlistenAbortSignal();
+      Object.defineProperty(promise, "_error", {
+        get: () => error
+      });
+      return Promise.reject(error);
+    }
+    this.pendingKeysSet.delete(key);
+    if (this.done) {
+      this.unlistenAbortSignal();
+    }
+    if (error === void 0 && data === void 0) {
+      const undefinedError = new Error(`Deferred data for key "${key}" resolved/rejected with \`undefined\`, you must resolve/reject with a value or \`null\`.`);
+      Object.defineProperty(promise, "_error", {
+        get: () => undefinedError
+      });
+      this.emit(false, key);
+      return Promise.reject(undefinedError);
+    }
+    if (data === void 0) {
+      Object.defineProperty(promise, "_error", {
+        get: () => error
+      });
+      this.emit(false, key);
+      return Promise.reject(error);
+    }
+    Object.defineProperty(promise, "_data", {
+      get: () => data
+    });
+    this.emit(false, key);
+    return data;
+  }
+  emit(aborted, settledKey) {
+    this.subscribers.forEach((subscriber) => subscriber(aborted, settledKey));
+  }
+  subscribe(fn) {
+    this.subscribers.add(fn);
+    return () => this.subscribers.delete(fn);
+  }
+  cancel() {
+    this.controller.abort();
+    this.pendingKeysSet.forEach((v, k) => this.pendingKeysSet.delete(k));
+    this.emit(true);
+  }
+  async resolveData(signal) {
+    let aborted = false;
+    if (!this.done) {
+      const onAbort = () => this.cancel();
+      signal.addEventListener("abort", onAbort);
+      aborted = await new Promise((resolve) => {
+        this.subscribe((aborted2) => {
+          signal.removeEventListener("abort", onAbort);
+          if (aborted2 || this.done) {
+            resolve(aborted2);
+          }
+        });
+      });
+    }
+    return aborted;
+  }
+  get done() {
+    return this.pendingKeysSet.size === 0;
+  }
+  get unwrappedData() {
+    invariant(this.data !== null && this.done, "Can only unwrap data on initialized and settled deferreds");
+    return Object.entries(this.data).reduce((acc, [key, value]) => Object.assign(acc, {
+      [key]: unwrapTrackedPromise(value)
+    }), {});
+  }
+  get pendingKeys() {
+    return Array.from(this.pendingKeysSet);
+  }
+  constructor(data, responseInit) {
+    this.pendingKeysSet = /* @__PURE__ */ new Set();
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.__modern_deferred = true;
+    this.deferredKeys = [];
+    invariant(data && typeof data === "object" && !Array.isArray(data), "defer() only accepts plain objects");
+    let reject;
+    this.abortPromise = new Promise((_, r) => reject = r);
+    this.controller = new AbortController();
+    const onAbort = () => reject(new AbortedDeferredError("Deferred data aborted"));
+    this.unlistenAbortSignal = () => this.controller.signal.removeEventListener("abort", onAbort);
+    this.controller.signal.addEventListener("abort", onAbort);
+    this.data = Object.entries(data).reduce((acc, [key, value]) => Object.assign(acc, {
+      [key]: this.trackPromise(key, value)
+    }), {});
+    if (this.done) {
+      this.unlistenAbortSignal();
+    }
+    this.init = responseInit;
+  }
+}
+const activeDeferreds = /* @__PURE__ */ new Map();
+export {
+  AbortedDeferredError,
+  DeferredData,
+  activeDeferreds,
+  invariant
+};

package/dist/esm-node/browser/index.js

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

package/dist/esm-node/browser/nestedRoutes.js

@@ -4,6 +4,10 @@ import { Suspense } from "react";
 import { Outlet, Route, createRoutesFromElements } from "react-router-dom";
 import { time } from "../time";
 import { getAsyncLocalStorage } from "../universal/async_storage";
+import { DeferredData, activeDeferreds as originalActiveDeferreds } from "./deferreds";
+const privateDefer = (data) => {
+  return new DeferredData(data);
+};
 const transformNestedRoutes = (routes) => {
   const routeElements = [];
   for (const route of routes) {
@@ -86,6 +90,9 @@ const renderNestedRoute = (nestedRoute, options = {}) => {
   }, id);
   return routeElement;
 };
+function isPlainObject(value) {
+  return value != null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
+}
 function createLoader(route) {
   const { loader } = route;
   if (loader) {
@@ -95,11 +102,25 @@ function createLoader(route) {
       }
       const end = time();
       const res = await loader(args);
+      const isRouterV7 = process.env._MODERN_ROUTER_VERSION === "v7";
+      if (isRouterV7) {
+        let activeDeferreds = null;
+        if (typeof document === "undefined") {
+          var _getAsyncLocalStorage_useContext, _getAsyncLocalStorage;
+          activeDeferreds = (_getAsyncLocalStorage = getAsyncLocalStorage()) === null || _getAsyncLocalStorage === void 0 ? void 0 : (_getAsyncLocalStorage_useContext = _getAsyncLocalStorage.useContext()) === null || _getAsyncLocalStorage_useContext === void 0 ? void 0 : _getAsyncLocalStorage_useContext.activeDeferreds;
+        } else {
+          activeDeferreds = originalActiveDeferreds;
+        }
+        if (isPlainObject(res)) {
+          const deferredData = privateDefer(res);
+          activeDeferreds.set(route.id, deferredData);
+        }
+      }
       const cost = end();
       if (typeof document === "undefined") {
-        var _storage_useContext_monitors;
+        var _route_id, _storage_useContext_monitors;
         const storage = getAsyncLocalStorage();
-        storage === null || storage === void 0 ? void 0 : (_storage_useContext_monitors = storage.useContext().monitors) === null || _storage_useContext_monitors === void 0 ? void 0 : _storage_useContext_monitors.timing(`${LOADER_REPORTER_NAME}-${route.id}`, cost);
+        storage === null || storage === void 0 ? void 0 : (_storage_useContext_monitors = storage.useContext().monitors) === null || _storage_useContext_monitors === void 0 ? void 0 : _storage_useContext_monitors.timing(`${LOADER_REPORTER_NAME}-${(_route_id = route.id) === null || _route_id === void 0 ? void 0 : _route_id.replace(/\//g, "_")}`, cost);
       }
       return res;
     };

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

@@ -1,6 +1,17 @@
+const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
 const getAsyncLocalStorage = () => {
-  console.error("You should not get async storage in browser");
-  return null;
+  if (isBrowser) {
+    console.error("You should not get async storage in browser");
+    return null;
+  } else {
+    try {
+      const serverStorage = require("./async_storage.server");
+      return serverStorage.getAsyncLocalStorage();
+    } catch (err) {
+      console.error("Failed to load server async storage", err);
+      return null;
+    }
+  }
 };
 export {
   getAsyncLocalStorage