@umijs/preset-umi 4.0.13 → 4.0.16

package/dist/commands/dev/dev.js

@@ -45,6 +45,7 @@ module.exports = __toCommonJS(dev_exports);
 var import_utils = require("@umijs/utils");
 var import_fs = require("fs");
 var import_path = require("path");
+var import_worker_threads = require("worker_threads");
 var import_constants = require("../../constants");
 var import_AutoUpdateSourceCodeCache = require("../../libs/folderCache/AutoUpdateSourceCodeCache");
 var import_lazyImportFromCurrentPkg = require("../../utils/lazyImportFromCurrentPkg");
@@ -236,6 +237,8 @@ PORT=8888 umi dev
       };
       const debouncedPrintMemoryUsage = import_utils.lodash.debounce(import_printMemoryUsage.printMemoryUsage, 5e3);
       let srcCodeCache;
+      let startBuildWorker = () => {
+      };
       if (((_b = api.config.mfsu) == null ? void 0 : _b.strategy) === "eager") {
         srcCodeCache = new import_AutoUpdateSourceCodeCache.AutoUpdateSrcCodeCache({
           cwd: api.paths.absSrcPath,
@@ -245,17 +248,34 @@ PORT=8888 umi dev
         (0, import_watch.addUnWatch)(() => {
           srcCodeCache.unwatch();
         });
+        let currentWorker = null;
+        const initWorker = () => {
+          currentWorker = new import_worker_threads.Worker((0, import_path.join)(__dirname, "depBuildWorker/depBuildWorker.js"));
+          currentWorker.on("exit", () => {
+            initWorker();
+          });
+          return currentWorker;
+        };
+        currentWorker = initWorker();
+        startBuildWorker = () => {
+          return currentWorker;
+        };
       }
+      const entry = await api.applyPlugins({
+        key: "modifyEntry",
+        initialValue: {
+          umi: (0, import_path.join)(api.paths.absTmpPath, "umi.ts")
+        }
+      });
       const opts = __spreadProps(__spreadValues({
         config: api.config,
         pkg: api.pkg,
         cwd: api.cwd,
         rootDir: process.cwd(),
-        entry: {
-          umi: (0, import_path.join)(api.paths.absTmpPath, "umi.ts")
-        },
+        entry,
         port: api.appData.port,
-        host: api.appData.host
+        host: api.appData.host,
+        ip: api.appData.ip
       }, enableVite ? { modifyViteConfig } : { babelPreset, chainWebpack, modifyWebpackConfig }), {
         beforeBabelPlugins,
         beforeBabelPresets,
@@ -265,7 +285,7 @@ PORT=8888 umi dev
           ...beforeMiddlewares
         ]),
         afterMiddlewares: enableVite ? [] : middlewares.concat([
-          (0, import_createRouteMiddleware.createRouteMiddleware)({ api }),
+          ...api.config.mpa ? [] : [(0, import_createRouteMiddleware.createRouteMiddleware)({ api })],
           import_faviconMiddleware.faviconMiddleware
         ]),
         onDevCompileDone(opts2) {
@@ -294,8 +314,12 @@ PORT=8888 umi dev
         mfsuInclude: import_utils.lodash.union([
           ...MFSU_EAGER_DEFAULT_INCLUDE,
           ...((_e = api.config.mfsu) == null ? void 0 : _e.include) || []
-        ])
+        ]),
+        startBuildWorker
       });
+      if (api.config.mf) {
+        opts.mfsuServerBase = `${api.config.https ? "https" : "http"}://${api.appData.ip}:${api.appData.port}`;
+      }
       if (enableVite) {
         await bundlerVite.dev(opts);
       } else {
@@ -308,6 +332,7 @@ PORT=8888 umi dev
       port: parseInt(String(process.env.PORT || import_constants.DEFAULT_PORT), 10)
     });
     memo.host = process.env.HOST || import_constants.DEFAULT_HOST;
