@modern-js/app-tools 2.7.0 → 2.7.1-alpha.0

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

@@ -0,0 +1,67 @@
+import { getEntryOptions } from "@modern-js/utils";
+import { template as lodashTemplate } from "@modern-js/utils/lodash";
+import { BottomTemplatePlugin } from "../bundlerPlugins";
+function isHtmlEnabled(config, target) {
+  var _a;
+  return ((_a = config.tools) == null ? void 0 : _a.htmlPlugin) !== false && target !== "node" && target !== "service-worker" && target !== "web-worker";
+}
+const builderPluginAdapterHtml = (options) => ({
+  name: "builder-plugin-adpater-modern-html",
+  setup(api) {
+    api.modifyBundlerChain(
+      (chain, { CHAIN_ID, target, HtmlPlugin: HtmlBundlerPlugin }) => {
+        const builderConfig = api.getNormalizedConfig();
+        if (isHtmlEnabled(builderConfig, target)) {
+          applyBottomHtmlPlugin({
+            api,
+            options,
+            chain,
+            CHAIN_ID,
+            HtmlBundlerPlugin
+          });
+        }
+      }
+    );
+  }
+});
+function applyBottomHtmlPlugin({
+  api,
+  chain,
+  options,
+  CHAIN_ID,
+  HtmlBundlerPlugin
+}) {
+  const { normalizedConfig: modernConfig, appContext } = options;
+  for (const entryName of Object.keys(api.context.entry)) {
+    const baseTemplateParams = {
+      entryName,
+      title: getEntryOptions(
+        entryName,
+        modernConfig.html.title,
+        modernConfig.html.titleByEntries,
+        appContext.packageName
+      ),
+      mountId: modernConfig.html.mountId,
+      ...getEntryOptions(
+        entryName,
+        modernConfig.html.templateParameters,
+        modernConfig.html.templateParametersByEntries,
+        appContext.packageName
+      )
+    };
+    chain.plugin(`${CHAIN_ID.PLUGIN.HTML}-${entryName}`).tap((args) => [
+      {
+        ...args[0] || {},
+        __internal__: true,
+        bottomTemplate: appContext.htmlTemplates[`__${entryName}-bottom__`] && lodashTemplate(appContext.htmlTemplates[`__${entryName}-bottom__`])(
+          baseTemplateParams
+        )
+      }
+    ]);
+  }
+  chain.plugin(CHAIN_ID.PLUGIN.BOTTOM_TEMPLATE).use(BottomTemplatePlugin, [HtmlBundlerPlugin]);
+}
+export {
+  builderPluginAdapterHtml,
+  isHtmlEnabled
+};

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

