@modern-js/runtime-utils 2.65.4 → 2.66.0

package/dist/cjs/universal/cache.js

@@ -142,17 +142,22 @@ function cache(fn, options) {
           requestCache = /* @__PURE__ */ new Map();
           requestCacheMap.set(request, requestCache);
         }
+        let fnCache = requestCache.get(fn);
+        if (!fnCache) {
+          fnCache = /* @__PURE__ */ new Map();
+          requestCache.set(fn, fnCache);
+        }
         const key = generateKey(args);
-        if (requestCache.has(key)) {
-          return requestCache.get(key);
+        if (fnCache.has(key)) {
+          return fnCache.get(key);
         }
         const promise = fn(...args);
-        requestCache.set(key, promise);
+        fnCache.set(key, promise);
         try {
           const data = await promise;
           return data;
         } catch (error) {
-          requestCache.delete(key);
+          fnCache.delete(key);
           throw error;
         }
       }

package/dist/esm/universal/cache.js

@@ -130,7 +130,7 @@ function cache(fn, options) {
     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 _len, args, _key, _storage_useContext, storage, request, requestCache, fnCache, key, promise, data, error, tagCache, key1, cached, now, age, data1;
     var _arguments = arguments;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
@@ -155,15 +155,20 @@ function cache(fn, options) {
             requestCache = /* @__PURE__ */ new Map();
             requestCacheMap.set(request, requestCache);
           }
+          fnCache = requestCache.get(fn);
+          if (!fnCache) {
+            fnCache = /* @__PURE__ */ new Map();
+            requestCache.set(fn, fnCache);
+          }
           key = generateKey(args);
-          if (requestCache.has(key)) {
+          if (fnCache.has(key)) {
             return [
               2,
-              requestCache.get(key)
+              fnCache.get(key)
             ];
           }
           promise = fn.apply(void 0, _to_consumable_array(args));
-          requestCache.set(key, promise);
+          fnCache.set(key, promise);
           _state.label = 1;
         case 1:
           _state.trys.push([
@@ -184,7 +189,7 @@ function cache(fn, options) {
           ];
         case 3:
           error = _state.sent();
-          requestCache.delete(key);
+          fnCache.delete(key);
           throw error;
         case 4:
           return [

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

@@ -112,17 +112,22 @@ function cache(fn, options) {
           requestCache = /* @__PURE__ */ new Map();
           requestCacheMap.set(request, requestCache);
         }
+        let fnCache = requestCache.get(fn);
+        if (!fnCache) {
+          fnCache = /* @__PURE__ */ new Map();
+          requestCache.set(fn, fnCache);
+        }
         const key = generateKey(args);
-        if (requestCache.has(key)) {
-          return requestCache.get(key);
+        if (fnCache.has(key)) {
+          return fnCache.get(key);
         }
         const promise = fn(...args);
-        requestCache.set(key, promise);
+        fnCache.set(key, promise);
         try {
           const data = await promise;
           return data;
         } catch (error) {
-          requestCache.delete(key);
+          fnCache.delete(key);
           throw error;
         }
       }

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

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 import type { NestedRoute } from '@modern-js/types';
 export declare const transformNestedRoutes: (routes: NestedRoute[]) => import("react-router-dom").RouteObject[];
 type DeferredDataComponentType = (props?: {

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

@@ -1,6 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Buffer } from 'buffer';
 import Fs from '@modern-js/utils/fs-extra';
 import type { Storage } from './storer/storage';
 export declare class FileReader {
@@ -11,7 +8,7 @@ export declare class FileReader {
     readFile(path: string, encoding?: 'buffer'): Promise<Buffer | null>;
     readFileFromSystem(path: string, encoding?: 'utf-8'): Promise<string | null>;
     readFileFromSystem(path: string, encoding?: 'buffer'): Promise<Buffer | null>;
-    _readFileFactory(fs: typeof Fs): (path: string, encoding?: 'utf-8' | 'buffer') => Promise<string | Buffer | null>;
+    _readFileFactory(fs: typeof Fs): (path: string, encoding?: "utf-8" | "buffer") => Promise<string | Buffer | null>;
     /**
      * Clear the fileCache entriely.
      */

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { type Readable } from 'stream';
 export declare const createReadableStreamFromReadable: (source: Readable & {
     readableHighWaterMark?: number;

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

@@ -1,24 +1,23 @@
-/// <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;
+        monitors?: Monitors;
+        headers?: IncomingHttpHeaders;
+        request?: Request;
         responseProxy?: {
             headers: Record<string, string>;
             status: number;
-        } | undefined;
+        };
     }, cb: () => O | Promise<O>) => Promise<O>;
     useContext: () => {
-        monitors?: Monitors | undefined;
-        headers?: IncomingHttpHeaders | undefined;
-        request?: Request | undefined;
+        monitors?: Monitors;
+        headers?: IncomingHttpHeaders;
+        request?: Request;
         responseProxy?: {
             headers: Record<string, string>;
             status: number;
-        } | undefined;
+        };
     };
 };
 type Storage = typeof storage;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.65.4",
+  "version": "2.66.0",
   "_comment": "Provide ESM and CJS exports, ESM is used by runtime package, for treeshaking",
   "exports": {
     "./router": {
@@ -91,8 +91,7 @@
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
-    "access": "public",
-    "provenance": true
+    "access": "public"
   },
   "typesVersions": {
     "*": {
@@ -146,8 +145,8 @@
     "lru-cache": "^10.4.3",
     "react-router-dom": "6.27.0",
     "serialize-javascript": "^6.0.0",
-    "@modern-js/types": "2.65.4",
-    "@modern-js/utils": "2.65.4"
+    "@modern-js/utils": "2.66.0",
+    "@modern-js/types": "2.66.0"
   },
   "peerDependencies": {
     "react": ">=17.0.0",
@@ -169,8 +168,8 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "typescript": "^5",
-    "@scripts/build": "2.65.4",
-    "@scripts/jest-config": "2.65.4"
+    "@scripts/build": "2.66.0",
+    "@scripts/jest-config": "2.66.0"
   },
   "sideEffects": false,
   "scripts": {