@modern-js/module-tools 2.35.0 → 2.36.0

package/dist/builder/feature/swc.js

@@ -0,0 +1,170 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], 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);
+var swc_exports = {};
+__export(swc_exports, {
+  swcRenderChunk: () => swcRenderChunk,
+  swcTransform: () => swcTransform
+});
+module.exports = __toCommonJS(swc_exports);
+var import_path = require("path");
+var import_swc_plugins = require("@modern-js/swc-plugins");
+var import_utils = require("../../utils");
+const name = "swc:transform";
+const getSwcTarget = (target) => {
+  const list = [
+    "es3",
+    "es5",
+    "es2015",
+    "es2016",
+    "es2017",
+    "es2018",
+    "es2019",
+    "es2020",
+    "es2021",
+    "es2022"
+  ];
+  if (list.includes(target)) {
+    return target;
+  }
+  if (target === "next") {
+    return "es2022";
+  }
+  if (target === "es6") {
+    return "es2015";
+  }
+  return "es2022";
+};
+const swcTransform = (userTsconfig) => ({
+  name,
+  apply(compiler) {
+    var _userTsconfig_compilerOptions, _userTsconfig_compilerOptions1, _userTsconfig_compilerOptions2;
+    const tsUseDefineForClassFields = userTsconfig === null || userTsconfig === void 0 ? void 0 : (_userTsconfig_compilerOptions = userTsconfig.compilerOptions) === null || _userTsconfig_compilerOptions === void 0 ? void 0 : _userTsconfig_compilerOptions.useDefineForClassFields;
+    var _userTsconfig_compilerOptions_emitDecoratorMetadata;
+    const emitDecoratorMetadata = (_userTsconfig_compilerOptions_emitDecoratorMetadata = userTsconfig === null || userTsconfig === void 0 ? void 0 : (_userTsconfig_compilerOptions1 = userTsconfig.compilerOptions) === null || _userTsconfig_compilerOptions1 === void 0 ? void 0 : _userTsconfig_compilerOptions1.emitDecoratorMetadata) !== null && _userTsconfig_compilerOptions_emitDecoratorMetadata !== void 0 ? _userTsconfig_compilerOptions_emitDecoratorMetadata : false;
+    let useDefineForClassFields;
+    let tsTarget = userTsconfig === null || userTsconfig === void 0 ? void 0 : (_userTsconfig_compilerOptions2 = userTsconfig.compilerOptions) === null || _userTsconfig_compilerOptions2 === void 0 ? void 0 : _userTsconfig_compilerOptions2.target;
+    tsTarget = tsTarget ? tsTarget.toLowerCase() : void 0;
+    if (tsUseDefineForClassFields !== void 0) {
+      useDefineForClassFields = tsUseDefineForClassFields;
+    } else if (tsTarget !== void 0) {
+      useDefineForClassFields = (0, import_utils.tsTargetAtOrAboveES2022)(tsTarget);
+    } else {
+      useDefineForClassFields = true;
+    }
+    const { transformImport, transformLodash, externalHelpers } = compiler.config;
+    compiler.hooks.transform.tapPromise({
+      name
+    }, async (source) => {
+      const { path } = source;
+      const isTs = (0, import_utils.isTsLoader)(source.loader) || (0, import_utils.isTsExt)(path);
+      const enableJsx = source.loader === "tsx" || source.loader === "jsx" || /\.tsx$|\.jsx$/i.test(path);
+      if ((0, import_utils.isJsExt)(path) || (0, import_utils.isJsLoader)(source.loader)) {
+        const { target, jsx } = compiler.config;
+        const swcCompilerOptions = {
+          sourceMaps: Boolean(compiler.config.sourceMap),
+          inputSourceMap: false,
+          swcrc: false,
+          configFile: false,
+          jsc: {
+            parser: isTs ? {
+              syntax: "typescript",
+              tsx: enableJsx,
+              decorators: true
+            } : {
+              syntax: "ecmascript",
+              jsx: enableJsx,
+              decorators: true
+            },
+            transform: {
+              react: {
+                runtime: jsx === "transform" ? "classic" : "automatic"
+              },
+              useDefineForClassFields,
+              legacyDecorator: emitDecoratorMetadata ? true : void 0,
+              decoratorMetadata: emitDecoratorMetadata ? true : void 0
+            },
+            externalHelpers,
+            target: getSwcTarget(target)
+          },
+          isModule: "unknown",
+          extensions: {
+            pluginImport: transformImport,
+            lodash: transformLodash ? {
+              cwd: compiler.context.root,
+              ids: [
+                "lodash",
+                "lodash-es"
+              ]
+            } : void 0
+          }
+        };
+        const swcCompiler = new import_swc_plugins.Compiler(swcCompilerOptions);
+        const result = await swcCompiler.transform((0, import_path.basename)(path), source.code);
+        return {
+          ...source,
+          code: result.code,
+          map: typeof result.map === "string" ? JSON.parse(result.map) : result.map
+        };
+      }
+      return source;
+    });
+  }
+});
+const swcRenderChunk = {
+  name: "swc:renderChunk",
+  apply(compiler) {
+    compiler.hooks.renderChunk.tapPromise({
+      name: "swc:renderChunk"
+    }, async (chunk) => {
+      if (chunk.fileName.endsWith(".js") && chunk.type === "chunk") {
+        const { umdModuleName, format } = compiler.config;
+        const name2 = typeof umdModuleName === "function" ? umdModuleName(chunk.fileName) : umdModuleName;
+        const swcCompiler = new import_swc_plugins.Compiler({
+          sourceMaps: Boolean(compiler.config.sourceMap),
+          inputSourceMap: false,
+          swcrc: false,
+          configFile: false,
+          extensions: {},
+          jsc: {
+            target: getSwcTarget(compiler.config.target),
+            parser: {
+              syntax: "ecmascript"
+            }
+          },
+          module: format === "umd" ? {
+            type: "umd"
+          } : void 0,
+          isModule: "unknown"
+        });
+        const result = await swcCompiler.transform(name2, chunk.contents.toString());
+        return {
+          ...chunk,
+          contents: result.code,
+          map: typeof result.map === "string" ? JSON.parse(result.map) : result.map
+        };
+      }
+      return chunk;
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  swcRenderChunk,
+  swcTransform
+});

package/dist/builder/feature/terser.d.ts

@@ -0,0 +1,5 @@
+import { ICompiler } from '../../types';
+export declare const minify: {
+  name: string;
+  apply: (compiler: ICompiler) => void;
+};

package/dist/builder/feature/terser.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], 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);
+var terser_exports = {};
+__export(terser_exports, {
+  minify: () => minify
+});
+module.exports = __toCommonJS(terser_exports);
+var import_utils = require("@modern-js/utils");
+var import_terser = require("terser");
+var import_types = require("../../types");
+var import_utils2 = require("../../utils");
+const name = "terser";
+const apply = (compiler) => {
+  compiler.hooks.renderChunk.tapPromise({
+    name
+  }, async (chunk) => {
+    const { sourceMap, minify: minify2 } = compiler.config;
+    if (chunk.type === import_types.ChunkType.chunk) {
+      const code = chunk.contents.toString();
+      const needSourceMap = Boolean(sourceMap);
+      const terserOptions = resolveTerserOptions(minify2, {
+        sourceMap: Boolean(needSourceMap)
+      });
+      const result = await (0, import_terser.minify)(code, {
+        ...terserOptions,
+        sourceMap: needSourceMap
+      });
+      return {
+        ...chunk,
+        contents: result.code || chunk.contents,
+        map: (0, import_utils2.normalizeSourceMap)(result.map, {
+          needSourceMap
+        })
+      };
+    }
+    return chunk;
+  });
+};
+const minify = {
+  name,
+  apply
+};
+function resolveTerserOptions(terserOptions, { sourceMap }) {
+  return import_utils.lodash.merge({
+    compress: {
+      inline: 2,
+      comparisons: false
+    },
+    format: {
+      keep_quoted_props: true,
+      comments: false
+    },
+    // Return object to avoid redundant `JSON.parse` in remapping
+    sourceMap: sourceMap ? {
+      asObject: true,
+      // `includeSources` is not necessary for minification,
+      // and we can utilize this to reduce the size of the source map.
+      includeSources: false
+    } : false,
+    safari10: true,
+    toplevel: true
+  }, (0, import_utils.isObject)(terserOptions) ? terserOptions : {});
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  minify
+});

