@modern-js/app-tools 2.54.6 → 2.56.0

package/dist/cjs/builder/generator/getBuilderEnvironments.js

@@ -0,0 +1,84 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getBuilderEnvironments_exports = {};
+__export(getBuilderEnvironments_exports, {
+  getBuilderEnvironments: () => getBuilderEnvironments
+});
+module.exports = __toCommonJS(getBuilderEnvironments_exports);
+var import_utils = require("@modern-js/utils");
+var import_uni_builder = require("@modern-js/uni-builder");
+function getBuilderEnvironments(normalizedConfig, appContext) {
+  const entries = {};
+  const { entrypoints = [], checkedEntries } = appContext;
+  for (const { entryName, internalEntry, entry } of entrypoints) {
+    if (checkedEntries && !checkedEntries.includes(entryName)) {
+      continue;
+    }
+    const finalEntry = internalEntry || entry;
+    if (entryName in entries) {
+      entries[entryName].push(finalEntry);
+    } else {
+      entries[entryName] = [
+        finalEntry
+      ];
+    }
+  }
+  const serverEntries = {};
+  for (const entry in entries) {
+    const v = entries[entry];
+    serverEntries[entry] = v.map((entry2) => entry2.replace("index.jsx", "index.server.jsx"));
+  }
+  const environments = {
+    web: {
+      output: {
+        target: "web"
+      },
+      source: {
+        entry: entries
+      }
+    }
+  };
+  const useNodeTarget = (0, import_utils.isProd)() ? (0, import_utils.isUseSSRBundle)(normalizedConfig) : (0, import_utils.isSSR)(normalizedConfig);
+  if (useNodeTarget) {
+    environments.node = {
+      output: {
+        target: "node"
+      },
+      source: {
+        entry: serverEntries
+      }
+    };
+  }
+  const useWorkerTarget = (0, import_utils.isServiceWorker)(normalizedConfig);
+  if (useWorkerTarget) {
+    environments[import_uni_builder.SERVICE_WORKER_ENVIRONMENT_NAME] = {
+      output: {
+        target: "web-worker"
+      },
+      source: {
+        entry: serverEntries
+      }
+    };
+  }
+  return environments;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBuilderEnvironments
+});

package/dist/cjs/builder/generator/index.js

@@ -32,16 +32,17 @@ __export(generator_exports, {
 });
 module.exports = __toCommonJS(generator_exports);
 var import_uni_builder = require("@modern-js/uni-builder");
+var import_core = require("@rsbuild/core");
 var import_createBuilderProviderConfig = require("./createBuilderProviderConfig");
