@modern-js/runtime-utils 2.67.3 → 2.67.4

package/dist/cjs/browser/deferreds.js

@@ -0,0 +1,165 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var deferreds_exports = {};
+__export(deferreds_exports, {
+  AbortedDeferredError: () => AbortedDeferredError,
+  DeferredData: () => DeferredData,
+  activeDeferreds: () => activeDeferreds,
+  invariant: () => invariant
+});
+module.exports = __toCommonJS(deferreds_exports);
+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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbortedDeferredError,
+  DeferredData,
+  activeDeferreds,
+  invariant
+});

package/dist/cjs/browser/index.js

@@ -16,7 +16,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var browser_exports = {};
 module.exports = __toCommonJS(browser_exports);
 __reExport(browser_exports, require("./nestedRoutes"), module.exports);
+__reExport(browser_exports, require("./deferreds"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./nestedRoutes")
+  ...require("./nestedRoutes"),
+  ...require("./deferreds")
 });

package/dist/cjs/browser/nestedRoutes.js

@@ -28,6 +28,10 @@ var import_react = require("react");
 var import_react_router_dom = require("react-router-dom");
 var import_time = require("../time");
 var import_async_storage = require("../universal/async_storage");
+var import_deferreds = require("./deferreds");
+const privateDefer = (data) => {
+  return new import_deferreds.DeferredData(data);
+};
 const transformNestedRoutes = (routes) => {
   const routeElements = [];
   for (const route of routes) {
@@ -110,6 +114,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) {
@@ -119,11 +126,25 @@ function createLoader(route) {
       }
       const end = (0, import_time.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 = (0, import_async_storage.getAsyncLocalStorage)()) === null || _getAsyncLocalStorage === void 0 ? void 0 : (_getAsyncLocalStorage_useContext = _getAsyncLocalStorage.useContext()) === null || _getAsyncLocalStorage_useContext === void 0 ? void 0 : _getAsyncLocalStorage_useContext.activeDeferreds;
+        } else {
+          activeDeferreds = import_deferreds.activeDeferreds;
+        }
+        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 = (0, import_async_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(`${import_constants.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(`${import_constants.LOADER_REPORTER_NAME}-${(_route_id = route.id) === null || _route_id === void 0 ? void 0 : _route_id.replace(/\//g, "_")}`, cost);
       }
       return res;
     };

package/dist/cjs/universal/async_storage.js

@@ -21,9 +21,20 @@ __export(async_storage_exports, {
   getAsyncLocalStorage: () => getAsyncLocalStorage
 });
 module.exports = __toCommonJS(async_storage_exports);
+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;
+    }
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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 = {
@@ -66,8 +66,9 @@ function configureCache(config) {
 }
 function getLRUCache() {
   if (!lruCache) {
+    var _cacheConfig_maxSize;
     lruCache = new import_lru_cache.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;
@@ -125,18 +126,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 = (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 cacheConfig.unstable_shouldDisable({
+            request
+          });
+        }
+        if (shouldDisableCaching) {
+          return fn(...args);
+        }
         let requestCache = requestCacheMap.get(request);
         if (!requestCache) {
           requestCache = /* @__PURE__ */ new Map();
@@ -162,30 +178,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 = (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
+          });
+        }
+      }
+      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 +249,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 +284,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/browser/deferreds.js

@@ -0,0 +1,227 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _call_super } from "@swc/helpers/_/_call_super";
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _inherits } from "@swc/helpers/_/_inherits";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _wrap_native_super } from "@swc/helpers/_/_wrap_native_super";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+function invariant(value, message) {
+  if (value === false || value === null || typeof value === "undefined") {
+    throw new Error(message);
+  }
+}
+var AbortedDeferredError = /* @__PURE__ */ function(Error1) {
+  "use strict";
+  _inherits(AbortedDeferredError2, Error1);
+  function AbortedDeferredError2() {
+    _class_call_check(this, AbortedDeferredError2);
+    return _call_super(this, AbortedDeferredError2, arguments);
+  }
+  return AbortedDeferredError2;
+}(_wrap_native_super(Error));
+function isTrackedPromise(value) {
+  return _instanceof(value, Promise) && value._tracked === true;
+}
+function unwrapTrackedPromise(value) {
+  if (!isTrackedPromise(value)) {
+    return value;
+  }
+  if (value._error) {
+    throw value._error;
+  }
+  return value._data;
+}
+var DeferredData = /* @__PURE__ */ function() {
+  "use strict";
+  function DeferredData2(data, responseInit) {
+    var _this = this;
+    _class_call_check(this, DeferredData2);
+    this.pendingKeysSet = /* @__PURE__ */ new Set();
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.__modern_deferred = true;
+    this.deferredKeys = [];
+    invariant(data && (typeof data === "undefined" ? "undefined" : _type_of(data)) === "object" && !Array.isArray(data), "defer() only accepts plain objects");
+    var reject;
+    this.abortPromise = new Promise(function(_, r) {
+      return reject = r;
+    });
+    this.controller = new AbortController();
+    var onAbort = function() {
+      return reject(new AbortedDeferredError("Deferred data aborted"));
+    };
+    this.unlistenAbortSignal = function() {
+      return _this.controller.signal.removeEventListener("abort", onAbort);
+    };
+    this.controller.signal.addEventListener("abort", onAbort);
+    this.data = Object.entries(data).reduce(function(acc, param) {
+      var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+      return Object.assign(acc, _define_property({}, key, _this.trackPromise(key, value)));
+    }, {});
+    if (this.done) {
+      this.unlistenAbortSignal();
+    }
+    this.init = responseInit;
+  }
+  var _proto = DeferredData2.prototype;
+  _proto.trackPromise = function trackPromise(key, value) {
+    var _this = this;
+    if (!_instanceof(value, Promise)) {
+      return value;
+    }
+    this.deferredKeys.push(key);
+    this.pendingKeysSet.add(key);
+    var promise = Promise.race([
+      value,
+      this.abortPromise
+    ]).then(function(data) {
+      return _this.onSettle(promise, key, void 0, data);
+    }, function(error) {
+      return _this.onSettle(promise, key, error);
+    });
+    promise.catch(function() {
+    });
+    Object.defineProperty(promise, "_tracked", {
+      get: function() {
+        return true;
+      }
+    });
+    return promise;
+  };
+  _proto.onSettle = function onSettle(promise, key, error, data) {
+    if (this.controller.signal.aborted && _instanceof(error, AbortedDeferredError)) {
+      this.unlistenAbortSignal();
+      Object.defineProperty(promise, "_error", {
+        get: function() {
+          return error;
+        }
+      });
+      return Promise.reject(error);
+    }
+    this.pendingKeysSet.delete(key);
+    if (this.done) {
+      this.unlistenAbortSignal();
+    }
+    if (error === void 0 && data === void 0) {
+      var undefinedError = new Error('Deferred data for key "'.concat(key, '" resolved/rejected with `undefined`, you must resolve/reject with a value or `null`.'));
+      Object.defineProperty(promise, "_error", {
+        get: function() {
+          return undefinedError;
+        }
+      });
+      this.emit(false, key);
+      return Promise.reject(undefinedError);
+    }
+    if (data === void 0) {
+      Object.defineProperty(promise, "_error", {
+        get: function() {
+          return error;
+        }
+      });
+      this.emit(false, key);
+      return Promise.reject(error);
+    }
+    Object.defineProperty(promise, "_data", {
+      get: function() {
+        return data;
+      }
+    });
+    this.emit(false, key);
+    return data;
+  };
+  _proto.emit = function emit(aborted, settledKey) {
+    this.subscribers.forEach(function(subscriber) {
+      return subscriber(aborted, settledKey);
+    });
+  };
+  _proto.subscribe = function subscribe(fn) {
+    var _this = this;
+    this.subscribers.add(fn);
+    return function() {
+      return _this.subscribers.delete(fn);
+    };
+  };
+  _proto.cancel = function cancel() {
+    var _this = this;
+    this.controller.abort();
+    this.pendingKeysSet.forEach(function(v, k) {
+      return _this.pendingKeysSet.delete(k);
+    });
+    this.emit(true);
+  };
+  _proto.resolveData = function resolveData(signal) {
+    var _this = this;
+    return _async_to_generator(function() {
+      var aborted, onAbort;
+      return _ts_generator(this, function(_state) {
+        switch (_state.label) {
+          case 0:
+            aborted = false;
+            if (!!_this.done)
+              return [
+                3,
+                2
+              ];
+            onAbort = function() {
+              return _this.cancel();
+            };
+            signal.addEventListener("abort", onAbort);
+            return [
+              4,
+              new Promise(function(resolve) {
+                _this.subscribe(function(aborted2) {
+                  signal.removeEventListener("abort", onAbort);
+                  if (aborted2 || _this.done) {
+                    resolve(aborted2);
+                  }
+                });
+              })
+            ];
+          case 1:
+            aborted = _state.sent();
+            _state.label = 2;
+          case 2:
+            return [
+              2,
+              aborted
+            ];
+        }
+      });
+    })();
+  };
+  _create_class(DeferredData2, [
+    {
+      key: "done",
+      get: function get() {
+        return this.pendingKeysSet.size === 0;
+      }
+    },
+    {
+      key: "unwrappedData",
+      get: function get() {
+        invariant(this.data !== null && this.done, "Can only unwrap data on initialized and settled deferreds");
+        return Object.entries(this.data).reduce(function(acc, param) {
+          var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+          return Object.assign(acc, _define_property({}, key, unwrapTrackedPromise(value)));
+        }, {});
+      }
+    },
+    {
+      key: "pendingKeys",
+      get: function get() {
+        return Array.from(this.pendingKeysSet);
+      }
+    }
+  ]);
+  return DeferredData2;
+}();
+var activeDeferreds = /* @__PURE__ */ new Map();
+export {
+  AbortedDeferredError,
+  DeferredData,
+  activeDeferreds,
+  invariant
+};

package/dist/esm/browser/index.js

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