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

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

@@ -0,0 +1,216 @@
+import { LRUCache } from "lru-cache";
+import { getAsyncLocalStorage } from "./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 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 = 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 = 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 = 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();
+}
+export {
+  CacheSize,
+  CacheTime,
+  cache,
+  clearStore,
+  configureCache,
+  generateKey,
+  revalidateTag,
+  withRequestCache
+};

package/dist/types/browser/nestedRoutes.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
-import type { NestedRoute, Reporter } from '@modern-js/types';
-export declare const transformNestedRoutes: (routes: NestedRoute[], reporter?: Reporter) => import("react-router-dom").RouteObject[];
+import type { NestedRoute } from '@modern-js/types';
+export declare const transformNestedRoutes: (routes: NestedRoute[]) => import("react-router-dom").RouteObject[];
 type DeferredDataComponentType = (props?: {
     nonce?: string;
 }) => JSX.Element | null;
@@ -8,6 +8,5 @@ export declare const renderNestedRoute: (nestedRoute: NestedRoute, options?: {
     parent?: NestedRoute;
     DeferredDataComponent?: DeferredDataComponentType;
     props?: Record<string, any>;
-    reporter?: Reporter;
 }) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/node/index.d.ts

@@ -1,10 +1,7 @@
-/// <reference types="node" />
 /**
  * ssr helpers
  */
-import type { IncomingHttpHeaders } from 'http';
-declare const run: <O>(context: IncomingHttpHeaders, cb: () => O | Promise<O>) => Promise<O>, useHeaders: () => IncomingHttpHeaders;
-export { run, useHeaders };
+export { storage } from '../universal/async_storage.server';
 export { serializeJson } from './serialize';
 export * from './loaderContext';
 export * from './stream';

package/dist/types/node/loaderContext/index.d.ts

@@ -1,16 +1,4 @@
 import type { Reporter } from '@modern-js/types';
-export { createRequestContext, type RequestContext } from './createRequestCtx';
+export { createRequestContext, type RequestContext, } from './createRequestCtx';
 export type { LoaderContext } from './createLoaderCtx';
-/**
- * @deprecated
- * Use `context.get('reporter')` instead of `context.get(reporterCtx)`. The `reporterCtx` will be removed in next major version.
- *
- * @example
- *
- * const loader = ({ context }: LoaderFunctionArgs) => {
- *  const reporter = context?.get('reporter')
- *  // doSomething
- * }
- *
- */
 export declare const reporterCtx: import("./createLoaderCtx").LoaderContext<Reporter>;

package/dist/types/node/storer/container.d.ts

