@modern-js/app-tools 2.52.0 → 2.53.1-alpha.0

package/dist/js/modern/analyze/utils.js

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import { isReact18, normalizeToPosixPath } from '@modern-js/utils';
+import { FILE_SYSTEM_ROUTES_FILE_NAME } from "./constants";
+export const walkDirectory = dir => fs.readdirSync(dir).reduce((previous, filename) => {
+  const filePath = path.join(dir, filename);
+
+  if (fs.statSync(filePath).isDirectory()) {
+    return [...previous, ...walkDirectory(filePath)];
+  } else {
+    return [...previous, filePath];
+  }
+}, []);
+export const getDefaultImports = ({
+  entrypoint,
+  srcDirectory,
+  internalSrcAlias,
+  internalDirAlias,
+  internalDirectory
+}) => {
+  const {
+    entryName,
+    fileSystemRoutes,
+    customBootstrap,
+    entry
+  } = entrypoint;
+  const imports = [{
+    specifiers: [{
+      local: 'React'
+    }],
+    value: 'react'
+  }, {
+    specifiers: [{
+      local: 'ReactDOM'
+    }],
+    value: isReact18(path.join(internalDirectory, '../../')) ? 'react-dom/client' : 'react-dom'
+  }, {
+    specifiers: [{
+      imported: 'createApp'
+    }, {
+      imported: 'bootstrap'
+    }],
+    value: '@modern-js/runtime'
+  }, customBootstrap && {
+    specifiers: [{
+      local: 'customBootstrap'
+    }],
+    value: normalizeToPosixPath(customBootstrap.replace(srcDirectory, internalSrcAlias))
+  }].filter(Boolean);
+
+  if (fileSystemRoutes) {
+    const route = {
+      specifiers: [{
+        imported: 'routes'
+      }],
+      value: normalizeToPosixPath(`${internalDirAlias}/${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`)
+    };
+
+    if (fileSystemRoutes.globalApp) {
+      imports.push({
+        specifiers: [{
+          local: 'App'
+        }],
+        value: normalizeToPosixPath(fileSystemRoutes.globalApp.replace(srcDirectory, internalSrcAlias))
+      });
+    } else {
+      route.initialize = 'const App = false;';
+    }
+
+    imports.push(route);
+  } else {
+    imports.push({
+      specifiers: [{
+        local: 'App'
+      }],
+      value: normalizeToPosixPath(entry.replace(srcDirectory, internalSrcAlias))
+    });
+  }
+
+  return imports;
+};
+export const isRouteComponentFile = filePath => {
+  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
+    return false;
+  }
+
+  if (['.js', '.jsx', '.ts', '.tsx'].includes(path.extname(filePath))) {
+    return true;
+  }
+
+  return false;
+};

package/dist/js/modern/commands/build.js

