@modern-js/app-tools 2.4.0 → 2.5.0

package/dist/esm-node/index.js

@@ -0,0 +1,172 @@
+import path from "path";
+import lintPlugin from "@modern-js/plugin-lint";
+import {
+  cleanRequireCache,
+  emptyDir,
+  Import,
+  getCommand
+} from "@modern-js/utils";
+import { castArray } from "@modern-js/utils/lodash";
+import analyzePlugin from "./analyze";
+import initializePlugin from "./initialize";
+import { hooks } from "./hooks";
+import { i18n, localeKeys } from "./locale";
+import { getLocaleLanguage } from "./utils/language";
+import { restart } from "./utils/restart";
+import { generateWatchFiles } from "./utils/generateWatchFiles";
+export * from "./defineConfig";
+export * from "./types";
+const upgradeModel = Import.lazy(
+  "@modern-js/upgrade",
+  require
+);
+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 { dev } = await import("./commands/dev");
+    await dev(api, options);
+  });
+  for (const meta of devToolMetas) {
+    if (!meta.subCommands) {
+      continue;
+    }
+    for (const subCmd of meta.subCommands) {
+      devProgram.command(subCmd).action(async (options = {}) => {
+        const { appDirectory } = api.useAppContext();
+        const { isTypescript } = await import("@modern-js/utils");
+        await runner.beforeDevTask(meta);
+        await meta.action(options, {
+          isTsProject: isTypescript(appDirectory)
+        });
+      });
+    }
+  }
+};
+const buildCommand = async (program, api) => {
+  const runner = api.useHookRunners();
+  const platformBuilders = await runner.registerBuildPlatform();
+  const buildProgram = program.command("build").usage("[options]").description(i18n.t(localeKeys.command.build.describe)).option("-c --config <config>", i18n.t(localeKeys.command.shared.config)).option("--analyze", i18n.t(localeKeys.command.shared.analyze)).action(async (options) => {
+    const { build } = await import("./commands/build");
+    await build(api, options);
+  });
+  for (const platformBuilder of platformBuilders) {
+    const platforms = castArray(platformBuilder.platform);
+    for (const platform of platforms) {
+      buildProgram.command(platform).action(async () => {
+        const { appDirectory } = api.useAppContext();
+        const { isTypescript } = await import("@modern-js/utils");
+        await runner.beforeBuildPlatform(platformBuilders);
+        await platformBuilder.build(platform, {
+          isTsProject: isTypescript(appDirectory)
+        });
+      });
+    }
+  }
+};
+var src_default = (options = {
+  bundler: "webpack"
+}) => ({
+  name: "@modern-js/app-tools",
+  post: [
+    "@modern-js/plugin-initialize",
+    "@modern-js/plugin-analyze",
+    "@modern-js/plugin-ssr",
+    "@modern-js/plugin-document",
+    "@modern-js/plugin-state",
+    "@modern-js/plugin-router",
+    "@modern-js/plugin-router-v5",
+    "@modern-js/plugin-polyfill"
+  ],
+  registerHook: hooks,
+  usePlugins: [
+    initializePlugin({
+      bundler: (options == null ? void 0 : options.bundler) === "experimental-rspack" ? "rspack" : "webpack"
+    }),
+    analyzePlugin({
+      bundler: (options == null ? void 0 : options.bundler) === "experimental-rspack" ? "rspack" : "webpack"
+    }),
+    lintPlugin()
+  ],
+  setup: (api) => {
+    const locale = getLocaleLanguage();
+    i18n.changeLanguage({ locale });
+    return {
+      async commands({ program }) {
+        await devCommand(program, api);
+        await buildCommand(program, api);
+        program.command("serve").usage("[options]").description(i18n.t(localeKeys.command.serve.describe)).option("--api-only", i18n.t(localeKeys.command.dev.apiOnly)).option(
+          "-c --config <config>",
+          i18n.t(localeKeys.command.shared.config)
+        ).action(async () => {
+          const { start } = await import("./commands/serve");
+          await start(api);
+        });
+        program.command("deploy").usage("[options]").option(
+          "-c --config <config>",
+          i18n.t(localeKeys.command.shared.config)
+        ).description(i18n.t(localeKeys.command.deploy.describe)).action(async (options2) => {
+          const { build } = await import("./commands/build");
+          await build(api);
+          const { deploy } = await import("./commands/deploy");
+          await deploy(api, options2);
+          process.exit(0);
+        });
+        program.command("new").usage("[options]").description(i18n.t(localeKeys.command.new.describe)).option("--lang <lang>", i18n.t(localeKeys.command.new.lang)).option("-d, --debug", i18n.t(localeKeys.command.new.debug), false).option(
+          "-c, --config <config>",
+          i18n.t(localeKeys.command.new.config)
+        ).option("--dist-tag <tag>", i18n.t(localeKeys.command.new.distTag)).option("--registry", i18n.t(localeKeys.command.new.registry)).action(async (options2) => {
+          const { MWANewAction } = await import("@modern-js/new-action");
+          await MWANewAction({ ...options2, locale: options2.lang || locale });
+        });
+        program.command("inspect").description("inspect internal webpack config").option(
+          `--env <env>`,
+          i18n.t(localeKeys.command.inspect.env),
+          "development"
+        ).option(
+          "--output <output>",
+          i18n.t(localeKeys.command.inspect.output),
+          "/"
+        ).option("--verbose", i18n.t(localeKeys.command.inspect.verbose)).option(
+          "-c --config <config>",
+          i18n.t(localeKeys.command.shared.config)
+        ).action(async (options2) => {
+          const { inspect } = await import("./commands/inspect");
+          inspect(api, options2);
+        });
+        upgradeModel.defineCommand(program.command("upgrade"));
+      },
+      async prepare() {
+        const command = getCommand();
+        if (command === "dev" || command === "start" || command === "build") {
+          const appContext = api.useAppContext();
+          await emptyDir(appContext.distDirectory);
+        }
+      },
+      async watchFiles() {
+        const appContext = api.useAppContext();
+        const config = api.useResolvedConfigContext();
+        return generateWatchFiles(appContext, config.source.configDir);
+      },
+      async fileChange(e) {
+        const { filename, eventType } = e;
+        const appContext = api.useAppContext();
+        const { appDirectory, srcDirectory } = appContext;
+        const absolutePath = path.resolve(appDirectory, filename);
+        if (!absolutePath.includes(srcDirectory) && (eventType === "change" || eventType === "unlink")) {
+          const { closeServer } = await import("./utils/createServer");
+          await closeServer();
+          await restart(api.useHookRunners(), filename);
+        }
+      },
+      async beforeRestart() {
+        cleanRequireCache([require.resolve("./analyze")]);
+      }
+    };
+  }
+});
+export {
+  buildCommand,
+  src_default as default,
+  devCommand
+};

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

