@modern-js/app-tools 2.58.1-alpha.2 → 2.58.1-alpha.4

package/dist/cjs/plugins/deploy/dependencies/index.js

@@ -40,9 +40,9 @@ var import_utils2 = require("./utils");
 var import_nft = require("@vercel/nft");
 const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = import_utils2.traceFiles, entryFilter, modifyPackageJson, copyWholePackage, cacheOptions = {
   cacheDir: ".modern-js/deploy",
-  fileCache: true,
   analysisCache: true,
-  symlinkCache: true
+  fileCache: false,
+  symlinkCache: false
 }, traceOptions }) => {
   const base = "/";
   const startTime = Date.now();

package/dist/cjs/plugins/deploy/dependencies/utils.js

@@ -174,71 +174,52 @@ function deserializeMap(serializedData) {
     return value;
   });
 }
+const loadCache = async (filePath, enabled) => {
+  if (enabled && await import_utils.fs.pathExists(filePath)) {
+    console.log("load cache:", filePath);
+    const data = (await import_utils.fs.readFile(filePath)).toString();
+    return deserializeMap(data);
+  }
+  return void 0;
+};
+const writeCache = async (filePath, cacheMap) => {
+  const newCacheMap = /* @__PURE__ */ new Map();
+  for (const [key, value] of cacheMap.entries()) {
+    if (key.includes("node_modules/")) {
+      newCacheMap.set(key, value);
+    }
+  }
+  await import_utils.fs.writeFile(filePath, await serializeMap(newCacheMap));
+  console.log(`write ${import_path.default.basename(filePath)} finish`);
+};
 const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions, traceOptions }) => {
-  const { cacheDir, fileCache: enableFileCache, analysisCache: enableAnalysisCache, symlinkCache: enableSymlinkCache } = cacheOptions;
+  const { cacheDir, fileCache, analysisCache, symlinkCache } = cacheOptions;
   const analysisCacheFile = import_path.default.join(cacheDir, "analysis-cache.json");
   const fileCacheFile = import_path.default.join(cacheDir, "file-cache.json");
   const symlinkCacheFile = import_path.default.join(cacheDir, "symlink-cache.json");
-  const cache = /* @__PURE__ */ Object.create(null);
-  if (enableAnalysisCache && await import_utils.fs.pathExists(analysisCacheFile)) {
-    const analysisCache2 = (await import_utils.fs.readFile(analysisCacheFile)).toString();
-    cache.analysisCache = deserializeMap(analysisCache2);
-  }
-  if (enableFileCache && await import_utils.fs.pathExists(fileCacheFile)) {
-    const fileCache2 = (await import_utils.fs.readFile(fileCacheFile)).toString();
-    cache.fileCache = deserializeMap(fileCache2);
-  }
-  if (enableSymlinkCache && await import_utils.fs.pathExists(symlinkCacheFile)) {
-    const symlinkCache2 = (await import_utils.fs.readFile(symlinkCacheFile)).toString();
-    cache.symlinkCache = deserializeMap(symlinkCache2);
-  }
+  const cache = {
+    analysisCache: await loadCache(analysisCacheFile, analysisCache),
+    fileCache: await loadCache(fileCacheFile, fileCache),
+    symlinkCache: await loadCache(symlinkCacheFile, symlinkCache)
+  };
   const res = await (0, import_nft.nodeFileTrace)(entryFiles, {
     base,
     processCwd: serverRootDir,
     cache,
     ...traceOptions
   });
-  const { analysisCache, fileCache, symlinkCache } = cache;
   if (analysisCache || fileCache || symlinkCache) {
     await import_utils.fs.ensureDir(cacheDir);
-    if (analysisCache) {
-      const newAnalysisCache = new Map(analysisCache);
-      for (const key of newAnalysisCache.keys()) {
-        if (!key.includes("node_modules/")) {
-          newAnalysisCache.delete(key);
-        }
-      }
-      (async () => {
-        await import_utils.fs.writeFile(analysisCacheFile, await serializeMap(newAnalysisCache));
-        console.log("write analysis cache finish");
-      })();
+    if (cache.analysisCache && analysisCache) {
+      await writeCache(analysisCacheFile, cache.analysisCache);
     }
-    if (fileCache) {
-      const newFileCache = new Map(fileCache);
-      for (const key of newFileCache.keys()) {
-        if (!key.includes("node_modules/")) {
-          newFileCache.delete(key);
-        }
-      }
-      (async () => {
-        await import_utils.fs.writeFile(fileCacheFile, await serializeMap(newFileCache));
-        console.log("write file cache finish");
-      })();
+    if (cache.fileCache && fileCache) {
+      await writeCache(fileCacheFile, cache.fileCache);
     }
-    if (symlinkCache) {
-      const newSymlinkCache = new Map(symlinkCache);
-      for (const key of newSymlinkCache.keys()) {
-        if (!key.includes("node_modules/")) {
-          newSymlinkCache.delete(key);
-        }
-      }
-      (async () => {
-        await import_utils.fs.writeFile(symlinkCacheFile, await serializeMap(newSymlinkCache));
-        console.log("write symlink cache finish");
-      })();
+    if (cache.symlinkCache && symlinkCache) {
+      await writeCache(symlinkCacheFile, cache.symlinkCache);
     }
   }
-  console.log("ffffffff", __filename);
   return res;
 };
 const resolveTracedPath = async (base, p) => import_utils.fs.realpath(import_path.default.resolve(base, p));

package/dist/esm/plugins/deploy/dependencies/index.js

@@ -19,9 +19,9 @@ var handleDependencies = function() {
         case 0:
           appDir = param.appDir, serverRootDir = param.serverRootDir, includeEntries = param.includeEntries, _param_traceFiles = param.traceFiles, traceFiles = _param_traceFiles === void 0 ? defaultTraceFiles : _param_traceFiles, entryFilter = param.entryFilter, modifyPackageJson = param.modifyPackageJson, copyWholePackage = param.copyWholePackage, _param_cacheOptions = param.cacheOptions, cacheOptions = _param_cacheOptions === void 0 ? {
             cacheDir: ".modern-js/deploy",
-            fileCache: true,
             analysisCache: true,
-            symlinkCache: true
+            fileCache: false,
+            symlinkCache: false
           } : _param_cacheOptions, traceOptions = param.traceOptions;
           base = "/";
           startTime = Date.now();

package/dist/esm/plugins/deploy/dependencies/utils.js

@@ -341,24 +341,7 @@ function serializeMap(map) {
   return _serializeMap.apply(this, arguments);
 }
 function _serializeMap() {
-  _serializeMap = // function serializeMap(map: Map<string, any>) {
-  //   return JSON.stringify(map, (key, value) => {
-  //     if (value instanceof Map) {
-  //       return {
-  //         dataType: 'Map',
-  //         value: [...value.entries()],
-  //       };
-  //     }
-  //     if (value instanceof Set) {
-  //       return {
-  //         dataType: 'Set',
-  //         value: [...value],
-  //       };
-  //     }
-  //     return value;
-  //   });
-  // }
-  _async_to_generator(function(map) {
+  _serializeMap = _async_to_generator(function(map) {
     var resolvedMap;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
@@ -449,19 +432,13 @@ function deserializeMap(serializedData) {
     return value;
   });
 }
-var traceFiles = function() {
-  var _ref = _async_to_generator(function(param) {
-    var entryFiles, serverRootDir, _param_base, base, cacheOptions, traceOptions, cacheDir, enableFileCache, enableAnalysisCache, enableSymlinkCache, analysisCacheFile, fileCacheFile, symlinkCacheFile, cache, _tmp, analysisCache, _tmp1, fileCache, _tmp2, symlinkCache, res, analysisCache1, fileCache1, symlinkCache1, newAnalysisCache, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, key, newFileCache, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, key1, newSymlinkCache, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, key2;
+var loadCache = function() {
+  var _ref = _async_to_generator(function(filePath, enabled) {
+    var _tmp, data;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
-          entryFiles = param.entryFiles, serverRootDir = param.serverRootDir, _param_base = param.base, base = _param_base === void 0 ? "/" : _param_base, cacheOptions = param.cacheOptions, traceOptions = param.traceOptions;
-          cacheDir = cacheOptions.cacheDir, enableFileCache = cacheOptions.fileCache, enableAnalysisCache = cacheOptions.analysisCache, enableSymlinkCache = cacheOptions.symlinkCache;
-          analysisCacheFile = path.join(cacheDir, "analysis-cache.json");
-          fileCacheFile = path.join(cacheDir, "file-cache.json");
-          symlinkCacheFile = path.join(cacheDir, "symlink-cache.json");
-          cache = /* @__PURE__ */ Object.create(null);
-          _tmp = enableAnalysisCache;
+          _tmp = enabled;
           if (!_tmp)
             return [
               3,
@@ -469,7 +446,7 @@ var traceFiles = function() {
             ];
           return [
             4,
-            fse.pathExists(analysisCacheFile)
+            fse.pathExists(filePath)
           ];
         case 1:
           _tmp = _state.sent();
@@ -480,71 +457,116 @@ var traceFiles = function() {
               3,
               4
             ];
+          console.log("load cache:", filePath);
           return [
             4,
-            fse.readFile(analysisCacheFile)
+            fse.readFile(filePath)
           ];
         case 3:
-          analysisCache = _state.sent().toString();
-          cache.analysisCache = deserializeMap(analysisCache);
-          _state.label = 4;
+          data = _state.sent().toString();
+          return [
+            2,
+            deserializeMap(data)
+          ];
         case 4:
-          _tmp1 = enableFileCache;
-          if (!_tmp1)
-            return [
-              3,
-              6
-            ];
+          return [
+            2,
+            void 0
+          ];
+      }
+    });
+  });
+  return function loadCache2(filePath, enabled) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var writeCache = function() {
+  var _ref = _async_to_generator(function(filePath, cacheMap) {
+    var newCacheMap, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, key, value, _, _tmp;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          newCacheMap = /* @__PURE__ */ new Map();
+          _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+          try {
+            for (_iterator = cacheMap.entries()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+              _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+              if (key.includes("node_modules/")) {
+                newCacheMap.set(key, value);
+              }
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
+            }
+          }
+          _ = fse.writeFile;
+          _tmp = [
+            filePath
+          ];
           return [
             4,
-            fse.pathExists(fileCacheFile)
+            serializeMap(newCacheMap)
           ];
-        case 5:
-          _tmp1 = _state.sent();
-          _state.label = 6;
-        case 6:
-          if (!_tmp1)
-            return [
-              3,
-              8
-            ];
+        case 1:
           return [
             4,
-            fse.readFile(fileCacheFile)
+            _.apply(fse, _tmp.concat([
+              _state.sent()
+            ]))
           ];
-        case 7:
-          fileCache = _state.sent().toString();
-          cache.fileCache = deserializeMap(fileCache);
-          _state.label = 8;
-        case 8:
-          _tmp2 = enableSymlinkCache;
-          if (!_tmp2)
-            return [
-              3,
-              10
-            ];
+        case 2:
+          _state.sent();
+          console.log("write ".concat(path.basename(filePath), " finish"));
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function writeCache2(filePath, cacheMap) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var traceFiles = function() {
+  var _ref = _async_to_generator(function(param) {
+    var entryFiles, serverRootDir, _param_base, base, cacheOptions, traceOptions, cacheDir, fileCache, analysisCache, symlinkCache, analysisCacheFile, fileCacheFile, symlinkCacheFile, cache, _tmp, res;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          entryFiles = param.entryFiles, serverRootDir = param.serverRootDir, _param_base = param.base, base = _param_base === void 0 ? "/" : _param_base, cacheOptions = param.cacheOptions, traceOptions = param.traceOptions;
+          cacheDir = cacheOptions.cacheDir, fileCache = cacheOptions.fileCache, analysisCache = cacheOptions.analysisCache, symlinkCache = cacheOptions.symlinkCache;
+          analysisCacheFile = path.join(cacheDir, "analysis-cache.json");
+          fileCacheFile = path.join(cacheDir, "file-cache.json");
+          symlinkCacheFile = path.join(cacheDir, "symlink-cache.json");
+          _tmp = {};
           return [
             4,
-            fse.pathExists(symlinkCacheFile)
+            loadCache(analysisCacheFile, analysisCache)
           ];
-        case 9:
-          _tmp2 = _state.sent();
-          _state.label = 10;
-        case 10:
-          if (!_tmp2)
-            return [
-              3,
-              12
-            ];
+        case 1:
+          _tmp.analysisCache = _state.sent();
           return [
             4,
-            fse.readFile(symlinkCacheFile)
+            loadCache(fileCacheFile, fileCache)
           ];
-        case 11:
-          symlinkCache = _state.sent().toString();
-          cache.symlinkCache = deserializeMap(symlinkCache);
-          _state.label = 12;
-        case 12:
+        case 2:
+          _tmp.fileCache = _state.sent();
+          return [
+            4,
+            loadCache(symlinkCacheFile, symlinkCache)
+          ];
+        case 3:
+          cache = (_tmp.symlinkCache = _state.sent(), _tmp);
           return [
             4,
             nodeFileTrace(entryFiles, _object_spread({
@@ -553,185 +575,58 @@ var traceFiles = function() {
               cache
             }, traceOptions))
           ];
-        case 13:
+        case 4:
           res = _state.sent();
-          analysisCache1 = cache.analysisCache, fileCache1 = cache.fileCache, symlinkCache1 = cache.symlinkCache;
-          if (!(analysisCache1 || fileCache1 || symlinkCache1))
+          if (!(analysisCache || fileCache || symlinkCache))
             return [
               3,
-              15
+              11
             ];
           return [
             4,
             fse.ensureDir(cacheDir)
           ];
-        case 14:
+        case 5:
           _state.sent();
-          if (analysisCache1) {
-            newAnalysisCache = new Map(analysisCache1);
-            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
-            try {
-              for (_iterator = newAnalysisCache.keys()[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                key = _step.value;
-                if (!key.includes("node_modules/")) {
-                  newAnalysisCache.delete(key);
-                }
-              }
-            } catch (err) {
-              _didIteratorError = true;
-              _iteratorError = err;
-            } finally {
-              try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                  _iterator.return();
-                }
-              } finally {
-                if (_didIteratorError) {
-                  throw _iteratorError;
-                }
-              }
-            }
-            _async_to_generator(function() {
-              var _, _tmp3;
-              return _ts_generator(this, function(_state2) {
-                switch (_state2.label) {
-                  case 0:
-                    _ = fse.writeFile;
-                    _tmp3 = [
-                      analysisCacheFile
-                    ];
-                    return [
-                      4,
-                      serializeMap(newAnalysisCache)
-                    ];
-                  case 1:
-                    return [
-                      4,
-                      _.apply(fse, _tmp3.concat([
-                        _state2.sent()
-                      ]))
-                    ];
-                  case 2:
-                    _state2.sent();
-                    console.log("write analysis cache finish");
-                    return [
-                      2
-                    ];
-                }
-              });
-            })();
-          }
-          if (fileCache1) {
-            newFileCache = new Map(fileCache1);
-            _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
-            try {
-              for (_iterator1 = newFileCache.keys()[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
-                key1 = _step1.value;
-                if (!key1.includes("node_modules/")) {
-                  newFileCache.delete(key1);
-                }
-              }
-            } catch (err) {
-              _didIteratorError1 = true;
-              _iteratorError1 = err;
-            } finally {
-              try {
-                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                  _iterator1.return();
-                }
-              } finally {
-                if (_didIteratorError1) {
-                  throw _iteratorError1;
-                }
-              }
-            }
-            _async_to_generator(function() {
-              var _, _tmp3;
-              return _ts_generator(this, function(_state2) {
-                switch (_state2.label) {
-                  case 0:
-                    _ = fse.writeFile;
-                    _tmp3 = [
-                      fileCacheFile
-                    ];
-                    return [
-                      4,
-                      serializeMap(newFileCache)
-                    ];
-                  case 1:
-                    return [
-                      4,
-                      _.apply(fse, _tmp3.concat([
-                        _state2.sent()
-                      ]))
-                    ];
-                  case 2:
-                    _state2.sent();
-                    console.log("write file cache finish");
-                    return [
-                      2
-                    ];
-                }
-              });
-            })();
-          }
-          if (symlinkCache1) {
-            newSymlinkCache = new Map(symlinkCache1);
-            _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = void 0;
-            try {
-              for (_iterator2 = newSymlinkCache.keys()[Symbol.iterator](); !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-                key2 = _step2.value;
-                if (!key2.includes("node_modules/")) {
-                  newSymlinkCache.delete(key2);
-                }
-              }
-            } catch (err) {
-              _didIteratorError2 = true;
-              _iteratorError2 = err;
-            } finally {
-              try {
-                if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-                  _iterator2.return();
-                }
-              } finally {
-                if (_didIteratorError2) {
-                  throw _iteratorError2;
-                }
-              }
-            }
-            _async_to_generator(function() {
-              var _, _tmp3;
-              return _ts_generator(this, function(_state2) {
-                switch (_state2.label) {
-                  case 0:
-                    _ = fse.writeFile;
-                    _tmp3 = [
-                      symlinkCacheFile
-                    ];
-                    return [
-                      4,
-                      serializeMap(newSymlinkCache)
-                    ];
-                  case 1:
-                    return [
-                      4,
-                      _.apply(fse, _tmp3.concat([
-                        _state2.sent()
-                      ]))
-                    ];
-                  case 2:
-                    _state2.sent();
-                    console.log("write symlink cache finish");
-                    return [
-                      2
-                    ];
-                }
-              });
-            })();
-          }
-          _state.label = 15;
-        case 15:
-          console.log("ffffffff", __filename);
+          if (!(cache.analysisCache && analysisCache))
+            return [
+              3,
+              7
+            ];
+          return [
+            4,
+            writeCache(analysisCacheFile, cache.analysisCache)
+          ];
+        case 6:
+          _state.sent();
+          _state.label = 7;
+        case 7:
+          if (!(cache.fileCache && fileCache))
+            return [
+              3,
+              9
+            ];
+          return [
+            4,
+            writeCache(fileCacheFile, cache.fileCache)
+          ];
+        case 8:
+          _state.sent();
+          _state.label = 9;
+        case 9:
+          if (!(cache.symlinkCache && symlinkCache))
+            return [
+              3,
+              11
+            ];
+          return [
+            4,
+            writeCache(symlinkCacheFile, cache.symlinkCache)
+          ];
+        case 10:
+          _state.sent();
+          _state.label = 11;
+        case 11:
           return [
             2,
             res

package/dist/esm-node/plugins/deploy/dependencies/index.js

@@ -6,9 +6,9 @@ import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles as defaul
 import { nodeFileTrace } from "@vercel/nft";
 const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = defaultTraceFiles, entryFilter, modifyPackageJson, copyWholePackage, cacheOptions = {
   cacheDir: ".modern-js/deploy",
-  fileCache: true,
   analysisCache: true,
-  symlinkCache: true
+  fileCache: false,
+  symlinkCache: false
 }, traceOptions }) => {
   const base = "/";
   const startTime = Date.now();

package/dist/esm-node/plugins/deploy/dependencies/utils.js

@@ -133,71 +133,52 @@ function deserializeMap(serializedData) {
     return value;
   });
 }
+const loadCache = async (filePath, enabled) => {
+  if (enabled && await fse.pathExists(filePath)) {
+    console.log("load cache:", filePath);
+    const data = (await fse.readFile(filePath)).toString();
+    return deserializeMap(data);
+  }
+  return void 0;
+};
+const writeCache = async (filePath, cacheMap) => {
+  const newCacheMap = /* @__PURE__ */ new Map();
+  for (const [key, value] of cacheMap.entries()) {
+    if (key.includes("node_modules/")) {
+      newCacheMap.set(key, value);
+    }
+  }
+  await fse.writeFile(filePath, await serializeMap(newCacheMap));
+  console.log(`write ${path.basename(filePath)} finish`);
+};
 const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions, traceOptions }) => {
-  const { cacheDir, fileCache: enableFileCache, analysisCache: enableAnalysisCache, symlinkCache: enableSymlinkCache } = cacheOptions;
+  const { cacheDir, fileCache, analysisCache, symlinkCache } = cacheOptions;
   const analysisCacheFile = path.join(cacheDir, "analysis-cache.json");
   const fileCacheFile = path.join(cacheDir, "file-cache.json");
   const symlinkCacheFile = path.join(cacheDir, "symlink-cache.json");
-  const cache = /* @__PURE__ */ Object.create(null);
-  if (enableAnalysisCache && await fse.pathExists(analysisCacheFile)) {
-    const analysisCache2 = (await fse.readFile(analysisCacheFile)).toString();
-    cache.analysisCache = deserializeMap(analysisCache2);
-  }
-  if (enableFileCache && await fse.pathExists(fileCacheFile)) {
-    const fileCache2 = (await fse.readFile(fileCacheFile)).toString();
-    cache.fileCache = deserializeMap(fileCache2);
-  }
-  if (enableSymlinkCache && await fse.pathExists(symlinkCacheFile)) {
-    const symlinkCache2 = (await fse.readFile(symlinkCacheFile)).toString();
-    cache.symlinkCache = deserializeMap(symlinkCache2);
-  }
+  const cache = {
+    analysisCache: await loadCache(analysisCacheFile, analysisCache),
+    fileCache: await loadCache(fileCacheFile, fileCache),
+    symlinkCache: await loadCache(symlinkCacheFile, symlinkCache)
+  };
   const res = await nodeFileTrace(entryFiles, {
     base,
     processCwd: serverRootDir,
     cache,
     ...traceOptions
   });
-  const { analysisCache, fileCache, symlinkCache } = cache;
   if (analysisCache || fileCache || symlinkCache) {
     await fse.ensureDir(cacheDir);
-    if (analysisCache) {
-      const newAnalysisCache = new Map(analysisCache);
-      for (const key of newAnalysisCache.keys()) {
-        if (!key.includes("node_modules/")) {
-          newAnalysisCache.delete(key);
-        }
-      }
-      (async () => {
-        await fse.writeFile(analysisCacheFile, await serializeMap(newAnalysisCache));
-        console.log("write analysis cache finish");
-      })();
+    if (cache.analysisCache && analysisCache) {
+      await writeCache(analysisCacheFile, cache.analysisCache);
     }
-    if (fileCache) {
-      const newFileCache = new Map(fileCache);
-      for (const key of newFileCache.keys()) {
-        if (!key.includes("node_modules/")) {
-          newFileCache.delete(key);
-        }
-      }
-      (async () => {
-        await fse.writeFile(fileCacheFile, await serializeMap(newFileCache));
-        console.log("write file cache finish");
-      })();
+    if (cache.fileCache && fileCache) {
+      await writeCache(fileCacheFile, cache.fileCache);
     }
-    if (symlinkCache) {
-      const newSymlinkCache = new Map(symlinkCache);
-      for (const key of newSymlinkCache.keys()) {
-        if (!key.includes("node_modules/")) {
-          newSymlinkCache.delete(key);
-        }
-      }
-      (async () => {
-        await fse.writeFile(symlinkCacheFile, await serializeMap(newSymlinkCache));
-        console.log("write symlink cache finish");
-      })();
+    if (cache.symlinkCache && symlinkCache) {
+      await writeCache(symlinkCacheFile, cache.symlinkCache);
     }
   }
-  console.log("ffffffff", __filename);
   return res;
 };
 const resolveTracedPath = async (base, p) => fse.realpath(path.resolve(base, p));

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.58.1-alpha.2",
+  "version": "2.58.1-alpha.4",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -89,19 +89,19 @@
     "mlly": "^1.6.1",
     "pkg-types": "^1.1.0",
     "std-env": "^3.7.0",
-    "@modern-js/core": "2.58.0",
     "@modern-js/node-bundle-require": "2.58.0",
+    "@modern-js/core": "2.58.0",
+    "@modern-js/plugin-lint": "2.58.0",
     "@modern-js/plugin": "2.58.0",
     "@modern-js/prod-server": "2.58.0",
     "@modern-js/plugin-i18n": "2.58.0",
-    "@modern-js/plugin-lint": "2.58.0",
-    "@modern-js/server-core": "2.58.0",
+    "@modern-js/rsbuild-plugin-esbuild": "2.58.0",
     "@modern-js/server": "2.58.0",
-    "@modern-js/server-utils": "2.58.0",
-    "@modern-js/uni-builder": "2.58.0",
+    "@modern-js/server-core": "2.58.0",
     "@modern-js/types": "2.58.0",
+    "@modern-js/server-utils": "2.58.0",
     "@modern-js/utils": "2.58.0",
-    "@modern-js/rsbuild-plugin-esbuild": "2.58.0",
+    "@modern-js/uni-builder": "2.58.0",
     "@modern-js/plugin-data-loader": "2.58.0"
   },
   "devDependencies": {