@@ -0,0 +1,154 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { webpack, getWebpackConfig, WebpackConfigTarget } from '@modern-js/webpack';
+import { ResolvedConfigContext } from '@modern-js/core';
+import { formatWebpackMessages, measureFileSizesBeforeBuild, printFileSizesAfterBuild, printBuildError, logger, isUseSSRBundle, emptyDir } from '@modern-js/utils';
+import { generateRoutes } from "../utils/routes";
+import { buildServerConfig, emitResolvedConfig } from "../utils/config";
+// These sizes are pretty large. We'll warn for bundles exceeding them.
+const WARN_AFTER_BUNDLE_GZIP_SIZE = 512 * 1024;
+const WARN_AFTER_CHUNK_GZIP_SIZE = 1024 * 1024;
+export const build = async (api, options) => {
+  let resolvedConfig = api.useResolvedConfigContext();
+  const appContext = api.useAppContext();
+  const hookRunners = api.useHookRunners();
+  const {
+    apiOnly
+  } = appContext;
+
+  if (apiOnly) {
+    const {
+      appDirectory,
+      distDirectory,
+      serverConfigFile
+    } = appContext;
+    await emptyDir(distDirectory);
+    await hookRunners.beforeBuild({
+      webpackConfigs: []
+    });
+    await buildServerConfig({
+      appDirectory,
+      distDirectory,
+      configFile: serverConfigFile
+    });
+    await generateRoutes(appContext);
+    await hookRunners.afterBuild();
+    return;
+  }
+
+  const webpackBuild = async (webpackConfig, type) => {
+    const compiler = webpack(webpackConfig);
+    return new Promise((resolve, reject) => {
+      let label = process.env.NODE_ENV || '';
+
+      if (type && type !== 'legacy') {
+        label += ` ${type}`;
+      }
+
+      logger.info(`Creating a ${label} build...`);
+      compiler.run((err, stats) => {
+        let messages;
+
+        if (!err) {
+          messages = formatWebpackMessages(stats.toJson({
+            all: false,
+            warnings: true,
+            errors: true
+          }));
+
+          if (messages.errors.length === 0) {
+            logger.info(`File sizes after ${label} build:\n`);
+            printFileSizesAfterBuild(stats, previousFileSizes, distDirectory, WARN_AFTER_BUNDLE_GZIP_SIZE, WARN_AFTER_CHUNK_GZIP_SIZE);
+            logger.log();
+          }
+        } // When using run or watch, call close and wait for it to finish before calling run or watch again.
+        // Concurrent compilations will corrupt the output files.
+
+
+        compiler.close(closeErr => {
+          if (closeErr) {
+            logger.error(closeErr);
+          }
+
+          if (err) {
+            reject(err);
+          } else {
+            if (messages.errors.length) {
+              reject(new Error(messages.errors.join('\n\n')));
+              return;
+            }
+
+            resolve({
+              warnings: messages.warnings
+            });
+          }
+        });
+      });
+    });
+  };
+
+  resolvedConfig = _objectSpread(_objectSpread({}, resolvedConfig), {}, {
+    cliOptions: options
+  });
+  ResolvedConfigContext.set(resolvedConfig);
+  const {
+    distDirectory,
+    appDirectory,
+    serverConfigFile
+  } = appContext;
+  const previousFileSizes = await measureFileSizesBeforeBuild(distDirectory);
+  await emptyDir(distDirectory);
+  await buildServerConfig({
+    appDirectory,
+    distDirectory,
+    configFile: serverConfigFile
+  });
+  const buildConfigs = [];
+  buildConfigs.push({
+    type: 'legacy',
+    config: getWebpackConfig(WebpackConfigTarget.CLIENT, appContext, resolvedConfig)
+  });
+
+  if (resolvedConfig.output.enableModernMode) {
+    buildConfigs.push({
+      type: 'modern',
+      config: getWebpackConfig(WebpackConfigTarget.MODERN, appContext, resolvedConfig)
+    });
+  }
+
+  if (isUseSSRBundle(resolvedConfig)) {
+    buildConfigs.push({
+      type: 'ssr',
+      config: getWebpackConfig(WebpackConfigTarget.NODE, appContext, resolvedConfig)
+    });
+  }
+
+  await hookRunners.beforeBuild({
+    webpackConfigs: buildConfigs.map(({
+      config
+    }) => config)
+  });
+
+  for (const buildConfig of buildConfigs) {
+    const {
+      type: buildType,
+      config
+    } = buildConfig;
+
+    try {
+      await webpackBuild(config, buildType);
+    } catch (error) {
+      printBuildError(error); // eslint-disable-next-line no-process-exit
+
+      process.exit(1);
+    }
+  }
+
+  await generateRoutes(appContext);
+  await hookRunners.afterBuild();
+  await emitResolvedConfig(appDirectory, resolvedConfig);
+};

package/dist/js/modern/commands/deploy.js

@@ -0,0 +1,5 @@
+export const deploy = async (api, options) => {
+  const hookRunners = api.useHookRunners();
+  await hookRunners.beforeDeploy(options);
+  await hookRunners.afterDeploy(options);
+};

package/dist/js/modern/commands/dev.js