@@ -0,0 +1,91 @@
+import {
+  ensureAbsolutePath,
+  getPort,
+  isDev,
+  isDevCommand
+} from "@modern-js/utils";
+import { legacySchema, schema } from "../schema";
+import {
+  checkIsLegacyConfig,
+  createDefaultConfig,
+  createLegacyDefaultConfig,
+  transformNormalizedConfig
+} from "../config";
+var initialize_default = ({
+  bundler
+}) => ({
+  name: "@modern-js/plugin-initialize",
+  setup(api) {
+    const config = () => {
+      const appContext = api.useAppContext();
+      const userConfig = api.useConfigContext();
+      return checkIsLegacyConfig(userConfig) ? createLegacyDefaultConfig(appContext) : createDefaultConfig(appContext, bundler);
+    };
+    const validateSchema = () => {
+      const userConfig = api.useConfigContext();
+      const schemas = checkIsLegacyConfig(userConfig) ? legacySchema : schema;
+      return schemas.generate();
+    };
+    return {
+      config,
+      validateSchema,
+      async resolvedConfig({ resolved }) {
+        var _a;
+        let appContext = api.useAppContext();
+        const userConfig = api.useConfigContext();
+        const port = await getServerPort(resolved);
+        appContext = {
+          ...appContext,
+          port,
+          distDirectory: ensureAbsolutePath(
+            appContext.distDirectory,
+            ((_a = resolved.output.distPath) == null ? void 0 : _a.root) || "dist"
+          )
+        };
+        api.setAppContext(appContext);
+        const normalizedConfig = checkIsLegacyConfig(resolved) ? transformNormalizedConfig(resolved) : resolved;
+        resolved._raw = userConfig;
+        resolved.server = {
+          ...normalizedConfig.server || {},
+          port
+        };
+        resolved.autoLoadPlugins = normalizedConfig.autoLoadPlugins || false;
+        stabilizeConfig(resolved, normalizedConfig, [
+          "source",
+          "bff",
+          "dev",
+          "html",
+          "output",
+          "tools",
+          "testing",
+          "plugins",
+          "builderPlugins",
+          "runtime",
+          "runtimeByEntries",
+          "deploy",
+          "performance"
+        ]);
+        if (bundler === "webpack") {
+          resolved.security = normalizedConfig.security || {};
+          resolved.experiments = normalizedConfig.experiments;
+        }
+        return { resolved };
+      }
+    };
+  }
+});
+function stabilizeConfig(resolve, config, keys) {
+  keys.forEach((key) => {
+    resolve[key] = config[key] || {};
+  });
+}
+async function getServerPort(config) {
+  const prodPort = config.server.port || 8080;
+  if (isDev() && isDevCommand()) {
+    return getPort(config.dev.port || prodPort);
+  }
+  return prodPort;
+}
+export {
+  initialize_default as default
+};

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