package/dist/builder/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="mocha" />
 import type { PluginAPI } from '@modern-js/core';
 import type { ModuleContext } from '../types/context';
 import type { BuildCommandOptions, BaseBuildConfig, ModuleTools } from '../types';

package/dist/builder/index.js

@@ -1,20 +1,42 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "run", {
-  enumerable: true,
-  get: function() {
-    return run;
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var builder_exports = {};
+__export(builder_exports, {
+  run: () => run
 });
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _os = /* @__PURE__ */ _interop_require_default._(require("os"));
-const _utils = require("@modern-js/utils");
-const _pmap = /* @__PURE__ */ _interop_require_default._(require("../../compiled/p-map"));
-const _build = require("./build");
-const _clear = require("./clear");
+module.exports = __toCommonJS(builder_exports);
+var import_os = __toESM(require("os"));
+var import_utils = require("@modern-js/utils");
+var import_p_map = __toESM(require("../../compiled/p-map"));
+var import_debug = require("../debug");
+var import_build = require("./build");
+var import_clear = require("./clear");
 const run = async (options, api) => {
   const { resolvedBuildConfig, context, cmdOptions } = options;
   const { watch, clear } = cmdOptions;
@@ -22,31 +44,36 @@ const run = async (options, api) => {
   let totalDuration = 0;
   if (resolvedBuildConfig.length !== 0) {
     totalDuration = Date.now();
-    await (0, _clear.clearBuildConfigPaths)(resolvedBuildConfig, {
-      noClear: !clear,
-      projectAbsRootPath: context.appDirectory
-    });
-    await (0, _clear.clearDtsTemp)();
+    if (clear) {
+      (0, import_debug.debug)("clear output paths");
+      await (0, import_clear.clearBuildConfigPaths)(resolvedBuildConfig, context.appDirectory);
+      (0, import_debug.debug)("clear output paths done");
+    }
+    await (0, import_clear.clearDtsTemp)();
     if (watch) {
-      _utils.logger.info("Start build in watch mode...\n");
+      import_utils.logger.info("Start build in watch mode...");
     }
     try {
-      await (0, _pmap.default)(resolvedBuildConfig, async (config) => {
+      await (0, import_p_map.default)(resolvedBuildConfig, async (config) => {
+        (0, import_debug.debug)("run beforeBuildTask hooks");
         const buildConfig = await runner.beforeBuildTask(config);
-        await (0, _build.runBuildTask)({
+        (0, import_debug.debug)("run beforeBuildTask hooks done");
+        await (0, import_build.runBuildTask)({
           buildConfig,
           buildCmdOptions: cmdOptions,
           context
         }, api);
+        (0, import_debug.debug)("run afterBuildTask hooks");
         await runner.afterBuildTask({
           status: "success",
           config
         });
+        (0, import_debug.debug)("run afterBuildTask hooks done");
       }, {
-        concurrency: _os.default.cpus().length
+        concurrency: import_os.default.cpus().length
       });
     } catch (e) {
-      const { isInternalError, ModuleBuildError } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../error")));
+      const { isInternalError, ModuleBuildError } = await Promise.resolve().then(() => __toESM(require("../error")));
       if (isInternalError(e)) {
         throw new ModuleBuildError(e);
       } else {
@@ -55,19 +82,23 @@ const run = async (options, api) => {
     }
     totalDuration = Date.now() - totalDuration;
     if (!watch) {
-      const { printFileSize, printSucceed } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("../utils/print")));
+      const { printFileSize, printSucceed } = await Promise.resolve().then(() => __toESM(require("../utils/print")));
       printSucceed(totalDuration);
       printFileSize();
     }
   } else {
-    _utils.logger.warn(_utils.chalk.yellow(`No build configuration found! Please configure \`buildConfig\` or \`buildPreset\``));
+    import_utils.logger.warn(import_utils.chalk.yellow(`No build configuration found! Please configure \`buildConfig\` or \`buildPreset\``));
   }
+  (0, import_debug.debug)("run afterBuild hooks");
   await runner.afterBuild({
     status: "success",
     config: resolvedBuildConfig,
     commandOptions: cmdOptions,
     totalDuration
   });
+  (0, import_debug.debug)("run afterBuild hooks done");
 };
-
-//# sourceMappingURL=index.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});

package/dist/builder/platform.js

@@ -1,27 +1,40 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "buildPlatform", {
-  enumerable: true,
-  get: function() {
-    return buildPlatform;
+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);
+var platform_exports = {};
+__export(platform_exports, {
+  buildPlatform: () => buildPlatform
 });
-const _utils = require("@modern-js/utils");
-const _color = require("../constants/color");
+module.exports = __toCommonJS(platform_exports);
+var import_utils = require("@modern-js/utils");
+var import_color = require("../constants/color");
 const buildPlatform = async (options, api, context) => {
   const runner = api.useHookRunners();
   const platformBuilders = await runner.registerBuildPlatform();
   if (platformBuilders.length === 0) {
     if (options.platform === true) {
-      _utils.logger.info("No executable platform build tasks");
+      import_utils.logger.info("No executable platform build tasks");
     } else if (Array.isArray(options.platform) && options.platform.length === 1) {
-      _utils.logger.info(`No build tasks with platform "${options.platform[0]}" found`);
+      import_utils.logger.info(`No build tasks with platform "${options.platform[0]}" found`);
     } else if (Array.isArray(options.platform) && options.platform.length > 1) {
-      _utils.logger.info(`No build tasks with platform ${options.platform.join(",")} found`);
+      import_utils.logger.info(`No build tasks with platform ${options.platform.join(",")} found`);
     } else {
-      _utils.logger.info("Unknown platform", JSON.stringify(options.platform));
+      import_utils.logger.info("Unknown platform", JSON.stringify(options.platform));
     }
     return;
   }
@@ -31,14 +44,14 @@ const buildPlatform = async (options, api, context) => {
     if (options.platform === true) {
       for (const platformBuilder of platformBuilders) {
         const currentPlatform = Array.isArray(platformBuilder.platform) ? platformBuilder.platform[0] : platformBuilder.platform;
-        _utils.logger.info(_utils.chalk.underline.rgb(..._color.blue)(`Running [${currentPlatform}] build task:`));
+        import_utils.logger.info(import_utils.chalk.underline.rgb(...import_color.blue)(`Running [${currentPlatform}] build task:`));
         await runner.buildPlatform({
           platform: currentPlatform
         });
         await platformBuilder.build(currentPlatform, {
           isTsProject: context.isTsProject
         });
-        _utils.logger.info(_utils.chalk.rgb(..._color.gray)(`Done for [${currentPlatform}] task`));
+        import_utils.logger.info(import_utils.chalk.rgb(...import_color.gray)(`Done for [${currentPlatform}] task`));
       }
     } else if (Array.isArray(options.platform) && options.platform.length === 1) {
       const targetPlatform = options.platform[0];
@@ -49,17 +62,17 @@ const buildPlatform = async (options, api, context) => {
         return builder.platform === targetPlatform;
       });
       if (!selectPlatformBuilder) {
-        _utils.logger.info(`The specified "${targetPlatform}" build does not exist`);
+        import_utils.logger.info(`The specified "${targetPlatform}" build does not exist`);
         return;
       }
-      _utils.logger.info(_utils.chalk.underline.rgb(..._color.blue)(`Running [${targetPlatform}] build task:`));
+      import_utils.logger.info(import_utils.chalk.underline.rgb(...import_color.blue)(`Running [${targetPlatform}] build task:`));
       await runner.buildPlatform({
         platform: targetPlatform
       });
       await selectPlatformBuilder.build(targetPlatform, {
         isTsProject: context.isTsProject
       });
-      _utils.logger.info(_utils.chalk.rgb(..._color.gray)(`Done for [${targetPlatform}] task`));
+      import_utils.logger.info(import_utils.chalk.rgb(...import_color.gray)(`Done for [${targetPlatform}] task`));
     } else if (Array.isArray(options.platform) && options.platform.length > 1) {
       for (const platform of options.platform) {
         const foundBuilder = platformBuilders.find((builder) => {
@@ -69,17 +82,17 @@ const buildPlatform = async (options, api, context) => {
           return builder.platform === platform;
         });
         if (!foundBuilder) {
-          _utils.logger.info(`skip ${platform} build, because it does not exist`);
+          import_utils.logger.info(`skip ${platform} build, because it does not exist`);
           continue;
         }
-        _utils.logger.info(_utils.chalk.underline.rgb(..._color.blue)(`Running [${platform}] build task:`));
+        import_utils.logger.info(import_utils.chalk.underline.rgb(...import_color.blue)(`Running [${platform}] build task:`));
         await runner.buildPlatform({
           platform
         });
         await foundBuilder.build(platform, {
           isTsProject: context.isTsProject
         });
-        _utils.logger.info(_utils.chalk.rgb(..._color.gray)(`Done for [${platform}] task`));
+        import_utils.logger.info(import_utils.chalk.rgb(...import_color.gray)(`Done for [${platform}] task`));
       }
     }
   } catch (e) {
@@ -94,5 +107,7 @@ const buildPlatform = async (options, api, context) => {
     message: errorMsg
   });
 };
-
-//# sourceMappingURL=platform.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPlatform
+});

package/dist/cli.js

@@ -1,26 +1,48 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "moduleTools", {
-  enumerable: true,
-  get: function() {
-    return moduleTools;
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cli_exports = {};
+__export(cli_exports, {
+  moduleTools: () => moduleTools
 });
-const _utils = require("@modern-js/utils");
-const _hooks = require("./hooks");
-const _plugins = require("./plugins");
-const _command = require("./command");
-const _language = require("./utils/language");
-const _onExit = require("./utils/onExit");
-const _merge = require("./config/merge");
-const _legacySchema = require("./config/legacySchema");
-const _schema = require("./config/schema");
+module.exports = __toCommonJS(cli_exports);
+var import_utils = require("@modern-js/utils");
+var import_hooks = require("./hooks");
+var import_plugins = require("./plugins");
+var import_command = require("./command");
+var import_merge = require("./config/merge");
+var import_onExit = require("./utils/onExit");
+var import_legacySchema = require("./config/legacySchema");
+var import_schema = require("./config/schema");
 const moduleTools = () => ({
   name: "@modern-js/module-tools",
-  registerHook: _hooks.registerHook,
-  usePlugins: (0, _plugins.getPlugins)(process.argv.slice(2)[0]),
+  registerHook: import_hooks.registerHook,
+  usePlugins: (0, import_plugins.getPlugins)(process.argv.slice(2)[0]),
   setup
 });
 const setup = async (api) => {
@@ -30,30 +52,37 @@ const setup = async (api) => {
     toolsType: "module-tools"
   });
   const prepare = async () => {
-    await (0, _language.initLocalLanguage)();
+    const local = await Promise.resolve().then(() => __toESM(require("./locale")));
+    const { getLocaleLanguage } = await Promise.resolve().then(() => __toESM(require("@modern-js/plugin-i18n/language-detector")));
+    const locale = getLocaleLanguage();
+    local.i18n.changeLanguage({
+      locale
+    });
     const appContext2 = api.useAppContext();
-    _utils.dotenv.config();
-    await _utils.fs.emptydir(appContext2.internalDirectory);
+    import_utils.dotenv.config();
+    await import_utils.fs.emptydir(appContext2.internalDirectory);
     const hookRunners = api.useHookRunners();
     await hookRunners.addRuntimeExports();
-    await (0, _onExit.addExitListener)(async () => {
+    await (0, import_onExit.addExitListener)(async () => {
       await hookRunners.afterDev();
     });
   };
   const validateSchema = async () => {
     const userConfig = api.useConfigContext();
-    return (0, _merge.isLegacyUserConfig)(userConfig) ? _legacySchema.legacySchema : _schema.schema;
+    return (0, import_merge.isLegacyUserConfig)(userConfig) ? import_legacySchema.legacySchema : import_schema.schema;
   };
   return {
     prepare,
     validateSchema,
     async commands({ program }) {
-      await (0, _command.buildCommand)(program, api);
-      await (0, _command.devCommand)(program, api);
-      await (0, _command.newCommand)(program);
-      await (0, _command.upgradeCommand)(program);
+      await (0, import_command.buildCommand)(program, api);
+      await (0, import_command.devCommand)(program, api);
+      await (0, import_command.newCommand)(program);
+      await (0, import_command.upgradeCommand)(program);
     }
   };
 };
-
-//# sourceMappingURL=cli.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  moduleTools
+});