+    memo.ip = import_utils.address.ip();
     return memo;
   });
   api.registerMethod({

package/dist/commands/generators/jest.js

@@ -66,6 +66,7 @@ var jest_default = (api) => {
         initial: true
       });
       const hasSrc = api.paths.absSrcPath.endsWith("src");
+      const importSource = api.appData.umi.importSource;
       const basicDeps = {
         jest: "^27",
         "@types/jest": "^27",
@@ -79,12 +80,12 @@ var jest_default = (api) => {
       }) : basicDeps;
       h.addDevDeps(packageToInstall);
       h.addScript("test", "jest");
-      if (res.willUseTLR) {
-        (0, import_fs.writeFileSync)((0, import_path.join)(api.cwd, "jest-setup.ts"), `import '@testing-library/jest-dom';
-          `.trimLeft());
-        import_utils.logger.info("Write jest-setup.ts");
-      }
-      const importSource = api.appData.umi.importSource;
+      const setupImports = res.willUseTLR ? [
+        `import '@testing-library/jest-dom';`,
+        `import '${api.appData.umi.importSource}/test-setup'`
+      ] : [`import '${api.appData.umi.importSource}/test-setup'`];
+      (0, import_fs.writeFileSync)((0, import_path.join)(api.cwd, "jest-setup.ts"), setupImports.join("\n"));
+      import_utils.logger.info("Write jest-setup.ts");
       const collectCoverageFrom = hasSrc ? [
         "src/**/*.{ts,js,tsx,jsx}",
         "!src/.umi/**",
@@ -115,7 +116,9 @@ export default async () => {
       jsTransformerOpts: { jsx: 'automatic' },
     }),
     ${res.willUseTLR ? `setupFilesAfterEnv: ['<rootDir>/jest-setup.ts'],` : ""}
-    collectCoverageFrom: [${collectCoverageFrom.map((v) => `'${v}'`).join(", ")}],
+    collectCoverageFrom: [
+${collectCoverageFrom.map((v) => `      '${v}'`).join(",\n")}
+    ],
     // if you require some es-module npm package, please uncomment below line and insert your package name
     // transformIgnorePatterns: ['node_modules/(?!.*(lodash-es|your-es-pkg-name)/)']
   })) as Config.InitialOptions;

package/dist/features/404/404.d.ts

@@ -0,0 +1,5 @@
+import { IApi, IRoute } from '../../types';
+declare type Routes = Record<string, IRoute>;
+export declare function patchRoutes(routes: Routes): Routes;
+declare const _default: (api: IApi) => void;
+export default _default;

package/dist/features/404/404.js

