@modern-js/app-tools 2.3.1-alpha.2 → 2.5.0-alpha.0

package/dist/esm-node/utils/getSelectedEntries.js

@@ -0,0 +1,38 @@
+import { chalk, inquirer } from "@modern-js/utils";
+import { i18n, localeKeys } from "../locale";
+const getSelectedEntries = async (entry, entrypoints) => {
+  const entryNames = entrypoints.map((e) => e.entryName);
+  if (!entry) {
+    return entryNames;
+  }
+  if (typeof entry === "boolean") {
+    const { selected } = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "selected",
+        choices: entryNames,
+        message: i18n.t(localeKeys.command.dev.selectEntry),
+        validate(answer) {
+          if (answer.length < 1) {
+            return i18n.t(localeKeys.command.dev.requireEntry);
+          }
+          return true;
+        }
+      }
+    ]);
+    return selected;
+  }
+  entry.forEach((name) => {
+    if (!entryNames.includes(name)) {
+      throw new Error(
+        `Can not found entry ${chalk.yellow(
+          name
+        )}, the entry should be one of ${chalk.yellow(entryNames.join(", "))}`
+      );
+    }
+  });
+  return entry;
+};
+export {
+  getSelectedEntries
+};

package/dist/esm-node/utils/getServerInternalPlugins.js

@@ -0,0 +1,18 @@
+async function getServerInternalPlugins(api) {
+  const hookRunners = api.useHookRunners();
+  const { plugins: serverPlugins } = await hookRunners.collectServerPlugins({
+    plugins: []
+  });
+  const serverInternalPlugins = serverPlugins.reduce(
+    (result, plugin) => Object.assign(result, plugin),
+    {}
+  );
+  api.setAppContext({
+    ...api.useAppContext(),
+    serverInternalPlugins
+  });
+  return serverInternalPlugins;
+}
+export {
+  getServerInternalPlugins
+};

package/dist/esm-node/utils/language.js

@@ -0,0 +1,8 @@
+import { I18CLILanguageDetector } from "@modern-js/plugin-i18n/language-detector";
+function getLocaleLanguage() {
+  const detector = new I18CLILanguageDetector();
+  return detector.detect();
+}
+export {
+  getLocaleLanguage
+};

package/dist/esm-node/utils/printInstructions.js

@@ -0,0 +1,11 @@
+import { prettyInstructions, logger } from "@modern-js/utils";
+const printInstructions = async (hookRunners, appContext, config) => {
+  const message = prettyInstructions(appContext, config);
+  const { instructions } = await hookRunners.beforePrintInstructions({
+    instructions: message
+  });
+  logger.info(instructions);
+};
+export {
+  printInstructions
+};

package/dist/esm-node/utils/restart.js

@@ -0,0 +1,22 @@
+import { cli } from "@modern-js/core";
+import { chalk, clearConsole, logger, program } from "@modern-js/utils";
+async function restart(hooksRunner, filename) {
+  clearConsole();
+  logger.info(`Restart because ${chalk.yellow(filename)} is changed...
+`);
+  let hasGetError = false;
+  await hooksRunner.beforeRestart();
+  try {
+    await cli.init(cli.getPrevInitOptions());
+  } catch (err) {
+    console.error(err);
+    hasGetError = true;
+  } finally {
+    if (!hasGetError) {
+      program.parse(process.argv);
+    }
+  }
+}
+export {
+  restart
+};

package/dist/esm-node/utils/routes.js

@@ -0,0 +1,10 @@
+import path from "path";
+import { fs, ROUTE_SPEC_FILE } from "@modern-js/utils";
+const generateRoutes = async (appContext) => {
+  const { serverRoutes, distDirectory } = appContext;
+  const output = JSON.stringify({ routes: serverRoutes }, null, 2);
+  await fs.outputFile(path.join(distDirectory, ROUTE_SPEC_FILE), output);
+};
+export {
+  generateRoutes
+};