-var import_getBuilderTargets = require("./getBuilderTargets");
-var import_createBuilderOptions = require("./createBuilderOptions");
+var import_getBuilderEnvironments = require("./getBuilderEnvironments");
 async function generateBuilder(options, bundlerType) {
   const { normalizedConfig, appContext } = options;
   const builderConfig = (0, import_createBuilderProviderConfig.createBuilderProviderConfig)(normalizedConfig, appContext);
-  const target = (0, import_getBuilderTargets.getBuilderTargets)(normalizedConfig);
-  const builderOptions = (0, import_createBuilderOptions.createBuilderOptions)(target, appContext);
+  const environments = (0, import_getBuilderEnvironments.getBuilderEnvironments)(normalizedConfig, appContext);
+  builderConfig.environments = builderConfig.environments ? (0, import_core.mergeRsbuildConfig)(environments, builderConfig.environments) : environments;
   const builder = await (0, import_uni_builder.createUniBuilder)({
-    ...builderOptions,
+    cwd: appContext.appDirectory,
+    frameworkConfigPath: appContext.configFile || void 0,
     bundlerType,
     config: builderConfig
   });

package/dist/cjs/builder/shared/builderPlugins/adapterBasic.js

@@ -32,21 +32,14 @@ __export(adapterBasic_exports, {
 });
 module.exports = __toCommonJS(adapterBasic_exports);
 var import_path = __toESM(require("path"));
+var import_uni_builder = require("@modern-js/uni-builder");
 const builderPluginAdapterBasic = () => ({
   name: "builder-plugin-adapter-modern-basic",
   setup(api) {
-    api.modifyBundlerChain((chain, { target, CHAIN_ID }) => {
-      if (target === "node") {
-        chain.name("server");
-      } else if (target === "service-worker") {
-        chain.name("service-worker");
-      } else if (target === "web-worker") {
-        chain.name("worker");
-      } else {
-        chain.name("client");
-      }
-      if (target === "node" || target === "service-worker") {
-        applyNodeCompat(target, chain);
+    api.modifyBundlerChain((chain, { target, CHAIN_ID, environment }) => {
+      const isServiceWorker = environment.name === import_uni_builder.SERVICE_WORKER_ENVIRONMENT_NAME;
+      if (target === "node" || isServiceWorker) {
+        applyNodeCompat(isServiceWorker, chain);
       }
       if (target === "web") {
         const bareServerModuleReg = /\.(server|node)\.[tj]sx?$/;
@@ -57,7 +50,7 @@ const builderPluginAdapterBasic = () => ({
     });
   }
 });
-function applyNodeCompat(target, chain) {
+function applyNodeCompat(isServiceWorker, chain) {
   const nodeExts = [
     ".node.js",
     ".node.jsx",
@@ -77,7 +70,7 @@ function applyNodeCompat(target, chain) {
   for (const ext of nodeExts) {
     chain.resolve.extensions.prepend(ext);
   }
-  if (target === "service-worker") {
+  if (isServiceWorker) {
     for (const ext of webWorkerExts) {
       chain.resolve.extensions.prepend(ext);
     }

package/dist/cjs/builder/shared/builderPlugins/adapterHtml.js

@@ -21,7 +21,7 @@ __export(adapterHtml_exports, {
   builderPluginAdapterHtml: () => builderPluginAdapterHtml
 });
 module.exports = __toCommonJS(adapterHtml_exports);
-var import_shared = require("@rsbuild/shared");
+var import_uni_builder = require("@modern-js/uni-builder");
 var import_utils = require("@modern-js/utils");
 var import_lodash = require("@modern-js/utils/lodash");
 var import_bundlerPlugins = require("../bundlerPlugins");
@@ -29,15 +29,15 @@ const createVirtualModule = (content) => `data:text/javascript,${content}`;
 const builderPluginAdapterHtml = (options) => ({
   name: "builder-plugin-adapter-modern-html",
   setup(api) {
-    api.modifyBundlerChain(async (chain, { CHAIN_ID, target, HtmlPlugin: HtmlBundlerPlugin }) => {
-      const builderConfig = api.getNormalizedConfig();
-      if (!(0, import_shared.isHtmlDisabled)(builderConfig, target)) {
+    api.modifyBundlerChain(async (chain, { CHAIN_ID, target, HtmlPlugin: HtmlBundlerPlugin, environment }) => {
+      const builderConfig = environment.config;
+      if (!(0, import_uni_builder.isHtmlDisabled)(builderConfig, target)) {
         applyBottomHtmlPlugin({
-          api,
           options,
           chain,
           CHAIN_ID,
-          HtmlBundlerPlugin
+          HtmlBundlerPlugin,
+          htmlPaths: environment.htmlPaths
         });
         await injectAssetPrefix({
           chain
@@ -55,9 +55,9 @@ async function injectAssetPrefix({ chain }) {
     entries[entryName].prepend(createVirtualModule(code));
   });
 }
-function applyBottomHtmlPlugin({ api, chain, options, CHAIN_ID, HtmlBundlerPlugin }) {
+function applyBottomHtmlPlugin({ chain, options, CHAIN_ID, HtmlBundlerPlugin, htmlPaths }) {
   const { normalizedConfig: modernConfig, appContext } = options;
-  for (const entryName of Object.keys(api.context.entry)) {
+  for (const entryName of Object.keys(htmlPaths)) {
     const { source: { mainEntryName } } = modernConfig;
     const isMainEntry = entryName === (mainEntryName || import_utils.MAIN_ENTRY_NAME);
     const baseTemplateParams = {

package/dist/cjs/builder/shared/builderPlugins/adapterSSR.js

@@ -32,9 +32,9 @@ __export(adapterSSR_exports, {
 });
 module.exports = __toCommonJS(adapterSSR_exports);
 var path = __toESM(require("path"));
-var import_shared = require("@rsbuild/shared");
 var import_core = require("@rsbuild/core");
 var import_utils = require("@modern-js/utils");
+var import_uni_builder = require("@modern-js/uni-builder");
 var import_bundlerPlugins = require("../bundlerPlugins");
 var import_utils2 = require("../../../plugins/analyze/utils");
 const builderPluginAdapterSSR = (options) => ({
@@ -53,25 +53,23 @@ const builderPluginAdapterSSR = (options) => ({
         }
       });
     });
-    api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer }) => {
-      const builderConfig = api.getNormalizedConfig();
+    api.modifyBundlerChain(async (chain, { target, isProd, HtmlPlugin: HtmlBundlerPlugin, isServer, environment }) => {
+      const builderConfig = environment.config;
       const { normalizedConfig: normalizedConfig2 } = options;
       applyRouterPlugin(chain, "route-plugin", options, HtmlBundlerPlugin);
       if ((0, import_utils.isUseSSRBundle)(normalizedConfig2)) {
         await applySSRLoaderEntry(chain, options, isServer);
         applySSRDataLoader(chain, options);
       }
-      if ([
-        "node",
-        "service-worker"
-      ].includes(target)) {
+      const isServiceWorker = environment.name === import_uni_builder.SERVICE_WORKER_ENVIRONMENT_NAME;
+      if (target === "node" || isServiceWorker) {
         applyFilterEntriesBySSRConfig({
           isProd,
           chain,
           appNormalizedConfig: normalizedConfig2
         });
       }
-      if (!(0, import_shared.isHtmlDisabled)(builderConfig, target)) {
+      if (!(0, import_uni_builder.isHtmlDisabled)(builderConfig, target)) {
         applyAsyncChunkHtmlPlugin({
           chain,
           modernConfig: options.normalizedConfig,

package/dist/cjs/builder/shared/builderPlugins/adapterWorker.js

@@ -22,6 +22,7 @@ __export(adapterWorker_exports, {
 });
 module.exports = __toCommonJS(adapterWorker_exports);
 var import_path = require("path");
+var import_uni_builder = require("@modern-js/uni-builder");
 const getDistPath = (outputConfig, type) => {
   const { distPath } = outputConfig;
   const ret = distPath[type];
@@ -33,10 +34,11 @@ const getDistPath = (outputConfig, type) => {
 const builderPluginAdapterWorker = () => ({
   name: "builder-plugin-adapter-worker",
   setup(api) {
-    api.modifyBundlerChain(async (chain, { isServiceWorker }) => {
-      const config = api.getNormalizedConfig();
+    api.modifyBundlerChain(async (chain, { environment }) => {
+      const { config, name } = environment;
+      const isServiceWorker = name === import_uni_builder.SERVICE_WORKER_ENVIRONMENT_NAME;
       if (isServiceWorker) {
-        const workerPath = getDistPath(config.output, "worker");
+        const workerPath = getDistPath(config.output, "root");
         const filename = import_path.posix.join(workerPath, `[name].js`);
         chain.output.filename(filename).chunkFilename(filename).libraryTarget("commonjs2");
       }

package/dist/cjs/commands/index.js

@@ -38,7 +38,7 @@ __export(commands_exports, {
 });
 module.exports = __toCommonJS(commands_exports);
 var import_utils = require("@modern-js/utils");
-var import_shared = require("@rsbuild/shared");
+var import_uni_builder = require("@modern-js/uni-builder");
 var import_locale = require("../locale");
 const devCommand = async (program, api) => {
   const runner = api.useHookRunners();
@@ -71,7 +71,7 @@ const buildCommand = async (program, api) => {
     await build(api, options);
   });
   for (const platformBuilder of platformBuilders) {
-    const platforms = (0, import_shared.castArray)(platformBuilder.platform);
+    const platforms = (0, import_uni_builder.castArray)(platformBuilder.platform);
     for (const platform of platforms) {
       buildProgram.command(platform).action(async () => {
         const { appDirectory } = api.useAppContext();

package/dist/cjs/commands/inspect.js

@@ -21,7 +21,6 @@ __export(inspect_exports, {
   inspect: () => inspect
 });
 module.exports = __toCommonJS(inspect_exports);
-var import_path = require("path");
 const inspect = async (api, options) => {
   const appContext = api.useAppContext();
   if (!appContext.builder) {
@@ -30,7 +29,7 @@ const inspect = async (api, options) => {
   return appContext.builder.inspectConfig({
     env: options.env,
     verbose: options.verbose,
-    outputPath: (0, import_path.join)(appContext === null || appContext === void 0 ? void 0 : appContext.builder.context.distPath, options.output),
+    outputPath: options.output,
     writeToDisk: true
   });
 };

package/dist/cjs/commands/serve.js

@@ -57,6 +57,7 @@ const start = async (api) => {
     config: {
       ...userConfig,
       dev: userConfig.dev,
+      // server-core can't get RegExp & Function output.enableInlineScripts by JSON.stringy;
       output: {
         path: (_userConfig_output_distPath = userConfig.output.distPath) === null || _userConfig_output_distPath === void 0 ? void 0 : _userConfig_output_distPath.root,
         ...userConfig.output || {}

package/dist/cjs/config/default.js

@@ -39,8 +39,6 @@ function createDefaultConfig(appContext) {
       server: "bundles",
       worker: "worker"
     },
-    // no need to emit assets for SSR bundles
-    emitAssets: ({ target }) => target !== "node",
     cleanDistPath: true,
     disableNodePolyfill: true,
     enableInlineRouteManifests: true,
@@ -50,6 +48,7 @@ function createDefaultConfig(appContext) {
     entries: void 0,
     mainEntryName: import_utils.MAIN_ENTRY_NAME,
     enableAsyncEntry: false,
+    enableCustomEntry: false,
     disableDefaultEntries: false,
     entriesDir: "./src",
     configDir: "./config",
@@ -122,6 +121,7 @@ function createLegacyDefaultConfig(appContext) {
     entries: void 0,
     mainEntryName: import_utils.MAIN_ENTRY_NAME,
     enableAsyncEntry: false,
+    enableCustomEntry: false,
     disableDefaultEntries: false,
     entriesDir: "./src",
     configDir: "./config",

package/dist/cjs/config/legacy/createSourceConfig.js

@@ -22,7 +22,7 @@ __export(createSourceConfig_exports, {
 });
 module.exports = __toCommonJS(createSourceConfig_exports);
 function createSourceConfig(config) {
-  const { alias, envVars, globalVars, include, moduleScopes, preEntry, entries, mainEntryName, enableAsyncEntry, disableDefaultEntries, entriesDir, configDir } = config.source;
+  const { alias, envVars, globalVars, include, moduleScopes, preEntry, entries, mainEntryName, enableAsyncEntry, enableCustomEntry, disableDefaultEntries, entriesDir, configDir } = config.source;
   const builderGlobalVars = globalVars || {};
   for (const envVar of envVars || []) {
     const envVarValue = process.env[envVar];
@@ -37,6 +37,7 @@ function createSourceConfig(config) {
     entries,
     mainEntryName,
     enableAsyncEntry,
+    enableCustomEntry,
     disableDefaultEntries,
     entriesDir,
     configDir,

package/dist/cjs/config/legacy/index.js

@@ -51,6 +51,7 @@ function transformNormalizedConfig(config) {
     security: {},
     _raw: {},
     experiments: {},
+    environments: {},
     autoLoadPlugins,
     performance: {
       removeMomentLocale: true

package/dist/cjs/hooks.js

@@ -23,17 +23,14 @@ __export(hooks_exports, {
 module.exports = __toCommonJS(hooks_exports);
 var import_plugin = require("@modern-js/plugin");
 const hooks = {
-  modifyEntryExport: (0, import_plugin.createAsyncWaterfall)(),
-  modifyEntryImports: (0, import_plugin.createAsyncWaterfall)(),
-  modifyEntryRuntimePlugins: (0, import_plugin.createAsyncWaterfall)(),
-  modifyEntryRenderFunction: (0, import_plugin.createAsyncWaterfall)(),
-  modifyAsyncEntry: (0, import_plugin.createAsyncWaterfall)(),
+  _internalRuntimePlugins: (0, import_plugin.createAsyncWaterfall)(),
   modifyFileSystemRoutes: (0, import_plugin.createAsyncWaterfall)(),
   modifyServerRoutes: (0, import_plugin.createAsyncWaterfall)(),
   /** add entry point info to entrypoints array */
   modifyEntrypoints: (0, import_plugin.createAsyncWaterfall)(),
   /** add entry type */
   checkEntryPoint: (0, import_plugin.createAsyncWaterfall)(),
+  generateEntryCode: (0, import_plugin.createAsyncWorkflow)(),
   htmlPartials: (0, import_plugin.createAsyncWaterfall)(),
   beforeGenerateRoutes: (0, import_plugin.createAsyncWaterfall)(),
   addDefineTypes: (0, import_plugin.createAsyncWaterfall)(),

package/dist/cjs/plugins/analyze/constants.js

@@ -18,38 +18,23 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var constants_exports = {};
 __export(constants_exports, {
-  APP_CONFIG_NAME: () => APP_CONFIG_NAME,
-  APP_INIT_EXPORTED: () => APP_INIT_EXPORTED,
-  APP_INIT_IMPORTED: () => APP_INIT_IMPORTED,
-  ENTRY_BOOTSTRAP_FILE_NAME: () => ENTRY_BOOTSTRAP_FILE_NAME,
-  ENTRY_POINT_FILE_NAME: () => ENTRY_POINT_FILE_NAME,
-  FILE_SYSTEM_ROUTES_FILE_NAME: () => FILE_SYSTEM_ROUTES_FILE_NAME,
+  ENTRY_FILE_NAME: () => ENTRY_FILE_NAME,
   HTML_PARTIALS_EXTENSIONS: () => HTML_PARTIALS_EXTENSIONS,
   HTML_PARTIALS_FOLDER: () => HTML_PARTIALS_FOLDER,
   INDEX_FILE_NAME: () => INDEX_FILE_NAME
 });
 module.exports = __toCommonJS(constants_exports);
 const INDEX_FILE_NAME = "index";
-const FILE_SYSTEM_ROUTES_FILE_NAME = "routes.js";
-const ENTRY_POINT_FILE_NAME = "index.jsx";
-const ENTRY_BOOTSTRAP_FILE_NAME = "bootstrap.jsx";
+const ENTRY_FILE_NAME = "entry";
 const HTML_PARTIALS_FOLDER = "html";
 const HTML_PARTIALS_EXTENSIONS = [
   ".htm",
   ".html",
   ".ejs"
 ];
-const APP_CONFIG_NAME = "config";
-const APP_INIT_EXPORTED = "init";
-const APP_INIT_IMPORTED = "appInit";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  APP_CONFIG_NAME,
-  APP_INIT_EXPORTED,
-  APP_INIT_IMPORTED,
-  ENTRY_BOOTSTRAP_FILE_NAME,
-  ENTRY_POINT_FILE_NAME,
-  FILE_SYSTEM_ROUTES_FILE_NAME,
+  ENTRY_FILE_NAME,
   HTML_PARTIALS_EXTENSIONS,
   HTML_PARTIALS_FOLDER,
   INDEX_FILE_NAME

package/dist/cjs/plugins/analyze/getBundleEntry.js

@@ -71,7 +71,8 @@ const getBundleEntry = async (hookRunners, appContext, config) => {
         absoluteEntryDir: isDirectory((0, import_utils.ensureAbsolutePath)(appDirectory, entryName)) ? (0, import_utils.ensureAbsolutePath)(appDirectory, entryName) : import_path.default.dirname((0, import_utils.ensureAbsolutePath)(appDirectory, entryName)),
         isAutoMount,
         customBootstrap: typeof value === "string" ? false : value.customBootstrap && (0, import_utils.ensureAbsolutePath)(appDirectory, value.customBootstrap),
-        fileSystemRoutes: import_utils.fs.statSync((0, import_utils.ensureAbsolutePath)(appDirectory, entryName)).isDirectory() ? {} : void 0
+        fileSystemRoutes: import_utils.fs.statSync((0, import_utils.ensureAbsolutePath)(appDirectory, entryName)).isDirectory() ? {} : void 0,
+        isCustomSourceEntry: true
       };
       if (!ifAlreadyExists(defaults, entrypoint)) {
         defaults.push(entrypoint);

package/dist/cjs/plugins/analyze/getFileSystemEntry.js

@@ -37,16 +37,28 @@ var import_utils = require("@modern-js/utils");
 var import_constants = require("./constants");
 var import_isDefaultExportFunction = require("./isDefaultExportFunction");
 const hasIndex = (dir) => (0, import_utils.findExists)(import_utils.JS_EXTENSIONS.map((ext) => import_path.default.resolve(dir, `${import_constants.INDEX_FILE_NAME}${ext}`)));
-const isBundleEntry = async (hookRunners, dir) => {
-  return (await hookRunners.checkEntryPoint({
+const hasEntry = (dir) => (0, import_utils.findExists)(import_utils.JS_EXTENSIONS.map((ext) => import_path.default.resolve(dir, `${import_constants.ENTRY_FILE_NAME}${ext}`)));
+const hasServerEntry = (dir) => (0, import_utils.findExists)(import_utils.JS_EXTENSIONS.map((ext) => import_path.default.resolve(dir, `${import_constants.ENTRY_FILE_NAME}.server${ext}`)));
+const isBundleEntry = async (hookRunners, dir, enableCustomEntry) => {
+  const { entry } = await hookRunners.checkEntryPoint({
     path: dir,
     entry: false
-  })).entry || hasIndex(dir);
+  });
+  if (entry) {
+    return entry;
+  }
+  const customEntry = hasEntry(dir);
+  if (enableCustomEntry && customEntry) {
+    return customEntry;
+  }
+  return hasIndex(dir);
 };
-const scanDir = (hookRunners, dirs) => Promise.all(dirs.map(async (dir) => {
+const scanDir = (hookRunners, dirs, enableCustomEntry) => Promise.all(dirs.map(async (dir) => {
   const indexFile = hasIndex(dir);
   const customBootstrap = (0, import_isDefaultExportFunction.isDefaultExportFunction)(indexFile) ? indexFile : false;
   const entryName = import_path.default.basename(dir);
+  const customEntryFile = hasEntry(dir);
+  const customServerEntry = hasServerEntry(dir);
   if (indexFile && !customBootstrap) {
     return {
       entryName,
@@ -65,17 +77,30 @@ const scanDir = (hookRunners, dirs) => Promise.all(dirs.map(async (dir) => {
     return {
       entryName,
       isMainEntry: false,
-      entry: entryFile,
+      entry: enableCustomEntry ? customEntryFile || entryFile : entryFile,
+      customServerEntry,
       absoluteEntryDir: import_path.default.resolve(dir),
       isAutoMount: true,
-      customBootstrap
+      customBootstrap,
+      customEntry: enableCustomEntry ? Boolean(customEntryFile) : false
+    };
+  }
+  if (enableCustomEntry && customEntryFile) {
+    return {
+      entryName,
+      isMainEntry: false,
+      entry: customEntryFile,
+      customServerEntry,
+      absoluteEntryDir: import_path.default.resolve(dir),
+      isAutoMount: false,
+      customEntry: Boolean(customEntryFile)
     };
   }
   throw Error("There is no valid entry point in the current project!");
 }));
 const getFileSystemEntry = async (hookRunners, appContext, config) => {
   const { appDirectory } = appContext;
-  const { source: { entriesDir, disableEntryDirs } } = config;
+  const { source: { entriesDir, disableEntryDirs, enableCustomEntry } } = config;
   let disabledDirs = [];
   if (disableEntryDirs && Array.isArray(disableEntryDirs)) {
     disabledDirs = disableEntryDirs === null || disableEntryDirs === void 0 ? void 0 : disableEntryDirs.map((dir) => (0, import_utils.ensureAbsolutePath)(appDirectory, dir));
@@ -83,19 +108,19 @@ const getFileSystemEntry = async (hookRunners, appContext, config) => {
   const src = (0, import_utils.ensureAbsolutePath)(appDirectory, entriesDir || "");
   if (import_fs.default.existsSync(src)) {
     if (import_fs.default.statSync(src).isDirectory()) {
-      if (await isBundleEntry(hookRunners, src)) {
+      if (await isBundleEntry(hookRunners, src, enableCustomEntry)) {
         return scanDir(hookRunners, [
           src
-        ]);
+        ], enableCustomEntry);
       }
       const dirs = [];
       await Promise.all(import_fs.default.readdirSync(src).map(async (filename) => {
         const file = import_path.default.join(src, filename);
-        if (import_fs.default.statSync(file).isDirectory() && await isBundleEntry(hookRunners, file) && !disabledDirs.includes(file)) {
+        if (import_fs.default.statSync(file).isDirectory() && await isBundleEntry(hookRunners, file, enableCustomEntry) && !disabledDirs.includes(file)) {
           dirs.push(file);
         }
       }));
-      return scanDir(hookRunners, dirs);
+      return scanDir(hookRunners, dirs, enableCustomEntry);
     } else {
       throw Error(`source.entriesDir accept a directory.`);
     }

package/dist/cjs/plugins/analyze/index.js

@@ -40,11 +40,12 @@ var import_getSelectedEntries = require("../../utils/getSelectedEntries");
 var import_config2 = require("../../config");
 var import_builder = require("../../builder");
 var import_utils2 = require("./utils");
-var import_constants = require("./constants");
-var import_generateCode = require("./generateCode");
 const debug = (0, import_utils.createDebugger)("plugin-analyze");
 var analyze_default = ({ bundler }) => ({
   name: "@modern-js/plugin-analyze",
+  post: [
+    "@modern-js/runtime"
+  ],
   setup: (api) => {
     let pagesDir = [];
     let nestedRouteEntries = [];
@@ -75,10 +76,9 @@ var analyze_default = ({ bundler }) => ({
           api.setAppContext(appContext);
           return;
         }
-        const [{ getBundleEntry }, { getServerRoutes }, { generateCode }, { getHtmlTemplate }] = await Promise.all([
+        const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
           Promise.resolve().then(() => __toESM(require("./getBundleEntry"))),
           Promise.resolve().then(() => __toESM(require("./getServerRoutes"))),
-          Promise.resolve().then(() => __toESM(require("./generateCode"))),
           Promise.resolve().then(() => __toESM(require("./getHtmlTemplate")))
         ]);
         const { entrypoints } = await hookRunners.modifyEntrypoints({
@@ -101,7 +101,6 @@ var analyze_default = ({ bundler }) => ({
         api.setAppContext(appContext);
         nestedRouteEntries = entrypoints.map((point) => point.nestedRoutesEntry).filter(Boolean);
         pagesDir = entrypoints.map((point) => point.entry).filter((entry) => entry && !path.extname(entry)).concat(nestedRouteEntries);
-        const { importsStatemets } = await generateCode(appContext, resolvedConfig, entrypoints, api);
         const htmlTemplates = await getHtmlTemplate(entrypoints, api, {
           appContext,
           config: resolvedConfig
@@ -124,6 +123,9 @@ var analyze_default = ({ bundler }) => ({
         };
         api.setAppContext(appContext);
         if ((0, import_utils2.checkIsBuildCommands)()) {
+          await hookRunners.generateEntryCode({
+            entrypoints
+          });
           const normalizedConfig = api.useResolvedConfigContext();
           const createBuilderForModern = await (0, import_builder.createBuilderGenerator)(bundler);
           const builder = await createBuilderForModern({
@@ -155,14 +157,6 @@ var analyze_default = ({ bundler }) => ({
           });
           builder.onBeforeCreateCompiler(async ({ bundlerConfigs }) => {
             const hookRunners2 = api.useHookRunners();
-            await (0, import_generateCode.generateIndexCode)({
-              appContext,
-              config: resolvedConfig,
-              entrypoints,
-              api,
-              importsStatemets,
-              bundlerConfigs
-            });
             await hookRunners2.beforeCreateCompiler({
               bundlerConfigs
             });
@@ -193,57 +187,6 @@ var analyze_default = ({ bundler }) => ({
         return {
           resolved: config
         };
-      },
-      // This logic is not in the router plugin to avoid having to include some dependencies in the utils package
-      async modifyEntryImports({ entrypoint, imports }) {
-        const appContext = api.useAppContext();
-        const { srcDirectory, internalSrcAlias } = appContext;
-        const { fileSystemRoutes, nestedRoutesEntry } = entrypoint;
-        if (fileSystemRoutes && nestedRoutesEntry) {
-          const rootLayoutPath = path.join(nestedRoutesEntry, "layout");
-          const rootLayoutFile = (0, import_utils.findExists)([
-            ".js",
-            ".ts",
-            ".jsx",
-            ".tsx"
-          ].map((ext) => `${rootLayoutPath}${ext}`));
-          if (rootLayoutFile) {
-            const rootLayoutBuffer = await import_utils.fs.readFile(rootLayoutFile);
-            const rootLayout = rootLayoutBuffer.toString();
-            const [, moduleExports] = await (0, import_utils2.parseModule)({
-              source: rootLayout.toString(),
-              filename: rootLayoutFile
-            });
-            const hasAppConfig = moduleExports.some((e) => e.n === import_constants.APP_CONFIG_NAME);
-            const generateLayoutPath = (0, import_routes.getPathWithoutExt)((0, import_utils2.replaceWithAlias)(srcDirectory, rootLayoutFile, internalSrcAlias));
-            if (hasAppConfig) {
-              imports.push({
-                value: generateLayoutPath,
-                specifiers: [
-                  {
-                    imported: import_constants.APP_CONFIG_NAME
-                  }
-                ]
-              });
-            }
-            const hasAppInit = moduleExports.some((e) => e.n === import_constants.APP_INIT_EXPORTED);
-            if (hasAppInit) {
-              imports.push({
-                value: generateLayoutPath,
-                specifiers: [
-                  {
-                    imported: import_constants.APP_INIT_EXPORTED,
-                    local: import_constants.APP_INIT_IMPORTED
-                  }
-                ]
-              });
-            }
-          }
-        }
-        return {
-          entrypoint,
-          imports
-        };
       }
     };
   }