@modern-js/app-tools 2.21.1 → 2.22.0

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

@@ -9,6 +9,7 @@ import { initialNormalizedConfig } from "../config";
 import { createBuilderGenerator } from "../builder";
 import { 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 {
@@ -67,7 +68,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
@@ -130,6 +131,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/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/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;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.21.1",
+  "version": "2.22.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -73,23 +73,23 @@
     "esbuild": "0.15.7",
     "rspack-plugin-virtual-module": "0.1.0",
     "@swc/helpers": "0.5.1",
-    "@modern-js/builder": "2.21.1",
-    "@modern-js/builder-plugin-esbuild": "2.21.1",
-    "@modern-js/builder-plugin-node-polyfill": "2.21.1",
-    "@modern-js/builder-shared": "2.21.1",
-    "@modern-js/builder-webpack-provider": "2.21.1",
-    "@modern-js/core": "2.21.1",
-    "@modern-js/new-action": "2.21.1",
-    "@modern-js/node-bundle-require": "2.21.1",
-    "@modern-js/plugin": "2.21.1",
-    "@modern-js/plugin-data-loader": "2.21.1",
-    "@modern-js/plugin-i18n": "2.21.1",
-    "@modern-js/plugin-lint": "2.21.1",
-    "@modern-js/prod-server": "2.21.1",
-    "@modern-js/server": "2.21.1",
-    "@modern-js/types": "2.21.1",
-    "@modern-js/upgrade": "2.21.1",
-    "@modern-js/utils": "2.21.1"
+    "@modern-js/builder": "2.22.0",
+    "@modern-js/builder-plugin-esbuild": "2.22.0",
+    "@modern-js/builder-plugin-node-polyfill": "2.22.0",
+    "@modern-js/builder-shared": "2.22.0",
+    "@modern-js/builder-webpack-provider": "2.22.0",
+    "@modern-js/core": "2.22.0",
+    "@modern-js/new-action": "2.22.0",
+    "@modern-js/node-bundle-require": "2.22.0",
+    "@modern-js/plugin": "2.22.0",
+    "@modern-js/plugin-data-loader": "2.22.0",
+    "@modern-js/plugin-i18n": "2.22.0",
+    "@modern-js/plugin-lint": "2.22.0",
+    "@modern-js/prod-server": "2.22.0",
+    "@modern-js/server": "2.22.0",
+    "@modern-js/types": "2.22.0",
+    "@modern-js/upgrade": "2.22.0",
+    "@modern-js/utils": "2.22.0"
   },
   "devDependencies": {
     "@types/babel__traverse": "^7.14.2",
@@ -98,14 +98,14 @@
     "jest": "^29",
     "typescript": "^5",
     "webpack": "^5.82.1",
-    "@modern-js/builder-plugin-swc": "2.21.1",
-    "@modern-js/builder-rspack-provider": "2.21.1",
-    "@modern-js/server-core": "2.21.1",
-    "@scripts/jest-config": "2.21.1",
-    "@scripts/build": "2.21.1"
+    "@modern-js/builder-rspack-provider": "2.22.0",
+    "@scripts/jest-config": "2.22.0",
+    "@modern-js/server-core": "2.22.0",
+    "@scripts/build": "2.22.0",
+    "@modern-js/builder-plugin-swc": "2.22.0"
   },
   "peerDependencies": {
-    "@modern-js/builder-rspack-provider": "^2.21.1"
+    "@modern-js/builder-rspack-provider": "^2.22.0"
   },
   "peerDependenciesMeta": {
     "@modern-js/builder-rspack-provider": {