@@ -8,7 +8,7 @@ interface MemoryContainerOptions {
  * MemoryContainer, it use lur-cache as cahe layer.
  * It has a Time to Live, by default as 1 hour.
  */
-export declare class MemoryContainer<K, V = unknown> implements Container<K, V> {
+export declare class MemoryContainer<K extends string, V extends {}> implements Container<K, V> {
     private static BYTE;
     private static KB;
     private static MB;

package/dist/types/node/storer/index.d.ts

@@ -1,3 +1,3 @@
 import { Storage } from './storage';
 export { Storage } from './storage';
-export declare function createMemoryStorage<V = unknown>(namespace: string): Storage<V>;
+export declare function createMemoryStorage<V extends {} | null>(namespace: string): Storage<V>;

package/dist/types/server/nestedRoutes.d.ts

@@ -1,3 +1,2 @@
-import type { ModernServerContext, ServerRoute } from '@modern-js/types';
-export type ServerContext = Pick<ModernServerContext, 'logger' | 'req' | 'reporter' | 'res' | 'params' | 'headers' | 'method' | 'url' | 'host' | 'protocol' | 'origin' | 'href' | 'path' | 'query'>;
+import type { ServerRoute } from '@modern-js/types';
 export declare const matchEntry: (pathname: string, entries: ServerRoute[]) => ServerRoute | undefined;

package/dist/types/universal/async_storage.d.ts

@@ -0,0 +1,2 @@
+import type { Storage } from './async_storage.server';
+export declare const getAsyncLocalStorage: () => Storage | null;

package/dist/types/universal/async_storage.server.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import type { IncomingHttpHeaders } from 'http';
+import type { Monitors } from '@modern-js/types';
+declare const storage: {
+    run: <O>(context: {
+        monitors?: Monitors | undefined;
+        headers?: IncomingHttpHeaders | undefined;
+        request?: Request | undefined;
+    }, cb: () => O | Promise<O>) => Promise<O>;
+    useContext: () => {
+        monitors?: Monitors | undefined;
+        headers?: IncomingHttpHeaders | undefined;
+        request?: Request | undefined;
+    };
+};
+type Storage = typeof storage;
+export { storage, type Storage };
+export declare const getAsyncLocalStorage: () => Storage;

package/dist/types/universal/cache.d.ts

@@ -0,0 +1,28 @@
+export declare const CacheSize: {
+    readonly KB: 1024;
+    readonly MB: number;
+    readonly GB: number;
+};
+export declare const CacheTime: {
+    readonly SECOND: 1000;
+    readonly MINUTE: number;
+    readonly HOUR: number;
+    readonly DAY: number;
+    readonly WEEK: number;
+    readonly MONTH: number;
+};
+interface CacheOptions {
+    tag?: string | string[];
+    maxAge?: number;
+    revalidate?: number;
+}
+interface CacheConfig {
+    maxSize: number;
+}
+export declare function configureCache(config: CacheConfig): void;
+export declare function generateKey(args: unknown[]): string;
+export declare function cache<T extends (...args: any[]) => Promise<any>>(fn: T, options?: CacheOptions): T;
+export declare function withRequestCache<T extends (req: Request, ...args: any[]) => Promise<any>>(handler: T): T;
+export declare function revalidateTag(tag: string): void;
+export declare function clearStore(): void;
+export {};

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.65.1",
+  "version": "2.65.3-alpha.0",
   "_comment": "Provide ESM and CJS exports, ESM is used by runtime package, for treeshaking",
   "exports": {
     "./router": {
@@ -30,7 +30,6 @@
     },
     "./browser": {
       "types": "./dist/types/browser/index.d.ts",
-      "jsnext:source": "./src/browser/index.d.ts",
       "require": "./dist/cjs/browser/index.js",
       "default": "./dist/esm/browser/index.js"
     },
@@ -83,12 +82,16 @@
       "types": "./dist/types/merge.d.ts",
       "require": "./dist/cjs/merge.js",
       "default": "./dist/esm/merge.js"
+    },
+    "./cache": {
+      "types": "./dist/types/universal/cache.d.ts",
+      "require": "./dist/cjs/universal/cache.js",
+      "default": "./dist/esm/universal/cache.js"
     }
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
-    "access": "public",
-    "provenance": true
+    "access": "public"
   },
   "typesVersions": {
     "*": {
@@ -130,16 +133,20 @@
       ],
       "merge": [
         "./dist/types/merge.d.ts"
+      ],
+      "cache": [
+        "./dist/types/universal/cache.d.ts"
       ]
     }
   },
   "dependencies": {
     "@remix-run/router": "1.20.0",
     "@swc/helpers": "0.5.13",
-    "lru-cache": "^6.0.0",
+    "lru-cache": "^10.4.3",
     "react-router-dom": "6.27.0",
     "serialize-javascript": "^6.0.0",
-    "@modern-js/utils": "2.65.1"
+    "@modern-js/types": "2.65.2",
+    "@modern-js/utils": "2.65.2"
   },
   "peerDependencies": {
     "react": ">=17.0.0",
@@ -155,16 +162,14 @@
   },
   "devDependencies": {
     "@types/jest": "^29",
-    "@types/lru-cache": "^5.1.1",
     "@types/node": "^14",
     "@types/serialize-javascript": "^5.0.1",
     "jest": "^29",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "typescript": "^5",
-    "@modern-js/types": "2.65.1",
-    "@scripts/build": "2.65.1",
-    "@scripts/jest-config": "2.65.1"
+    "@scripts/build": "2.65.2",
+    "@scripts/jest-config": "2.65.2"
   },
   "sideEffects": false,
   "scripts": {

package/dist/types/node/storage.d.ts

@@ -1,5 +0,0 @@
-declare const createStorage: <T>() => {
-    run: <O>(context: T, cb: () => O | Promise<O>) => Promise<O>;
-    useContext: () => T;
-};
-export { createStorage };