@modern-js/app-tools 2.8.1-alpha.0 → 2.8.1-alpha.1

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

@@ -66,16 +66,18 @@ module.exports = __toCommonJS(analyze_exports);
 var path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 var import_lodash = require("@modern-js/utils/lodash");
-var import_builder = require("../builder");
 var import_printInstructions = require("../utils/printInstructions");
 var import_routes = require("../utils/routes");
 var import_config = require("../utils/config");
 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");
 const debug = (0, import_utils.createDebugger)("plugin-analyze");
-var analyze_default = () => ({
+var analyze_default = ({
+  bundler
+}) => ({
   name: "@modern-js/plugin-analyze",
   setup: (api) => {
     let pagesDir = [];
@@ -167,56 +169,55 @@ var analyze_default = () => ({
           if (buildCommands.includes(command)) {
             let _b;
             const normalizedConfig = api.useResolvedConfigContext();
-            const builder = yield (0, import_builder.createBuilderForModern)({
+            const createBuilderForModern = yield (0, import_builder.createBuilderGenerator)(bundler);
+            const builder = yield createBuilderForModern({
               normalizedConfig,
               appContext,
-              compatPluginConfig: {
-                onBeforeBuild(_0) {
-                  return __async(this, arguments, function* ({ bundlerConfigs }) {
-                    const hookRunners2 = api.useHookRunners();
-                    yield (0, import_routes.generateRoutes)(appContext);
-                    yield hookRunners2.beforeBuild({ bundlerConfigs });
-                  });
-                },
-                onAfterBuild(_0) {
-                  return __async(this, arguments, function* ({ stats }) {
-                    const hookRunners2 = api.useHookRunners();
-                    yield hookRunners2.afterBuild({ stats });
-                    yield (0, import_config.emitResolvedConfig)(
-                      appContext.appDirectory,
-                      normalizedConfig
-                    );
+              onBeforeBuild(_0) {
+                return __async(this, arguments, function* ({ bundlerConfigs }) {
+                  const hookRunners2 = api.useHookRunners();
+                  yield (0, import_routes.generateRoutes)(appContext);
+                  yield hookRunners2.beforeBuild({
+                    bundlerConfigs
                   });
-                },
-                onDevCompileDone(_0) {
-                  return __async(this, arguments, function* ({ isFirstCompile }) {
-                    const hookRunners2 = api.useHookRunners();
-                    if (process.stdout.isTTY || isFirstCompile) {
-                      hookRunners2.afterDev();
-                      if (isFirstCompile) {
-                        (0, import_printInstructions.printInstructions)(
-                          hookRunners2,
-                          appContext,
-                          normalizedConfig
-                        );
-                      }
+                });
+              },
+              onAfterBuild(_0) {
+                return __async(this, arguments, function* ({ stats }) {
+                  const hookRunners2 = api.useHookRunners();
+                  yield hookRunners2.afterBuild({ stats });
+                  yield (0, import_config.emitResolvedConfig)(
+                    appContext.appDirectory,
+                    normalizedConfig
+                  );
+                });
+              },
+              onDevCompileDone(_0) {
+                return __async(this, arguments, function* ({ isFirstCompile }) {
+                  const hookRunners2 = api.useHookRunners();
+                  if (process.stdout.isTTY || isFirstCompile) {
+                    hookRunners2.afterDev();
+                    if (isFirstCompile) {
+                      (0, import_printInstructions.printInstructions)(hookRunners2, appContext, normalizedConfig);
                     }
+                  }
+                });
+              },
+              onBeforeCreateCompiler(_0) {
+                return __async(this, arguments, function* ({ bundlerConfigs }) {
+                  const hookRunners2 = api.useHookRunners();
+                  yield hookRunners2.beforeCreateCompiler({
+                    bundlerConfigs
                   });
-                },
-                onBeforeCreateCompiler(_0) {
-                  return __async(this, arguments, function* ({ bundlerConfigs }) {
-                    const hookRunners2 = api.useHookRunners();
-                    yield hookRunners2.beforeCreateCompiler({
-                      bundlerConfigs
-                    });
-                  });
-                },
-                onAfterCreateCompiler(_0) {
-                  return __async(this, arguments, function* ({ compiler }) {
-                    const hookRunners2 = api.useHookRunners();
-                    yield hookRunners2.afterCreateCompiler({ compiler });
+                });
+              },
+              onAfterCreateCompiler(_0) {
+                return __async(this, arguments, function* ({ compiler }) {
+                  const hookRunners2 = api.useHookRunners();
+                  yield hookRunners2.afterCreateCompiler({
+                    compiler
                   });
-                }
+                });
               }
             });
             builder.addPlugins(resolvedConfig.builderPlugins);
@@ -259,7 +260,7 @@ var analyze_default = () => ({
       },
       resolvedConfig({ resolved }) {
         const appContext = api.useAppContext();
-        const config = (0, import_config2.initialNormalizedConfig)(resolved, appContext);
+        const config = (0, import_config2.initialNormalizedConfig)(resolved, appContext, bundler);
         return {
           resolved: config
         };

package/dist/js/node/analyze/nestedRoutes.js

@@ -90,7 +90,7 @@ const createRoute = (routeInfo, rootDir, filename, entryName) => {
   });
 };
 const walk = (dirname, rootDir, alias, entryName) => __async(void 0, null, function* () {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   if (!(yield import_utils.fs.pathExists(dirname))) {
     return null;
   }
@@ -116,6 +116,8 @@ const walk = (dirname, rootDir, alias, entryName) => __async(void 0, null, funct
   };
   let pageLoaderFile = "";
   let pageRoute = null;
+  let splatLoaderFile = "";
+  let splatRoute = null;
   const items = yield import_utils.fs.readdir(dirname);
   for (const item of items) {
     const itemPath = path.join(dirname, item);
@@ -156,6 +158,24 @@ const walk = (dirname, rootDir, alias, entryName) => __async(void 0, null, funct
       }
       (_b = route.children) == null ? void 0 : _b.push(pageRoute);
     }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_LOADER_FILE) {
+      splatLoaderFile = itemPath;
+    }
+    if (itemWithoutExt === import_constants.NESTED_ROUTE.SPLATE_FILE) {
+      splatRoute = createRoute(
+        {
+          _component: (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name),
+          path: "*"
+        },
+        rootDir,
+        itemPath,
+        entryName
+      );
+      if (splatLoaderFile) {
+        splatRoute.loader = splatLoaderFile;
+      }
+      (_c = route.children) == null ? void 0 : _c.push(splatRoute);
+    }
     if (itemWithoutExt === import_constants.NESTED_ROUTE.LOADING_FILE) {
       route.loading = (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name);
     }
@@ -163,7 +183,7 @@ const walk = (dirname, rootDir, alias, entryName) => __async(void 0, null, funct
       route.error = (0, import_utils2.replaceWithAlias)(alias.basename, itemPath, alias.name);
     }
   }
-  const finalRoute = createRoute(
+  let finalRoute = createRoute(
     route,
     rootDir,
     path.join(dirname, `${import_constants.NESTED_ROUTE.LAYOUT_FILE}.ts`),
@@ -172,10 +192,19 @@ const walk = (dirname, rootDir, alias, entryName) => __async(void 0, null, funct
   if (isPathlessLayout) {
     delete finalRoute.path;
   }
-  route.children = (_c = route.children) == null ? void 0 : _c.filter((childRoute) => childRoute);
+  route.children = (_d = route.children) == null ? void 0 : _d.filter((childRoute) => childRoute);
   if (route.children && route.children.length === 0 && !route.index) {
     return null;
   }
+  if (finalRoute.children && finalRoute.children.length === 1 && !finalRoute._component) {
+    const childRoute = finalRoute.children[0];
+    if (childRoute.path === "*") {
+      const path2 = `${finalRoute.path || ""}/${childRoute.path || ""}`;
+      finalRoute = __spreadProps(__spreadValues({}, childRoute), {
+        path: path2
+      });
+    }
+  }
   return finalRoute;
 });
 // Annotate the CommonJS export names for ESM import in node:

package/dist/js/node/analyze/templates.js

@@ -99,6 +99,7 @@ const renderFunction = ({
   customBootstrap,
   fileSystemRoutes: fileSystemRoutes2
 }) => {
+  const bootstrap = "bootstrap(AppWrapper, MOUNT_ID, root, ReactDOM)";
   return `
   const finalAppConfig = {
     ...App.config,
@@ -120,7 +121,7 @@ const renderFunction = ({
 
 
   if (IS_BROWSER) {
-    ${customBootstrap ? `customBootstrap(AppWrapper);` : `bootstrap(AppWrapper, MOUNT_ID, root, ReactDOM);`}
+    ${customBootstrap ? `customBootstrap(AppWrapper, () => ${bootstrap});` : `${bootstrap};`}
   }
 
   return AppWrapper
@@ -228,7 +229,6 @@ const fileSystemRoutes = (_0) => __async(void 0, [_0], function* ({
     import loadable, { lazy as loadableLazy } from "@modern-js/runtime/loadable"
   `;
   let rootLayoutCode = ``;
-  let componentLoaderPath = "";
   const getDataLoaderPath = (loaderId) => {
     if (!ssrMode) {
       return "";
@@ -241,12 +241,6 @@ const fileSystemRoutes = (_0) => __async(void 0, [_0], function* ({
     }
     return dataLoaderPath;
   };
-  if (ssrMode) {
-    componentLoaderPath = `${import_path.default.join(
-      __dirname,
-      "../builder/loaders/routerLoader"
-    )}!`;
-  }
   const traverseRouteTree = (route) => {
     var _a;
     let children;
@@ -282,10 +276,10 @@ const fileSystemRoutes = (_0) => __async(void 0, [_0], function* ({
           rootLayoutCode = `import RootLayout from '${route._component}'`;
           component = `RootLayout`;
         } else if (ssrMode === "string") {
-          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${componentLoaderPath}${route._component}')`;
+          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}')`;
           component = `loadable(${lazyImport})`;
         } else {
-          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${componentLoaderPath}${route._component}')`;
+          lazyImport = `() => import(/* webpackChunkName: "${route.id}" */  '${route._component}')`;
           component = `lazy(${lazyImport})`;
         }
       }

package/dist/js/node/{config/initial → builder/builder-rspack}/index.js

@@ -15,27 +15,17 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var initial_exports = {};
-__export(initial_exports, {
-  checkIsLegacyConfig: () => checkIsLegacyConfig,
-  initialNormalizedConfig: () => initialNormalizedConfig,
-  transformNormalizedConfig: () => import_transformNormalizedConfig.transformNormalizedConfig
+var builder_rspack_exports = {};
+__export(builder_rspack_exports, {
+  createRspackBuilderForModern: () => createRspackBuilderForModern
 });
-module.exports = __toCommonJS(initial_exports);
-var import_inits = require("./inits");
-var import_transformNormalizedConfig = require("./transformNormalizedConfig");
-function checkIsLegacyConfig(config) {
-  return Boolean(config.legacy);
-}
-function initialNormalizedConfig(config, appContext) {
-  (0, import_inits.initHtmlConfig)(config, appContext);
-  (0, import_inits.initSourceConfig)(config, appContext);
-  (0, import_inits.initToolsConfig)(config);
-  return config;
+module.exports = __toCommonJS(builder_rspack_exports);
+var import_builder_rspack_provider = require("@modern-js/builder-rspack-provider");
+var import_generator = require("../generator");
+function createRspackBuilderForModern(options) {
+  return (0, import_generator.generateBuilder)(options, import_builder_rspack_provider.builderRspackProvider);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  checkIsLegacyConfig,
-  initialNormalizedConfig,
-  transformNormalizedConfig
+  createRspackBuilderForModern
 });

package/dist/js/node/builder/builder-webpack/builderPlugins/compatModern.js

@@ -0,0 +1,64 @@
+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 compatModern_exports = {};
+__export(compatModern_exports, {
+  PluginCompatModern: () => PluginCompatModern
+});
+module.exports = __toCommonJS(compatModern_exports);
+var import_path = require("path");
+var import_shared = require("../../shared");
+var import_webpackPlugins = require("../webpackPlugins");
+const PluginCompatModern = (options) => ({
+  name: "builder-plugin-compat-modern",
+  setup(api) {
+    const { normalizedConfig: modernConfig, appContext } = options;
+    api.modifyWebpackChain((chain, { CHAIN_ID }) => {
+      var _a;
+      chain.resolve.modules.add("node_modules").add((0, import_path.join)(api.context.rootPath, "node_modules"));
+      if (chain.plugins.has(CHAIN_ID.PLUGIN.COPY)) {
+        const defaultCopyPattern = (0, import_shared.createCopyPattern)(
+          appContext,
+          modernConfig,
+          "public",
+          chain
+        );
+        chain.plugin(CHAIN_ID.PLUGIN.COPY).tap((args) => {
+          var _a2;
+          return [
+            {
+              patterns: [...((_a2 = args[0]) == null ? void 0 : _a2.patterns) || [], defaultCopyPattern]
+            }
+          ];
+        });
+      }
+      const { entrypoints } = appContext;
+      const existNestedRoutes = entrypoints.some(
+        (entrypoint) => entrypoint.nestedRoutesEntry
+      );
+      const routerConfig = (_a = modernConfig == null ? void 0 : modernConfig.runtime) == null ? void 0 : _a.router;
+      const routerManifest = Boolean(routerConfig == null ? void 0 : routerConfig.manifest);
+      if (existNestedRoutes || routerManifest) {
+        chain.plugin("route-plugin").use(import_webpackPlugins.RouterPlugin);
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginCompatModern
+});

package/dist/js/node/builder/builder-webpack/index.js

@@ -0,0 +1,118 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var builder_webpack_exports = {};
+__export(builder_webpack_exports, {
+  createWebpackBuilderForModern: () => createWebpackBuilderForModern
+});
+module.exports = __toCommonJS(builder_webpack_exports);
+var import_builder_webpack_provider = require("@modern-js/builder-webpack-provider");
+var import_utils = require("@modern-js/utils");
+var import_shared = require("../shared");
+var import_generator = require("../generator");
+var import_compatModern = require("./builderPlugins/compatModern");
+function createWebpackBuilderForModern(options) {
+  return (0, import_generator.generateBuilder)(options, import_builder_webpack_provider.builderWebpackProvider, {
+    modifyBuilderConfig(config) {
+      modifyOutputConfig(config, options.appContext);
+    },
+    modifyBuilderInstance(builder) {
+      return __async(this, null, function* () {
+        yield applyBuilderPlugins(builder, options);
+      });
+    }
+  });
+}
+function modifyOutputConfig(config, appContext) {
+  config.output = createOutputConfig(config, appContext);
+  function createOutputConfig(config2, appContext2) {
+    const defaultCopyPattern = (0, import_shared.createCopyPattern)(appContext2, config2, "upload");
+    const { copy } = config2.output;
+    const copyOptions = Array.isArray(copy) ? copy : copy == null ? void 0 : copy.patterns;
+    const builderCopy = [...copyOptions || [], defaultCopyPattern];
+    return __spreadProps(__spreadValues({}, config2.output), {
+      copy: builderCopy
+    });
+  }
+}
+function applyBuilderPlugins(builder, options) {
+  return __async(this, null, function* () {
+    const { normalizedConfig } = options;
+    if (!normalizedConfig.output.disableNodePolyfill) {
+      const { PluginNodePolyfill } = yield Promise.resolve().then(() => __toESM(require("@modern-js/builder-plugin-node-polyfill")));
+      builder.addPlugins([PluginNodePolyfill()]);
+    }
+    if (normalizedConfig.tools.esbuild) {
+      const { esbuild: esbuildOptions } = normalizedConfig.tools;
+      const { PluginEsbuild } = yield Promise.resolve().then(() => __toESM(require("@modern-js/builder-plugin-esbuild")));
+      builder.addPlugins([
+        PluginEsbuild({
+          loader: false,
+          minimize: (0, import_utils.applyOptionsChain)({}, esbuildOptions)
+        })
+      ]);
+    }
+    builder.addPlugins([(0, import_compatModern.PluginCompatModern)(options)]);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createWebpackBuilderForModern
+});

package/dist/js/node/builder/{webpackPlugins/routerPlugin.js → builder-webpack/webpackPlugins/RouterPlugin.js}

@@ -41,11 +41,11 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-var routerPlugin_exports = {};
-__export(routerPlugin_exports, {
-  default: () => RouterPlugin
+var RouterPlugin_exports = {};
+__export(RouterPlugin_exports, {
+  RouterPlugin: () => RouterPlugin
 });
-module.exports = __toCommonJS(routerPlugin_exports);
+module.exports = __toCommonJS(RouterPlugin_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
 const PLUGIN_NAME = "ModernjsRoutePlugin";
@@ -55,6 +55,9 @@ class RouterPlugin {
     if (target === "node" || Array.isArray(target) && target.includes("node")) {
       return;
     }
+    if (target === "webworker" || Array.isArray(target) && target.includes("webworker")) {
+      return;
+    }
     const { webpack } = compiler;
     const { Compilation, sources } = webpack;
     const { RawSource } = sources;
@@ -132,4 +135,6 @@ class RouterPlugin {
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {});
+0 && (module.exports = {
+  RouterPlugin
+});

package/dist/js/node/builder/builder-webpack/webpackPlugins/index.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webpackPlugins_exports = {};
+module.exports = __toCommonJS(webpackPlugins_exports);
+__reExport(webpackPlugins_exports, require("./RouterPlugin"), module.exports);

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

@@ -0,0 +1,47 @@
+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 createBuilderOptions_exports = {};
+__export(createBuilderOptions_exports, {
+  createBuilderOptions: () => createBuilderOptions
+});
+module.exports = __toCommonJS(createBuilderOptions_exports);
+function createBuilderOptions(target, appContext) {
+  const entries = {};
+  const { entrypoints = [], checkedEntries } = appContext;
+  for (const { entryName, entry } of entrypoints) {
+    if (checkedEntries && !checkedEntries.includes(entryName)) {
+      continue;
+    }
+    if (entryName in entries) {
+      entries[entryName].push(entry);
+    } else {
+      entries[entryName] = [entry];
+    }
+  }
+  return {
+    cwd: appContext.appDirectory,
+    target,
+    configPath: appContext.configFile || void 0,
+    entry: entries,
+    framework: appContext.metaName
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBuilderOptions
+});

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

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 createBuilderProviderConfig_exports = {};
+__export(createBuilderProviderConfig_exports, {
+  createBuilderProviderConfig: () => createBuilderProviderConfig
+});
+module.exports = __toCommonJS(createBuilderProviderConfig_exports);
+function createBuilderProviderConfig(resolveConfig, appContext, modifyBuilderConfig) {
+  const htmlConfig = __spreadValues({}, resolveConfig.html);
+  if (!htmlConfig.template) {
+    htmlConfig.templateByEntries = __spreadValues(__spreadValues({}, htmlConfig.templateByEntries), appContext.htmlTemplates);
+  }
+  const config = __spreadProps(__spreadValues({}, resolveConfig), {
+    dev: __spreadProps(__spreadValues({}, resolveConfig.dev), {
+      port: appContext.port
+    }),
+    html: htmlConfig,
+    output: __spreadProps(__spreadValues({}, resolveConfig.output), {
+      cleanDistPath: false
+    })
+  });
+  modifyBuilderConfig == null ? void 0 : modifyBuilderConfig(config);
+  return config;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBuilderProviderConfig
+});