@modern-js/app-tools 2.21.1 → 2.22.1

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

@@ -5,7 +5,8 @@ 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";
-import { fs, ROUTE_MANIFEST_FILE } from "@modern-js/utils";
+import { 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";
 export var RouterPlugin = /* @__PURE__ */ function() {
@@ -41,130 +42,137 @@ export var RouterPlugin = /* @__PURE__ */ function() {
             name: PLUGIN_NAME,
             stage: PROCESS_ASSETS_STAGE_REPORT
           }, /* @__PURE__ */ _async_to_generator(function() {
-            var stats, publicPath, _stats_chunks, chunks, namedChunkGroups, routeAssets, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, chunkGroup, assets, referenceCssAssets, manifest, injectedContent, entrypointsArray, entryChunkIds, entryChunks, entryChunkFiles, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, file, asset, newContent, filename;
+            var stats, publicPath, _stats_chunks, chunks, namedChunkGroups, routeAssets, prevManifestAsset, prevManifestStr, prevManifest, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, chunkGroup, assets, referenceCssAssets, manifest, injectedContent, entrypointsArray, entryChunkIds, entryChunks, entryChunkFiles, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, file, asset, newContent;
             return _ts_generator(this, function(_state) {
-              switch (_state.label) {
-                case 0:
-                  stats = compilation.getStats().toJson({
-                    all: false,
-                    publicPath: true,
-                    assets: true,
-                    chunkGroups: true,
-                    chunks: true,
-                    ids: true
-                  });
-                  publicPath = stats.publicPath, _stats_chunks = stats.chunks, chunks = _stats_chunks === void 0 ? [] : _stats_chunks, namedChunkGroups = stats.namedChunkGroups;
-                  routeAssets = {};
-                  if (!namedChunkGroups) {
-                    return [
-                      2
-                    ];
-                  }
-                  _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];
-                      assets = chunkGroup.assets.map(function(asset2) {
-                        var filename2 = asset2.name;
-                        return publicPath ? normalizePath(publicPath) + filename2 : filename2;
-                      });
-                      referenceCssAssets = assets.filter(function(asset2) {
-                        return /\.css$/.test(asset2);
-                      });
-                      routeAssets[name] = {
-                        chunkIds: chunkGroup.chunks,
-                        assets: assets,
-                        referenceCssAssets: referenceCssAssets
-                      };
-                    }
-                  } catch (err) {
-                    _didIteratorError = true;
-                    _iteratorError = err;
-                  } finally {
-                    try {
-                      if (!_iteratorNormalCompletion && _iterator.return != null) {
-                        _iterator.return();
-                      }
-                    } finally {
-                      if (_didIteratorError) {
-                        throw _iteratorError;
-                      }
-                    }
-                  }
-                  manifest = {
-                    routeAssets: routeAssets
-                  };
-                  injectedContent = "\n            ;(function(){\n              window.".concat(ROUTE_MANIFEST, " = ").concat(JSON.stringify(manifest, function(k, v) {
-                    if ((k === "assets" || k === "referenceCssAssets") && Array.isArray(v)) {
-                      return v.map(function(item) {
-                        return item.replace(publicPath, "");
-                      });
-                    }
-                    return v;
-                  }), ";\n            })();\n          ");
-                  entrypointsArray = Array.from(compilation.entrypoints.entries());
-                  entryChunkIds = entrypointsArray.map(function(entrypoint) {
-                    return entrypoint[0];
+              stats = compilation.getStats().toJson({
+                all: false,
+                publicPath: true,
+                assets: true,
+                chunkGroups: true,
+                chunks: true,
+                ids: true
+              });
+              publicPath = stats.publicPath, _stats_chunks = stats.chunks, chunks = _stats_chunks === void 0 ? [] : _stats_chunks, namedChunkGroups = stats.namedChunkGroups;
+              routeAssets = {};
+              if (!namedChunkGroups) {
+                return [
+                  2
+                ];
+              }
+              prevManifestAsset = compilation.getAsset(ROUTE_MANIFEST_FILE);
+              prevManifestStr = prevManifestAsset ? prevManifestAsset.source.source().toString() : JSON.stringify({
+                routeAssets: {}
+              });
+              prevManifest = JSON.parse(prevManifestStr);
+              _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];
+                  assets = chunkGroup.assets.map(function(asset2) {
+                    var filename = asset2.name;
+                    return publicPath ? normalizePath(publicPath) + filename : filename;
                   });
-                  entryChunks = _to_consumable_array(chunks).filter(function(chunk) {
-                    var _chunk_names;
-                    return (_chunk_names = chunk.names) === null || _chunk_names === void 0 ? void 0 : _chunk_names.some(function(name2) {
-                      return entryChunkIds.includes(name2);
-                    });
+                  referenceCssAssets = assets.filter(function(asset2) {
+                    return /\.css$/.test(asset2);
                   });
-                  entryChunkFiles = entryChunks.map(function(chunk) {
-                    return _to_consumable_array(chunk.files || []).find(function(fname) {
-                      return fname.includes(".js");
+                  routeAssets[name] = {
+                    chunkIds: chunkGroup.chunks,
+                    assets: assets,
+                    referenceCssAssets: referenceCssAssets
+                  };
+                  if (prevManifest.routeAssets[name]) {
+                    mergeWith(routeAssets[name], prevManifest.routeAssets[name], function(obj, source) {
+                      if (Array.isArray(obj)) {
+                        return obj.concat(source);
+                      }
+                      return Object.assign(source, obj);
                     });
+                  }
+                }
+              } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                  }
+                } finally {
+                  if (_didIteratorError) {
+                    throw _iteratorError;
+                  }
+                }
+              }
+              manifest = {
+                routeAssets: routeAssets
+              };
+              injectedContent = "\n            ;(function(){\n              window.".concat(ROUTE_MANIFEST, " = ").concat(JSON.stringify(manifest, function(k, v) {
+                if ((k === "assets" || k === "referenceCssAssets") && Array.isArray(v)) {
+                  return v.map(function(item) {
+                    return item.replace(publicPath, "");
                   });
-                  _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
-                  try {
-                    for (_iterator1 = entryChunkFiles[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
-                      file = _step1.value;
-                      asset = compilation.assets[file];
-                      if (!asset) {
-                        continue;
-                      }
-                      newContent = "".concat(injectedContent).concat(asset.source().toString());
-                      newAssetsMap.set(path.join(outputPath, file), newContent);
-                      compilation.updateAsset(
-                        file,
-                        new RawSource(newContent),
-                        // FIXME: The arguments third of updatgeAsset is a optional function in webpack.
-                        void 0
-                      );
-                    }
-                  } catch (err) {
-                    _didIteratorError1 = true;
-                    _iteratorError1 = err;
-                  } finally {
-                    try {
-                      if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                        _iterator1.return();
-                      }
-                    } finally {
-                      if (_didIteratorError1) {
-                        throw _iteratorError1;
-                      }
-                    }
+                }
+                return v;
+              }), ";\n            })();\n          ");
+              entrypointsArray = Array.from(compilation.entrypoints.entries());
+              entryChunkIds = entrypointsArray.map(function(entrypoint) {
+                return entrypoint[0];
+              });
+              entryChunks = _to_consumable_array(chunks).filter(function(chunk) {
+                var _chunk_names;
+                return (_chunk_names = chunk.names) === null || _chunk_names === void 0 ? void 0 : _chunk_names.some(function(name2) {
+                  return entryChunkIds.includes(name2);
+                });
+              });
+              entryChunkFiles = entryChunks.map(function(chunk) {
+                return _to_consumable_array(chunk.files || []).find(function(fname) {
+                  return fname.includes(".js");
+                });
+              });
+              _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = void 0;
+              try {
+                for (_iterator1 = entryChunkFiles[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true) {
+                  file = _step1.value;
+                  asset = compilation.assets[file];
+                  if (!asset) {
+                    continue;
+                  }
+                  newContent = "".concat(injectedContent).concat(asset.source().toString());
+                  newAssetsMap.set(path.join(outputPath, file), newContent);
+                  compilation.updateAsset(
+                    file,
+                    new RawSource(newContent),
+                    // FIXME: The arguments third of updatgeAsset is a optional function in webpack.
+                    void 0
+                  );
+                }
+              } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+              } finally {
+                try {
+                  if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
                   }
-                  filename = path.join(outputPath, ROUTE_MANIFEST_FILE);
-                  return [
-                    4,
-                    fs.ensureFile(filename)
-                  ];
-                case 1:
-                  _state.sent();
-                  return [
-                    4,
-                    fs.writeFile(filename, JSON.stringify(manifest, null, 2))
-                  ];
-                case 2:
-                  _state.sent();
-                  return [
-                    2
-                  ];
+                } finally {
+                  if (_didIteratorError1) {
+                    throw _iteratorError1;
+                  }
+                }
+              }
+              if (prevManifestAsset) {
+                compilation.updateAsset(
+                  ROUTE_MANIFEST_FILE,
+                  new RawSource(JSON.stringify(manifest, null, 2)),
+                  // FIXME: The arguments third of updatgeAsset is a optional function in webpack.
+                  void 0
+                );
+              } else {
+                compilation.emitAsset(ROUTE_MANIFEST_FILE, new RawSource(JSON.stringify(manifest, null, 2)));
               }
+              return [
+                2
+              ];
             });
           }));
         });