@@ -0,0 +1,48 @@
+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);
+
+// src/features/404/404.ts
+var __exports = {};
+__export(__exports, {
+  default: () => __default,
+  patchRoutes: () => patchRoutes
+});
+module.exports = __toCommonJS(__exports);
+function patchRoutes(routes) {
+  Object.keys(routes).forEach((key) => {
+    if (routes[key].path === "404") {
+      routes[key].path = "*";
+    }
+  });
+  return routes;
+}
+var __default = (api) => {
+  api.describe({
+    key: "404"
+  });
+  api.modifyRoutes(async (routes) => {
+    if (api.config.routes) {
+      return routes;
+    }
+    return patchRoutes(routes);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  patchRoutes
+});

package/dist/features/apiRoute/request.js

@@ -149,7 +149,7 @@ function parseMultipart(body, boundary) {
 function parseUrlEncoded(body) {
   return body.split("&").reduce((acc, cur) => {
     const [key, value] = cur.split("=");
-    acc[key] = decodeURI(value);
+    acc[key] = decodeURIComponent(value);
     return acc;
   }, {});
 }

package/dist/features/appData/appData.js

@@ -45,7 +45,8 @@ var appData_default = (api) => {
     memo.umi = {
       version: require("../../../package.json").version,
       name: "Umi",
-      importSource: "umi"
+      importSource: "umi",
+      cliName: "umi"
     };
     memo.bundleStatus = {
       done: false

package/dist/features/legacy/legacy.d.ts

@@ -0,0 +1,3 @@
+import type { IApi } from '../../types';
+declare const _default: (api: IApi) => void;
+export default _default;

package/dist/features/legacy/legacy.js

@@ -0,0 +1,133 @@
+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);
+
+// src/features/legacy/legacy.ts
+var legacy_exports = {};
+__export(legacy_exports, {
+  default: () => legacy_default
+});
+module.exports = __toCommonJS(legacy_exports);
+var import_types = require("@umijs/bundler-webpack/dist/types");
+var import_utils = require("@umijs/utils");
+var legacy_default = (api) => {
+  api.describe({
+    key: "legacy",
+    config: {
+      schema(Joi) {
+        return Joi.object({
+          buildOnly: Joi.boolean(),
+          nodeModulesTransform: Joi.boolean()
+        });
+      }
+    },
+    enableBy: api.EnableBy.config
+  });
+  api.modifyConfig({
+    stage: Number.MAX_SAFE_INTEGER,
+    fn: (memo) => {
+      const { userConfig } = api;
+      const { buildOnly = true, nodeModulesTransform = true } = api.config.legacy || userConfig.legacy || {};
+      if (api.env === import_types.Env.development) {
+        if (buildOnly) {
+          return memo;
+        }
+        memo.mfsu = false;
+        import_utils.logger.warn(`mfsu is not supported in ${import_utils.chalk.cyan("legacy")} mode, we automatically close mfsu`);
+      }
+      if (userConfig.srcTranspiler || userConfig.jsMinifier || userConfig.cssMinifier) {
+        import_utils.logger.fatal(`Manual configuration of ${[
+          "srcTranspiler",
+          "jsMinifier",
+          "cssMinifier"
+        ].map((i) => import_utils.chalk.yellow(i)).join(", ")} is not supported when ${import_utils.chalk.cyan("legacy")} build mode enabled.`);
+        throw new Error("Manual configuration of legacy mode is not supported.");
+      }
+      memo.srcTranspiler = import_types.Transpiler.babel;
+      memo.jsMinifier = import_types.JSMinifier.terser;
+      memo.cssMinifier = import_types.CSSMinifier.cssnano;
+      memo.targets = __spreadProps(__spreadValues({}, userConfig.targets), {
+        ie: 11
+      });
+      import_utils.logger.ready(`${import_utils.chalk.cyan("legacy")} mode is enabled, we automatically modify the ${[
+        "srcTranspiler",
+        "jsMinifier",
+        "cssMinifier"
+      ].map((i) => import_utils.chalk.yellow(i)).join(", ")} to be compatible with IE 11`);
+      const originChainWebpack = userConfig.chainWebpack;
+      memo.chainWebpack = (memo2, ...args) => {
+        if (originChainWebpack) {
+          originChainWebpack(memo2, ...args);
+        }
+        if (nodeModulesTransform) {
+          memo2.module.rule("extra-src").include.add(/node_modules/).end();
+        }
+        memo2.module.rule("extra-src").exclude.add(/core-js/).add(/node_modules\/(css-loader)/).end();
+        useBabelTransformSvgr(memo2, api);
+        if (!import_utils.lodash.isEmpty(userConfig.externals)) {
+          const externalsAsString = JSON.stringify(userConfig.externals);
+          const externalsType = memo2.get("externalsType");
+          if (externalsAsString.includes("script ") || externalsType) {
+            import_utils.logger.warn(`Legacy browsers do not support ${import_utils.chalk.yellow("Top level await")}, ensure you are not using both ${import_utils.chalk.bold.red(`Top level sync import`)} and ${import_utils.chalk.bold.red("Async externalsType (e.g. script)")}`);
+          }
+        }
+        return memo2;
+      };
+      return memo;
+    }
+  });
+};
+function useBabelTransformSvgr(memo, api) {
+  memo.module.rule("svgr").use("babel-loader").loader(require.resolve("@umijs/bundler-webpack/compiled/babel-loader")).options({
+    sourceType: "unambiguous",
+    babelrc: false,
+    cacheDirectory: false,
+    targets: api.config.targets,
+    presets: [
+      [
+        require.resolve("@umijs/babel-preset-umi"),
+        {
+          presetEnv: {},
+          presetReact: {},
+          presetTypeScript: {}
+        }
+      ]
+    ]
+  }).before("svgr-loader").end();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/dist/features/mpa/extractExports.d.ts

@@ -0,0 +1,4 @@
+export declare function extractExports(opts: {
+    entry: string;
+    exportName: string;
+}): Promise<Record<string, any>>;

package/dist/features/mpa/extractExports.js

@@ -0,0 +1,112 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __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);
+
+// src/features/mpa/extractExports.ts
+var extractExports_exports = {};
+__export(extractExports_exports, {
+  extractExports: () => extractExports
+});
+module.exports = __toCommonJS(extractExports_exports);
+var import_esbuild = __toESM(require("@umijs/bundler-utils/compiled/esbuild"));
+async function extractExports(opts) {
+  const res = await import_esbuild.default.build({
+    format: "cjs",
+    platform: "browser",
+    target: "esnext",
+    loader: {
+      ".aac": "text",
+      ".css": "text",
+      ".less": "text",
+      ".sass": "text",
+      ".scss": "text",
+      ".eot": "text",
+      ".flac": "text",
+      ".gif": "text",
+      ".ico": "text",
+      ".jpeg": "text",
+      ".jpg": "text",
+      ".js": "jsx",
+      ".jsx": "jsx",
+      ".json": "json",
+      ".md": "jsx",
+      ".mdx": "jsx",
+      ".mp3": "text",
+      ".mp4": "text",
+      ".ogg": "text",
+      ".otf": "text",
+      ".png": "text",
+      ".svg": "text",
+      ".ts": "ts",
+      ".tsx": "tsx",
+      ".ttf": "text",
+      ".wav": "text",
+      ".webm": "text",
+      ".webp": "text",
+      ".woff": "text",
+      ".woff2": "text"
+    },
+    bundle: true,
+    write: false,
+    entryPoints: [`${opts.entry}?entry`],
+    plugins: [
+      {
+        name: "virtual-entry",
+        setup(build) {
+          build.onResolve({ filter: /\?entry$/ }, (args) => {
+            return {
+              path: args.path.split("?")[0],
+              namespace: "entry"
+            };
+          });
+          build.onResolve({ filter: /^[@a-z0-9-_~]/ }, (args) => {
+            return {
+              path: args.path,
+              external: true,
+              sideEffects: false
+            };
+          });
+          build.onResolve({ filter: /^\// }, (args) => {
+            return {
+              path: args.path
+            };
+          });
+          build.onLoad({ filter: /.*/, namespace: "entry" }, (args) => {
+            return {
+              contents: `
+import * as x from "${args.path}";
+ret = x.${opts.exportName} || {};
+              `,
+              loader: "ts"
+            };
+          });
+        }
+      }
+    ]
+  });
+  let ret = {};
+  let code = res.outputFiles[0].text;
+  eval(`(() => { ${code}; })();`);
+  return ret;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractExports
+});

package/dist/features/mpa/mpa.d.ts

@@ -0,0 +1,3 @@
+import { IApi } from '../../types';
+declare const _default: (api: IApi) => void;
+export default _default;

package/dist/features/mpa/mpa.js

@@ -0,0 +1,207 @@
+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);
+
+// src/features/mpa/mpa.ts
+var mpa_exports = {};
+__export(mpa_exports, {
+  default: () => mpa_default
+});
+module.exports = __toCommonJS(mpa_exports);
+var import_utils = require("@umijs/utils");
+var import_assert = __toESM(require("assert"));
+var import_fs = require("fs");
+var import_html_webpack_plugin = __toESM(require("html-webpack-plugin"));
+var import_path = require("path");
+var import_extractExports = require("./extractExports");
+var mpa_default = (api) => {
+  api.describe({
+    key: "mpa",
+    config: {
+      schema(Joi) {
+        return Joi.object({
+          template: Joi.string(),
+          getConfigFromEntryFile: Joi.boolean()
+        });
+      }
+    },
+    enableBy: api.EnableBy.config
+  });
+  api.onStart(() => {
+    import_utils.logger.warn(import_utils.chalk.yellow("[MPA] MPA Mode Enabled"));
+  });
+  api.modifyAppData(async (memo) => {
+    memo.mpa = {
+      entry: await collectEntryWithTimeCount(api.paths.absPagesPath, api.config.mpa)
+    };
+    return memo;
+  });
+  api.onGenerateFiles(async ({ isFirstTime }) => {
+    if (!isFirstTime) {
+      api.appData.mpa.entry = await collectEntryWithTimeCount(api.paths.absPagesPath, api.config.mpa);
+    }
+    const isReact18 = api.appData.react.version.startsWith("18.");
+    api.appData.mpa.entry.forEach((entry) => {
+      const layoutImport = entry.layout ? `import Layout from '${entry.layout}';` : "";
+      const layoutJSX = entry.layout ? `<Layout><App /></Layout>` : `<App />`;
+      const rootElement = `document.getElementById('${entry.mountElementId}')`;
+      const renderer = isReact18 ? `ReactDOM.createRoot(${rootElement}).render(${layoutJSX});` : `ReactDOM.render(${layoutJSX}, ${rootElement});`;
+      const reactDOMSource = isReact18 ? "react-dom/client" : "react-dom";
+      api.writeTmpFile({
+        path: entry.tmpFilePath,
+        noPluginDir: true,
+        content: `
+import React from 'react';
+import ReactDOM from '${reactDOMSource}';
+import App from '${entry.file}';
+${layoutImport}
+${renderer}
+        `.trimStart()
+      });
+    });
+    api.writeTmpFile({
+      path: "mpa/template.html",
+      noPluginDir: true,
+      content: `
+<!DOCTYPE html>
+<html>
+<head><title><%= title %></title></head>
+<body>
+<div id="<%= mountElementId %>"></div>
+</body>
+</html>
+      `.trimStart()
+    });
+  });
+  api.modifyEntry((memo) => {
+    if ("umi" in memo)
+      delete memo["umi"];
+    api.appData.mpa.entry.forEach((entry) => {
+      memo[entry.name] = (0, import_path.join)(api.paths.absTmpPath, entry.tmpFilePath);
+    });
+    return memo;
+  });
+  api.chainWebpack((memo) => {
+    api.appData.mpa.entry.forEach((entry) => {
+      memo.plugin(`html-${entry.name}`).use(import_html_webpack_plugin.default, [
+        {
+          filename: `${entry.name}.html`,
+          minify: false,
+          template: entry.template ? (0, import_path.resolve)(api.cwd, entry.template) : api.config.mpa.template ? (0, import_path.resolve)(api.cwd, api.config.mpa.template) : (0, import_path.join)(api.paths.absTmpPath, "mpa/template.html"),
+          templateParameters: entry,
+          chunks: [entry.name]
+        }
+      ]);
+    });
+    return memo;
+  });
+};
+async function collectEntryWithTimeCount(root, opts) {
+  const d = new Date();
+  const entries = await collectEntry(root, opts);
+  import_utils.logger.info(`[MPA] Collect Entries in ${new Date().getTime() - d.getTime()}ms`);
+  return entries;
+}
+async function collectEntry(root, opts) {
+  return await (0, import_fs.readdirSync)(root).reduce(async (memoP, dir) => {
+    const memo = await memoP;
+    const absDir = (0, import_path.join)(root, dir);
+    if ((0, import_fs.existsSync)(absDir) && (0, import_fs.statSync)(absDir).isDirectory()) {
+      const indexFile = getIndexFile(absDir);
+      if (indexFile) {
+        const config = opts.getConfigFromEntryFile ? await getConfigFromEntryFile(indexFile) : await getConfig(indexFile);
+        memo.push(__spreadProps(__spreadValues({
+          name: dir,
+          file: indexFile,
+          tmpFilePath: `mpa/${dir}${(0, import_path.extname)(indexFile)}`,
+          mountElementId: "root"
+        }, config), {
+          title: config.title || dir
+        }));
+      }
+    }
+    return memo;
+  }, Promise.resolve([]));
+}
+function getIndexFile(dir) {
+  if ((0, import_fs.existsSync)((0, import_path.join)(dir, "index.tsx")))
+    return (0, import_path.join)(dir, "index.tsx");
+  if ((0, import_fs.existsSync)((0, import_path.join)(dir, "index.ts")))
+    return (0, import_path.join)(dir, "index.ts");
+  if ((0, import_fs.existsSync)((0, import_path.join)(dir, "index.jsx")))
+    return (0, import_path.join)(dir, "index.jsx");
+  if ((0, import_fs.existsSync)((0, import_path.join)(dir, "index.js")))
+    return (0, import_path.join)(dir, "index.js");
+  return null;
+}
+async function getConfig(indexFile) {
+  const dir = (0, import_path.dirname)(indexFile);
+  if ((0, import_fs.existsSync)((0, import_path.join)(dir, "config.json"))) {
+    const config = JSON.parse((0, import_fs.readFileSync)((0, import_path.join)(dir, "config.json"), "utf-8"));
+    checkConfig(config);
+    return config;
+  } else {
+    return {};
+  }
+}
+async function getConfigFromEntryFile(indexFile) {
+  const config = await (0, import_extractExports.extractExports)({
+    entry: indexFile,
+    exportName: "config"
+  });
+  checkConfig(config);
+  return config;
+}
+function checkConfig(config) {
+  if (config.layout) {
+    (0, import_assert.default)(typeof config.layout === "string" && (config.layout.startsWith("@/") || config.layout.startsWith("/")), `layout must be an absolute path or start with '@/'`);
+  }
+  if (config.template) {
+    (0, import_assert.default)(typeof config.template === "string", "template must be string");
+  }
+  if (config.title) {
+    (0, import_assert.default)(typeof config.title === "string", "title must be string");
+  }
+  if (config.head) {
+    (0, import_assert.default)(Array.isArray(config.head), "head must be string");
+  }
+  if (config.scripts) {
+    (0, import_assert.default)(Array.isArray(config.scripts), "scripts must be string");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});