@@ -0,0 +1,88 @@
+import * as path from "path";
+import { bundle } from "@modern-js/node-bundle-require";
+import {
+  CONFIG_FILE_EXTENSIONS,
+  fs,
+  getServerConfig,
+  OUTPUT_CONFIG_FILE
+} from "@modern-js/utils";
+const defineServerConfig = (config) => config;
+const buildServerConfig = async ({
+  appDirectory,
+  distDirectory,
+  configFile,
+  options
+}) => {
+  const configFilePath = await getServerConfig(appDirectory, configFile);
+  const getOutputFile = async (filepath) => path.resolve(
+    distDirectory,
+    `${filepath.replace(
+      new RegExp(CONFIG_FILE_EXTENSIONS.join("|")),
+      ""
+    )}.js`
+  );
+  if (configFilePath) {
+    const configHelperFilePath = path.normalize(
+      path.join(distDirectory, "./config-helper.js")
+    );
+    const helperCode = `
+      export const defineConfig = (config) => config;
+    `;
+    await fs.ensureDir(distDirectory);
+    await fs.writeFile(configHelperFilePath, helperCode);
+    await bundle(configFilePath, {
+      ...options,
+      getOutputFile,
+      esbuildPlugins: [
+        {
+          name: "native-build-config",
+          setup(ctx) {
+            ctx.onResolve(
+              {
+                filter: /app-tools\/server/
+              },
+              () => {
+                return {
+                  path: configHelperFilePath
+                };
+              }
+            );
+          }
+        }
+      ]
+    });
+  }
+};
+const safeReplacer = () => {
+  const cache = [];
+  const keyCache = [];
+  return function(key, value) {
+    if (typeof value === "object" && value !== null) {
+      const index = cache.indexOf(value);
+      if (index !== -1) {
+        return `[Circular ${keyCache[index]}]`;
+      }
+      cache.push(value);
+      keyCache.push(key || "root");
+    }
+    return value;
+  };
+};
+const emitResolvedConfig = async (appDirectory, resolvedConfig) => {
+  var _a;
+  const outputPath = path.join(
+    appDirectory,
+    ((_a = resolvedConfig.output.distPath) == null ? void 0 : _a.root) || "./dist",
+    OUTPUT_CONFIG_FILE
+  );
+  await fs.writeJSON(outputPath, resolvedConfig, {
+    spaces: 2,
+    replacer: safeReplacer()
+  });
+};
+export {
+  buildServerConfig,
+  defineServerConfig,
+  emitResolvedConfig,
+  safeReplacer
+};

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

@@ -0,0 +1,37 @@
+import { Server } from "@modern-js/server";
+let server = null;
+const getServer = () => server;
+const setServer = (newServer) => {
+  server = newServer;
+};
+const closeServer = async () => {
+  if (server) {
+    await server.close();
+    server = null;
+  }
+};
+const createServer = async (options) => {
+  if (server) {
+    await server.close();
+  }
+  server = new Server(options);
+  const app = await server.init();
+  return app;
+};
+const injectDataLoaderPlugin = (internalPlugins) => {
+  const DataLoaderPlugin = require.resolve("@modern-js/plugin-data-loader/server");
+  return {
+    ...internalPlugins,
+    "@modern-js/plugin-data-loader": {
+      path: DataLoaderPlugin,
+      forced: true
+    }
+  };
+};
+export {
+  closeServer,
+  createServer,
+  getServer,
+  injectDataLoaderPlugin,
+  setServer
+};

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

@@ -0,0 +1,33 @@
+import path from "path";
+import { fs, getServerConfig } from "@modern-js/utils";
+const getPackageConfig = (appDirectory, packageJsonConfig) => {
+  const PACKAGE_JSON_CONFIG_NAME = "modernConfig";
+  const json = JSON.parse(
+    fs.readFileSync(path.resolve(appDirectory, "./package.json"), "utf8")
+  );
+  return json[packageJsonConfig != null ? packageJsonConfig : PACKAGE_JSON_CONFIG_NAME];
+};
+const addServerConfigToDeps = async (dependencies, appDirectory, serverConfigFile) => {
+  const serverConfig = await getServerConfig(appDirectory, serverConfigFile);
+  if (serverConfig) {
+    dependencies.push(serverConfig);
+  }
+};
+async function generateWatchFiles(appContext, configDir) {
+  const { appDirectory, configFile } = appContext;
+  const configPath = path.join(appDirectory, configDir || "");
+  const dependencies = getPackageConfig(
+    appContext.appDirectory,
+    appContext.packageName
+  ) ? [path.resolve(appDirectory, "./package.json")] : [];
+  await addServerConfigToDeps(
+    dependencies,
+    appContext.appDirectory,
+    appContext.serverConfigFile
+  );
+  return [`${configPath}/html`, configFile || "./config", ...dependencies];
+}
+export {
+  addServerConfigToDeps,
+  generateWatchFiles
+};

