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

package/dist/cjs/builder/shared/bundlerPlugins/RouterPlugin.js

@@ -103,7 +103,11 @@ class RouterPlugin {
           routeAssets: {}
         });
         const prevManifest = JSON.parse(prevManifestStr);
+        const asyncEntryNames = [];
         for (const [name, chunkGroup] of Object.entries(namedChunkGroups)) {
+          if (name.startsWith("async-")) {
+            asyncEntryNames.push(name);
+          }
           const assets = chunkGroup.assets.map((asset) => {
             const filename = asset.name;
             return publicPath ? normalizePath(publicPath) + filename : filename;
@@ -123,6 +127,14 @@ class RouterPlugin {
             });
           }
         }
+        if (asyncEntryNames.length > 0) {
+          for (const asyncEntryName of asyncEntryNames) {
+            const syncEntryName = asyncEntryName.replace("async-", "");
+            const syncEntry = routeAssets[syncEntryName];
+            const asyncEntry = routeAssets[asyncEntryName];
+            (0, import_lodash.merge)(syncEntry, asyncEntry);
+          }
+        }
         const manifest = {
           routeAssets
         };

package/dist/cjs/commands/inspect.js

@@ -27,7 +27,7 @@ const inspect = async (api, options) => {
     throw new Error("Expect the Builder to have been initialized, But the appContext.builder received `undefined`");
   }
   return appContext.builder.inspectConfig({
-    env: options.env,
+    mode: options.env,
     verbose: options.verbose,
     outputPath: options.output,
     writeToDisk: true

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

@@ -38,27 +38,15 @@ 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, cacheOptions = {
-  cacheDir: ".modern-js/deploy",
-  analysisCache: true,
-  fileCache: false,
-  symlinkCache: false
-}, traceOptions }) => {
+const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = import_utils2.traceFiles, entryFilter, modifyPackageJson, copyWholePackage, 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([
@@ -240,8 +228,6 @@ 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,88 +139,12 @@ const findPackageParents = (pkg, version, tracedFiles) => {
   ];
   return parentPkgs.filter((parentPkg) => parentPkg);
 };
-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 === null) {
-      return void 0;
-    }
-    if (value instanceof Map) {
-      return {
-        dataType: "Map",
-        value: Array.from(value.entries())
-      };
-    }
-    if (value instanceof Set) {
-      return {
-        dataType: "Set",
-        value: Array.from(value)
-      };
-    }
-    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 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, 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 = {
-    analysisCache: await loadCache(analysisCacheFile, analysisCache),
-    fileCache: await loadCache(fileCacheFile, fileCache),
-    symlinkCache: await loadCache(symlinkCacheFile, symlinkCache)
-  };
-  const res = await (0, import_nft.nodeFileTrace)(entryFiles, {
+const traceFiles = async ({ entryFiles, serverRootDir, base = "/", traceOptions }) => {
+  return await (0, import_nft.nodeFileTrace)(entryFiles, {
     base,
     processCwd: serverRootDir,
-    cache,
     ...traceOptions
   });
-  if (analysisCache || fileCache || symlinkCache) {
-    await import_utils.fs.ensureDir(cacheDir);
-    if (cache.analysisCache && analysisCache) {
-      await writeCache(analysisCacheFile, cache.analysisCache);
-    }
-    if (cache.fileCache && fileCache) {
-      await writeCache(fileCacheFile, cache.fileCache);
-    }
-    if (cache.symlinkCache && symlinkCache) {
-      await writeCache(symlinkCacheFile, cache.symlinkCache);
-    }
-  }
-  return res;
 };
 const resolveTracedPath = async (base, p) => import_utils.fs.realpath(import_path.default.resolve(base, p));
 const isSubPath = (parentPath, childPath) => {

package/dist/esm/builder/shared/bundlerPlugins/RouterPlugin.js

@@ -4,7 +4,7 @@ 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 { createHash } from "crypto";
-import { mergeWith } from "@modern-js/utils/lodash";
+import { merge, mergeWith } from "@modern-js/utils/lodash";
 import { ROUTE_MANIFEST_FILE } from "@modern-js/utils";
 import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
 var PLUGIN_NAME = "ModernjsRoutePlugin";
@@ -86,7 +86,7 @@ var RouterPlugin = /* @__PURE__ */ function() {
         name: PLUGIN_NAME,
         stage: Compilation.PROCESS_ASSETS_STAGE_REPORT
       }, /* @__PURE__ */ _async_to_generator(function() {
-        var _loop, stats, publicPath, _stats_chunks, chunks, namedChunkGroups, routeAssets, prevManifestAsset, prevManifestStr, prevManifest, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, chunkGroup, assets, referenceCssAssets, manifest, entryNames, entryChunks, orignalEntryIds, entryChunkFiles, entryChunkFileIds, i;
+        var _loop, stats, publicPath, _stats_chunks, chunks, namedChunkGroups, routeAssets, prevManifestAsset, prevManifestStr, prevManifest, asyncEntryNames, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, chunkGroup, assets, referenceCssAssets, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, asyncEntryName, syncEntryName, syncEntry, asyncEntry, manifest, entryNames, entryChunks, orignalEntryIds, entryChunkFiles, entryChunkFileIds, i;
         return _ts_generator(this, function(_state) {
           _loop = function(i2) {
             var entryName = entryNames[i2];
@@ -200,10 +200,14 @@ var RouterPlugin = /* @__PURE__ */ function() {
             routeAssets: {}
           });
           prevManifest = JSON.parse(prevManifestStr);
+          asyncEntryNames = [];
           _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
           try {
             for (_iterator = Object.entries(namedChunkGroups)[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
               _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], chunkGroup = _step_value[1];
+              if (name.startsWith("async-")) {
+                asyncEntryNames.push(name);
+              }
               assets = chunkGroup.assets.map(function(asset) {
                 var filename = asset.name;
                 return publicPath ? normalizePath(publicPath) + filename : filename;
@@ -239,6 +243,31 @@ var RouterPlugin = /* @__PURE__ */ function() {
               }
             }
           }
+          if (asyncEntryNames.length > 0) {
+            _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+            try {
+              for (_iterator1 = asyncEntryNames[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+                asyncEntryName = _step1.value;
+                syncEntryName = asyncEntryName.replace("async-", "");
+                syncEntry = routeAssets[syncEntryName];
+                asyncEntry = routeAssets[asyncEntryName];
+                merge(syncEntry, asyncEntry);
+              }
+            } catch (err) {
+              _didIteratorError1 = true;
+              _iteratorError1 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                  _iterator1.return();
+                }
+              } finally {
+                if (_didIteratorError1) {
+                  throw _iteratorError1;
+                }
+              }
+            }
+          }
           manifest = {
             routeAssets
           };

package/dist/esm/commands/inspect.js

@@ -11,7 +11,7 @@ var inspect = function() {
       return [
         2,
         appContext.builder.inspectConfig({
-          env: options.env,
+          mode: options.env,
           verbose: options.verbose,
           outputPath: options.output,
           writeToDisk: true

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

@@ -1,6 +1,4 @@
 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";
@@ -13,40 +11,29 @@ 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, _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;
+    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;
     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, _param_cacheOptions = param.cacheOptions, cacheOptions = _param_cacheOptions === void 0 ? {
-            cacheDir: ".modern-js/deploy",
-            analysisCache: true,
-            fileCache: false,
-            symlinkCache: false
-          } : _param_cacheOptions, 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, 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;
@@ -611,8 +598,6 @@ 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,7 +1,5 @@
 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";
@@ -337,299 +335,24 @@ var findPackageParents = function(pkg, version, tracedFiles) {
     return parentPkg;
   });
 };
-function serializeMap(map) {
-  return _serializeMap.apply(this, arguments);
-}
-function _serializeMap() {
-  _serializeMap = _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 (value === null) {
-                return void 0;
-              }
-              if (_instanceof(value, Map)) {
-                return {
-                  dataType: "Map",
-                  value: Array.from(value.entries())
-                };
-              }
-              if (_instanceof(value, Set)) {
-                return {
-                  dataType: "Set",
-                  value: Array.from(value)
-                };
-              }
-              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 loadCache = function() {
-  var _ref = _async_to_generator(function(filePath, enabled) {
-    var _tmp, data;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          _tmp = enabled;
-          if (!_tmp)
-            return [
-              3,
-              2
-            ];
-          return [
-            4,
-            fse.pathExists(filePath)
-          ];
-        case 1:
-          _tmp = _state.sent();
-          _state.label = 2;
-        case 2:
-          if (!_tmp)
-            return [
-              3,
-              4
-            ];
-          console.log("load cache:", filePath);
-          return [
-            4,
-            fse.readFile(filePath)
-          ];
-        case 3:
-          data = _state.sent().toString();
-          return [
-            2,
-            deserializeMap(data)
-          ];
-        case 4:
-          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,
-            serializeMap(newCacheMap)
-          ];
-        case 1:
-          return [
-            4,
-            _.apply(fse, _tmp.concat([
-              _state.sent()
-            ]))
-          ];
-        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;
+    var entryFiles, serverRootDir, _param_base, base, traceOptions;
     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,
-            loadCache(analysisCacheFile, analysisCache)
-          ];
-        case 1:
-          _tmp.analysisCache = _state.sent();
-          return [
-            4,
-            loadCache(fileCacheFile, fileCache)
-          ];
-        case 2:
-          _tmp.fileCache = _state.sent();
-          return [
-            4,
-            loadCache(symlinkCacheFile, symlinkCache)
-          ];
-        case 3:
-          cache = (_tmp.symlinkCache = _state.sent(), _tmp);
+          entryFiles = param.entryFiles, serverRootDir = param.serverRootDir, _param_base = param.base, base = _param_base === void 0 ? "/" : _param_base, traceOptions = param.traceOptions;
           return [
             4,
             nodeFileTrace(entryFiles, _object_spread({
               base,
-              processCwd: serverRootDir,
-              cache
+              processCwd: serverRootDir
             }, traceOptions))
           ];
-        case 4:
-          res = _state.sent();
-          if (!(analysisCache || fileCache || symlinkCache))
-            return [
-              3,
-              11
-            ];
-          return [
-            4,
-            fse.ensureDir(cacheDir)
-          ];
-        case 5:
-          _state.sent();
-          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:
+        case 1:
           return [
             2,
-            res
+            _state.sent()
           ];
       }
     });

package/dist/esm-node/builder/shared/bundlerPlugins/RouterPlugin.js

@@ -1,5 +1,5 @@
 import { createHash } from "crypto";
-import { mergeWith } from "@modern-js/utils/lodash";
+import { merge, mergeWith } from "@modern-js/utils/lodash";
 import { ROUTE_MANIFEST_FILE } from "@modern-js/utils";
 import { ROUTE_MANIFEST } from "@modern-js/utils/universal/constants";
 const PLUGIN_NAME = "ModernjsRoutePlugin";
@@ -80,7 +80,11 @@ class RouterPlugin {
           routeAssets: {}
         });
         const prevManifest = JSON.parse(prevManifestStr);
+        const asyncEntryNames = [];
         for (const [name, chunkGroup] of Object.entries(namedChunkGroups)) {
+          if (name.startsWith("async-")) {
+            asyncEntryNames.push(name);
+          }
           const assets = chunkGroup.assets.map((asset) => {
             const filename = asset.name;
             return publicPath ? normalizePath(publicPath) + filename : filename;
@@ -100,6 +104,14 @@ class RouterPlugin {
             });
           }
         }
+        if (asyncEntryNames.length > 0) {
+          for (const asyncEntryName of asyncEntryNames) {
+            const syncEntryName = asyncEntryName.replace("async-", "");
+            const syncEntry = routeAssets[syncEntryName];
+            const asyncEntry = routeAssets[asyncEntryName];
+            merge(syncEntry, asyncEntry);
+          }
+        }
         const manifest = {
           routeAssets
         };

package/dist/esm-node/commands/inspect.js

@@ -4,7 +4,7 @@ const inspect = async (api, options) => {
     throw new Error("Expect the Builder to have been initialized, But the appContext.builder received `undefined`");
   }
   return appContext.builder.inspectConfig({
-    env: options.env,
+    mode: options.env,
     verbose: options.verbose,
     outputPath: options.output,
     writeToDisk: true

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

@@ -4,27 +4,15 @@ 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, cacheOptions = {
-  cacheDir: ".modern-js/deploy",
-  analysisCache: true,
-  fileCache: false,
-  symlinkCache: false
-}, traceOptions }) => {
+const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = defaultTraceFiles, entryFilter, modifyPackageJson, copyWholePackage, 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([
@@ -206,8 +194,6 @@ 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,88 +98,12 @@ const findPackageParents = (pkg, version, tracedFiles) => {
   ];
   return parentPkgs.filter((parentPkg) => parentPkg);
 };
-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 === null) {
-      return void 0;
-    }
-    if (value instanceof Map) {
-      return {
-        dataType: "Map",
-        value: Array.from(value.entries())
-      };
-    }
-    if (value instanceof Set) {
-      return {
-        dataType: "Set",
-        value: Array.from(value)
-      };
-    }
-    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 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, 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 = {
-    analysisCache: await loadCache(analysisCacheFile, analysisCache),
-    fileCache: await loadCache(fileCacheFile, fileCache),
-    symlinkCache: await loadCache(symlinkCacheFile, symlinkCache)
-  };
-  const res = await nodeFileTrace(entryFiles, {
+const traceFiles = async ({ entryFiles, serverRootDir, base = "/", traceOptions }) => {
+  return await nodeFileTrace(entryFiles, {
     base,
     processCwd: serverRootDir,
-    cache,
     ...traceOptions
   });
-  if (analysisCache || fileCache || symlinkCache) {
-    await fse.ensureDir(cacheDir);
-    if (cache.analysisCache && analysisCache) {
-      await writeCache(analysisCacheFile, cache.analysisCache);
-    }
-    if (cache.fileCache && fileCache) {
-      await writeCache(fileCacheFile, cache.fileCache);
-    }
-    if (cache.symlinkCache && symlinkCache) {
-      await writeCache(symlinkCacheFile, cache.symlinkCache);
-    }
-  }
-  return res;
 };
 const resolveTracedPath = async (base, p) => fse.realpath(path.resolve(base, p));
 const isSubPath = (parentPath, childPath) => {

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

@@ -1,22 +1,20 @@
 import type { PackageJson } from 'pkg-types';
 import type { NodeFileTraceOptions } from '@vercel/nft';
-import { traceFiles as defaultTraceFiles, CacheOptions } from './utils';
+import { traceFiles as defaultTraceFiles } from './utils';
 export type { NodeFileTraceOptions } from '@vercel/nft';
 export { nodeFileTrace } from '@vercel/nft';
-export declare const handleDependencies: ({ appDir, serverRootDir, includeEntries, traceFiles, entryFilter, modifyPackageJson, copyWholePackage, cacheOptions, traceOptions, }: {
+export declare const handleDependencies: ({ appDir, serverRootDir, includeEntries, traceFiles, entryFilter, modifyPackageJson, copyWholePackage, traceOptions, }: {
     appDir: string;
     serverRootDir: string;
     includeEntries: string[];
-    traceFiles?: (({ entryFiles, serverRootDir, base, cacheOptions, traceOptions, }: {
+    traceFiles?: (({ entryFiles, serverRootDir, base, 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,17 +33,10 @@ 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 interface CacheOptions {
-    fileCache: boolean;
-    analysisCache: boolean;
-    symlinkCache: boolean;
-    cacheDir: string;
-}
-export declare const traceFiles: ({ entryFiles, serverRootDir, base, cacheOptions, traceOptions, }: {
+export declare const traceFiles: ({ entryFiles, serverRootDir, base, 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/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.58.1-alpha.4",
+  "version": "2.58.1",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -77,10 +77,9 @@
     "@babel/parser": "^7.22.15",
     "@babel/traverse": "^7.23.2",
     "@babel/types": "^7.24.7",
-    "@rsbuild/core": "1.0.1-beta.10",
+    "@rsbuild/core": "1.0.1-beta.13",
     "@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",
@@ -89,23 +88,23 @@
     "mlly": "^1.6.1",
     "pkg-types": "^1.1.0",
     "std-env": "^3.7.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/rsbuild-plugin-esbuild": "2.58.0",
-    "@modern-js/server": "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/uni-builder": "2.58.0",
-    "@modern-js/plugin-data-loader": "2.58.0"
+    "@modern-js/core": "2.58.1",
+    "@modern-js/node-bundle-require": "2.58.1",
+    "@modern-js/plugin": "2.58.1",
+    "@modern-js/plugin-data-loader": "2.58.1",
+    "@modern-js/plugin-i18n": "2.58.1",
+    "@modern-js/prod-server": "2.58.1",
+    "@modern-js/plugin-lint": "2.58.1",
+    "@modern-js/server": "2.58.1",
+    "@modern-js/rsbuild-plugin-esbuild": "2.58.1",
+    "@modern-js/server-utils": "2.58.1",
+    "@modern-js/server-core": "2.58.1",
+    "@modern-js/types": "2.58.1",
+    "@modern-js/uni-builder": "2.58.1",
+    "@modern-js/utils": "2.58.1"
   },
   "devDependencies": {
-    "@rsbuild/plugin-swc": "1.0.1-beta.10",
+    "@rsbuild/plugin-swc": "1.0.1-beta.13",
     "@types/babel__traverse": "7.18.5",
     "@types/jest": "^29",
     "@types/node": "^14",
@@ -114,8 +113,8 @@
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5",
     "webpack": "^5.93.0",
-    "@scripts/build": "2.58.0",
-    "@scripts/jest-config": "2.58.0"
+    "@scripts/build": "2.58.1",
+    "@scripts/jest-config": "2.58.1"
   },
   "sideEffects": false,
   "publishConfig": {