@@ -0,0 +1,119 @@
+import {
+  mergeBuilderConfig
+} from "@modern-js/builder-shared";
+import { HtmlAsyncChunkPlugin, RouterPlugin } from "../bundlerPlugins";
+import { isHtmlEnabled } from "./adapterHtml";
+const builderPluginAdapterSSR = (options) => ({
+  name: "builder-plugin-adapter-modern-ssr",
+  setup(api) {
+    const { normalizedConfig } = options;
+    api.modifyBuilderConfig((config) => {
+      if (isStreamingSSR(normalizedConfig)) {
+        return mergeBuilderConfig(config, {
+          html: {
+            inject: "body"
+          }
+        });
+      }
+      return config;
+    });
+    api.modifyBundlerChain(
+      (chain, { target, CHAIN_ID, isProd, HtmlPlugin: HtmlBundlerPlugin }) => {
+        const builderConfig = api.getNormalizedConfig();
+        applyRouterPlugin(chain, options);
+        if (["node", "service-worker"].includes(target)) {
+          applyFilterEntriesBySSRConfig({
+            isProd,
+            chain,
+            appNormalizedConfig: options.normalizedConfig
+          });
+        }
+        if (isHtmlEnabled(builderConfig, target)) {
+          applyAsyncChunkHtmlPlugin({
+            chain,
+            modernConfig: options.normalizedConfig,
+            CHAIN_ID,
+            HtmlBundlerPlugin
+          });
+        }
+      }
+    );
+  }
+});
+const isStreamingSSR = (userConfig) => {
+  const isStreaming = (ssr) => ssr && typeof ssr === "object" && ssr.mode === "stream";
+  const { server } = userConfig;
+  if (isStreaming(server.ssr)) {
+    return true;
+  }
+  if ((server == null ? void 0 : server.ssrByEntries) && typeof server.ssrByEntries === "object") {
+    for (const name of Object.keys(server.ssrByEntries)) {
+      if (isStreaming(server.ssrByEntries[name])) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+function applyAsyncChunkHtmlPlugin({
+  chain,
+  modernConfig,
+  CHAIN_ID,
+  HtmlBundlerPlugin
+}) {
+  if (isStreamingSSR(modernConfig)) {
+    chain.plugin(CHAIN_ID.PLUGIN.HTML_ASYNC_CHUNK).use(HtmlAsyncChunkPlugin, [HtmlBundlerPlugin]);
+  }
+}
+function applyRouterPlugin(chain, options) {
+  var _a;
+  const { appContext, normalizedConfig } = options;
+  const { entrypoints } = appContext;
+  const existNestedRoutes = entrypoints.some(
+    (entrypoint) => entrypoint.nestedRoutesEntry
+  );
+  const routerConfig = (_a = normalizedConfig == null ? void 0 : normalizedConfig.runtime) == null ? void 0 : _a.router;
+  const routerManifest = Boolean(routerConfig == null ? void 0 : routerConfig.manifest);
+  if (existNestedRoutes || routerManifest) {
+    chain.plugin("route-plugin").use(RouterPlugin);
+  }
+}
+function applyFilterEntriesBySSRConfig({
+  isProd,
+  chain,
+  appNormalizedConfig
+}) {
+  var _a;
+  const { server: serverConfig, output: outputConfig } = appNormalizedConfig;
+  const entries = chain.entryPoints.entries();
+  if (isProd && ((outputConfig == null ? void 0 : outputConfig.ssg) === true || typeof ((_a = outputConfig == null ? void 0 : outputConfig.ssg) == null ? void 0 : _a[0]) === "function")) {
+    return;
+  }
+  if (typeof entries === "undefined") {
+    throw new Error(
+      "No entry found, one of src/routes/layout.tsx, src/App.tsx, src/index.tsx is required"
+    );
+  }
+  const entryNames = Object.keys(entries);
+  if (isProd && entryNames.length === 1 && (outputConfig == null ? void 0 : outputConfig.ssg)) {
+    return;
+  }
+  const ssgEntries = [];
+  if (isProd && (outputConfig == null ? void 0 : outputConfig.ssg)) {
+    const { ssg } = outputConfig;
+    entryNames.forEach((name) => {
+      if (ssg[name]) {
+        ssgEntries.push(name);
+      }
+    });
+  }
+  const { ssr, ssrByEntries } = serverConfig || {};
+  entryNames.forEach((name) => {
+    if (!ssgEntries.includes(name) && (ssr && (ssrByEntries == null ? void 0 : ssrByEntries[name]) === false || !ssr && !(ssrByEntries == null ? void 0 : ssrByEntries[name]))) {
+      chain.entryPoints.delete(name);
+    }
+  });
+}
+export {
+  builderPluginAdapterSSR
+};

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

@@ -0,0 +1,3 @@
+export * from "./adapterBasic";
+export * from "./adapterHtml";
+export * from "./adapterSSR";

package/dist/esm-node/builder/{builder-webpack/webpackPlugins → shared/bundlerPlugins}/RouterPlugin.js

@@ -38,7 +38,7 @@ class RouterPlugin {
             chunkGroups: true,
             chunks: true
           });
-          const { publicPath } = stats;
+          const { publicPath, chunks = [] } = stats;
           const routeAssets = {};
           const { namedChunkGroups, assetsByChunkName } = stats;
           if (!namedChunkGroups || !assetsByChunkName) {
@@ -71,17 +71,23 @@ class RouterPlugin {
           const entryChunkIds = entrypointsArray.map(
             (entrypoint) => entrypoint[0]
           );
-          const entryChunks = [...compilation.chunks].filter((chunk) => {
-            return entryChunkIds.includes(chunk.name);
+          const entryChunks = [...chunks].filter((chunk) => {
+            var _a;
+            return (_a = chunk.names) == null ? void 0 : _a.some((name) => entryChunkIds.includes(name));
           });
           const entryChunkFiles = entryChunks.map(
-            (chunk) => [...chunk.files].find((fname) => fname.includes(".js"))
+            (chunk) => [...chunk.files || []].find((fname) => fname.includes(".js"))
           );
           for (const file of entryChunkFiles) {
             const asset = compilation.assets[file];
             const newContent = `${injectedContent}${asset.source().toString()}`;
             newAssetsMap.set(path.join(outputPath, file), newContent);
-            compilation.updateAsset(file, new RawSource(newContent));
+            compilation.updateAsset(
+              file,
+              new RawSource(newContent),
+              // FIXME: The arguments third of updatgeAsset is a optional function in webpack.
+              void 0
+            );
           }
           const filename = path.join(outputPath, ROUTE_MINIFEST_FILE);
           await fs.ensureFile(filename);

package/dist/esm-node/builder/shared/bundlerPlugins/index.js

@@ -0,0 +1,3 @@
+export * from "./HtmlAsyncChunkPlugin";
+export * from "./HtmlBottomTemplate";
+export * from "./RouterPlugin";

package/dist/esm-node/builder/shared/index.js

@@ -1,3 +1,3 @@
 export * from "./createCopyPattern";
 export * from "./types";
-export * from "./builderPlugins/adapterModern";
+export * from "./builderPlugins";

package/dist/esm-node/index.js

@@ -23,7 +23,7 @@ const upgradeModel = Import.lazy(
 const devCommand = async (program, api) => {
   const runner = api.useHookRunners();
   const devToolMetas = await runner.registerDev();
-  const devProgram = program.command("dev").alias("start").usage("[options]").description(i18n.t(localeKeys.command.dev.describe)).option("-c --config <config>", i18n.t(localeKeys.command.shared.config)).option("-e --entry [entry...]", i18n.t(localeKeys.command.dev.entry)).option("--analyze", i18n.t(localeKeys.command.shared.analyze)).option("--api-only", i18n.t(localeKeys.command.dev.apiOnly)).action(async (options) => {
+  const devProgram = program.command("dev").alias("start").usage("[options]").description(i18n.t(localeKeys.command.dev.describe)).option("-c --config <config>", i18n.t(localeKeys.command.shared.config)).option("-e --entry [entry...]", i18n.t(localeKeys.command.dev.entry)).option("--analyze", i18n.t(localeKeys.command.shared.analyze)).option("--api-only", i18n.t(localeKeys.command.dev.apiOnly)).option("--web-only", i18n.t(localeKeys.command.dev.webOnly)).action(async (options) => {
     const { dev } = await import("./commands/dev");
     await dev(api, options);
   });

package/dist/esm-node/locale/en.js

@@ -8,6 +8,7 @@ const EN_LOCALE = {
       describe: "start dev server",
       entry: "compiler by entry",
       apiOnly: "start api server only",
+      webOnly: "start web server only",
       selectEntry: "Please select the entry that needs to be built",
       requireEntry: "You must choose at least one entry"
     },

package/dist/esm-node/locale/zh.js

@@ -8,6 +8,7 @@ const ZH_LOCALE = {
       describe: "本地开发命令",
       entry: "指定入口，编译特定的页面",
       apiOnly: "仅启动 API 接口服务",
+      webOnly: "仅启动 Web 服务",
       selectEntry: "请选择需要构建的入口",
       requireEntry: "请至少选择一个入口"
     },

package/dist/js/modern/analyze/constants.js

@@ -0,0 +1,54 @@
+const JS_EXTENSIONS = [".js", ".ts", ".jsx", ".tsx"];
+const INDEX_FILE_NAME = "index";
+const APP_FILE_NAME = "App";
+const PAGES_DIR_NAME = "pages";
+const NESTED_ROUTES_DIR = "routes";
+const FILE_SYSTEM_ROUTES_FILE_NAME = "routes.js";
+const LOADER_EXPORT_NAME = "loader";
+const TEMP_LOADERS_DIR = "__loaders__";
+const ENTRY_POINT_FILE_NAME = "index.js";
+const ENTRY_BOOTSTRAP_FILE_NAME = "bootstrap.js";
+const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
+const FILE_SYSTEM_ROUTES_LAYOUT = "_layout";
+const FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = "_app";
+const FILE_SYSTEM_ROUTES_INDEX = "index";
+const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
+const HTML_PARTIALS_FOLDER = "html";
+const HTML_PARTIALS_EXTENSIONS = [".htm", ".html", ".ejs"];
+const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = "internal_components";
+const NESTED_ROUTE = {
+  LAYOUT_FILE: "layout",
+  LAYOUT_LOADER_FILE: "layout.loader",
+  PAGE_FILE: "page",
+  PAGE_LOADER_FILE: "page.loader",
+  LOADING_FILE: "loading",
+  ERROR_FILE: "error",
+  LOADER_FILE: "loader"
+};
+const APP_CONFIG_NAME = "config";
+const APP_INIT_EXPORTED = "init";
+const APP_INIT_IMPORTED = "appInit";
+export {
+  APP_CONFIG_NAME,
+  APP_FILE_NAME,
+  APP_INIT_EXPORTED,
+  APP_INIT_IMPORTED,
+  ENTRY_BOOTSTRAP_FILE_NAME,
+  ENTRY_POINT_FILE_NAME,
+  FILE_SYSTEM_ROUTES_COMPONENTS_DIR,
+  FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP,
+  FILE_SYSTEM_ROUTES_FILE_NAME,
+  FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT,
+  FILE_SYSTEM_ROUTES_IGNORED_REGEX,
+  FILE_SYSTEM_ROUTES_INDEX,
+  FILE_SYSTEM_ROUTES_LAYOUT,
+  HTML_PARTIALS_EXTENSIONS,
+  HTML_PARTIALS_FOLDER,
+  INDEX_FILE_NAME,
+  JS_EXTENSIONS,
+  LOADER_EXPORT_NAME,
+  NESTED_ROUTE,
+  NESTED_ROUTES_DIR,
+  PAGES_DIR_NAME,
+  TEMP_LOADERS_DIR
+};

package/dist/js/modern/analyze/generateCode.js

@@ -0,0 +1,247 @@
+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());
+  });
+};
+import path from "path";
+import { fs, getEntryOptions, logger } from "@modern-js/utils";
+import {
+  useResolvedConfigContext
+} from "@modern-js/core";
+import * as templates from "./templates";
+import { getClientRoutes, getClientRoutesLegacy } from "./getClientRoutes";
+import {
+  FILE_SYSTEM_ROUTES_FILE_NAME,
+  ENTRY_POINT_FILE_NAME,
+  ENTRY_BOOTSTRAP_FILE_NAME
+} from "./constants";
+import { getDefaultImports, getServerLoadersFile } from "./utils";
+import { walk } from "./nestedRoutes";
+const createImportSpecifier = (specifiers) => {
+  let defaults = "";
+  const named = [];
+  for (const { local, imported } of specifiers) {
+    if (local && imported) {
+      named.push(`${imported} as ${local}`);
+    } else if (local) {
+      defaults = local;
+    } else {
+      named.push(imported);
+    }
+  }
+  if (defaults && named.length) {
+    return `${defaults}, { ${named.join(", ")} }`;
+  } else if (defaults) {
+    return defaults;
+  } else {
+    return `{ ${named.join(", ")} }`;
+  }
+};
+const createImportStatements = (statements) => {
+  var _a, _b;
+  const deDuplicated = [];
+  const seen = /* @__PURE__ */ new Map();
+  for (const { value, specifiers, initialize } of statements) {
+    if (!seen.has(value)) {
+      deDuplicated.push({
+        value,
+        specifiers,
+        initialize
+      });
+      seen.set(value, specifiers);
+    } else {
+      seen.get(value).push(...specifiers);
+      const modifyIndex = deDuplicated.findIndex((v) => v.value === value);
+      const originInitialize = (_b = (_a = deDuplicated[modifyIndex]) == null ? void 0 : _a.initialize) != null ? _b : "";
+      deDuplicated[modifyIndex].initialize = originInitialize.concat(
+        `
+${initialize || ""}`
+      );
+    }
+  }
+  return deDuplicated.map(
+    ({ value, specifiers, initialize }) => `import ${createImportSpecifier(specifiers)} from '${value}';
+${initialize || ""}`
+  ).join("\n");
+};
+const generateCode = (appContext, config, entrypoints, api) => __async(void 0, null, function* () {
+  var _a, _b, _c;
+  const {
+    internalDirectory,
+    srcDirectory,
+    internalDirAlias,
+    internalSrcAlias,
+    packageName
+  } = appContext;
+  const hookRunners = api.useHookRunners();
+  const isV5 = typeof ((_a = config.runtime) == null ? void 0 : _a.router) !== "boolean" && ((_c = (_b = config == null ? void 0 : config.runtime) == null ? void 0 : _b.router) == null ? void 0 : _c.mode) === "react-router-5";
+  const { mountId } = config.html;
+  const getRoutes = isV5 ? getClientRoutesLegacy : getClientRoutes;
+  yield Promise.all(entrypoints.map(generateEntryCode));
+  function generateEntryCode(entrypoint) {
+    return __async(this, null, function* () {
+      const { entryName, isAutoMount, customBootstrap, fileSystemRoutes } = entrypoint;
+      if (isAutoMount) {
+        if (fileSystemRoutes) {
+          let initialRoutes = [];
+          let nestedRoute = null;
+          if (entrypoint.entry) {
+            initialRoutes = getRoutes({
+              entrypoint,
+              srcDirectory,
+              srcAlias: internalSrcAlias,
+              internalDirectory,
+              internalDirAlias
+            });
+          }
+          if (entrypoint.nestedRoutesEntry) {
+            if (!isV5) {
+              nestedRoute = yield walk(
+                entrypoint.nestedRoutesEntry,
+                entrypoint.nestedRoutesEntry,
+                {
+                  name: internalSrcAlias,
+                  basename: srcDirectory
+                },
+                entrypoint.entryName
+              );
+              if (nestedRoute) {
+                initialRoutes.unshift(nestedRoute);
+              }
+            } else {
+              logger.error("Nested routes is not supported in legacy mode.");
+              process.exit(1);
+            }
+          }
+          const { routes } = yield hookRunners.modifyFileSystemRoutes({
+            entrypoint,
+            routes: initialRoutes
+          });
+          const config2 = useResolvedConfigContext();
+          const ssr = getEntryOptions(
+            entryName,
+            config2.server.ssr,
+            config2.server.ssrByEntries,
+            packageName
+          );
+          let mode;
+          if (ssr) {
+            mode = typeof ssr === "object" ? ssr.mode || "string" : "string";
+          } else {
+            mode = false;
+          }
+          if (mode === "stream") {
+            const hasPageRoute = routes.some(
+              (route) => "type" in route && route.type === "page"
+            );
+            if (hasPageRoute) {
+              logger.error(
+                "Streaming ssr is not supported when pages dir exists"
+              );
+              process.exit(1);
+            }
+          }
+          const { code: code2 } = yield hookRunners.beforeGenerateRoutes({
+            entrypoint,
+            code: yield templates.fileSystemRoutes({
+              routes,
+              ssrMode: mode,
+              nestedRoutesEntry: entrypoint.nestedRoutesEntry,
+              entryName: entrypoint.entryName,
+              internalDirectory
+            })
+          });
+          if (entrypoint.nestedRoutesEntry && mode) {
+            const routesServerFile = getServerLoadersFile(
+              internalDirectory,
+              entryName
+            );
+            const code3 = templates.routesForServer({
+              routes
+            });
+            yield fs.ensureFile(routesServerFile);
+            yield fs.writeFile(routesServerFile, code3);
+          }
+          fs.outputFileSync(
+            path.resolve(
+              internalDirectory,
+              `./${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`
+            ),
+            code2,
+            "utf8"
+          );
+        }
+        const { imports: importStatements } = yield hookRunners.modifyEntryImports({
+          entrypoint,
+          imports: getDefaultImports({
+            entrypoint,
+            srcDirectory,
+            internalSrcAlias,
+            internalDirAlias,
+            internalDirectory
+          })
+        });
+        const { plugins } = yield hookRunners.modifyEntryRuntimePlugins({
+          entrypoint,
+          plugins: []
+        });
+        const { code: renderFunction } = yield hookRunners.modifyEntryRenderFunction({
+          entrypoint,
+          code: templates.renderFunction({
+            plugins,
+            customBootstrap,
+            fileSystemRoutes
+          })
+        });
+        const { exportStatement } = yield hookRunners.modifyEntryExport({
+          entrypoint,
+          exportStatement: "export default AppWrapper;"
+        });
+        const code = templates.index({
+          mountId,
+          imports: createImportStatements(importStatements),
+          renderFunction,
+          exportStatement
+        });
+        const entryFile = path.resolve(
+          internalDirectory,
+          `./${entryName}/${ENTRY_POINT_FILE_NAME}`
+        );
+        entrypoint.entry = entryFile;
+        if (config.source.enableAsyncEntry) {
+          const { code: asyncEntryCode } = yield hookRunners.modifyAsyncEntry({
+            entrypoint,
+            code: `import('./${ENTRY_BOOTSTRAP_FILE_NAME}');`
+          });
+          fs.outputFileSync(entryFile, asyncEntryCode, "utf8");
+          const bootstrapFile = path.resolve(
+            internalDirectory,
+            `./${entryName}/${ENTRY_BOOTSTRAP_FILE_NAME}`
+          );
+          fs.outputFileSync(bootstrapFile, code, "utf8");
+        } else {
+          fs.outputFileSync(entryFile, code, "utf8");
+        }
+      }
+    });
+  }
+});
+export {
+  createImportStatements,
+  generateCode
+};

package/dist/js/modern/analyze/getBundleEntry.js

@@ -0,0 +1,71 @@
+import path from "path";
+import {
+  ensureAbsolutePath,
+  fs,
+  findExists,
+  MAIN_ENTRY_NAME
+} from "@modern-js/utils";
+import { getFileSystemEntry } from "./getFileSystemEntry";
+import { JS_EXTENSIONS } from "./constants";
+const ensureExtensions = (file) => {
+  if (!path.extname(file)) {
+    return findExists(JS_EXTENSIONS.map((ext) => `${file}${ext}`)) || file;
+  }
+  return file;
+};
+const ifAlreadyExists = (entrypoints, checked) => entrypoints.some((entrypoint) => {
+  if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
+    checked.entryName = entrypoint.entryName;
+    return true;
+  }
+  if (entrypoint.entry.startsWith(checked.entry) || checked.entry.startsWith(entrypoint.entry)) {
+    throw new Error(
+      `Entry configuration conflicts
+ Your configuration: ${checked.entry}.
+ Default entrypoint: ${entrypoint.entry}
+ Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules.`
+    );
+  }
+  return false;
+});
+const getBundleEntry = (appContext, config) => {
+  const { appDirectory, packageName } = appContext;
+  const {
+    source: { disableDefaultEntries, entries, entriesDir }
+  } = config;
+  const defaults = disableDefaultEntries ? [] : getFileSystemEntry(appContext, config);
+  if (entries) {
+    Object.keys(entries).forEach((name) => {
+      const value = entries[name];
+      const entrypoint = typeof value === "string" ? {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value),
+        isAutoMount: true,
+        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, value)).isDirectory() ? {} : void 0
+      } : {
+        entryName: name,
+        entry: ensureAbsolutePath(appDirectory, value.entry),
+        isAutoMount: !value.disableMount,
+        customBootstrap: value.customBootstrap && ensureAbsolutePath(appDirectory, value.customBootstrap),
+        fileSystemRoutes: fs.statSync(ensureAbsolutePath(appDirectory, value.entry)).isDirectory() ? {} : void 0
+      };
+      if (entrypoint.fileSystemRoutes) {
+        entrypoint.nestedRoutesEntry = entrypoint.entry;
+      }
+      if (!ifAlreadyExists(defaults, entrypoint)) {
+        defaults.push(entrypoint);
+      }
+    });
+  }
+  if (!disableDefaultEntries) {
+    const entriesDirAbs = ensureAbsolutePath(appDirectory, entriesDir || "");
+    const found = defaults.find(
+      ({ entryName, entry, nestedRoutesEntry = "" }) => entryName === packageName || path.dirname(entry) === entriesDirAbs || path.dirname(nestedRoutesEntry) === entriesDirAbs
+    );
+    found && (found.entryName = MAIN_ENTRY_NAME);
+  }
+  return defaults;
+};
+export {
+  getBundleEntry
+};