package/dist/{js/modern → esm-node}/utils/getSelectedEntries.js

@@ -1,32 +1,12 @@
-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 { chalk, inquirer } from "@modern-js/utils";
 import { i18n, localeKeys } from "../locale";
-const getSelectedEntries = (entry, entrypoints) => __async(void 0, null, function* () {
+const getSelectedEntries = async (entry, entrypoints) => {
   const entryNames = entrypoints.map((e) => e.entryName);
   if (!entry) {
     return entryNames;
   }
   if (typeof entry === "boolean") {
-    const { selected } = yield inquirer.prompt([
+    const { selected } = await inquirer.prompt([
       {
         type: "checkbox",
         name: "selected",
@@ -52,7 +32,7 @@ const getSelectedEntries = (entry, entrypoints) => __async(void 0, null, functio
     }
   });
   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/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/types/types/config/tools.d.ts

@@ -8,7 +8,7 @@ import type { UnwrapBuilderConfig } from '../utils';
 export type BuilderToolsConfig = UnwrapBuilderConfig<BuilderConfig, 'tools'> & {
   esbuild?: PluginEsbuildOptions;
 };
-export type RsBuilderToolsConfig = UnwrapBuilderConfig<RsBuilderConfig, 'source'>;
+export type RsBuilderToolsConfig = UnwrapBuilderConfig<RsBuilderConfig, 'tools'>;
 /**
  * The configuration of `tools.tailwindcss` is provided by `tailwindcss` plugin.
  * Please use `yarn new` or `pnpm new` to enable the corresponding capability.

package/dist/types/types/hooks.d.ts

@@ -4,6 +4,7 @@ import type { Entrypoint, HtmlPartials, NestedRoute, PageRoute, RouteLegacy, Ser
 import type { RegisterBuildPlatformResult, DevToolData } from '@modern-js/core';
 import type { Stats, MultiStats } from '@modern-js/builder-shared';
 import type { Rspack } from '@modern-js/builder-rspack-provider';
+import { Bundler } from './utils';
 export interface ImportSpecifier {
   local?: string;
   imported?: string;
@@ -18,7 +19,7 @@ export interface RuntimePlugin {
   options: string;
   args?: string;
 }
-export type AppToolsHooks = {
+export type AppToolsHooks<B extends Bundler = 'webpack'> = {
   modifyEntryExport: AsyncWaterfall<{
     entrypoint: Entrypoint;
     exportStatement: string;
@@ -61,16 +62,16 @@ export type AppToolsHooks = {
   beforeDev: AsyncWorkflow<void, unknown>;
   afterDev: AsyncWorkflow<void, unknown>;
   beforeCreateCompiler: AsyncWorkflow<{
-    bundlerConfigs: webpack.Configuration[] | Rspack.Configuration[];
+    bundlerConfigs?: B extends 'rspack' ? Rspack.Configuration[] : webpack.Configuration[];
   }, unknown>;
   afterCreateCompiler: AsyncWorkflow<{
-    compiler?: webpack.Compiler | webpack.MultiCompiler | Rspack.Compiler;
+    compiler?: B extends 'rspack' ? Rspack.Compiler : webpack.Compiler | webpack.MultiCompiler;
   }, unknown>;
   beforePrintInstructions: AsyncWaterfall<{
     instructions: string;
   }>;
   beforeBuild: AsyncWorkflow<{
-    bundlerConfigs?: webpack.Configuration[] | Rspack.Configuration[];
+    bundlerConfigs?: B extends 'rspack' ? Rspack.Configuration[] : webpack.Configuration[];
   }, unknown>;
   afterBuild: AsyncWorkflow<{
     stats?: Stats | MultiStats;

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

@@ -6,11 +6,13 @@ import { Bundler, FromConfig } from './utils';
 export * from './hooks';
 export * from './config';
 export * from './legacyConfig';
+export type { webpack } from '@modern-js/builder-webpack-provider';
+export type { Rspack } from '@modern-js/builder-rspack-provider';
 export type { Bundler } from './utils';
 export type { ServerUserConfig, ServerNormalizedConfig, BffUserConfig, BffNormalizedConfig, SSR, SSRByEntries } from '@modern-js/server-core';
 export type { IAppContext, PluginAPI, CliPlugin, NormalizedConfig, UserConfig } from '@modern-js/core';
 export type AppTools<B extends Bundler = 'webpack'> = {
-  hooks: AppToolsHooks;
+  hooks: AppToolsHooks<B>;
   userConfig: FromConfig<B, {
     rspack: RsAppToolsUserConfig;
     webpack: AppToolsUserConfig;