@modern-js/runtime-utils 2.69.4 → 3.0.0-alpha.0

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

@@ -0,0 +1,326 @@
+import { LRUCache } from "lru-cache";
+import { getAsyncLocalStorage } from "./async_storage.mjs";
+const CacheSize = {
+    KB: 1024,
+    MB: 1048576,
+    GB: 1073741824
+};
+const CacheTime = {
+    SECOND: 1000,
+    MINUTE: 60000,
+    HOUR: 3600000,
+    DAY: 86400000,
+    WEEK: 604800000,
+    MONTH: 2592000000
+};
+function estimateObjectSize(data) {
+    const type = typeof data;
+    if ('number' === type) return 8;
+    if ('boolean' === type) return 4;
+    if ('string' === type) return Math.max(2 * data.length, 1);
+    if (null == data) 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 ('object' === type) return Math.max(Object.entries(data).reduce((acc, [key, value])=>acc + 2 * key.length + estimateObjectSize(value), 0), 1);
+    return 1;
+}
+class MemoryContainer {
+    async get(key) {
+        return this.lru.get(key);
+    }
+    async set(key, value, options) {
+        if (options?.ttl) this.lru.set(key, value, {
+            ttl: 1000 * options.ttl
+        });
+        else this.lru.set(key, value);
+    }
+    async has(key) {
+        return this.lru.has(key);
+    }
+    async delete(key) {
+        return this.lru.delete(key);
+    }
+    async clear() {
+        this.lru.clear();
+    }
+    constructor(options){
+        this.lru = new LRUCache({
+            maxSize: options?.maxSize ?? CacheSize.GB,
+            sizeCalculation: estimateObjectSize,
+            updateAgeOnGet: true,
+            updateAgeOnHas: true
+        });
+    }
+}
+const isServer = "u" < typeof window;
+const requestCacheMap = new WeakMap();
+const TAG_PREFIX = 'tag:';
+const CACHE_PREFIX = 'modernjs_cache:';
+const ongoingRevalidations = new Map();
+let cache_storage;
+let cacheConfig = {
+    maxSize: CacheSize.GB
+};
+function getStorage() {
+    if (cache_storage) return cache_storage;
+    cache_storage = cacheConfig.container ? cacheConfig.container : new MemoryContainer({
+        maxSize: cacheConfig.maxSize
+    });
+    return cache_storage;
+}
+function configureCache(config) {
+    cacheConfig = {
+        ...cacheConfig,
+        ...config
+    };
+    cache_storage = void 0;
+}
+function generateKey(args) {
+    return JSON.stringify(args, (_, value)=>{
+        if (value && 'object' == typeof value && !Array.isArray(value)) return Object.keys(value).sort().reduce((result, key)=>{
+            result[key] = value[key];
+            return result;
+        }, {});
+        return value;
+    });
+}
+function generateStableFunctionId(fn) {
+    const fnString = fn.toString();
+    let hash = 0;
+    for(let i = 0; i < fnString.length; i++){
+        const char = fnString.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash &= hash;
+    }
+    return `fn_${fn.name || 'anonymous'}_${Math.abs(hash).toString(36)}`;
+}
+function cache(fn, options) {
+    return async (...args)=>{
+        if (isServer && void 0 === options) {
+            const storage = await getAsyncLocalStorage();
+            const request = 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 = new Map();
+                    requestCacheMap.set(request, requestCache);
+                }
+                let fnCache = requestCache.get(fn);
+                if (!fnCache) {
+                    fnCache = new Map();
+                    requestCache.set(fn, fnCache);
+                }
+                const key = generateKey(args);
+                if (fnCache.has(key)) return fnCache.get(key);
+                const promise = fn(...args);
+                fnCache.set(key, promise);
+                try {
+                    const data = await promise;
+                    return data;
+                } catch (error) {
+                    fnCache.delete(key);
+                    throw error;
+                }
+            }
+        } else if (void 0 !== options) try {
+            const { tag, maxAge = 5 * CacheTime.MINUTE, revalidate = 0, customKey, onCache, getKey, unstable_shouldCache } = options;
+            let missReason;
+            const currentStorage = getStorage();
+            const now = Date.now();
+            const tags = tag ? Array.isArray(tag) ? tag : [
+                tag
+            ] : [];
+            const genKey = getKey ? getKey(...args) : generateKey(args);
+            let finalKey;
+            if (customKey) finalKey = customKey({
+                params: args,
+                fn,
+                generatedKey: genKey
+            });
+            else {
+                const functionId = generateStableFunctionId(fn);
+                finalKey = `${functionId}:${genKey}`;
+            }
+            const storageKey = `${CACHE_PREFIX}${finalKey}`;
+            let shouldDisableCaching = false;
+            if (isServer && cacheConfig.unstable_shouldDisable) {
+                const asyncStorage = await getAsyncLocalStorage();
+                const request = asyncStorage?.useContext()?.request;
+                if (request) shouldDisableCaching = await cacheConfig.unstable_shouldDisable({
+                    request
+                });
+            }
+            if (shouldDisableCaching) missReason = 1;
+            else {
+                const cached = await currentStorage.get(storageKey);
+                if (cached) try {
+                    const cacheItem = cached;
+                    const age = now - cacheItem.timestamp;
+                    if (age < maxAge) {
+                        onCache?.({
+                            status: 'hit',
+                            key: finalKey,
+                            params: args,
+                            result: cacheItem.data
+                        });
+                        return cacheItem.data;
+                    }
+                    if (revalidate > 0 && age < maxAge + revalidate) {
+                        onCache?.({
+                            status: 'stale',
+                            key: finalKey,
+                            params: args,
+                            result: cacheItem.data
+                        });
+                        if (!ongoingRevalidations.has(storageKey)) {
+                            const revalidationPromise = (async ()=>{
+                                try {
+                                    const newData = await fn(...args);
+                                    let shouldCache = true;
+                                    if (unstable_shouldCache) shouldCache = await unstable_shouldCache({
+                                        params: args,
+                                        result: newData
+                                    });
+                                    if (shouldCache) await setCacheItem(currentStorage, storageKey, newData, tags, maxAge, revalidate);
+                                } catch (error) {
+                                    if (isServer) {
+                                        const asyncStorage = await getAsyncLocalStorage();
+                                        asyncStorage?.useContext()?.monitors?.error(error.message);
+                                    } else console.error('Background revalidation failed:', error);
+                                } finally{
+                                    ongoingRevalidations.delete(storageKey);
+                                }
+                            })();
+                            ongoingRevalidations.set(storageKey, revalidationPromise);
+                        }
+                        return cacheItem.data;
+                    }
+                    missReason = 3;
+                } catch (error) {
+                    console.warn('Failed to parse cached data:', error);
+                    missReason = 4;
+                }
+                else missReason = 2;
+            }
+            const data = await fn(...args);
+            if (!shouldDisableCaching) {
+                let shouldCache = true;
+                if (unstable_shouldCache) shouldCache = await unstable_shouldCache({
+                    params: args,
+                    result: data
+                });
+                if (shouldCache) await setCacheItem(currentStorage, storageKey, data, tags, maxAge, revalidate);
+            }
+            onCache?.({
+                status: 'miss',
+                key: finalKey,
+                params: args,
+                result: data,
+                reason: missReason
+            });
+            return data;
+        } catch (error) {
+            console.warn('Cache operation failed, falling back to direct execution:', error);
+            const data = await fn(...args);
+            const { onCache } = options;
+            try {
+                onCache?.({
+                    status: 'miss',
+                    key: 'cache_failed',
+                    params: args,
+                    result: data,
+                    reason: 5
+                });
+            } catch (callbackError) {
+                console.warn('Failed to call onCache callback:', callbackError);
+            }
+            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);
+        }
+    };
+}
+async function setCacheItem(storage, storageKey, data, tags, maxAge, revalidate) {
+    const newItem = {
+        data,
+        timestamp: Date.now(),
+        tags: tags.length > 0 ? tags : void 0
+    };
+    const ttl = (maxAge + revalidate) / 1000;
+    await storage.set(storageKey, newItem, {
+        ttl: ttl > 0 ? ttl : void 0
+    });
+    await updateTagRelationships(storage, storageKey, tags);
+}
+async function updateTagRelationships(storage, storageKey, tags) {
+    for (const tag of tags){
+        const tagStoreKey = `${TAG_PREFIX}${tag}`;
+        const keyList = await storage.get(tagStoreKey);
+        const keyArray = keyList || [];
+        if (!keyArray.includes(storageKey)) keyArray.push(storageKey);
+        await storage.set(tagStoreKey, keyArray);
+    }
+}
+async function removeKeyFromTags(storage, storageKey, tags) {
+    for (const tag of tags){
+        const tagStoreKey = `${TAG_PREFIX}${tag}`;
+        const keyList = await storage.get(tagStoreKey);
+        if (keyList) try {
+            const keyArray = Array.isArray(keyList) ? keyList : [];
+            const updatedKeyList = keyArray.filter((key)=>key !== storageKey);
+            if (updatedKeyList.length > 0) await storage.set(tagStoreKey, updatedKeyList);
+            else await storage.delete(tagStoreKey);
+        } catch (error) {
+            console.warn(`Failed to process tag key list for tag ${tag}:`, error);
+        }
+    }
+}
+function withRequestCache(handler) {
+    if (!isServer) return handler;
+    return async (req, ...args)=>{
+        const storage = await getAsyncLocalStorage();
+        return storage.run({
+            request: req
+        }, ()=>handler(req, ...args));
+    };
+}
+async function revalidateTag(tag) {
+    const currentStorage = getStorage();
+    const tagStoreKey = `${TAG_PREFIX}${tag}`;
+    const keyList = await currentStorage.get(tagStoreKey);
+    if (keyList) try {
+        const keyArray = Array.isArray(keyList) ? keyList : [];
+        for (const cacheKey of keyArray){
+            const cached = await currentStorage.get(cacheKey);
+            if (cached) try {
+                const cacheItem = cached;
+                if (cacheItem.tags) {
+                    const otherTags = cacheItem.tags.filter((t)=>t !== tag);
+                    await removeKeyFromTags(currentStorage, cacheKey, otherTags);
+                }
+            } catch (error) {
+                console.warn('Failed to parse cached data while revalidating:', error);
+            }
+            await currentStorage.delete(cacheKey);
+        }
+        await currentStorage.delete(tagStoreKey);
+    } catch (error) {
+        console.warn('Failed to process tag key list:', error);
+    }
+}
+async function clearStore() {
+    const currentStorage = getStorage();
+    await currentStorage.clear();
+    cache_storage = void 0;
+    ongoingRevalidations.clear();
+}
+export { CacheSize, CacheTime, cache, clearStore, configureCache, generateKey, revalidateTag, withRequestCache };

