@modern-js/app-tools 2.58.0 → 2.58.1-alpha.1

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

@@ -38,15 +38,26 @@ var import_pkg_types = require("pkg-types");
 var import_mlly = require("mlly");
 var import_utils2 = require("./utils");
 var import_nft = require("@vercel/nft");
-const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = import_utils2.traceFiles, entryFilter, modifyPackageJson, copyWholePackage, traceOptions }) => {
+const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = import_utils2.traceFiles, entryFilter, modifyPackageJson, copyWholePackage, cacheOptions = {
+  cacheDir: ".modern-js/deploy",
+  fileCache: true,
+  analysisCache: true
+}, traceOptions }) => {
   const base = "/";
+  const startTime = Date.now();
   const entryFiles = await (0, import_utils2.findEntryFiles)(serverRootDir, entryFilter);
+  console.time("traceFiles");
   const fileTrace = await traceFiles({
     entryFiles: entryFiles.concat(includeEntries),
     serverRootDir,
+    cacheOptions: {
+      ...cacheOptions,
+      cacheDir: import_node_path.default.resolve(appDir, cacheOptions.cacheDir)
+    },
     base,
     traceOptions
   });
+  console.timeEnd("traceFiles");
   const currentProjectModules = import_node_path.default.join(appDir, "node_modules");
   const dependencySearchRoot = import_node_path.default.resolve(appDir, "../../../../../../");
   const tracedFiles = Object.fromEntries(await Promise.all([
@@ -228,6 +239,8 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
   };
   const finalPkgJson = (modifyPackageJson === null || modifyPackageJson === void 0 ? void 0 : modifyPackageJson(newPkgJson)) || newPkgJson;
   await import_utils.fs.writeJSON(outputPkgPath, finalPkgJson);
+  const endTime = Date.now();
+  console.log("handleDependencies cost:", `${endTime - startTime}ms`);
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

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

@@ -139,12 +139,108 @@ const findPackageParents = (pkg, version, tracedFiles) => {
   ];
   return parentPkgs.filter((parentPkg) => parentPkg);
 };
-const traceFiles = async ({ entryFiles, serverRootDir, base = "/", traceOptions }) => {
-  return await (0, import_nft.nodeFileTrace)(entryFiles, {
+async function serializeMap(map) {
+  const resolvedMap = /* @__PURE__ */ new Map();
+  await Promise.all(Array.from(map.entries()).map(async ([key, value]) => {
+    resolvedMap.set(key, value instanceof Promise ? await Promise.resolve(value) : value);
+  }));
+  return JSON.stringify(resolvedMap, (key, value) => {
+    if (value instanceof Map) {
+      return {
+        dataType: "Map",
+        value: Array.from(value.entries())
+      };
+    }
+    if (value instanceof Set) {
+      return {
+        dataType: "Set",
+        value: Array.from(value)
+      };
+    }
+    if (value === null) {
+      return void 0;
+    }
+    return value;
+  });
+}
+function deserializeMap(serializedData) {
+  return JSON.parse(serializedData, (key, value) => {
+    if (value && value.dataType === "Map") {
+      return new Map(value.value);
+    }
+    if (value && value.dataType === "Set") {
+      return new Set(value.value);
+    }
+    return value;
+  });
+}
+const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions, traceOptions }) => {
+  const { cacheDir, fileCache: enableFileCache, analysisCache: enableAnalysisCache } = cacheOptions;
+  const analysisCacheFile = import_path.default.join(cacheDir, "analysis-cache.json");
+  const fileCacheFile = import_path.default.join(cacheDir, "file-cache.json");
+  const statCacheFile = import_path.default.join(cacheDir, "stat-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 (await import_utils.fs.pathExists(symlinkCacheFile)) {
+    const symlinkCache2 = (await import_utils.fs.readFile(symlinkCacheFile)).toString();
+    cache.symlinkCache = deserializeMap(symlinkCache2);
+  }
+  const res = await (0, import_nft.nodeFileTrace)(entryFiles, {
     base,
     processCwd: serverRootDir,
+    cache,
     ...traceOptions
   });
+  const { analysisCache, fileCache, statCache, symlinkCache } = cache;
+  if (analysisCache || fileCache || statCache || 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 (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 (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");
+      })();
+    }
+  }
+  console.log("ffffffff", __filename);
+  return res;
 };
 const resolveTracedPath = async (base, p) => import_utils.fs.realpath(import_path.default.resolve(base, p));
 const isSubPath = (parentPath, childPath) => {

package/dist/cjs/utils/config.js

@@ -30,13 +30,13 @@ var config_exports = {};
 __export(config_exports, {
   buildServerConfig: () => buildServerConfig,
   defineServerConfig: () => defineServerConfig,
-  emitResolvedConfig: () => emitResolvedConfig,
-  safeReplacer: () => safeReplacer
+  emitResolvedConfig: () => emitResolvedConfig
 });
 module.exports = __toCommonJS(config_exports);
 var path = __toESM(require("path"));
 var import_node_bundle_require = require("@modern-js/node-bundle-require");
 var import_utils = require("@modern-js/utils");
+var import_flatted = require("flatted");
 const defineServerConfig = (config) => config;
 const buildServerConfig = async ({ appDirectory, distDirectory, configFile, options, watch }) => {
   const configFilePath = await (0, import_utils.getServerConfig)(appDirectory, configFile);
@@ -69,33 +69,17 @@ const buildServerConfig = async ({ appDirectory, distDirectory, configFile, opti
     });
   }
 };
-const safeReplacer = () => {
-  const cache = [];
-  const keyCache = [];
-  return function(key, value) {
-    if (typeof value === "object" && value !== null) {
-      const index = cache.indexOf(value);
-      if (index !== -1) {
-        return `[Circular ${keyCache[index]}]`;
-      }
-      cache.push(value);
-      keyCache.push(key || "root");
-    }
-    return value;
-  };
-};
 const emitResolvedConfig = async (appDirectory, resolvedConfig) => {
   var _resolvedConfig_output_distPath;
   const outputPath = (0, import_utils.ensureAbsolutePath)(appDirectory, path.join(((_resolvedConfig_output_distPath = resolvedConfig.output.distPath) === null || _resolvedConfig_output_distPath === void 0 ? void 0 : _resolvedConfig_output_distPath.root) || "./dist", import_utils.OUTPUT_CONFIG_FILE));
-  await import_utils.fs.writeJSON(outputPath, resolvedConfig, {
-    spaces: 2,
-    replacer: safeReplacer()
+  const output = (0, import_flatted.stringify)(resolvedConfig);
+  await import_utils.fs.writeFile(outputPath, output, {
+    encoding: "utf-8"
   });
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildServerConfig,
   defineServerConfig,
-  emitResolvedConfig,
-  safeReplacer
+  emitResolvedConfig
 });

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

@@ -1,4 +1,6 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
 import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
@@ -11,29 +13,39 @@ import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles as defaul
 import { nodeFileTrace } from "@vercel/nft";
 var handleDependencies = function() {
   var _ref = _async_to_generator(function(param) {
-    var appDir, serverRootDir, includeEntries, _param_traceFiles, traceFiles, entryFilter, modifyPackageJson, copyWholePackage, traceOptions, base, entryFiles, fileTrace, currentProjectModules, dependencySearchRoot, tracedFiles, _, tracedPackages, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, tracedFile, pkgName, tracedPackage, pkgJSON, tracedPackageVersion, shouldCopyWholePackage, _tracedPackageVersion_files, allFiles, err, multiVersionPkgs, singleVersionPackages, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, tracedPackage1, versions, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, version, projectPkgJson, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _loop, _iterator3, _step3, err, outputPkgPath, newPkgJson, finalPkgJson;
+    var appDir, serverRootDir, includeEntries, _param_traceFiles, traceFiles, entryFilter, modifyPackageJson, copyWholePackage, _param_cacheOptions, cacheOptions, traceOptions, base, startTime, entryFiles, fileTrace, currentProjectModules, dependencySearchRoot, tracedFiles, _, tracedPackages, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, tracedFile, pkgName, tracedPackage, pkgJSON, tracedPackageVersion, shouldCopyWholePackage, _tracedPackageVersion_files, allFiles, err, multiVersionPkgs, singleVersionPackages, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, tracedPackage1, versions, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, version, projectPkgJson, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _loop, _iterator3, _step3, err, outputPkgPath, newPkgJson, finalPkgJson, endTime;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         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, traceOptions = param.traceOptions;
+          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
+          } : _param_cacheOptions, traceOptions = param.traceOptions;
           base = "/";
+          startTime = Date.now();
           return [
             4,
             findEntryFiles(serverRootDir, entryFilter)
           ];
         case 1:
           entryFiles = _state.sent();
+          console.time("traceFiles");
           return [
             4,
             traceFiles({
               entryFiles: entryFiles.concat(includeEntries),
               serverRootDir,
+              cacheOptions: _object_spread_props(_object_spread({}, cacheOptions), {
+                cacheDir: path.resolve(appDir, cacheOptions.cacheDir)
+              }),
               base,
               traceOptions
             })
           ];
         case 2:
           fileTrace = _state.sent();
+          console.timeEnd("traceFiles");
           currentProjectModules = path.join(appDir, "node_modules");
           dependencySearchRoot = path.resolve(appDir, "../../../../../../");
           _ = Object.fromEntries;
@@ -598,6 +610,8 @@ var handleDependencies = function() {
           ];
         case 24:
           _state.sent();
+          endTime = Date.now();
+          console.log("handleDependencies cost:", "".concat(endTime - startTime, "ms"));
           return [
             2
           ];

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

@@ -1,5 +1,7 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
 import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
@@ -335,24 +337,396 @@ var findPackageParents = function(pkg, version, tracedFiles) {
     return parentPkg;
   });
 };
+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) {
+    var resolvedMap;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          resolvedMap = /* @__PURE__ */ new Map();
+          return [
+            4,
+            Promise.all(Array.from(map.entries()).map(function() {
+              var _ref = _async_to_generator(function(param) {
+                var _param, key, value, _, _tmp, _tmp1;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+                      _ = resolvedMap.set;
+                      _tmp = [
+                        key
+                      ];
+                      if (!_instanceof(value, Promise))
+                        return [
+                          3,
+                          2
+                        ];
+                      return [
+                        4,
+                        Promise.resolve(value)
+                      ];
+                    case 1:
+                      _tmp1 = _state2.sent();
+                      return [
+                        3,
+                        3
+                      ];
+                    case 2:
+                      _tmp1 = value;
+                      _state2.label = 3;
+                    case 3:
+                      _.apply(resolvedMap, _tmp.concat([
+                        _tmp1
+                      ]));
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(_) {
+                return _ref.apply(this, arguments);
+              };
+            }()))
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2,
+            JSON.stringify(resolvedMap, function(key, value) {
+              if (_instanceof(value, Map)) {
+                return {
+                  dataType: "Map",
+                  value: Array.from(value.entries())
+                };
+              }
+              if (_instanceof(value, Set)) {
+                return {
+                  dataType: "Set",
+                  value: Array.from(value)
+                };
+              }
+              if (value === null) {
+                return void 0;
+              }
+              return value;
+            })
+          ];
+      }
+    });
+  });
+  return _serializeMap.apply(this, arguments);
+}
+function deserializeMap(serializedData) {
+  return JSON.parse(serializedData, function(key, value) {
+    if (value && value.dataType === "Map") {
+      return new Map(value.value);
+    }
+    if (value && value.dataType === "Set") {
+      return new Set(value.value);
+    }
+    return value;
+  });
+}
 var traceFiles = function() {
   var _ref = _async_to_generator(function(param) {
-    var entryFiles, serverRootDir, _param_base, base, traceOptions;
+    var entryFiles, serverRootDir, _param_base, base, cacheOptions, traceOptions, cacheDir, enableFileCache, enableAnalysisCache, analysisCacheFile, fileCacheFile, statCacheFile, symlinkCacheFile, cache, _tmp, analysisCache, _tmp1, fileCache, symlinkCache, res, analysisCache1, fileCache1, statCache, symlinkCache1, newAnalysisCache, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, key, newFileCache, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, key1, newSymlinkCache, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, key2;
     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, traceOptions = param.traceOptions;
+          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;
+          analysisCacheFile = path.join(cacheDir, "analysis-cache.json");
+          fileCacheFile = path.join(cacheDir, "file-cache.json");
+          statCacheFile = path.join(cacheDir, "stat-cache.json");
+          symlinkCacheFile = path.join(cacheDir, "symlink-cache.json");
+          cache = /* @__PURE__ */ Object.create(null);
+          _tmp = enableAnalysisCache;
+          if (!_tmp)
+            return [
+              3,
+              2
+            ];
+          return [
+            4,
+            fse.pathExists(analysisCacheFile)
+          ];
+        case 1:
+          _tmp = _state.sent();
+          _state.label = 2;
+        case 2:
+          if (!_tmp)
+            return [
+              3,
+              4
+            ];
+          return [
+            4,
+            fse.readFile(analysisCacheFile)
+          ];
+        case 3:
+          analysisCache = _state.sent().toString();
+          cache.analysisCache = deserializeMap(analysisCache);
+          _state.label = 4;
+        case 4:
+          _tmp1 = enableFileCache;
+          if (!_tmp1)
+            return [
+              3,
+              6
+            ];
+          return [
+            4,
+            fse.pathExists(fileCacheFile)
+          ];
+        case 5:
+          _tmp1 = _state.sent();
+          _state.label = 6;
+        case 6:
+          if (!_tmp1)
+            return [
+              3,
+              8
+            ];
+          return [
+            4,
+            fse.readFile(fileCacheFile)
+          ];
+        case 7:
+          fileCache = _state.sent().toString();
+          cache.fileCache = deserializeMap(fileCache);
+          _state.label = 8;
+        case 8:
+          return [
+            4,
+            fse.pathExists(symlinkCacheFile)
+          ];
+        case 9:
+          if (!_state.sent())
+            return [
+              3,
+              11
+            ];
+          return [
+            4,
+            fse.readFile(symlinkCacheFile)
+          ];
+        case 10:
+          symlinkCache = _state.sent().toString();
+          cache.symlinkCache = deserializeMap(symlinkCache);
+          _state.label = 11;
+        case 11:
           return [
             4,
             nodeFileTrace(entryFiles, _object_spread({
               base,
-              processCwd: serverRootDir
+              processCwd: serverRootDir,
+              cache
             }, traceOptions))
           ];
-        case 1:
+        case 12:
+          res = _state.sent();
+          analysisCache1 = cache.analysisCache, fileCache1 = cache.fileCache, statCache = cache.statCache, symlinkCache1 = cache.symlinkCache;
+          if (!(analysisCache1 || fileCache1 || statCache || symlinkCache1))
+            return [
+              3,
+              14
+            ];
+          return [
+            4,
+            fse.ensureDir(cacheDir)
+          ];
+        case 13:
+          _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 _, _tmp2;
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    _ = fse.writeFile;
+                    _tmp2 = [
+                      analysisCacheFile
+                    ];
+                    return [
+                      4,
+                      serializeMap(newAnalysisCache)
+                    ];
+                  case 1:
+                    return [
+                      4,
+                      _.apply(fse, _tmp2.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 _, _tmp2;
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    _ = fse.writeFile;
+                    _tmp2 = [
+                      fileCacheFile
+                    ];
+                    return [
+                      4,
+                      serializeMap(newFileCache)
+                    ];
+                  case 1:
+                    return [
+                      4,
+                      _.apply(fse, _tmp2.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 _, _tmp2;
+              return _ts_generator(this, function(_state2) {
+                switch (_state2.label) {
+                  case 0:
+                    _ = fse.writeFile;
+                    _tmp2 = [
+                      symlinkCacheFile
+                    ];
+                    return [
+                      4,
+                      serializeMap(newSymlinkCache)
+                    ];
+                  case 1:
+                    return [
+                      4,
+                      _.apply(fse, _tmp2.concat([
+                        _state2.sent()
+                      ]))
+                    ];
+                  case 2:
+                    _state2.sent();
+                    console.log("write symlink cache finish");
+                    return [
+                      2
+                    ];
+                }
+              });
+            })();
+          }
+          _state.label = 14;
+        case 14:
+          console.log("ffffffff", __filename);
           return [
             2,
-            _state.sent()
+            res
           ];
       }
     });

package/dist/esm/utils/config.js

@@ -5,6 +5,7 @@ import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import * as path from "path";
 import { bundle } from "@modern-js/node-bundle-require";
 import { fs, getServerConfig, ensureAbsolutePath, OUTPUT_CONFIG_FILE, CONFIG_FILE_EXTENSIONS } from "@modern-js/utils";
+import { stringify } from "flatted";
 var defineServerConfig = function(config) {
   return config;
 };
@@ -88,33 +89,18 @@ var buildServerConfig = function() {
     return _ref.apply(this, arguments);
   };
 }();