package/dist/esm-node/analyze/generateCode.js

@@ -53,11 +53,14 @@ export const generateCode = async (appContext, config, entrypoints, api) => {
   const { internalDirectory, srcDirectory, internalDirAlias, internalSrcAlias, packageName } = appContext;
   const hookRunners = api.useHookRunners();
   const isV5 = isRouterV5(config);
-  const { mountId } = config.html;
   const getRoutes = isV5 ? getClientRoutesLegacy : getClientRoutes;
+  const importsStatemets = /* @__PURE__ */ new Map();
   await Promise.all(entrypoints.map(generateEntryCode));
+  return {
+    importsStatemets
+  };
   async function generateEntryCode(entrypoint) {
-    const { entryName, isAutoMount, customBootstrap, fileSystemRoutes } = entrypoint;
+    const { entryName, isAutoMount, fileSystemRoutes } = entrypoint;
     if (isAutoMount) {
       if (fileSystemRoutes) {
         var _config_output;
@@ -99,7 +102,7 @@ export const generateCode = async (appContext, config, entrypoints, api) => {
             process.exit(1);
           }
         }
-        const { code: code2 } = await hookRunners.beforeGenerateRoutes({
+        const { code } = await hookRunners.beforeGenerateRoutes({
           entrypoint,
           code: await templates.fileSystemRoutes({
             routes,
@@ -112,20 +115,20 @@ export const generateCode = async (appContext, config, entrypoints, api) => {
         });
         if (entrypoint.nestedRoutesEntry && isUseSSRBundle(config2)) {
           const routesServerFile = getServerLoadersFile(internalDirectory, entryName);
-          const code3 = templates.routesForServer({
+          const code2 = templates.routesForServer({
             routes
           });
           await fs.ensureFile(routesServerFile);
-          await fs.writeFile(routesServerFile, code3);
+          await fs.writeFile(routesServerFile, code2);
         }
         const serverLoaderCombined = templates.ssrLoaderCombinedModule(entrypoints, entrypoint, config2, appContext);
         if (serverLoaderCombined) {
           const serverLoaderFile = getServerCombinedModueFile(internalDirectory, entryName);
           await fs.outputFile(serverLoaderFile, serverLoaderCombined);
         }
-        fs.outputFileSync(path.resolve(internalDirectory, `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`), code2, "utf8");
+        fs.outputFileSync(path.resolve(internalDirectory, `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`), code, "utf8");
       }
-      const { imports: importStatements } = await hookRunners.modifyEntryImports({
+      const { imports } = await hookRunners.modifyEntryImports({
         entrypoint,
         imports: getDefaultImports({
           entrypoint,
@@ -135,9 +138,23 @@ export const generateCode = async (appContext, config, entrypoints, api) => {
           internalDirectory
         })
       });
+      importsStatemets.set(entryName, imports);
+      const entryFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_FILE_NAME}`);
+      entrypoint.internalEntry = entryFile;
+    }
+  }
+};
+export const generateIndexCode = async ({ appContext, api, entrypoints, config, importsStatemets, bundlerConfigs }) => {
+  const hookRunners = api.useHookRunners();
+  const { mountId } = config.html;
+  const { internalDirectory, packageName } = appContext;
+  await Promise.all(entrypoints.map(async (entrypoint) => {
+    const { entryName, isAutoMount, customBootstrap, fileSystemRoutes } = entrypoint;
+    if (isAutoMount) {
       const { plugins } = await hookRunners.modifyEntryRuntimePlugins({
         entrypoint,
-        plugins: []
+        plugins: [],
+        bundlerConfigs
       });
       const { code: renderFunction } = await hookRunners.modifyEntryRenderFunction({
         entrypoint,
@@ -151,31 +168,31 @@ export const generateCode = async (appContext, config, entrypoints, api) => {
         entrypoint,
         exportStatement: "export default AppWrapper;"
       });
+      const imports = importsStatemets.get(entryName);
       const code = templates.index({
         mountId,
-        imports: createImportStatements(importStatements),
+        imports: createImportStatements(imports),
         renderFunction,
         exportStatement
       });
       const entryFile = path.resolve(internalDirectory, `./${entryName}/${ENTRY_POINT_FILE_NAME}`);
-      entrypoint.entry = entryFile;
       if (config.source.enableAsyncEntry) {
         let rawAsyncEntryCode = `import('./${ENTRY_BOOTSTRAP_FILE_NAME}');`;
         const ssr = getEntryOptions(entryName, config.server.ssr, config.server.ssrByEntries, packageName);
         if (ssr) {
           rawAsyncEntryCode = `
-          export const ${SERVER_RENDER_FUNCTION_NAME} = async (...args) => {
-            let entry = await ${rawAsyncEntryCode};
-            if (entry.default instanceof Promise){
-              entry = await entry.default;
-              return entry.default.${SERVER_RENDER_FUNCTION_NAME}.apply(null, args);
-            }
-            return entry.${SERVER_RENDER_FUNCTION_NAME}.apply(null, args);
-          };
-          if(typeof window!=='undefined'){
-            ${rawAsyncEntryCode}
+        export const ${SERVER_RENDER_FUNCTION_NAME} = async (...args) => {
+          let entry = await ${rawAsyncEntryCode};
+          if (entry.default instanceof Promise){
+            entry = await entry.default;
+            return entry.default.${SERVER_RENDER_FUNCTION_NAME}.apply(null, args);
           }
-          `;
+          return entry.${SERVER_RENDER_FUNCTION_NAME}.apply(null, args);
+        };
+        if(typeof window!=='undefined'){
+          ${rawAsyncEntryCode}
+        }
+        `;
         }
         const { code: asyncEntryCode } = await hookRunners.modifyAsyncEntry({
           entrypoint,
@@ -188,5 +205,5 @@ export const generateCode = async (appContext, config, entrypoints, api) => {
         fs.outputFileSync(entryFile, code, "utf8");
       }
     }
-  }
+  }));
 };

package/dist/esm-node/analyze/index.js

@@ -1,5 +1,5 @@
 import * as path from "path";
-import { createDebugger, findExists, fs, isApiOnly, minimist, getCommand, isDevCommand, getArgv } from "@modern-js/utils";
+import { createDebugger, findExists, fs, isApiOnly, minimist, isDevCommand, getArgv } from "@modern-js/utils";
 import { cloneDeep } from "@modern-js/utils/lodash";
 import { printInstructions } from "../utils/printInstructions";
 import { generateRoutes } from "../utils/routes";
@@ -7,8 +7,9 @@ import { emitResolvedConfig } from "../utils/config";
 import { getSelectedEntries } from "../utils/getSelectedEntries";
 import { initialNormalizedConfig } from "../config";
 import { createBuilderGenerator } from "../builder";
-import { isPageComponentFile, parseModule, replaceWithAlias } from "./utils";
+import { checkIsBuildCommands, isPageComponentFile, parseModule, replaceWithAlias } from "./utils";
 import { APP_CONFIG_NAME, APP_INIT_EXPORTED, APP_INIT_IMPORTED } from "./constants";
+import { generateIndexCode } from "./generateCode";
 const debug = createDebugger("plugin-analyze");
 export default ({ bundler }) => {
   return {
@@ -24,7 +25,9 @@ export default ({ bundler }) => {
           const resolvedConfig = api.useResolvedConfigContext();
           const hookRunners = api.useHookRunners();
           try {
-            fs.emptydirSync(appContext.internalDirectory);
+            if (checkIsBuildCommands()) {
+              fs.emptydirSync(appContext.internalDirectory);
+            }
           } catch {
           }
           const apiOnly = await isApiOnly(appContext.appDirectory, (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.entriesDir);
@@ -67,7 +70,7 @@ export default ({ bundler }) => {
           nestedRouteEntries = entrypoints.map((point) => point.nestedRoutesEntry).filter(Boolean);
           pagesDir = entrypoints.map((point) => point.entry).filter((entry) => entry && !path.extname(entry)).concat(nestedRouteEntries);
           originEntrypoints = cloneDeep(entrypoints);
-          await generateCode(appContext, resolvedConfig, entrypoints, api);
+          const { importsStatemets } = await generateCode(appContext, resolvedConfig, entrypoints, api);
           const htmlTemplates = await getHtmlTemplate(entrypoints, api, {
             appContext,
             config: resolvedConfig
@@ -89,15 +92,7 @@ export default ({ bundler }) => {
             htmlTemplates
           };
           api.setAppContext(appContext);
-          const command = getCommand();
-          const buildCommands = [
-            "dev",
-            "start",
-            "build",
-            "inspect",
-            "deploy"
-          ];
-          if (buildCommands.includes(command)) {
+          if (checkIsBuildCommands()) {
             const normalizedConfig = api.useResolvedConfigContext();
             const createBuilderForModern = await createBuilderGenerator(bundler);
             const builder = await createBuilderForModern({
@@ -130,6 +125,14 @@ export default ({ bundler }) => {
               },
               async onBeforeCreateCompiler({ bundlerConfigs }) {
                 const hookRunners2 = api.useHookRunners();
+                await generateIndexCode({
+                  appContext,
+                  config: resolvedConfig,
+                  entrypoints,
+                  api,
+                  importsStatemets,
+                  bundlerConfigs
+                });
                 await hookRunners2.beforeCreateCompiler({
                   bundlerConfigs
                 });

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

@@ -1,6 +1,6 @@
 import fs from "fs";
 import path from "path";
-import { isReact18, normalizeToPosixPath, fs as fse } from "@modern-js/utils";
+import { isReact18, normalizeToPosixPath, fs as fse, getCommand } from "@modern-js/utils";
 import { transform } from "esbuild";
 import { parse } from "es-module-lexer";
 import { FILE_SYSTEM_ROUTES_FILE_NAME, JS_EXTENSIONS, LOADER_EXPORT_NAME } from "./constants";
@@ -137,3 +137,14 @@ export const getServerLoadersFile = (internalDirectory, entryName) => {
 export const getServerCombinedModueFile = (internalDirectory, entryName) => {
   return path.join(internalDirectory, entryName, "server-loader-combined.js");
 };
+export const checkIsBuildCommands = () => {
+  const buildCommands = [
+    "dev",
+    "start",
+    "build",
+    "inspect",
+    "deploy"
+  ];
+  const command = getCommand();
+  return buildCommands.includes(command);
+};

package/dist/esm-node/builder/generator/createBuilderOptions.js

@@ -1,15 +1,16 @@
 export function createBuilderOptions(target, appContext) {
   const entries = {};
   const { entrypoints = [], checkedEntries } = appContext;
-  for (const { entryName, entry } of entrypoints) {
+  for (const { entryName, internalEntry, entry } of entrypoints) {
     if (checkedEntries && !checkedEntries.includes(entryName)) {
       continue;
     }
+    const finalEntry = internalEntry || entry;
     if (entryName in entries) {
-      entries[entryName].push(entry);
+      entries[entryName].push(finalEntry);
     } else {
       entries[entryName] = [
-        entry
+        finalEntry
       ];
     }
   }

package/dist/esm-node/builder/generator/createBuilderProviderConfig.js

@@ -4,8 +4,8 @@ export function createBuilderProviderConfig(resolveConfig, appContext, modifyBui
   };
   if (!htmlConfig.template) {
     htmlConfig.templateByEntries = {
-      ...htmlConfig.templateByEntries,
-      ...appContext.htmlTemplates
+      ...appContext.htmlTemplates,
+      ...htmlConfig.templateByEntries
     };
   }
   const config = {

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

@@ -1,5 +1,6 @@
 import path from "path";
-import { fs, ROUTE_MANIFEST_FILE } from "@modern-js/utils";
+import { 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";
 export class RouterPlugin {
@@ -41,10 +42,15 @@ export class RouterPlugin {
         if (!namedChunkGroups) {
           return;
         }
+        const prevManifestAsset = compilation.getAsset(ROUTE_MANIFEST_FILE);
+        const prevManifestStr = prevManifestAsset ? prevManifestAsset.source.source().toString() : JSON.stringify({
+          routeAssets: {}
+        });
+        const prevManifest = JSON.parse(prevManifestStr);
         for (const [name, chunkGroup] of Object.entries(namedChunkGroups)) {
           const assets = chunkGroup.assets.map((asset) => {
-            const filename2 = asset.name;
-            return publicPath ? normalizePath(publicPath) + filename2 : filename2;
+            const filename = asset.name;
+            return publicPath ? normalizePath(publicPath) + filename : filename;
           });
           const referenceCssAssets = assets.filter((asset) => /\.css$/.test(asset));
           routeAssets[name] = {
@@ -52,6 +58,14 @@ export class RouterPlugin {
             assets,
             referenceCssAssets
           };
+          if (prevManifest.routeAssets[name]) {
+            mergeWith(routeAssets[name], prevManifest.routeAssets[name], (obj, source) => {
+              if (Array.isArray(obj)) {
+                return obj.concat(source);
+              }
+              return Object.assign(source, obj);
+            });
+          }
         }
         const manifest = {
           routeAssets
@@ -93,9 +107,16 @@ export class RouterPlugin {
             void 0
           );
         }
-        const filename = path.join(outputPath, ROUTE_MANIFEST_FILE);
-        await fs.ensureFile(filename);
-        await fs.writeFile(filename, JSON.stringify(manifest, null, 2));
+        if (prevManifestAsset) {
+          compilation.updateAsset(
+            ROUTE_MANIFEST_FILE,
+            new RawSource(JSON.stringify(manifest, null, 2)),
+            // FIXME: The arguments third of updatgeAsset is a optional function in webpack.
+            void 0
+          );
+        } else {
+          compilation.emitAsset(ROUTE_MANIFEST_FILE, new RawSource(JSON.stringify(manifest, null, 2)));
+        }
       });
     });
   }

package/dist/types/analyze/generateCode.d.ts

@@ -1,5 +1,22 @@
 import { IAppContext, PluginAPI } from '@modern-js/core';
 import type { Entrypoint } from '@modern-js/types';
-import { AppNormalizedConfig, AppTools, ImportStatement } from '../types';
+import { AppNormalizedConfig, AppTools, ImportStatement, Rspack, webpack } from '../types';
 export declare const createImportStatements: (statements: ImportStatement[]) => string;
-export declare const generateCode: (appContext: IAppContext, config: AppNormalizedConfig<'shared'>, entrypoints: Entrypoint[], api: PluginAPI<AppTools<'shared'>>) => Promise<void>;
+export declare const generateCode: (appContext: IAppContext, config: AppNormalizedConfig<'shared'>, entrypoints: Entrypoint[], api: PluginAPI<AppTools<'shared'>>) => Promise<{
+  importsStatemets: Map<string, ImportStatement[]>;
+}>;
+export declare const generateIndexCode: ({
+  appContext,
+  api,
+  entrypoints,
+  config,
+  importsStatemets,
+  bundlerConfigs
+}: {
+  appContext: IAppContext;
+  api: PluginAPI<AppTools<'shared'>>;
+  entrypoints: Entrypoint[];
+  config: AppNormalizedConfig<'shared'>;
+  importsStatemets: Map<string, ImportStatement[]>;
+  bundlerConfigs?: webpack.Configuration[] | Rspack.RspackOptions[] | undefined;
+}) => Promise<void>;

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

@@ -25,4 +25,5 @@ export declare const parseModule: ({
 }) => Promise<readonly [imports: readonly import("es-module-lexer").ImportSpecifier[], exports: readonly import("es-module-lexer").ExportSpecifier[], facade: boolean]>;
 export declare const hasLoader: (filename: string) => Promise<boolean>;
 export declare const getServerLoadersFile: (internalDirectory: string, entryName: string) => string;
-export declare const getServerCombinedModueFile: (internalDirectory: string, entryName: string) => string;
+export declare const getServerCombinedModueFile: (internalDirectory: string, entryName: string) => string;
+export declare const checkIsBuildCommands: () => boolean;

package/dist/types/builder/shared/bundlerPlugins/RouterPlugin.d.ts

@@ -1,5 +1,12 @@
 import type { webpack } from '@modern-js/builder-webpack-provider';
 import type { Rspack } from '@modern-js/builder-rspack-provider';
+export interface RouteAssets {
+  [routeId: string]: {
+    chunkIds?: (string | number)[];
+    assets?: string[];
+    referenceCssAssets?: string[];
+  };
+}
 export declare class RouterPlugin {
   apply(compiler: Rspack.Compiler | webpack.Compiler): void;
 }

package/dist/types/types/hooks.d.ts

@@ -31,6 +31,7 @@ export type AppToolsHooks<B extends Bundler = 'webpack'> = {
   modifyEntryRuntimePlugins: AsyncWaterfall<{
     entrypoint: Entrypoint;
     plugins: RuntimePlugin[];
+    bundlerConfigs?: B extends 'rspack' ? Rspack.Configuration[] : webpack.Configuration[];
   }>;
   modifyEntryRenderFunction: AsyncWaterfall<{
     entrypoint: Entrypoint;