@@ -0,0 +1,95 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { fs, logger, chalk, isSSR } from '@modern-js/utils';
+import { ResolvedConfigContext } from '@modern-js/core';
+import { createCompiler } from "../utils/createCompiler";
+import { createServer } from "../utils/createServer";
+import { generateRoutes } from "../utils/routes";
+import { printInstructions } from "../utils/printInstructions";
+import { getSpecifiedEntries } from "../utils/getSpecifiedEntries";
+import { buildServerConfig } from "../utils/config";
+export const dev = async (api, options) => {
+  let userConfig = api.useResolvedConfigContext();
+  const appContext = api.useAppContext();
+  const hookRunners = api.useHookRunners();
+  userConfig = _objectSpread(_objectSpread({}, userConfig), {}, {
+    cliOptions: options
+  });
+  ResolvedConfigContext.set(userConfig);
+  const {
+    appDirectory,
+    distDirectory,
+    port,
+    apiOnly,
+    entrypoints,
+    serverConfigFile
+  } = appContext;
+  const checkedEntries = await getSpecifiedEntries(options.entry || false, entrypoints);
+  api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+    checkedEntries
+  }));
+  appContext.checkedEntries = checkedEntries;
+  fs.emptyDirSync(distDirectory);
+  await buildServerConfig({
+    appDirectory,
+    distDirectory,
+    configFile: serverConfigFile,
+    options: {
+      esbuildOptions: {
+        watch: true
+      }
+    }
+  });
+  await hookRunners.beforeDev();
+  let compiler = null;
+
+  if (!apiOnly) {
+    const {
+      getWebpackConfig,
+      WebpackConfigTarget
+    } = await import('@modern-js/webpack');
+    const webpackConfigs = [isSSR(userConfig) && getWebpackConfig(WebpackConfigTarget.NODE, appContext, userConfig), getWebpackConfig(WebpackConfigTarget.CLIENT, appContext, userConfig)].filter(Boolean);
+    compiler = await createCompiler({
+      api,
+      webpackConfigs,
+      userConfig,
+      appContext
+    });
+  }
+
+  await generateRoutes(appContext);
+  const app = await createServer({
+    dev: _objectSpread(_objectSpread({}, {
+      client: {
+        port: port.toString()
+      },
+      devMiddleware: {
+        writeToDisk: file => !file.includes('.hot-update.')
+      },
+      hot: true,
+      liveReload: true,
+      port,
+      https: userConfig.dev.https
+    }), userConfig.tools.devServer),
+    compiler,
+    pwd: appDirectory,
+    config: userConfig,
+    serverConfigFile,
+    plugins: appContext.plugins.filter(p => p.server).map(p => p.server)
+  });
+  app.listen(port, async err => {
+    if (err) {
+      throw err;
+    }
+
+    if (apiOnly) {
+      return printInstructions(hookRunners, appContext, userConfig);
+    }
+
+    return logger.log(chalk.cyan(`Starting the development server...`));
+  });
+};

package/dist/js/modern/commands/index.js

@@ -0,0 +1,3 @@
+export * from "./dev";
+export * from "./build";
+export * from "./start";

package/dist/js/modern/commands/inspect.js

@@ -0,0 +1,69 @@
+import path from 'path';
+import { getWebpackConfig, WebpackConfigTarget } from '@modern-js/webpack';
+import { fs, logger, isUseSSRBundle, chalk } from '@modern-js/utils';
+import WebpackChain from '@modern-js/utils/webpack-chain';
+export const formatWebpackConfig = (config, verbose) => {
+  const stringify = WebpackChain.toString;
+  return `module.exports = ${stringify(config, {
+    verbose
+  })};`;
+};
+export const inspect = (api, options) => {
+  process.env.NODE_ENV = options.env;
+  const resolvedConfig = api.useResolvedConfigContext();
+  const appContext = api.useAppContext();
+  const outputFiles = [];
+  outputFiles.push(printInspectResult(WebpackConfigTarget.CLIENT, appContext, resolvedConfig, options));
+
+  if (resolvedConfig.output.enableModernMode) {
+    outputFiles.push(printInspectResult(WebpackConfigTarget.MODERN, appContext, resolvedConfig, options));
+  }
+
+  if (isUseSSRBundle(resolvedConfig)) {
+    outputFiles.push(printInspectResult(WebpackConfigTarget.NODE, appContext, resolvedConfig, options));
+  }
+
+  logger.success('Inspect succeed, you can open following files to view the full webpack config: \n');
+  outputFiles.forEach(file => {
+    logger.log(`  - ${chalk.yellow(path.relative(appContext.appDirectory, file))}`);
+  });
+  logger.log();
+};
+export const getTagByWebpackTarget = webpackTarget => {
+  switch (webpackTarget) {
+    case WebpackConfigTarget.CLIENT:
+      return 'client';
+
+    case WebpackConfigTarget.MODERN:
+      return 'modern';
+
+    case WebpackConfigTarget.NODE:
+      return 'ssr';
+
+    default:
+      throw Error(`Unsupported webpack target: ${webpackTarget}`);
+  }
+};
+export const printInspectResult = (webpackTarget, appContext, resolvedConfig, options) => {
+  const webpackConfig = getWebpackConfig(webpackTarget, appContext, resolvedConfig);
+  const {
+    output,
+    verbose,
+    console = true
+  } = options;
+  const outputPath = output ? path.posix.join(appContext.distDirectory, output) : appContext.distDirectory;
+  const tag = getTagByWebpackTarget(webpackTarget);
+  const outputFile = `webpack.${tag}.inspect.js`;
+  const outputFilePath = path.posix.join(outputPath, outputFile);
+  const rawWebpackConfig = formatWebpackConfig(webpackConfig, verbose);
+  fs.outputFileSync(outputFilePath, rawWebpackConfig);
+
+  if (console) {
+    logger.log(`
+webpack config for ${tag} build:
+${rawWebpackConfig}
+    `);
+  }
+
+  return outputFilePath;
+};

