@modern-js/runtime-utils 2.65.0 → 2.65.2

package/dist/cjs/browser/nestedRoutes.js

@@ -27,12 +27,11 @@ var import_constants = require("@modern-js/utils/universal/constants");
 var import_react = require("react");
 var import_react_router_dom = require("react-router-dom");
 var import_time = require("../time");
-const transformNestedRoutes = (routes, reporter) => {
+var import_async_storage = require("../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 (0, import_react_router_dom.createRoutesFromElements)(routeElements);
@@ -40,12 +39,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,
@@ -98,8 +97,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__ */ (0, import_jsx_runtime.jsx)(import_react_router_dom.Route, {
@@ -112,7 +110,7 @@ const renderNestedRoute = (nestedRoute, options = {}) => {
   }, id);
   return routeElement;
 };
-function createLoader(route, reporter) {
+function createLoader(route) {
   const { loader } = route;
   if (loader) {
     return async (args) => {
@@ -122,8 +120,10 @@ function createLoader(route, reporter) {
       const end = (0, import_time.time)();
       const res = await loader(args);
       const cost = end();
-      if (typeof document === "undefined" && reporter) {
-        reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(`${import_constants.LOADER_REPORTER_NAME}-${route.id}`, cost);
+      if (typeof document === "undefined") {
+        var _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);
       }
       return res;
     };

package/dist/cjs/node/index.js

@@ -19,21 +19,18 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
-  run: () => run,
   serializeJson: () => import_serialize.serializeJson,
-  useHeaders: () => useHeaders
+  storage: () => import_async_storage.storage
 });
 module.exports = __toCommonJS(node_exports);
-var import_storage = require("./storage");
+var import_async_storage = require("../universal/async_storage.server");
 var import_serialize = require("./serialize");
 __reExport(node_exports, require("./loaderContext"), module.exports);
 __reExport(node_exports, require("./stream"), module.exports);
-const { run, useContext: useHeaders } = (0, import_storage.createStorage)();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  run,
   serializeJson,
-  useHeaders,
+  storage,
   ...require("./loaderContext"),
   ...require("./stream")
 });

package/dist/cjs/node/storer/container.js

@@ -1,9 +1,7 @@
 "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)
@@ -17,21 +15,13 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-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 container_exports = {};
 __export(container_exports, {
   MemoryContainer: () => MemoryContainer
 });
 module.exports = __toCommonJS(container_exports);
-var import_lru_cache = __toESM(require("lru-cache"));
+var import_lru_cache = require("lru-cache");
 class MemoryContainer {
   async get(key) {
     return this.cache.get(key);
@@ -46,7 +36,7 @@ class MemoryContainer {
   async delete(key) {
     const exist = await this.has(key);
     if (exist) {
-      this.cache.del(key);
+      this.cache.delete(key);
     }
     return exist;
   }
@@ -56,9 +46,12 @@ class MemoryContainer {
     });
   }
   constructor({ max, maxAge } = {}) {
-    this.cache = new import_lru_cache.default({
-      max: (max || 256) * MemoryContainer.MB,
-      maxAge: maxAge || MemoryContainer.hour
+    this.cache = new import_lru_cache.LRUCache({
+      maxSize: (max || 256) * MemoryContainer.MB,
+      ttl: maxAge || MemoryContainer.hour,
+      sizeCalculation: (value, key) => {
+        return JSON.stringify(value).length;
+      }
     });
   }
 }

package/dist/cjs/universal/async_storage.js

@@ -0,0 +1,31 @@
+"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 async_storage_exports = {};
+__export(async_storage_exports, {
+  getAsyncLocalStorage: () => getAsyncLocalStorage
+});
+module.exports = __toCommonJS(async_storage_exports);
+const getAsyncLocalStorage = () => {
+  console.error("You should not get async storage in browser");
+  return null;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAsyncLocalStorage
+});

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

@@ -26,24 +26,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var storage_exports = {};
-__export(storage_exports, {
-  createStorage: () => createStorage
+var async_storage_server_exports = {};
+__export(async_storage_server_exports, {
+  getAsyncLocalStorage: () => getAsyncLocalStorage,
+  storage: () => storage
 });
-module.exports = __toCommonJS(storage_exports);
+module.exports = __toCommonJS(async_storage_server_exports);
 var ah = __toESM(require("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) {
@@ -53,13 +54,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;
   };
@@ -68,7 +69,12 @@ const createStorage = () => {
     useContext
   };
 };
+const storage = createStorage();
+const getAsyncLocalStorage = () => {
+  return storage;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  createStorage
+  getAsyncLocalStorage,
+  storage
 });

package/dist/cjs/universal/cache.js

@@ -0,0 +1,247 @@
+"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 cache_exports = {};
+__export(cache_exports, {
+  CacheSize: () => CacheSize,
+  CacheTime: () => CacheTime,
+  cache: () => cache,
+  clearStore: () => clearStore,
+  configureCache: () => configureCache,
+  generateKey: () => generateKey,
+  revalidateTag: () => revalidateTag,
+  withRequestCache: () => withRequestCache
+});
+module.exports = __toCommonJS(cache_exports);
+var import_lru_cache = require("lru-cache");
+var import_async_storage = require("./async_storage");
+const CacheSize = {
+  KB: 1024,
+  MB: 1024 * 1024,
+  GB: 1024 * 1024 * 1024
+};
+const 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
+};
+const isServer = typeof window === "undefined";
+const requestCacheMap = /* @__PURE__ */ new WeakMap();
+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);
+  }
+  fns.add(fn);
+}
+function configureCache(config) {
+  cacheConfig = {
+    ...cacheConfig,
+    ...config
+  };
+}
+function getLRUCache() {
+  if (!lruCache) {
+    lruCache = new import_lru_cache.LRUCache({
+      maxSize: cacheConfig.maxSize,
+      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")
+    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((acc, item) => acc + estimateObjectSize(item), 0), 1);
+  }
+  if (data instanceof Map || data instanceof Set) {
+    return 1024;
+  }
+  if (data instanceof Date) {
+    return 8;
+  }
+  if (type === "object") {
+    return Math.max(Object.entries(data).reduce((acc, [key, value]) => acc + key.length * 2 + estimateObjectSize(value), 0), 1);
+  }
+  return 1;
+}
+function generateKey(args) {
+  return JSON.stringify(args, (_, value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      return Object.keys(value).sort().reduce((result, key) => {
+        result[key] = value[key];
+        return result;
+      }, {});
+    }
+    return value;
+  });
+}
+function cache(fn, options) {
+  const { tag = "default", maxAge = CacheTime.MINUTE * 5, revalidate = 0 } = options || {};
+  const store = getLRUCache();
+  const tags = Array.isArray(tag) ? tag : [
+    tag
+  ];
+  tags.forEach((t) => addTagFnRelation(t, 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 requestCache = requestCacheMap.get(request);
+        if (!requestCache) {
+          requestCache = /* @__PURE__ */ new Map();
+          requestCacheMap.set(request, requestCache);
+        }
+        const key = generateKey(args);
+        if (requestCache.has(key)) {
+          return requestCache.get(key);
+        }
+        const promise = fn(...args);
+        requestCache.set(key, promise);
+        try {
+          const data = await promise;
+          return data;
+        } catch (error) {
+          requestCache.delete(key);
+          throw error;
+        }
+      }
+    } 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 now = Date.now();
+      if (cached) {
+        const age = now - cached.timestamp;
+        if (age < maxAge) {
+          return cached.data;
+        }
+        if (revalidate > 0 && age < maxAge + revalidate) {
+          if (!cached.isRevalidating) {
+            cached.isRevalidating = true;
+            Promise.resolve().then(async () => {
+              try {
+                const newData = await fn(...args);
+                tagCache.set(key, {
+                  data: newData,
+                  timestamp: Date.now(),
+                  isRevalidating: false
+                });
+                store.set(fn, tagCache);
+              } 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);
+                }
+              }
+            });
+          }
+          return cached.data;
+        }
+      }
+      const data = await fn(...args);
+      tagCache.set(key, {
+        data,
+        timestamp: now,
+        isRevalidating: false
+      });
+      store.set(fn, tagCache);
+      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);
+    }
+  };
+}
+function withRequestCache(handler) {
+  if (!isServer) {
+    return handler;
+  }
+  return async (req, ...args) => {
+    const storage = (0, import_async_storage.getAsyncLocalStorage)();
+    return storage.run({
+      request: req
+    }, () => handler(req, ...args));
+  };
+}
+function revalidateTag(tag) {
+  const fns = tagFnMap.get(tag);
+  if (fns) {
+    fns.forEach((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();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheSize,
+  CacheTime,
+  cache,
+  clearStore,
+  configureCache,
+  generateKey,
+  revalidateTag,
+  withRequestCache
+});

package/dist/esm/browser/nestedRoutes.js

@@ -8,15 +8,14 @@ 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";
-var transformNestedRoutes = function(routes, reporter) {
+import { getAsyncLocalStorage } from "../universal/async_storage";
+var transformNestedRoutes = function(routes) {
   var routeElements = [];
   var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
   try {
     for (var _iterator = routes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
       var route = _step.value;
-      var routeElement = renderNestedRoute(route, {
-        reporter
-      });
+      var routeElement = renderNestedRoute(route);
       routeElements.push(routeElement);
     }
   } catch (err) {
@@ -39,12 +38,12 @@ var renderNestedRoute = function(nestedRoute) {
   var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
   var children = nestedRoute.children, index = nestedRoute.index, id = nestedRoute.id, component = nestedRoute.component, isRoot = nestedRoute.isRoot, lazyImport = nestedRoute.lazyImport, config = nestedRoute.config, handle = nestedRoute.handle;
   var Component = component;
-  var parent = options.parent, _options_props = options.props, props = _options_props === void 0 ? {} : _options_props, reporter = options.reporter;
+  var parent = options.parent, _options_props = options.props, props = _options_props === void 0 ? {} : _options_props;
   var 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,
@@ -92,8 +91,7 @@ var renderNestedRoute = function(nestedRoute) {
   }
   var childElements = children === null || children === void 0 ? void 0 : children.map(function(childRoute) {
     return renderNestedRoute(childRoute, {
-      parent: nestedRoute,
-      reporter
+      parent: nestedRoute
     });
   });
   var routeElement = index ? /* @__PURE__ */ _jsx(Route, _object_spread_props(_object_spread({}, routeProps), {
@@ -104,12 +102,12 @@ var renderNestedRoute = function(nestedRoute) {
   }), id);
   return routeElement;
 };
-function createLoader(route, reporter) {
+function createLoader(route) {
   var loader = route.loader;
   if (loader) {
     return function() {
       var _ref = _async_to_generator(function(args) {
-        var end, res, cost;
+        var end, res, cost, _storage_useContext_monitors, storage;
         return _ts_generator(this, function(_state) {
           switch (_state.label) {
             case 0:
@@ -124,8 +122,10 @@ function createLoader(route, reporter) {
             case 1:
               res = _state.sent();
               cost = end();
-              if (typeof document === "undefined" && reporter) {
-                reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming("".concat(LOADER_REPORTER_NAME, "-").concat(route.id), cost);
+              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);
               }
               return [
                 2,

package/dist/esm/node/index.js

@@ -1,10 +1,8 @@
-import { createStorage } from "./storage";
-var _createStorage = createStorage(), run = _createStorage.run, useHeaders = _createStorage.useContext;
+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/storer/container.js

@@ -1,15 +1,18 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
-import LRU from "lru-cache";
+import { LRUCache } from "lru-cache";
 var MemoryContainer = /* @__PURE__ */ function() {
   "use strict";
   function MemoryContainer2() {
     var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, max = _ref.max, maxAge = _ref.maxAge;
     _class_call_check(this, MemoryContainer2);
-    this.cache = new LRU({
-      max: (max || 256) * MemoryContainer2.MB,
-      maxAge: maxAge || MemoryContainer2.hour
+    this.cache = new LRUCache({
+      maxSize: (max || 256) * MemoryContainer2.MB,
+      ttl: maxAge || MemoryContainer2.hour,
+      sizeCalculation: function(value, key) {
+        return JSON.stringify(value).length;
+      }
     });
   }
   var _proto = MemoryContainer2.prototype;
@@ -61,7 +64,7 @@ var MemoryContainer = /* @__PURE__ */ function() {
           case 1:
             exist = _state.sent();
             if (exist) {
-              _this.cache.del(key);
+              _this.cache.delete(key);
             }
             return [
               2,

package/dist/esm/universal/async_storage.js

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

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

@@ -1,15 +1,15 @@
 import * as ah from "async_hooks";
 var createStorage = function() {
-  var storage;
+  var storage2;
   if (typeof ah.AsyncLocalStorage !== "undefined") {
-    storage = new ah.AsyncLocalStorage();
+    storage2 = new ah.AsyncLocalStorage();
   }
   var run = function(context, cb) {
-    if (!storage) {
+    if (!storage2) {
       throw new Error("Unable to use async_hook, please confirm the node version >= 12.17\n        ");
     }
     return new Promise(function(resolve, reject) {
-      storage.run(context, function() {
+      storage2.run(context, function() {
         try {
           return resolve(cb());
         } catch (error) {
@@ -19,12 +19,12 @@ var createStorage = function() {
     });
   };
   var useContext = function() {
-    if (!storage) {
+    if (!storage2) {
       throw new Error("Unable to use async_hook, please confirm the node version >= 12.17\n        ");
     }
-    var context = storage.getStore();
+    var 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;
   };
@@ -33,6 +33,11 @@ var createStorage = function() {
     useContext
   };
 };
+var storage = createStorage();
+var getAsyncLocalStorage = function() {
+  return storage;
+};
 export {
-  createStorage
+  getAsyncLocalStorage,
+  storage
 };