package/dist/esm-node/universal/request.mjs

@@ -0,0 +1,40 @@
+function parseQuery(req) {
+    const query = {};
+    const { url } = req;
+    const q = url.split('?')[1];
+    if (q) {
+        const search = new URLSearchParams(q);
+        search.forEach((v, k)=>{
+            query[k] = v;
+        });
+    }
+    return query;
+}
+function parseHeaders(request) {
+    const headersData = {};
+    request.headers.forEach((value, key)=>{
+        headersData[key] = value;
+    });
+    return headersData;
+}
+function getPathname(request) {
+    const match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
+    return match ? match[1] : '/';
+}
+function getHost(request) {
+    const { headers } = request;
+    let host = headers.get('X-Forwarded-Host');
+    if (!host) host = headers.get('Host');
+    host = host?.split(/\s*,\s*/, 1)[0] || 'undefined';
+    return host;
+}
+function parseCookie(req) {
+    const _cookie = req.headers.get('Cookie');
+    const cookie = {};
+    _cookie?.trim().split(';').forEach((item)=>{
+        const [k, v] = item.trim().split('=');
+        if (k) cookie[k] = v;
+    });
+    return cookie;
+}
+export { getHost, getPathname, parseCookie, parseHeaders, parseQuery };

package/dist/esm-node/url.mjs