package/dist/js/modern/commands/start.js

@@ -0,0 +1,31 @@
+import { logger, chalk, isApiOnly } from '@modern-js/utils';
+import server from '@modern-js/prod-server';
+import { printInstructions } from "../utils/printInstructions";
+export const start = async api => {
+  var _userConfig$source;
+
+  const appContext = api.useAppContext();
+  const userConfig = api.useResolvedConfigContext();
+  const hookRunners = api.useHookRunners();
+  const {
+    appDirectory,
+    port,
+    serverConfigFile
+  } = appContext;
+  logger.log(chalk.cyan(`Starting the modern server...`));
+  const apiOnly = await isApiOnly(appContext.appDirectory, userConfig === null || userConfig === void 0 ? void 0 : (_userConfig$source = userConfig.source) === null || _userConfig$source === void 0 ? void 0 : _userConfig$source.entriesDir);
+  const app = await server({
+    pwd: appDirectory,
+    config: userConfig,
+    plugins: appContext.plugins.filter(p => p.server).map(p => p.server),
+    serverConfigFile,
+    apiOnly
+  });
+  app.listen(port, async err => {
+    if (err) {
+      throw err;
+    }
+
+    await printInstructions(hookRunners, appContext, userConfig);
+  });
+};

package/dist/js/modern/exports/server.js

@@ -0,0 +1 @@
+export { defineServerConfig as defineConfig } from "../utils/config";

package/dist/js/modern/hooks.js

@@ -0,0 +1,21 @@
+import { createAsyncWaterfall, createAsyncWorkflow } from '@modern-js/plugin';
+export const beforeDev = createAsyncWorkflow();
+export const afterDev = createAsyncWorkflow();
+export const beforeCreateCompiler = createAsyncWorkflow();
+export const afterCreateCompiler = createAsyncWorkflow();
+export const beforePrintInstructions = createAsyncWaterfall();
+export const beforeBuild = createAsyncWorkflow();
+export const afterBuild = createAsyncWorkflow();
+export const beforeDeploy = createAsyncWorkflow();
+export const afterDeploy = createAsyncWorkflow();
+export const hooks = {
+  beforeDev,
+  afterDev,
+  beforeCreateCompiler,
+  afterCreateCompiler,
+  beforePrintInstructions,
+  beforeBuild,
+  afterBuild,
+  beforeDeploy,
+  afterDeploy
+};

package/dist/js/modern/index.js

