@modern-js/runtime-utils 2.65.1 → 2.65.3-alpha.0

package/dist/esm/universal/cache.js

@@ -0,0 +1,355 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { LRUCache } from "lru-cache";
+import { getAsyncLocalStorage } from "./async_storage";
+var CacheSize = {
+  KB: 1024,
+  MB: 1024 * 1024,
+  GB: 1024 * 1024 * 1024
+};
+var CacheTime = {
+  SECOND: 1e3,
+  MINUTE: 60 * 1e3,
+  HOUR: 60 * 60 * 1e3,
+  DAY: 24 * 60 * 60 * 1e3,
+  WEEK: 7 * 24 * 60 * 60 * 1e3,
+  MONTH: 30 * 24 * 60 * 60 * 1e3
+};
+var isServer = typeof window === "undefined";
+var requestCacheMap = /* @__PURE__ */ new WeakMap();
+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);
+  }
+  fns.add(fn);
+}
+function configureCache(config) {
+  cacheConfig = _object_spread({}, cacheConfig, config);
+}
+function getLRUCache() {
+  if (!lruCache) {
+    lruCache = new LRUCache({
+      maxSize: cacheConfig.maxSize,
+      sizeCalculation: function(value) {
+        if (!value.size) {
+          return 1;
+        }
+        var size = 0;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+        try {
+          for (var _iterator = value.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var _step_value = _sliced_to_array(_step.value, 2), k = _step_value[0], item = _step_value[1];
+            size += k.length * 2;
+            size += estimateObjectSize(item.data);
+            size += 8;
+          }
+        } catch (err) {
+          _didIteratorError = true;
+          _iteratorError = err;
+        } finally {
+          try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+              _iterator.return();
+            }
+          } finally {
+            if (_didIteratorError) {
+              throw _iteratorError;
+            }
+          }
+        }
+        return size;
+      },
+      updateAgeOnGet: true,
+      updateAgeOnHas: true
+    });
+  }
+  return lruCache;
+}
+function estimateObjectSize(data) {
+  var type = typeof data === "undefined" ? "undefined" : _type_of(data);
+  if (type === "number")
+    return 8;
+  if (type === "boolean")
+    return 4;
+  if (type === "string")
+    return Math.max(data.length * 2, 1);
+  if (data === null || data === void 0)
+    return 1;
+  if (ArrayBuffer.isView(data)) {
+    return Math.max(data.byteLength, 1);
+  }
+  if (Array.isArray(data)) {
+    return Math.max(data.reduce(function(acc, item) {
+      return acc + estimateObjectSize(item);
+    }, 0), 1);
+  }
+  if (_instanceof(data, Map) || _instanceof(data, Set)) {
+    return 1024;
+  }
+  if (_instanceof(data, Date)) {
+    return 8;
+  }
+  if (type === "object") {
+    return Math.max(Object.entries(data).reduce(function(acc, param) {
+      var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+      return acc + key.length * 2 + estimateObjectSize(value);
+    }, 0), 1);
+  }
+  return 1;
+}
+function generateKey(args) {
+  return JSON.stringify(args, function(_, value) {
+    if (value && (typeof value === "undefined" ? "undefined" : _type_of(value)) === "object" && !Array.isArray(value)) {
+      return Object.keys(value).sort().reduce(function(result, key) {
+        result[key] = value[key];
+        return result;
+      }, {});
+    }
+    return value;
+  });
+}
+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 store = getLRUCache();
+  var tags = Array.isArray(tag) ? tag : [
+    tag
+  ];
+  tags.forEach(function(t) {
+    return addTagFnRelation(t, fn);
+  });
+  return /* @__PURE__ */ _async_to_generator(function() {
+    var _len, args, _key, _storage_useContext, storage, request, requestCache, key, promise, data, error, tagCache, key1, cached, now, age, data1;
+    var _arguments = arguments;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          for (_len = _arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = _arguments[_key];
+          }
+          if (!(isServer && typeof options === "undefined"))
+            return [
+              3,
+              5
+            ];
+          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
+            ];
+          requestCache = requestCacheMap.get(request);
+          if (!requestCache) {
+            requestCache = /* @__PURE__ */ new Map();
+            requestCacheMap.set(request, requestCache);
+          }
+          key = generateKey(args);
+          if (requestCache.has(key)) {
+            return [
+              2,
+              requestCache.get(key)
+            ];
+          }
+          promise = fn.apply(void 0, _to_consumable_array(args));
+          requestCache.set(key, promise);
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            3,
+            ,
+            4
+          ]);
+          return [
+            4,
+            promise
+          ];
+        case 2:
+          data = _state.sent();
+          return [
+            2,
+            data
+          ];
+        case 3:
+          error = _state.sent();
+          requestCache.delete(key);
+          throw error;
+        case 4:
+          return [
+            3,
+            8
+          ];
+        case 5:
+          if (!(typeof options !== "undefined"))
+            return [
+              3,
+              7
+            ];
+          tagCache = store.get(fn);
+          if (!tagCache) {
+            tagCache = /* @__PURE__ */ new Map();
+          }
+          key1 = generateKey(args);
+          cached = tagCache.get(key1);
+          now = Date.now();
+          if (cached) {
+            age = now - cached.timestamp;
+            if (age < maxAge) {
+              return [
+                2,
+                cached.data
+              ];
+            }
+            if (revalidate > 0 && age < maxAge + revalidate) {
+              if (!cached.isRevalidating) {
+                cached.isRevalidating = true;
+                Promise.resolve().then(/* @__PURE__ */ _async_to_generator(function() {
+                  var newData, error2, _storage_useContext_monitors, _storage_useContext2, storage2;
+                  return _ts_generator(this, function(_state2) {
+                    switch (_state2.label) {
+                      case 0:
+                        _state2.trys.push([
+                          0,
+                          2,
+                          ,
+                          3
+                        ]);
+                        return [
+                          4,
+                          fn.apply(void 0, _to_consumable_array(args))
+                        ];
+                      case 1:
+                        newData = _state2.sent();
+                        tagCache.set(key1, {
+                          data: newData,
+                          timestamp: Date.now(),
+                          isRevalidating: false
+                        });
+                        store.set(fn, tagCache);
+                        return [
+                          3,
+                          3
+                        ];
+                      case 2:
+                        error2 = _state2.sent();
+                        cached.isRevalidating = false;
+                        if (isServer) {
+                          ;
+                          storage2 = getAsyncLocalStorage();
+                          storage2 === null || storage2 === void 0 ? void 0 : (_storage_useContext2 = storage2.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(error2.message);
+                        } else {
+                          console.error("Background revalidation failed:", error2);
+                        }
+                        return [
+                          3,
+                          3
+                        ];
+                      case 3:
+                        return [
+                          2
+                        ];
+                    }
+                  });
+                }));
+              }
+              return [
+                2,
+                cached.data
+              ];
+            }
+          }
+          return [
+            4,
+            fn.apply(void 0, _to_consumable_array(args))
+          ];
+        case 6:
+          data1 = _state.sent();
+          tagCache.set(key1, {
+            data: data1,
+            timestamp: now,
+            isRevalidating: false
+          });
+          store.set(fn, tagCache);
+          return [
+            2,
+            data1
+          ];
+        case 7:
+          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:
+          return [
+            2
+          ];
+      }
+    });
+  });
+}
+function withRequestCache(handler) {
+  if (!isServer) {
+    return handler;
+  }
+  return function() {
+    var _ref = _async_to_generator(function(req) {
+      var _len, args, _key, storage;
+      var _arguments = arguments;
+      return _ts_generator(this, function(_state) {
+        for (_len = _arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          args[_key - 1] = _arguments[_key];
+        }
+        storage = getAsyncLocalStorage();
+        return [
+          2,
+          storage.run({
+            request: req
+          }, function() {
+            return handler.apply(void 0, [
+              req
+            ].concat(_to_consumable_array(args)));
+          })
+        ];
+      });
+    });
+    return function(req) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+}
+function revalidateTag(tag) {
+  var fns = tagFnMap.get(tag);
+  if (fns) {
+    fns.forEach(function(fn) {
+      lruCache === null || lruCache === void 0 ? void 0 : lruCache.delete(fn);
+    });
+  }
+}
+function clearStore() {
+  lruCache === null || lruCache === void 0 ? void 0 : lruCache.clear();
+  lruCache = void 0;
+  tagFnMap.clear();
+}
+export {
+  CacheSize,
+  CacheTime,
+  cache,
+  clearStore,
+  configureCache,
+  generateKey,
+  revalidateTag,
+  withRequestCache
+};

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

@@ -3,12 +3,11 @@ import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
 import { Suspense } from "react";
 import { Outlet, Route, createRoutesFromElements } from "react-router-dom";
 import { time } from "../time";
-const transformNestedRoutes = (routes, reporter) => {
+import { getAsyncLocalStorage } from "../universal/async_storage";
+const transformNestedRoutes = (routes) => {
   const routeElements = [];
   for (const route of routes) {
-    const routeElement = renderNestedRoute(route, {
-      reporter
-    });
+    const routeElement = renderNestedRoute(route);
     routeElements.push(routeElement);
   }
   return createRoutesFromElements(routeElements);
@@ -16,12 +15,12 @@ const transformNestedRoutes = (routes, reporter) => {
 const renderNestedRoute = (nestedRoute, options = {}) => {
   const { children, index, id, component, isRoot, lazyImport, config, handle } = nestedRoute;
   const Component = component;
-  const { parent, props = {}, reporter } = options;
+  const { parent, props = {} } = options;
   const routeProps = {
     caseSensitive: nestedRoute.caseSensitive,
     path: nestedRoute.path,
     id: nestedRoute.id,
-    loader: createLoader(nestedRoute, reporter),
+    loader: createLoader(nestedRoute),
     action: nestedRoute.action,
     hasErrorBoundary: nestedRoute.hasErrorBoundary,
     shouldRevalidate: nestedRoute.shouldRevalidate,
@@ -74,8 +73,7 @@ const renderNestedRoute = (nestedRoute, options = {}) => {
   }
   const childElements = children === null || children === void 0 ? void 0 : children.map((childRoute) => {
     return renderNestedRoute(childRoute, {
-      parent: nestedRoute,
-      reporter
+      parent: nestedRoute
     });
   });
   const routeElement = index ? /* @__PURE__ */ _jsx(Route, {
@@ -88,7 +86,7 @@ const renderNestedRoute = (nestedRoute, options = {}) => {
   }, id);
   return routeElement;
 };
-function createLoader(route, reporter) {
+function createLoader(route) {
   const { loader } = route;
   if (loader) {
     return async (args) => {
@@ -98,8 +96,10 @@ function createLoader(route, reporter) {
       const end = time();
       const res = await loader(args);
       const cost = end();
-      if (typeof document === "undefined" && reporter) {
-        reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(`${LOADER_REPORTER_NAME}-${route.id}`, cost);
+      if (typeof document === "undefined") {
+        var _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);
       }
       return res;
     };

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

@@ -1,10 +1,8 @@
-import { createStorage } from "./storage";
-const { run, useContext: useHeaders } = createStorage();
+import { storage } from "../universal/async_storage.server";
 import { serializeJson } from "./serialize";
 export * from "./loaderContext";
 export * from "./stream";
 export {
-  run,
   serializeJson,
-  useHeaders
+  storage
 };

package/dist/esm-node/node/storer/container.js

@@ -1,4 +1,4 @@
-import LRU from "lru-cache";
+import { LRUCache } from "lru-cache";
 class MemoryContainer {
   async get(key) {
     return this.cache.get(key);
@@ -13,7 +13,7 @@ class MemoryContainer {
   async delete(key) {
     const exist = await this.has(key);
     if (exist) {
-      this.cache.del(key);
+      this.cache.delete(key);
     }
     return exist;
   }
@@ -23,9 +23,12 @@ class MemoryContainer {
     });
   }
   constructor({ max, maxAge } = {}) {
-    this.cache = new LRU({
-      max: (max || 256) * MemoryContainer.MB,
-      maxAge: maxAge || MemoryContainer.hour
+    this.cache = new LRUCache({
+      maxSize: (max || 256) * MemoryContainer.MB,
+      ttl: maxAge || MemoryContainer.hour,
+      sizeCalculation: (value, key) => {
+        return JSON.stringify(value).length;
+      }
     });
   }
 }

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

@@ -0,0 +1,7 @@
+const getAsyncLocalStorage = () => {
+  console.error("You should not get async storage in browser");
+  return null;
+};
+export {
+  getAsyncLocalStorage
+};

package/dist/esm-node/{node/storage.js → universal/async_storage.server.js}

@@ -1,16 +1,16 @@
 import * as ah from "async_hooks";
 const createStorage = () => {
-  let storage;
+  let storage2;
   if (typeof ah.AsyncLocalStorage !== "undefined") {
-    storage = new ah.AsyncLocalStorage();
+    storage2 = new ah.AsyncLocalStorage();
   }
   const run = (context, cb) => {
-    if (!storage) {
+    if (!storage2) {
       throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
         `);
     }
     return new Promise((resolve, reject) => {
-      storage.run(context, () => {
+      storage2.run(context, () => {
         try {
           return resolve(cb());
         } catch (error) {
@@ -20,13 +20,13 @@ const createStorage = () => {
     });
   };
   const useContext = () => {
-    if (!storage) {
+    if (!storage2) {
       throw new Error(`Unable to use async_hook, please confirm the node version >= 12.17
         `);
     }
-    const context = storage.getStore();
+    const context = storage2 === null || storage2 === void 0 ? void 0 : storage2.getStore();
     if (!context) {
-      throw new Error(`Can't call useContext out of scope, make sure @modern-js/utils is a single version in node_modules`);
+      throw new Error(`Can't call useContext out of scope, make sure @modern-js/runtime-utils is a single version in node_modules`);
     }
     return context;
   };
@@ -35,6 +35,11 @@ const createStorage = () => {
     useContext
   };
 };
+const storage = createStorage();
+const getAsyncLocalStorage = () => {
+  return storage;
+};
 export {
-  createStorage
+  getAsyncLocalStorage,
+  storage
 };