@@ -0,0 +1,5 @@
+function normalizePathname(pathname) {
+    const normalized = '/' + pathname.replace(/^\/+|\/+$/g, '');
+    return normalized;
+}
+export { normalizePathname };

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

@@ -1,5 +1,6 @@
 import type { NestedRoute } from '@modern-js/types';
-export declare const transformNestedRoutes: (routes: NestedRoute[]) => import("react-router-dom").RouteObject[];
+import { type JSX } from 'react';
+export declare const transformNestedRoutes: (routes: NestedRoute[]) => import("react-router").RouteObject[];
 type DeferredDataComponentType = (props?: {
     nonce?: string;
 }) => JSX.Element | null;

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

@@ -1,4 +1,4 @@
 import { type Readable } from 'stream';
 export declare const createReadableStreamFromReadable: (source: Readable & {
     readableHighWaterMark?: number;
-}) => ReadableStream<Uint8Array>;
+}) => ReadableStream<Uint8Array<ArrayBufferLike>>;

package/dist/types/router.d.ts

@@ -1 +1,6 @@
-export * from 'react-router-dom';
+export * from 'react-router';
+export declare const DEFERRED_SYMBOL: unique symbol;
+/** @deprecated Please use Response.json instead. */
+export declare const json: (data: any, init?: number | ResponseInit) => Response;
+/** @deprecated defer is deprecated, You don't need to use it. */
+export declare const defer: (data: any, init?: number | ResponseInit) => any;