package/dist/js/modern/analyze/index.js

@@ -49,12 +49,12 @@ import {
   isDevCommand
 } from "@modern-js/utils";
 import { cloneDeep } from "@modern-js/utils/lodash";
-import { createBuilderForModern } from "../builder";
 import { printInstructions } from "../utils/printInstructions";
 import { generateRoutes } from "../utils/routes";
 import { emitResolvedConfig } from "../utils/config";
 import { getSelectedEntries } from "../utils/getSelectedEntries";
 import { initialNormalizedConfig } from "../config";
+import { createBuilderGenerator } from "../builder";
 import {
   getServerLoadersFile,
   isPageComponentFile,
@@ -67,7 +67,9 @@ import {
   APP_INIT_IMPORTED
 } from "./constants";
 const debug = createDebugger("plugin-analyze");
-var analyze_default = () => ({
+var analyze_default = ({
+  bundler
+}) => ({
   name: "@modern-js/plugin-analyze",
   setup: (api) => {
     let pagesDir = [];
@@ -159,56 +161,51 @@ var analyze_default = () => ({
           if (buildCommands.includes(command)) {
             let _b;
             const normalizedConfig = api.useResolvedConfigContext();
+            const createBuilderForModern = yield createBuilderGenerator(bundler);
             const builder = yield createBuilderForModern({
               normalizedConfig,
               appContext,
-              compatPluginConfig: {
-                onBeforeBuild(_0) {
-                  return __async(this, arguments, function* ({ bundlerConfigs }) {
-                    const hookRunners2 = api.useHookRunners();
-                    yield generateRoutes(appContext);
-                    yield hookRunners2.beforeBuild({ bundlerConfigs });
-                  });
-                },
-                onAfterBuild(_0) {
-                  return __async(this, arguments, function* ({ stats }) {
-                    const hookRunners2 = api.useHookRunners();
-                    yield hookRunners2.afterBuild({ stats });
-                    yield 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) {
-                        printInstructions(
-                          hookRunners2,
-                          appContext,
-                          normalizedConfig
-                        );
-                      }
+              onBeforeBuild(_0) {
+                return __async(this, arguments, function* ({ bundlerConfigs }) {
+                  const hookRunners2 = api.useHookRunners();
+                  yield generateRoutes(appContext);
+                  yield hookRunners2.beforeBuild({ bundlerConfigs });
+                });
+              },
+              onAfterBuild(_0) {
+                return __async(this, arguments, function* ({ stats }) {
+                  const hookRunners2 = api.useHookRunners();
+                  yield hookRunners2.afterBuild({ stats });
+                  yield 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) {
+                      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);
@@ -251,7 +248,7 @@ var analyze_default = () => ({
       },
       resolvedConfig({ resolved }) {
         const appContext = api.useAppContext();
-        const config = initialNormalizedConfig(resolved, appContext);
+        const config = initialNormalizedConfig(resolved, appContext, bundler);
         return {
           resolved: config
         };

package/dist/js/modern/analyze/nestedRoutes.js

@@ -157,7 +157,7 @@ const walk = (dirname, rootDir, alias, entryName) => __async(void 0, null, funct
       route.error = replaceWithAlias(alias.basename, itemPath, alias.name);
     }
   }
-  let finalRoute = createRoute(
+  const finalRoute = createRoute(
     route,
     rootDir,
     path.join(dirname, `${NESTED_ROUTE.LAYOUT_FILE}.ts`),
@@ -170,15 +170,6 @@ const walk = (dirname, rootDir, alias, entryName) => __async(void 0, null, funct
   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;
 });
 export {

package/dist/js/modern/builder/builder-rspack/index.js

@@ -0,0 +1,8 @@
+import { builderRspackProvider } from "@modern-js/builder-rspack-provider";
+import { generateBuilder } from "../generator";
+function createRspackBuilderForModern(options) {
+  return generateBuilder(options, builderRspackProvider);
+}
+export {
+  createRspackBuilderForModern
+};

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

@@ -0,0 +1,41 @@
+import { join } from "path";
+import { createCopyPattern } from "../../shared";
+import { RouterPlugin } from "../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(join(api.context.rootPath, "node_modules"));
+      if (chain.plugins.has(CHAIN_ID.PLUGIN.COPY)) {
+        const defaultCopyPattern = 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(RouterPlugin);
+      }
+    });
+  }
+});
+export {
+  PluginCompatModern
+};

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

@@ -0,0 +1,93 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __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 {
+  builderWebpackProvider
+} from "@modern-js/builder-webpack-provider";
+import { applyOptionsChain } from "@modern-js/utils";
+import { createCopyPattern } from "../shared";
+import { generateBuilder } from "../generator";
+import { PluginCompatModern } from "./builderPlugins/compatModern";
+function createWebpackBuilderForModern(options) {
+  return generateBuilder(options, 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 = 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 import("@modern-js/builder-plugin-node-polyfill");
+      builder.addPlugins([PluginNodePolyfill()]);
+    }
+    if (normalizedConfig.tools.esbuild) {
+      const { esbuild: esbuildOptions } = normalizedConfig.tools;
+      const { PluginEsbuild } = yield import("@modern-js/builder-plugin-esbuild");
+      builder.addPlugins([
+        PluginEsbuild({
+          loader: false,
+          minimize: applyOptionsChain({}, esbuildOptions)
+        })
+      ]);
+    }
+    builder.addPlugins([PluginCompatModern(options)]);
+  });
+}
+export {
+  createWebpackBuilderForModern
+};

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

@@ -109,5 +109,5 @@ class RouterPlugin {
   }
 }
 export {
-  RouterPlugin as default
+  RouterPlugin
 };

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

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

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

@@ -0,0 +1,24 @@
+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
+  };
+}
+export {
+  createBuilderOptions
+};

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

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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));
+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;
+}
+export {
+  createBuilderProviderConfig
+};

package/dist/js/modern/builder/generator/getBuilderTargets.js

@@ -0,0 +1,12 @@
+import { isProd, isSSR, isUseSSRBundle } from "@modern-js/utils";
+function getBuilderTargets(normalizedConfig) {
+  const targets = ["web"];
+  const useNodeTarget = isProd() ? isUseSSRBundle(normalizedConfig) : isSSR(normalizedConfig);
+  if (useNodeTarget) {
+    targets.push("node");
+  }
+  return targets;
+}
+export {
+  getBuilderTargets
+};

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

@@ -0,0 +1,53 @@
+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 { createBuilder } from "@modern-js/builder";
+import { createBuilderProviderConfig } from "./createBuilderProviderConfig";
+import { getBuilderTargets } from "./getBuilderTargets";
+import { createBuilderOptions } from "./createBuilderOptions";
+function generateBuilder(options, generateProvider, utils) {
+  return __async(this, null, function* () {
+    const { normalizedConfig, appContext } = options;
+    const { modifyBuilderConfig, modifyBuilderInstance } = utils || {};
+    const builderConfig = createBuilderProviderConfig(
+      normalizedConfig,
+      appContext,
+      modifyBuilderConfig
+    );
+    const provider = generateProvider({
+      builderConfig
+    });
+    const target = getBuilderTargets(normalizedConfig);
+    const builderOptions = createBuilderOptions(target, appContext);
+    const builder = yield createBuilder(provider, builderOptions);
+    yield applyBuilderPlugins(builder, options);
+    yield modifyBuilderInstance == null ? void 0 : modifyBuilderInstance(builder);
+    return builder;
+  });
+}
+function applyBuilderPlugins(builder, options) {
+  return __async(this, null, function* () {
+    const { builderPluginAdapterModern } = yield import("../shared/builderPlugins/adapterModern");
+    builder.addPlugins([builderPluginAdapterModern(options)]);
+  });
+}
+export {
+  generateBuilder
+};