@modern-js/app-tools 2.54.6 → 2.56.0

package/dist/esm-node/builder/shared/builderPlugins/adapterHtml.js

@@ -1,4 +1,4 @@
-import { isHtmlDisabled } from "@rsbuild/shared";
+import { isHtmlDisabled } from "@modern-js/uni-builder";
 import { MAIN_ENTRY_NAME, getEntryOptions, removeTailSlash } from "@modern-js/utils";
 import { template as lodashTemplate } from "@modern-js/utils/lodash";
 import { BottomTemplatePlugin } from "../bundlerPlugins";
@@ -6,15 +6,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();
+    api.modifyBundlerChain(async (chain, { CHAIN_ID, target, HtmlPlugin: HtmlBundlerPlugin, environment }) => {
+      const builderConfig = environment.config;
       if (!isHtmlDisabled(builderConfig, target)) {
         applyBottomHtmlPlugin({
-          api,
           options,
           chain,
           CHAIN_ID,
-          HtmlBundlerPlugin
+          HtmlBundlerPlugin,
+          htmlPaths: environment.htmlPaths
         });
         await injectAssetPrefix({
           chain
@@ -32,9 +32,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 || MAIN_ENTRY_NAME);
     const baseTemplateParams = {

package/dist/esm-node/builder/shared/builderPlugins/adapterSSR.js

@@ -1,7 +1,7 @@
 import * as path from "path";
-import { isHtmlDisabled } from "@rsbuild/shared";
 import { mergeRsbuildConfig } from "@rsbuild/core";
 import { fs, isUseSSRBundle } from "@modern-js/utils";
+import { isHtmlDisabled, SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/uni-builder";
 import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins";
 import { getServerCombinedModueFile } from "../../../plugins/analyze/utils";
 const builderPluginAdapterSSR = (options) => ({
@@ -20,18 +20,16 @@ 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 (isUseSSRBundle(normalizedConfig2)) {
         await applySSRLoaderEntry(chain, options, isServer);
         applySSRDataLoader(chain, options);
       }
-      if ([
-        "node",
-        "service-worker"
-      ].includes(target)) {
+      const isServiceWorker = environment.name === SERVICE_WORKER_ENVIRONMENT_NAME;
+      if (target === "node" || isServiceWorker) {
         applyFilterEntriesBySSRConfig({
           isProd,
           chain,

package/dist/esm-node/builder/shared/builderPlugins/adapterWorker.js

@@ -1,4 +1,5 @@
 import { posix } from "path";
+import { SERVICE_WORKER_ENVIRONMENT_NAME } from "@modern-js/uni-builder";
 const getDistPath = (outputConfig, type) => {
   const { distPath } = outputConfig;
   const ret = distPath[type];
@@ -10,10 +11,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 === SERVICE_WORKER_ENVIRONMENT_NAME;
       if (isServiceWorker) {
-        const workerPath = getDistPath(config.output, "worker");
+        const workerPath = getDistPath(config.output, "root");
         const filename = posix.join(workerPath, `[name].js`);
         chain.output.filename(filename).chunkFilename(filename).libraryTarget("commonjs2");
       }

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

@@ -1,5 +1,5 @@
 import { newAction, upgradeAction } from "@modern-js/utils";
-import { castArray } from "@rsbuild/shared";
+import { castArray } from "@modern-js/uni-builder";
 import { i18n, localeKeys } from "../locale";
 const devCommand = async (program, api) => {
   const runner = api.useHookRunners();

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

@@ -1,4 +1,3 @@
-import { join } from "path";
 const inspect = async (api, options) => {
   const appContext = api.useAppContext();
   if (!appContext.builder) {
@@ -7,7 +6,7 @@ const inspect = async (api, options) => {
   return appContext.builder.inspectConfig({
     env: options.env,
     verbose: options.verbose,
-    outputPath: join(appContext === null || appContext === void 0 ? void 0 : appContext.builder.context.distPath, options.output),
+    outputPath: options.output,
     writeToDisk: true
   });
 };

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

@@ -24,6 +24,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/esm-node/config/default.js

@@ -15,8 +15,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,
@@ -26,6 +24,7 @@ function createDefaultConfig(appContext) {
     entries: void 0,
     mainEntryName: MAIN_ENTRY_NAME,
     enableAsyncEntry: false,
+    enableCustomEntry: false,
     disableDefaultEntries: false,
     entriesDir: "./src",
     configDir: "./config",
@@ -98,6 +97,7 @@ function createLegacyDefaultConfig(appContext) {
     entries: void 0,
     mainEntryName: MAIN_ENTRY_NAME,
     enableAsyncEntry: false,
+    enableCustomEntry: false,
     disableDefaultEntries: false,
     entriesDir: "./src",
     configDir: "./config",

package/dist/esm-node/config/legacy/createSourceConfig.js

@@ -1,5 +1,5 @@
 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];
@@ -14,6 +14,7 @@ function createSourceConfig(config) {
     entries,
     mainEntryName,
     enableAsyncEntry,
+    enableCustomEntry,
     disableDefaultEntries,
     entriesDir,
     configDir,

package/dist/esm-node/config/legacy/index.js

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

package/dist/esm-node/hooks.js

@@ -1,16 +1,13 @@
 import { createAsyncWaterfall, createAsyncWorkflow, createParallelWorkflow } from "@modern-js/plugin";
 const hooks = {
-  modifyEntryExport: createAsyncWaterfall(),
-  modifyEntryImports: createAsyncWaterfall(),
-  modifyEntryRuntimePlugins: createAsyncWaterfall(),
-  modifyEntryRenderFunction: createAsyncWaterfall(),
-  modifyAsyncEntry: createAsyncWaterfall(),
+  _internalRuntimePlugins: createAsyncWaterfall(),
   modifyFileSystemRoutes: createAsyncWaterfall(),
   modifyServerRoutes: createAsyncWaterfall(),
   /** add entry point info to entrypoints array */
   modifyEntrypoints: createAsyncWaterfall(),
   /** add entry type */
   checkEntryPoint: createAsyncWaterfall(),
+  generateEntryCode: createAsyncWorkflow(),
   htmlPartials: createAsyncWaterfall(),
   beforeGenerateRoutes: createAsyncWaterfall(),
   addDefineTypes: createAsyncWaterfall(),

package/dist/esm-node/plugins/analyze/constants.js

@@ -1,23 +1,13 @@
 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";
 export {
-  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/esm-node/plugins/analyze/getBundleEntry.js

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

package/dist/esm-node/plugins/analyze/getFileSystemEntry.js

@@ -1,19 +1,31 @@
 import fs from "fs";
 import path from "path";
 import { findExists, ensureAbsolutePath, JS_EXTENSIONS } from "@modern-js/utils";
-import { INDEX_FILE_NAME } from "./constants";
+import { ENTRY_FILE_NAME, INDEX_FILE_NAME } from "./constants";
 import { isDefaultExportFunction } from "./isDefaultExportFunction";
 const hasIndex = (dir) => findExists(JS_EXTENSIONS.map((ext) => path.resolve(dir, `${INDEX_FILE_NAME}${ext}`)));
-const isBundleEntry = async (hookRunners, dir) => {
-  return (await hookRunners.checkEntryPoint({
+const hasEntry = (dir) => findExists(JS_EXTENSIONS.map((ext) => path.resolve(dir, `${ENTRY_FILE_NAME}${ext}`)));
+const hasServerEntry = (dir) => findExists(JS_EXTENSIONS.map((ext) => path.resolve(dir, `${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 = isDefaultExportFunction(indexFile) ? indexFile : false;
   const entryName = path.basename(dir);
+  const customEntryFile = hasEntry(dir);
+  const customServerEntry = hasServerEntry(dir);
   if (indexFile && !customBootstrap) {
     return {
       entryName,
@@ -32,17 +44,30 @@ const scanDir = (hookRunners, dirs) => Promise.all(dirs.map(async (dir) => {
     return {
       entryName,
       isMainEntry: false,
-      entry: entryFile,
+      entry: enableCustomEntry ? customEntryFile || entryFile : entryFile,
+      customServerEntry,
       absoluteEntryDir: path.resolve(dir),
       isAutoMount: true,
-      customBootstrap
+      customBootstrap,
+      customEntry: enableCustomEntry ? Boolean(customEntryFile) : false
+    };
+  }
+  if (enableCustomEntry && customEntryFile) {
+    return {
+      entryName,
+      isMainEntry: false,
+      entry: customEntryFile,
+      customServerEntry,
+      absoluteEntryDir: path.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) => ensureAbsolutePath(appDirectory, dir));
@@ -50,19 +75,19 @@ const getFileSystemEntry = async (hookRunners, appContext, config) => {
   const src = ensureAbsolutePath(appDirectory, entriesDir || "");
   if (fs.existsSync(src)) {
     if (fs.statSync(src).isDirectory()) {
-      if (await isBundleEntry(hookRunners, src)) {
+      if (await isBundleEntry(hookRunners, src, enableCustomEntry)) {
         return scanDir(hookRunners, [
           src
-        ]);
+        ], enableCustomEntry);
       }
       const dirs = [];
       await Promise.all(fs.readdirSync(src).map(async (filename) => {
         const file = path.join(src, filename);
-        if (fs.statSync(file).isDirectory() && await isBundleEntry(hookRunners, file) && !disabledDirs.includes(file)) {
+        if (fs.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/esm-node/plugins/analyze/index.js

@@ -1,17 +1,18 @@
 import * as path from "path";
-import { createDebugger, findExists, fs, isApiOnly, minimist, isDevCommand, getArgv } from "@modern-js/utils";
+import { createDebugger, fs, isApiOnly, minimist, isDevCommand, getArgv } from "@modern-js/utils";
 import { printInstructions } from "../../utils/printInstructions";
-import { generateRoutes, getPathWithoutExt } from "../../utils/routes";
+import { generateRoutes } from "../../utils/routes";
 import { emitResolvedConfig } from "../../utils/config";
 import { getSelectedEntries } from "../../utils/getSelectedEntries";
 import { initialNormalizedConfig } from "../../config";
 import { createBuilderGenerator } from "../../builder";
-import { checkIsBuildCommands, parseModule, replaceWithAlias } from "./utils";
-import { APP_CONFIG_NAME, APP_INIT_EXPORTED, APP_INIT_IMPORTED } from "./constants";
-import { generateIndexCode } from "./generateCode";
+import { checkIsBuildCommands } from "./utils";
 const debug = createDebugger("plugin-analyze");
 var analyze_default = ({ bundler }) => ({
   name: "@modern-js/plugin-analyze",
+  post: [
+    "@modern-js/runtime"
+  ],
   setup: (api) => {
     let pagesDir = [];
     let nestedRouteEntries = [];
@@ -42,10 +43,9 @@ var analyze_default = ({ bundler }) => ({
           api.setAppContext(appContext);
           return;
         }
-        const [{ getBundleEntry }, { getServerRoutes }, { generateCode }, { getHtmlTemplate }] = await Promise.all([
+        const [{ getBundleEntry }, { getServerRoutes }, { getHtmlTemplate }] = await Promise.all([
           import("./getBundleEntry"),
           import("./getServerRoutes"),
-          import("./generateCode"),
           import("./getHtmlTemplate")
         ]);
         const { entrypoints } = await hookRunners.modifyEntrypoints({
@@ -68,7 +68,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
@@ -91,6 +90,9 @@ var analyze_default = ({ bundler }) => ({
         };
         api.setAppContext(appContext);
         if (checkIsBuildCommands()) {
+          await hookRunners.generateEntryCode({
+            entrypoints
+          });
           const normalizedConfig = api.useResolvedConfigContext();
           const createBuilderForModern = await createBuilderGenerator(bundler);
           const builder = await createBuilderForModern({
@@ -122,14 +124,6 @@ var analyze_default = ({ bundler }) => ({
           });
           builder.onBeforeCreateCompiler(async ({ bundlerConfigs }) => {
             const hookRunners2 = api.useHookRunners();
-            await generateIndexCode({
-              appContext,
-              config: resolvedConfig,
-              entrypoints,
-              api,
-              importsStatemets,
-              bundlerConfigs
-            });
             await hookRunners2.beforeCreateCompiler({
               bundlerConfigs
             });
@@ -160,57 +154,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 = findExists([
-            ".js",
-            ".ts",
-            ".jsx",
-            ".tsx"
-          ].map((ext) => `${rootLayoutPath}${ext}`));
-          if (rootLayoutFile) {
-            const rootLayoutBuffer = await fs.readFile(rootLayoutFile);
-            const rootLayout = rootLayoutBuffer.toString();
-            const [, moduleExports] = await parseModule({
-              source: rootLayout.toString(),
-              filename: rootLayoutFile
-            });
-            const hasAppConfig = moduleExports.some((e) => e.n === APP_CONFIG_NAME);
-            const generateLayoutPath = getPathWithoutExt(replaceWithAlias(srcDirectory, rootLayoutFile, internalSrcAlias));
-            if (hasAppConfig) {
-              imports.push({
-                value: generateLayoutPath,
-                specifiers: [
-                  {
-                    imported: APP_CONFIG_NAME
-                  }
-                ]
-              });
-            }
-            const hasAppInit = moduleExports.some((e) => e.n === APP_INIT_EXPORTED);
-            if (hasAppInit) {
-              imports.push({
-                value: generateLayoutPath,
-                specifiers: [
-                  {
-                    imported: APP_INIT_EXPORTED,
-                    local: APP_INIT_IMPORTED
-                  }
-                ]
-              });
-            }
-          }
-        }
-        return {
-          entrypoint,
-          imports
-        };
       }
     };
   }

package/dist/esm-node/plugins/analyze/templates.js

@@ -1,52 +1,3 @@
-import { APP_CONFIG_NAME } from "./constants";
-const index = ({ mountId, imports, renderFunction: renderFunction2, exportStatement }) => `
-const IS_BROWSER = typeof window !== 'undefined' && window.name !== 'nodejs';
-const IS_REACT18 = process.env.IS_REACT18 === 'true';
-const MOUNT_ID = '${mountId}';
-
-${imports}
-
-let AppWrapper = null;
-
-let root = null;
-
-function render() {
-  ${renderFunction2}
-}
-
-AppWrapper = render();
-
-${exportStatement};
-`;
-const renderFunction = ({ plugins, customBootstrap, fileSystemRoutes, customRuntimeConfig }) => {
-  const bootstrap = "bootstrap(AppWrapper, MOUNT_ID, root, ReactDOM)";
-  const runtimePlugins = `...(runtimeConfig?.plugins || []),`;
-  return `
-  const finalAppConfig = {
-    ...App.config,
-    ...typeof ${APP_CONFIG_NAME} === 'function' ? ${APP_CONFIG_NAME}() : {},
-  }
-
-  AppWrapper = createApp({
-    plugins: [
-     ${plugins.map(({ name, options, args }) => `${name}({...${options}, ...finalAppConfig?.${args || name}}),`).join("\n")}
-       ${customRuntimeConfig ? runtimePlugins : ""}
-    ]
-  })(${fileSystemRoutes ? "" : `App`})
-
-
-  if(!AppWrapper.init && typeof appInit !== 'undefined') {
-    AppWrapper.init = appInit;
-  }
-
-
-  if (IS_BROWSER) {
-    ${customBootstrap ? `customBootstrap(AppWrapper, () => ${bootstrap});` : `${bootstrap};`}
-  }
-
-  return AppWrapper
-`;
-};
 const html = (partials) => `
 <!DOCTYPE html>
 <html>
@@ -69,7 +20,5 @@ const html = (partials) => `
 </html>
 `;
 export {
-  html,
-  index,
-  renderFunction
+  html
 };

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

@@ -1,9 +1,8 @@
 import fs from "fs";
 import path from "path";
-import { isReact18, normalizeToPosixPath, getCommand, JS_EXTENSIONS } from "@modern-js/utils";
+import { normalizeToPosixPath, getCommand, JS_EXTENSIONS } from "@modern-js/utils";
 import { transform } from "esbuild";
 import { parse } from "es-module-lexer";
-import { FILE_SYSTEM_ROUTES_FILE_NAME } from "./constants";
 const walkDirectory = (dir) => fs.readdirSync(dir).reduce((previous, filename) => {
   const filePath = path.join(dir, filename);
   if (fs.statSync(filePath).isDirectory()) {
@@ -18,89 +17,6 @@ const walkDirectory = (dir) => fs.readdirSync(dir).reduce((previous, filename) =
     ];
   }
 }, []);
-const getDefaultImports = ({ entrypoint, srcDirectory, appDirectory, internalSrcAlias, internalDirAlias, runtimeConfigFile, customRuntimeConfig }) => {
-  const { entryName, fileSystemRoutes, customBootstrap, entry } = entrypoint;
-  const imports = [
-    {
-      specifiers: [
-        {
-          local: "React"
-        }
-      ],
-      value: "react"
-    },
-    {
-      specifiers: [
-        {
-          local: "ReactDOM"
-        }
-      ],
-      value: isReact18(path.join(appDirectory)) ? "react-dom/client" : "react-dom"
-    },
-    {
-      specifiers: [
-        {
-          imported: "createApp"
-        },
-        {
-          imported: "bootstrap"
-        }
-      ],
-      value: "@modern-js/runtime"
-    },
-    customBootstrap && {
-      specifiers: [
-        {
-          local: "customBootstrap"
-        }
-      ],
-      value: normalizeToPosixPath(customBootstrap.replace(srcDirectory, internalSrcAlias))
-    }
-  ].filter(Boolean);
-  if (fileSystemRoutes) {
-    const route = {
-      specifiers: [
-        {
-          imported: "routes"
-        }
-      ],
-      value: normalizeToPosixPath(`${internalDirAlias}/${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME.replace(".js", "")}`)
-    };
-    if (fileSystemRoutes.globalApp) {
-      imports.push({
-        specifiers: [
-          {
-            local: "App"
-          }
-        ],
-        value: normalizeToPosixPath(fileSystemRoutes.globalApp.replace(srcDirectory, internalSrcAlias))
-      });
-    } else {
-      route.initialize = "const App = false;";
-    }
-    imports.push(route);
-  } else {
-    imports.push({
-      specifiers: [
-        {
-          local: "App"
-        }
-      ],
-      value: normalizeToPosixPath(entry.replace(srcDirectory, internalSrcAlias))
-    });
-  }
-  if (customRuntimeConfig) {
-    imports.push({
-      specifiers: [
-        {
-          local: "runtimeConfig"
-        }
-      ],
-      value: path.join(internalSrcAlias, runtimeConfigFile || "")
-    });
-  }
-  return imports;
-};
 const replaceWithAlias = (base, filePath, alias) => {
   if (filePath.includes(base)) {
     return normalizeToPosixPath(path.join(alias, path.relative(base, filePath)));
@@ -144,7 +60,6 @@ const isSubDirOrEqual = (parent, child) => {
 };
 export {
   checkIsBuildCommands,
-  getDefaultImports,
   getServerCombinedModueFile,
   isSubDirOrEqual,
   parseModule,

package/dist/types/builder/builder-webpack/createCopyPattern.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { CopyPluginOptions, RspackChain } from '@modern-js/uni-builder';
+import type { Rspack, RspackChain } from '@rsbuild/core';
 import type { AppNormalizedConfig, Bundler, IAppContext } from '../../types';
 export declare function createPublicPattern(appContext: IAppContext, config: AppNormalizedConfig, chain: RspackChain): {
     info: (file: {
@@ -13,4 +13,4 @@ export declare function createPublicPattern(appContext: IAppContext, config: App
     noErrorOnMissing: boolean;
     transform: (content: Buffer, absoluteFrom: string) => string | Buffer;
 };
-export declare function createUploadPattern<B extends Bundler>(appContext: IAppContext, config: AppNormalizedConfig<B>): CopyPluginOptions['patterns']['0'];
+export declare function createUploadPattern<B extends Bundler>(appContext: IAppContext, config: AppNormalizedConfig<B>): Rspack.CopyRspackPluginOptions['patterns']['0'];

package/dist/types/builder/generator/getBuilderEnvironments.d.ts

@@ -0,0 +1,5 @@
+import type { IAppContext } from '@modern-js/core';
+import type { AppNormalizedConfig } from '../../types';
+export declare function getBuilderEnvironments(normalizedConfig: AppNormalizedConfig<'shared'>, appContext: IAppContext): {
+    [name: string]: import("@rsbuild/core/dist-types/types").EnvironmentConfig;
+};

package/dist/types/builder/generator/index.d.ts

@@ -1,5 +1,4 @@
-import { UniBuilderInstance } from '@modern-js/uni-builder';
-import { BundlerType } from '@rsbuild/shared';
+import { type UniBuilderInstance, type BundlerType } from '@modern-js/uni-builder';
 import { BuilderOptions } from '../shared';
 import { Bundler } from '../../types';
 /**

package/dist/types/builder/shared/builderPlugins/adapterBasic.d.ts

@@ -1,2 +1,2 @@
-import { RsbuildPlugin } from '@rsbuild/shared';
+import type { RsbuildPlugin } from '@rsbuild/core';
 export declare const builderPluginAdapterBasic: () => RsbuildPlugin;

package/dist/types/builder/shared/builderPlugins/adapterHtml.d.ts

@@ -1,4 +1,4 @@
-import { RsbuildPlugin } from '@rsbuild/shared';
+import type { RsbuildPlugin } from '@rsbuild/core';
 import { Bundler } from '../../../types';
 import type { BuilderOptions } from '../types';
 export declare const builderPluginAdapterHtml: <B extends Bundler>(options: BuilderOptions<B>) => RsbuildPlugin;