package/dist/types/rsc.d.ts

@@ -0,0 +1 @@
+export * from 'react-router';

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

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

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

@@ -26,4 +26,4 @@ declare const storage: {
 };
 type Storage = typeof storage;
 export { storage, type Storage };
-export declare const getAsyncLocalStorage: () => Storage;
+export declare const getAsyncLocalStorage: () => Promise<Storage>;

package/package.json

@@ -15,78 +15,73 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.69.4",
+  "version": "3.0.0-alpha.0",
   "_comment": "Provide ESM and CJS exports, ESM is used by runtime package, for treeshaking",
   "exports": {
     "./router": {
       "types": "./dist/types/router.d.ts",
       "require": "./dist/cjs/router.js",
-      "default": "./dist/esm/router.js"
+      "default": "./dist/esm/router.mjs"
     },
-    "./remix-router": {
-      "types": "./dist/types/remixRouter.d.ts",
-      "require": "./dist/cjs/remixRouter.js",
-      "default": "./dist/esm/remixRouter.js"
+    "./router/rsc": {
+      "types": "./dist/types/rsc.d.ts",
+      "require": "./dist/cjs/rsc.js",
+      "default": "./dist/esm/rsc.js"
     },
     "./browser": {
       "types": "./dist/types/browser/index.d.ts",
       "require": "./dist/cjs/browser/index.js",
-      "default": "./dist/esm/browser/index.js"
+      "default": "./dist/esm/browser/index.mjs"
     },
     "./node": {
       "types": "./dist/types/node/index.d.ts",
       "require": "./dist/cjs/node/index.js",
-      "default": "./dist/esm/node/index.js"
+      "default": "./dist/esm-node/node/index.mjs"
     },
     "./server": {
       "types": "./dist/types/server/index.d.ts",
       "require": "./dist/cjs/server/index.js",
-      "default": "./dist/esm/server/index.js"
-    },
-    "./node/router": {
-      "types": "./dist/types/node/router.d.ts",
-      "require": "./dist/cjs/node/router.js",
-      "default": "./dist/esm/node/router.js"
+      "default": "./dist/esm/server/index.mjs"
     },
     "./universal/request": {
       "types": "./dist/universal/request.d.ts",
       "require": "./dist/cjs/universal/request.js",
-      "default": "./dist/esm/universal/request.js"
+      "default": "./dist/esm/universal/request.mjs"
     },
     "./time": {
       "types": "./dist/types/time.d.ts",
       "require": "./dist/cjs/time.js",
-      "default": "./dist/esm/time.js"
+      "default": "./dist/esm/time.mjs"
     },
     "./parsed": {
       "types": "./dist/types/parsed.d.ts",
       "require": "./dist/cjs/parsed.js",
-      "default": "./dist/esm/parsed.js"
+      "default": "./dist/esm/parsed.mjs"
     },
     "./storer": {
       "types": "./dist/types/node/storer/index.d.ts",
       "require": "./dist/cjs/node/storer/index.js",
-      "default": "./dist/esm/node/storer/index.js"
+      "default": "./dist/esm/node/storer/index.mjs"
     },
     "./fileReader": {
       "types": "./dist/types/node/fileReader.d.ts",
       "require": "./dist/cjs/node/fileReader.js",
-      "default": "./dist/esm/node/fileReader.js"
+      "default": "./dist/esm/node/fileReader.mjs"
     },
     "./url": {
       "types": "./dist/types/url.d.ts",
       "require": "./dist/cjs/url.js",
-      "default": "./dist/esm/url.js"
+      "default": "./dist/esm/url.mjs"
     },
     "./merge": {
       "types": "./dist/types/merge.d.ts",
       "require": "./dist/cjs/merge.js",
-      "default": "./dist/esm/merge.js"
+      "default": "./dist/esm/merge.mjs"
     },
     "./cache": {
       "types": "./dist/types/universal/cache.d.ts",
       "require": "./dist/cjs/universal/cache.js",
-      "default": "./dist/esm/universal/cache.js"
+      "default": "./dist/esm/universal/cache.mjs"
     }
   },
   "publishConfig": {
@@ -98,8 +93,8 @@
       "router": [
         "./dist/types/router.d.ts"
       ],
-      "remix-router": [
-        "./dist/types/remixRouter.d.ts"
+      "router/rsc": [
+        "./dist/types/rsc.d.ts"
       ],
       "browser": [
         "./dist/types/browser/index.d.ts"
@@ -110,9 +105,6 @@
       "server": [
         "./dist/types/server/index.d.ts"
       ],
-      "node/router": [
-        "./dist/types/node/router.d.ts"
-      ],
       "universal/request": [
         "./dist/types/universal/request.d.ts"
       ],
@@ -140,17 +132,16 @@
     }
   },
   "dependencies": {
-    "@remix-run/router": "1.20.0",
     "@swc/helpers": "^0.5.17",
     "lru-cache": "^10.4.3",
-    "react-router-dom": "6.27.0",
-    "serialize-javascript": "^6.0.0",
-    "@modern-js/types": "2.69.4",
-    "@modern-js/utils": "2.69.4"
+    "react-router": "7.8.2",
+    "serialize-javascript": "^6.0.2",
+    "@modern-js/types": "3.0.0-alpha.0",
+    "@modern-js/utils": "3.0.0-alpha.0"
   },
   "peerDependencies": {
-    "react": ">=17.0.0",
-    "react-dom": ">=17.0.0"
+    "react": ">=17.0.2",
+    "react-dom": ">=17.0.2"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -162,23 +153,22 @@
   },
   "devDependencies": {
     "@types/ioredis-mock": "^8.2.6",
-    "@types/jest": "^29",
-    "@types/node": "^18",
-    "@types/serialize-javascript": "^5.0.1",
-    "ioredis-mock": "^8.9.0",
-    "jest": "^29",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
+    "@types/node": "^20",
+    "@types/serialize-javascript": "^5.0.4",
+    "ioredis-mock": "^8.13.1",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3",
+    "@rslib/core": "0.18.5",
     "typescript": "^5",
     "@scripts/build": "2.66.0",
-    "@scripts/jest-config": "2.66.0"
+    "@scripts/rstest-config": "2.66.0",
+    "@modern-js/rslib": "2.68.10"
   },
   "sideEffects": false,
   "scripts": {
-    "new": "modern-lib new",
-    "dev": "modern-lib build --watch",
-    "build": "modern-lib build",
-    "test": "jest --passWithNoTests"
+    "dev": "rslib build --watch",
+    "build": "rslib build",
+    "test": "rstest --passWithNoTests"
   },
   "types": "./dist/types/index.d.ts"
 }

package/rslib.config.mts

@@ -0,0 +1,27 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig({
+  ...rslibConfig,
+  lib: rslibConfig.lib?.map(libConfig => {
+    const isWebTarget = libConfig.output?.target === 'web';
+
+    return {
+      ...libConfig,
+      ...(isWebTarget && {
+        source: {
+          define: {
+            IS_WEB: 'true',
+          },
+        },
+      }),
+      output: {
+        ...libConfig.output,
+        externals: {
+          async_hooks: 'async_hooks',
+          './async_storage.server': './async_storage.server',
+        },
+      },
+    };
+  }),
+});

package/rstest.config.ts

@@ -0,0 +1,26 @@
+import { withTestPreset } from '@scripts/rstest-config';
+
+export default {
+  projects: [
+    withTestPreset({
+      name: 'runtime-utils-node',
+      root: __dirname,
+      testEnvironment: 'node',
+      exclude: [
+        'tests/universal/cache-client.test.ts',
+        'tests/browser/**/*.{test,spec}.{js,cjs,mjs,ts,tsx}',
+      ],
+      globals: true,
+    }),
+    withTestPreset({
+      name: 'runtime-utils-client',
+      root: __dirname,
+      testEnvironment: 'jsdom',
+      include: [
+        'tests/universal/cache-client.test.ts',
+        'tests/browser/**/*.{test,spec}.{js,cjs,mjs,ts,tsx}',
+      ],
+      globals: true,
+    }),
+  ],
+};

package/dist/cjs/node/router.js

@@ -1,22 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var router_exports = {};
-module.exports = __toCommonJS(router_exports);
-__reExport(router_exports, require("react-router-dom/server"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("react-router-dom/server")
-});