@@ -0,0 +1,109 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import path from 'path';
+import { defineConfig, cli } from '@modern-js/core';
+import LintPlugin from '@modern-js/plugin-jarvis';
+import { cleanRequireCache, Import } from '@modern-js/utils';
+import AnalyzePlugin from "./analyze";
+import { hooks } from "./hooks";
+import { i18n, localeKeys } from "./locale";
+import { getLocaleLanguage } from "./utils/language";
+export { defineConfig };
+const upgradeModel = Import.lazy('@modern-js/upgrade', require);
+export default (() => ({
+  name: '@modern-js/app-tools',
+  post: ['@modern-js/plugin-analyze', '@modern-js/plugin-ssr', '@modern-js/plugin-state', '@modern-js/plugin-router', '@modern-js/plugin-polyfill'],
+  registerHook: hooks,
+  usePlugins: [AnalyzePlugin(), LintPlugin()],
+  setup: api => {
+    const locale = getLocaleLanguage();
+    i18n.changeLanguage({
+      locale
+    });
+    return {
+      commands({
+        program
+      }) {
+        program.command('dev').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);
+        });
+        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); // force exit after build.
+          // eslint-disable-next-line no-process-exit
+
+          process.exit(0);
+        });
+        program.command('start').usage('[options]').description(i18n.t(localeKeys.command.start.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/start");
+          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 options => {
+          const {
+            build
+          } = await import("./commands/build");
+          await build(api);
+          const {
+            deploy
+          } = await import("./commands/deploy");
+          await deploy(api, options); // eslint-disable-next-line no-process-exit
+
+          process.exit(0);
+        });
+        program.command('new').usage('[options]').description(i18n.t(localeKeys.command.new.describe)).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 options => {
+          const {
+            MWANewAction
+          } = await import('@modern-js/new-action');
+          await MWANewAction(_objectSpread(_objectSpread({}, options), {}, {
+            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('--no-console', i18n.t(localeKeys.command.inspect.noConsole)).option('--verbose', i18n.t(localeKeys.command.inspect.verbose)).option('-c --config <config>', i18n.t(localeKeys.command.shared.config)).action(async options => {
+          const {
+            inspect
+          } = await import("./commands/inspect");
+          inspect(api, options);
+        });
+        upgradeModel.defineCommand(program.command('upgrade'));
+      },
+
+      // 这里会被 core/initWatcher 监听的文件变动触发，如果是 src 目录下的文件变动，则不做 restart
+      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 cli.restart();
+        }
+      },
+
+      async beforeRestart() {
+        cleanRequireCache([require.resolve("./analyze")]);
+      }
+
+    };
+  }
+}));

package/dist/js/modern/locale/en.js

@@ -0,0 +1,35 @@
+export const EN_LOCALE = {
+  command: {
+    shared: {
+      analyze: 'analyze bundle size',
+      config: 'specify config file'
+    },
+    dev: {
+      describe: 'start dev server',
+      entry: 'compiler by entry',
+      apiOnly: 'start api server only'
+    },
+    build: {
+      describe: 'build application'
+    },
+    start: {
+      describe: 'start server'
+    },
+    deploy: {
+      describe: 'deploy application'
+    },
+    new: {
+      describe: 'generator runner for MWA project',
+      debug: 'using debug mode to log something',
+      config: 'set default generator config(json string)',
+      distTag: `use specified tag version for it's generator`,
+      registry: 'set npm registry url to run npm command'
+    },
+    inspect: {
+      env: 'specify env mode',
+      output: 'specify inspect content output path',
+      noConsole: 'do not log the result in terminal',
+      verbose: 'show full function definitions in output'
+    }
+  }
+};

package/dist/js/modern/locale/index.js

@@ -0,0 +1,9 @@
+import { I18n } from '@modern-js/plugin-i18n';
+import { ZH_LOCALE } from "./zh";
+import { EN_LOCALE } from "./en";
+const i18n = new I18n();
+const localeKeys = i18n.init('zh', {
+  zh: ZH_LOCALE,
+  en: EN_LOCALE
+});
+export { i18n, localeKeys };

package/dist/js/modern/locale/zh.js

@@ -0,0 +1,35 @@
+export const ZH_LOCALE = {
+  command: {
+    shared: {
+      analyze: '分析构建产物体积，查看各个模块打包后的大小',
+      config: '指定配置文件路径，可以为相对路径或绝对路径'
+    },
+    dev: {
+      describe: '本地开发命令',
+      entry: '指定入口，编译特定的页面',
+      apiOnly: '仅启动 API 接口服务'
+    },
+    build: {
+      describe: '构建应用命令'
+    },
+    start: {
+      describe: '应用启动命令'
+    },
+    deploy: {
+      describe: '部署应用命令'
+    },
+    new: {
+      describe: 'MWA 项目中执行生成器',
+      debug: '开启 Debug 模式，打印调试日志信息',
+      config: '生成器运行默认配置(JSON 字符串)',
+      distTag: '生成器使用特殊的 npm Tag 版本',
+      registry: '生成器运行过程中定制 npm Registry'
+    },
+    inspect: {
+      env: '查看指定环境下的配置',
+      output: '指定在 dist 目录下输出的路径',
+      noConsole: '不在终端中输出完整结果',
+      verbose: '在结果中展示函数的完整内容'
+    }
+  }
+};