-var safeReplacer = function() {
-  var cache = [];
-  var keyCache = [];
-  return function safeReplacer2(key, value) {
-    if (typeof value === "object" && value !== null) {
-      var index = cache.indexOf(value);
-      if (index !== -1) {
-        return "[Circular ".concat(keyCache[index], "]");
-      }
-      cache.push(value);
-      keyCache.push(key || "root");
-    }
-    return value;
-  };
-};
 var emitResolvedConfig = function() {
   var _ref = _async_to_generator(function(appDirectory, resolvedConfig) {
-    var _resolvedConfig_output_distPath, outputPath;
+    var _resolvedConfig_output_distPath, outputPath, output;
     return _ts_generator(this, function(_state) {
       switch (_state.label) {
         case 0:
           outputPath = ensureAbsolutePath(appDirectory, path.join(((_resolvedConfig_output_distPath = resolvedConfig.output.distPath) === null || _resolvedConfig_output_distPath === void 0 ? void 0 : _resolvedConfig_output_distPath.root) || "./dist", OUTPUT_CONFIG_FILE));
+          output = stringify(resolvedConfig);
           return [
             4,
-            fs.writeJSON(outputPath, resolvedConfig, {
-              spaces: 2,
-              replacer: safeReplacer()
+            fs.writeFile(outputPath, output, {
+              encoding: "utf-8"
             })
           ];
         case 1:
@@ -132,6 +118,5 @@ var emitResolvedConfig = function() {
 export {
   buildServerConfig,
   defineServerConfig,
-  emitResolvedConfig,
-  safeReplacer
+  emitResolvedConfig
 };

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

@@ -4,15 +4,26 @@ import { readPackageJSON } from "pkg-types";
 import { parseNodeModulePath } from "mlly";
 import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles as defaultTraceFiles, findPackageParents, resolveTracedPath, readDirRecursive, isSubPath } from "./utils";
 import { nodeFileTrace } from "@vercel/nft";
-const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = defaultTraceFiles, entryFilter, modifyPackageJson, copyWholePackage, traceOptions }) => {
+const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = defaultTraceFiles, entryFilter, modifyPackageJson, copyWholePackage, cacheOptions = {
+  cacheDir: ".modern-js/deploy",
+  fileCache: true,
+  analysisCache: true
+}, traceOptions }) => {
   const base = "/";
+  const startTime = Date.now();
   const entryFiles = await findEntryFiles(serverRootDir, entryFilter);
+  console.time("traceFiles");
   const fileTrace = await traceFiles({
     entryFiles: entryFiles.concat(includeEntries),
     serverRootDir,
+    cacheOptions: {
+      ...cacheOptions,
+      cacheDir: path.resolve(appDir, cacheOptions.cacheDir)
+    },
     base,
     traceOptions
   });
+  console.timeEnd("traceFiles");
   const currentProjectModules = path.join(appDir, "node_modules");
   const dependencySearchRoot = path.resolve(appDir, "../../../../../../");
   const tracedFiles = Object.fromEntries(await Promise.all([
@@ -194,6 +205,8 @@ const handleDependencies = async ({ appDir, serverRootDir, includeEntries, trace
   };
   const finalPkgJson = (modifyPackageJson === null || modifyPackageJson === void 0 ? void 0 : modifyPackageJson(newPkgJson)) || newPkgJson;
   await fse.writeJSON(outputPkgPath, finalPkgJson);
+  const endTime = Date.now();
+  console.log("handleDependencies cost:", `${endTime - startTime}ms`);
 };
 export {
   handleDependencies,

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

@@ -98,12 +98,108 @@ const findPackageParents = (pkg, version, tracedFiles) => {
   ];
   return parentPkgs.filter((parentPkg) => parentPkg);
 };
-const traceFiles = async ({ entryFiles, serverRootDir, base = "/", traceOptions }) => {
-  return await nodeFileTrace(entryFiles, {
+async function serializeMap(map) {
+  const resolvedMap = /* @__PURE__ */ new Map();
+  await Promise.all(Array.from(map.entries()).map(async ([key, value]) => {
+    resolvedMap.set(key, value instanceof Promise ? await Promise.resolve(value) : value);
+  }));
+  return JSON.stringify(resolvedMap, (key, value) => {
+    if (value instanceof Map) {
+      return {
+        dataType: "Map",
+        value: Array.from(value.entries())
+      };
+    }
+    if (value instanceof Set) {
+      return {
+        dataType: "Set",
+        value: Array.from(value)
+      };
+    }
+    if (value === null) {
+      return void 0;
+    }
+    return value;
+  });
+}
+function deserializeMap(serializedData) {
+  return JSON.parse(serializedData, (key, value) => {
+    if (value && value.dataType === "Map") {
+      return new Map(value.value);
+    }
+    if (value && value.dataType === "Set") {
+      return new Set(value.value);
+    }
+    return value;
+  });
+}
+const traceFiles = async ({ entryFiles, serverRootDir, base = "/", cacheOptions, traceOptions }) => {
+  const { cacheDir, fileCache: enableFileCache, analysisCache: enableAnalysisCache } = cacheOptions;
+  const analysisCacheFile = path.join(cacheDir, "analysis-cache.json");
+  const fileCacheFile = path.join(cacheDir, "file-cache.json");
+  const statCacheFile = path.join(cacheDir, "stat-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 (await fse.pathExists(symlinkCacheFile)) {
+    const symlinkCache2 = (await fse.readFile(symlinkCacheFile)).toString();
+    cache.symlinkCache = deserializeMap(symlinkCache2);
+  }
+  const res = await nodeFileTrace(entryFiles, {
     base,
     processCwd: serverRootDir,
+    cache,
     ...traceOptions
   });
+  const { analysisCache, fileCache, statCache, symlinkCache } = cache;
+  if (analysisCache || fileCache || statCache || 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 (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 (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");
+      })();
+    }
+  }
+  console.log("ffffffff", __filename);
+  return res;
 };
 const resolveTracedPath = async (base, p) => fse.realpath(path.resolve(base, p));
 const isSubPath = (parentPath, childPath) => {

package/dist/esm-node/utils/config.js

@@ -1,6 +1,7 @@
 import * as path from "path";
 import { bundle } from "@modern-js/node-bundle-require";
 import { fs, getServerConfig, ensureAbsolutePath, OUTPUT_CONFIG_FILE, CONFIG_FILE_EXTENSIONS } from "@modern-js/utils";
+import { stringify } from "flatted";
 const defineServerConfig = (config) => config;
 const buildServerConfig = async ({ appDirectory, distDirectory, configFile, options, watch }) => {
   const configFilePath = await getServerConfig(appDirectory, configFile);
@@ -33,32 +34,16 @@ const buildServerConfig = async ({ appDirectory, distDirectory, configFile, opti
     });
   }
 };
-const safeReplacer = () => {
-  const cache = [];
-  const keyCache = [];
-  return function(key, value) {
-    if (typeof value === "object" && value !== null) {
-      const index = cache.indexOf(value);
-      if (index !== -1) {
-        return `[Circular ${keyCache[index]}]`;
-      }
-      cache.push(value);
-      keyCache.push(key || "root");
-    }
-    return value;
-  };
-};
 const emitResolvedConfig = async (appDirectory, resolvedConfig) => {
   var _resolvedConfig_output_distPath;
   const outputPath = ensureAbsolutePath(appDirectory, path.join(((_resolvedConfig_output_distPath = resolvedConfig.output.distPath) === null || _resolvedConfig_output_distPath === void 0 ? void 0 : _resolvedConfig_output_distPath.root) || "./dist", OUTPUT_CONFIG_FILE));
-  await fs.writeJSON(outputPath, resolvedConfig, {
-    spaces: 2,
-    replacer: safeReplacer()
+  const output = stringify(resolvedConfig);
+  await fs.writeFile(outputPath, output, {
+    encoding: "utf-8"
   });
 };
 export {
   buildServerConfig,
   defineServerConfig,
-  emitResolvedConfig,
-  safeReplacer
+  emitResolvedConfig
 };

package/dist/types/plugins/deploy/dependencies/index.d.ts

@@ -1,20 +1,22 @@
 import type { PackageJson } from 'pkg-types';
 import type { NodeFileTraceOptions } from '@vercel/nft';
-import { traceFiles as defaultTraceFiles } from './utils';
+import { traceFiles as defaultTraceFiles, CacheOptions } from './utils';
 export type { NodeFileTraceOptions } from '@vercel/nft';
 export { nodeFileTrace } from '@vercel/nft';
-export declare const handleDependencies: ({ appDir, serverRootDir, includeEntries, traceFiles, entryFilter, modifyPackageJson, copyWholePackage, traceOptions, }: {
+export declare const handleDependencies: ({ appDir, serverRootDir, includeEntries, traceFiles, entryFilter, modifyPackageJson, copyWholePackage, cacheOptions, traceOptions, }: {
     appDir: string;
     serverRootDir: string;
     includeEntries: string[];
-    traceFiles?: (({ entryFiles, serverRootDir, base, traceOptions, }: {
+    traceFiles?: (({ entryFiles, serverRootDir, base, cacheOptions, traceOptions, }: {
         entryFiles: string[];
         serverRootDir: string;
         base?: string | undefined;
+        cacheOptions: CacheOptions;
         traceOptions?: NodeFileTraceOptions | undefined;
     }) => Promise<import("@vercel/nft").NodeFileTraceResult>) | undefined;
     entryFilter?: ((filePath: string) => boolean) | undefined;
     modifyPackageJson?: ((pkgJson: PackageJson) => PackageJson) | undefined;
     copyWholePackage?: ((pkgName: string) => boolean) | undefined;
+    cacheOptions?: CacheOptions | undefined;
     traceOptions?: NodeFileTraceOptions | undefined;
 }) => Promise<void>;

package/dist/types/plugins/deploy/dependencies/utils.d.ts

@@ -33,10 +33,16 @@ export declare const readDirRecursive: (dir: string, options?: ReadDirOptions) =
 export declare const isFile: (file: string) => Promise<boolean>;
 export declare const findEntryFiles: (rootDir: string, entryFilter?: ((filePath: string) => boolean) | undefined) => Promise<string[]>;
 export declare const findPackageParents: (pkg: TracedPackage, version: string, tracedFiles: Record<string, TracedFile>) => string[];
-export declare const traceFiles: ({ entryFiles, serverRootDir, base, traceOptions, }: {
+export interface CacheOptions {
+    fileCache: boolean;
+    analysisCache: boolean;
+    cacheDir: string;
+}
+export declare const traceFiles: ({ entryFiles, serverRootDir, base, cacheOptions, traceOptions, }: {
     entryFiles: string[];
     serverRootDir: string;
     base?: string | undefined;
+    cacheOptions: CacheOptions;
     traceOptions?: NodeFileTraceOptions | undefined;
 }) => Promise<import("@vercel/nft").NodeFileTraceResult>;
 export declare const resolveTracedPath: (base: string, p: string) => Promise<string>;

package/dist/types/utils/config.d.ts

@@ -9,9 +9,4 @@ export declare const buildServerConfig: ({ appDirectory, distDirectory, configFi
     options?: Parameters<typeof bundle>[1];
     watch?: boolean | undefined;
 }) => Promise<void>;
-/**
- *
- * 处理循环引用的 replacer
- */
-export declare const safeReplacer: () => (key: string, value: unknown) => unknown;
 export declare const emitResolvedConfig: (appDirectory: string, resolvedConfig: AppNormalizedConfig<'shared'>) => Promise<void>;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.58.0",
+  "version": "2.58.1-alpha.1",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -77,33 +77,35 @@
     "@babel/parser": "^7.22.15",
     "@babel/traverse": "^7.23.2",
     "@babel/types": "^7.24.7",
-    "@rsbuild/plugin-node-polyfill": "1.0.3",
-    "@rsbuild/core": "1.0.1-beta.9",
+    "@rsbuild/core": "1.0.1-beta.10",
+    "@rsbuild/plugin-node-polyfill": "1.0.4",
     "@swc/helpers": "0.5.3",
+    "@ungap/structured-clone": "^1.2.0",
     "@vercel/nft": "^0.26.4",
     "es-module-lexer": "^1.1.0",
     "esbuild": "0.17.19",
     "esbuild-register": "^3.5.0",
+    "flatted": "^3.2.9",
     "mlly": "^1.6.1",
     "pkg-types": "^1.1.0",
     "std-env": "^3.7.0",
-    "@modern-js/core": "2.58.0",
-    "@modern-js/plugin-data-loader": "2.58.0",
     "@modern-js/node-bundle-require": "2.58.0",
-    "@modern-js/plugin-lint": "2.58.0",
-    "@modern-js/rsbuild-plugin-esbuild": "2.58.0",
     "@modern-js/plugin": "2.58.0",
+    "@modern-js/core": "2.58.0",
     "@modern-js/plugin-i18n": "2.58.0",
-    "@modern-js/prod-server": "2.58.0",
     "@modern-js/server": "2.58.0",
-    "@modern-js/server-utils": "2.58.0",
+    "@modern-js/prod-server": "2.58.0",
+    "@modern-js/server-core": "2.58.0",
+    "@modern-js/plugin-lint": "2.58.0",
     "@modern-js/types": "2.58.0",
+    "@modern-js/utils": "2.58.0",
     "@modern-js/uni-builder": "2.58.0",
-    "@modern-js/server-core": "2.58.0",
-    "@modern-js/utils": "2.58.0"
+    "@modern-js/rsbuild-plugin-esbuild": "2.58.0",
+    "@modern-js/plugin-data-loader": "2.58.0",
+    "@modern-js/server-utils": "2.58.0"
   },
   "devDependencies": {
-    "@rsbuild/plugin-swc": "1.0.1-beta.9",
+    "@rsbuild/plugin-swc": "1.0.1-beta.10",
     "@types/babel__traverse": "7.18.5",
     "@types/jest": "^29",
     "@types/node": "^14",
@@ -112,8 +114,8 @@
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5",
     "webpack": "^5.93.0",
-    "@scripts/jest-config": "2.58.0",
-    "@scripts/build": "2.58.0"
+    "@scripts/build": "2.58.0",
+    "@scripts/jest-config": "2.58.0"
   },
   "sideEffects": false,
   "publishConfig": {