@modern-js/module-tools 2.0.0-beta.3 → 2.0.0-beta.6

package/dist/cli.js

@@ -0,0 +1,95 @@
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var cli_exports = {};
+__export(cli_exports, {
+  cli: () => cli
+});
+module.exports = __toCommonJS(cli_exports);
+var import_hooks = require("./hooks");
+var import_plugins = require("./plugins");
+const cli = () => ({
+  name: "@modern-js/module-tools",
+  registerHook: import_hooks.registerHook,
+  usePlugins: (0, import_plugins.getPlugins)(process.argv.slice(2)[0]),
+  setup
+});
+const setup = (api) => __async(void 0, null, function* () {
+  const prepare = () => __async(void 0, null, function* () {
+    const { initLocalLanguage } = yield Promise.resolve().then(() => __toESM(require("./utils/language")));
+    yield initLocalLanguage();
+    const appContext = api.useAppContext();
+    const { fs, dotenv } = yield Promise.resolve().then(() => __toESM(require("@modern-js/utils")));
+    dotenv.config();
+    yield fs.emptydir(appContext.internalDirectory);
+    const hookRunners = api.useHookRunners();
+    yield hookRunners.addRuntimeExports();
+    const { addExitListener } = yield Promise.resolve().then(() => __toESM(require("./utils/onExit")));
+    yield addExitListener(() => __async(void 0, null, function* () {
+      yield hookRunners.afterDev();
+    }));
+  });
+  const validateSchema = () => __async(void 0, null, function* () {
+    const { schema } = yield Promise.resolve().then(() => __toESM(require("./config/schema")));
+    return schema;
+  });
+  return {
+    prepare,
+    validateSchema,
+    commands(_0) {
+      return __async(this, arguments, function* ({ program }) {
+        const { buildCommand, devCommand, newCommand, upgradCommand } = yield Promise.resolve().then(() => __toESM(require("./command")));
+        yield buildCommand(program, api);
+        yield devCommand(program, api);
+        yield newCommand(program);
+        yield upgradCommand(program);
+      });
+    }
+  };
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cli
+});
+
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":null,"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEA,mBAA6B;AAC7B,qBAA2B;AAEpB,MAAM,MAAM,OAA+B;AAAA,EAChD,MAAM;AAAA,EACN;AAAA,EACA,gBAAY,2BAAW,QAAQ,KAAK,MAAM,CAAC,EAAE,EAAE;AAAA,EAC/C;AACF;AAEA,MAAM,QAAyC,CAAM,QAAO;AAC1D,QAAM,UAAU,MAAY;AAC1B,UAAM,EAAE,kBAAkB,IAAI,MAAM,6CAAO;AAC3C,UAAM,kBAAkB;AAExB,UAAM,aAAa,IAAI,cAAc;AACrC,UAAM,EAAE,IAAI,OAAO,IAAI,MAAM,6CAAO;AACpC,WAAO,OAAO;AAEd,UAAM,GAAG,SAAS,WAAW,iBAAiB;AAE9C,UAAM,cAAc,IAAI,eAAe;AACvC,UAAM,YAAY,kBAAkB;AAEpC,UAAM,EAAE,gBAAgB,IAAI,MAAM,6CAAO;AACzC,UAAM,gBAAgB,MAAY;AAChC,YAAM,YAAY,SAAS;AAAA,IAC7B,EAAC;AAAA,EACH;AAEA,QAAM,iBAAiB,MAAY;AACjC,UAAM,EAAE,OAAO,IAAI,MAAM,6CAAO;AAChC,WAAO;AAAA,EACT;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACM,SAAS,IAAa;AAAA,iDAAb,EAAE,QAAQ,GAAG;AAC1B,cAAM,EAAE,cAAc,YAAY,YAAY,cAAc,IAC1D,MAAM,6CAAO;AACf,cAAM,aAAa,SAAS,GAAG;AAC/B,cAAM,WAAW,SAAS,GAAG;AAC7B,cAAM,WAAW,OAAO;AACxB,cAAM,cAAc,OAAO;AAAA,MAC7B;AAAA;AAAA,EACF;AACF;;;;;","names":[],"sources":["../src/cli.ts"],"sourcesContent":["import type { CliPlugin } from '@modern-js/core';\nimport type { ModuleTools } from './types';\nimport { registerHook } from './hooks';\nimport { getPlugins } from './plugins';\n\nexport const cli = (): CliPlugin<ModuleTools> => ({\n  name: '@modern-js/module-tools',\n  registerHook,\n  usePlugins: getPlugins(process.argv.slice(2)[0]),\n  setup,\n});\n\nconst setup: CliPlugin<ModuleTools>['setup'] = async api => {\n  const prepare = async () => {\n    const { initLocalLanguage } = await import('./utils/language');\n    await initLocalLanguage();\n\n    const appContext = api.useAppContext();\n    const { fs, dotenv } = await import('@modern-js/utils');\n    dotenv.config();\n    // remove '/node_modules/.modern-js'\n    await fs.emptydir(appContext.internalDirectory);\n\n    const hookRunners = api.useHookRunners();\n    await hookRunners.addRuntimeExports();\n\n    const { addExitListener } = await import('./utils/onExit');\n    await addExitListener(async () => {\n      await hookRunners.afterDev();\n    });\n  };\n\n  const validateSchema = async () => {\n    const { schema } = await import('./config/schema');\n    return schema;\n  };\n\n  return {\n    prepare,\n    validateSchema,\n    async commands({ program }) {\n      const { buildCommand, devCommand, newCommand, upgradCommand } =\n        await import('./command');\n      await buildCommand(program, api);\n      await devCommand(program, api);\n      await newCommand(program);\n      await upgradCommand(program);\n    },\n  };\n};\n"]}

package/dist/command.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from '@modern-js/utils';
+import type { PluginAPI } from '@modern-js/core';
+import type { ModuleTools } from './types';
+export declare const buildCommand: (program: Command, api: PluginAPI<ModuleTools>) => Promise<void>;
+export declare const devCommand: (program: Command, api: PluginAPI<ModuleTools>) => Promise<void>;
+export declare const newCommand: (program: Command) => Promise<void>;
+export declare const upgradCommand: (program: Command) => Promise<void>;

package/dist/command.js

@@ -0,0 +1,164 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 __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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var command_exports = {};
+__export(command_exports, {
+  buildCommand: () => buildCommand,
+  devCommand: () => devCommand,
+  newCommand: () => newCommand,
+  upgradCommand: () => upgradCommand
+});
+module.exports = __toCommonJS(command_exports);
+var import_utils = require("@modern-js/utils");
+const debug = (0, import_utils.createDebugger)("module-tools");
+const buildCommand = (program, api) => __async(void 0, null, function* () {
+  const local = yield Promise.resolve().then(() => __toESM(require("./locale")));
+  const { defaultTsConfigPath } = yield Promise.resolve().then(() => __toESM(require("./constants/dts")));
+  program.command("build").usage("[options]").description(local.i18n.t(local.localeKeys.command.build.describe)).option("-w, --watch", local.i18n.t(local.localeKeys.command.build.watch)).option(
+    "--tsconfig [tsconfig]",
+    local.i18n.t(local.localeKeys.command.build.tsconfig),
+    defaultTsConfigPath
+  ).option(
+    "-p, --platform [platform...]",
+    local.i18n.t(local.localeKeys.command.build.platform)
+  ).option("--no-dts", local.i18n.t(local.localeKeys.command.build.dts)).option("--no-clear", local.i18n.t(local.localeKeys.command.build.no_clear)).option(
+    "-c --config <config>",
+    local.i18n.t(local.localeKeys.command.build.config)
+  ).action((options) => __async(void 0, null, function* () {
+    const { initModuleContext } = yield Promise.resolve().then(() => __toESM(require("./utils/context")));
+    const context = yield initModuleContext(api);
+    if (options.platform) {
+      const { buildPlatform } = yield Promise.resolve().then(() => __toESM(require("./builder/platform")));
+      yield buildPlatform(options, api, context);
+      return;
+    }
+    const runner = api.useHookRunners();
+    const { normalizeBuildConfig } = yield Promise.resolve().then(() => __toESM(require("./config/normalize")));
+    const resolvedBuildConfig = yield normalizeBuildConfig(
+      api,
+      context,
+      options
+    );
+    debug("resolvedBuildConfig", resolvedBuildConfig);
+    yield runner.beforeBuild({ config: resolvedBuildConfig, options });
+    const builder = yield Promise.resolve().then(() => __toESM(require("./builder")));
+    yield builder.run(
+      { cmdOptions: options, resolvedBuildConfig, context },
+      api
+    );
+  }));
+});
+const devCommand = (program, api) => __async(void 0, null, function* () {
+  const local = yield Promise.resolve().then(() => __toESM(require("./locale")));
+  const runner = api.useHookRunners();
+  const devToolMetas = yield runner.registerDev();
+  yield runner.beforeDev(devToolMetas);
+  const devProgram = program.command("dev").usage("[options]").description(local.i18n.t(local.localeKeys.command.dev.describe)).action((..._0) => __async(void 0, [..._0], function* (options = {}) {
+    const { initModuleContext } = yield Promise.resolve().then(() => __toESM(require("./utils/context")));
+    const context = yield initModuleContext(api);
+    const { dev } = yield Promise.resolve().then(() => __toESM(require("./dev")));
+    yield dev(options, devToolMetas, api, context);
+  }));
+  for (const meta of devToolMetas) {
+    if (!meta.subCommands) {
+      continue;
+    }
+    for (const subCmd of meta.subCommands) {
+      devProgram.command(subCmd).action((..._0) => __async(void 0, [..._0], function* (options = {}) {
+        const { initModuleContext } = yield Promise.resolve().then(() => __toESM(require("./utils/context")));
+        const context = yield initModuleContext(api);
+        yield runner.beforeDevTask(meta);
+        yield meta.action(options, { isTsProject: context.isTsProject });
+      }));
+    }
+  }
+});
+const newCommand = (program) => __async(void 0, null, function* () {
+  const local = yield Promise.resolve().then(() => __toESM(require("./locale")));
+  program.command("new").usage("[options]").description(local.i18n.t(local.localeKeys.command.new.describe)).option(
+    "-d, --debug",
+    local.i18n.t(local.localeKeys.command.new.debug),
+    false
+  ).option(
+    "-c, --config <config>",
+    local.i18n.t(local.localeKeys.command.new.config)
+  ).option(
+    "--dist-tag <tag>",
+    local.i18n.t(local.localeKeys.command.new.distTag)
+  ).option("--registry", local.i18n.t(local.localeKeys.command.new.registry)).action((options) => __async(void 0, null, function* () {
+    const { ModuleNewAction } = yield Promise.resolve().then(() => __toESM(require("@modern-js/new-action")));
+    const { getLocaleLanguage } = yield Promise.resolve().then(() => __toESM(require("./utils/language")));
+    const locale = getLocaleLanguage();
+    yield ModuleNewAction(__spreadProps(__spreadValues({}, options), { locale }));
+  }));
+});
+const upgradCommand = (program) => __async(void 0, null, function* () {
+  const { defineCommand } = yield Promise.resolve().then(() => __toESM(require("@modern-js/upgrade")));
+  defineCommand(program.command("upgrade"));
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildCommand,
+  devCommand,
+  newCommand,
+  upgradCommand
+});
+
+//# sourceMappingURL=command.js.map

package/dist/command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":null,"mappings":"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","names":[],"sources":["../src/command.ts"],"sourcesContent":["import type { Command } from '@modern-js/utils';\nimport { createDebugger } from '@modern-js/utils';\nimport type { PluginAPI } from '@modern-js/core';\nimport type { ModuleTools } from './types';\nimport type { DevCommandOptions, BuildCommandOptions } from './types/command';\n\nconst debug = createDebugger('module-tools');\n\nexport const buildCommand = async (\n  program: Command,\n  api: PluginAPI<ModuleTools>,\n) => {\n  const local = await import('./locale');\n  const { defaultTsConfigPath } = await import('./constants/dts');\n\n  program\n    .command('build')\n    .usage('[options]')\n    .description(local.i18n.t(local.localeKeys.command.build.describe))\n    .option('-w, --watch', local.i18n.t(local.localeKeys.command.build.watch))\n    .option(\n      '--tsconfig [tsconfig]',\n      local.i18n.t(local.localeKeys.command.build.tsconfig),\n      defaultTsConfigPath,\n    )\n    .option(\n      '-p, --platform [platform...]',\n      local.i18n.t(local.localeKeys.command.build.platform),\n    )\n    .option('--no-dts', local.i18n.t(local.localeKeys.command.build.dts))\n    .option('--no-clear', local.i18n.t(local.localeKeys.command.build.no_clear))\n    .option(\n      '-c --config <config>',\n      local.i18n.t(local.localeKeys.command.build.config),\n    )\n    .action(async (options: BuildCommandOptions) => {\n      const { initModuleContext } = await import('./utils/context');\n      const context = await initModuleContext(api);\n      if (options.platform) {\n        const { buildPlatform } = await import('./builder/platform');\n        await buildPlatform(options, api, context);\n        return;\n      }\n\n      const runner = api.useHookRunners();\n\n      const { normalizeBuildConfig } = await import('./config/normalize');\n      const resolvedBuildConfig = await normalizeBuildConfig(\n        api,\n        context,\n        options,\n      );\n\n      debug('resolvedBuildConfig', resolvedBuildConfig);\n\n      await runner.beforeBuild({ config: resolvedBuildConfig, options });\n      const builder = await import('./builder');\n      await builder.run(\n        { cmdOptions: options, resolvedBuildConfig, context },\n        api,\n      );\n    });\n};\n\nexport const devCommand = async (\n  program: Command,\n  api: PluginAPI<ModuleTools>,\n) => {\n  const local = await import('./locale');\n  const runner = api.useHookRunners();\n  const devToolMetas = await runner.registerDev();\n\n  await runner.beforeDev(devToolMetas);\n\n  const devProgram = program\n    .command('dev')\n    .usage('[options]')\n    .description(local.i18n.t(local.localeKeys.command.dev.describe))\n    .action(async (options: DevCommandOptions = {}) => {\n      const { initModuleContext } = await import('./utils/context');\n      const context = await initModuleContext(api);\n      const { dev } = await import('./dev');\n      await dev(options, devToolMetas, api, context);\n    });\n\n  for (const meta of devToolMetas) {\n    if (!meta.subCommands) {\n      continue;\n    }\n\n    for (const subCmd of meta.subCommands) {\n      devProgram\n        .command(subCmd)\n        .action(async (options: DevCommandOptions = {}) => {\n          const { initModuleContext } = await import('./utils/context');\n          const context = await initModuleContext(api);\n          await runner.beforeDevTask(meta);\n          await meta.action(options, { isTsProject: context.isTsProject });\n        });\n    }\n  }\n};\n\nexport const newCommand = async (program: Command) => {\n  const local = await import('./locale');\n\n  program\n    .command('new')\n    .usage('[options]')\n    .description(local.i18n.t(local.localeKeys.command.new.describe))\n    .option(\n      '-d, --debug',\n      local.i18n.t(local.localeKeys.command.new.debug),\n      false,\n    )\n    .option(\n      '-c, --config <config>',\n      local.i18n.t(local.localeKeys.command.new.config),\n    )\n    .option(\n      '--dist-tag <tag>',\n      local.i18n.t(local.localeKeys.command.new.distTag),\n    )\n    .option('--registry', local.i18n.t(local.localeKeys.command.new.registry))\n    .action(async options => {\n      const { ModuleNewAction } = await import('@modern-js/new-action');\n      const { getLocaleLanguage } = await import('./utils/language');\n      const locale = getLocaleLanguage();\n\n      await ModuleNewAction({ ...options, locale });\n    });\n};\n\nexport const upgradCommand = async (program: Command) => {\n  const { defineCommand } = await import('@modern-js/upgrade');\n  defineCommand(program.command('upgrade'));\n};\n"]}

package/dist/config/defineConfig.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleConfigParams } from '../types';
+export declare const defineConfig: (config: ModuleConfigParams) => ModuleConfigParams;

package/dist/config/defineConfig.js

@@ -0,0 +1,29 @@
+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 defineConfig_exports = {};
+__export(defineConfig_exports, {
+  defineConfig: () => defineConfig
+});
+module.exports = __toCommonJS(defineConfig_exports);
+const defineConfig = (config) => config;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineConfig
+});
+
+//# sourceMappingURL=defineConfig.js.map

package/dist/config/defineConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"mappings":";;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAEO,MAAM,eAAe,CAAC,WAC3B;","names":[],"sources":["../../src/config/defineConfig.ts"],"sourcesContent":["import type { ModuleConfigParams } from '../types';\n\nexport const defineConfig = (config: ModuleConfigParams): ModuleConfigParams =>\n  config;\n"]}

package/dist/config/normalize.d.ts

@@ -0,0 +1,17 @@
+import type { PluginAPI } from '@modern-js/core';
+import type { ModuleUserConfig, BaseBuildConfig, BuildPreset, PartialBuildConfig, PartialBaseBuildConfig, ModuleContext, BuildCommandOptions, ModuleTools } from '../types';
+export declare const transformBuildPresetToBaseConfigs: (options: {
+  context: ModuleContext;
+  buildCmdOptions: BuildCommandOptions;
+}, preset?: BuildPreset) => Promise<BaseBuildConfig[]>;
+export declare const transformBuildConfigToBaseConfigs: (config: PartialBuildConfig, options: {
+  buildCmdOptions: BuildCommandOptions;
+  context: ModuleContext;
+}) => Promise<BaseBuildConfig[]>;
+export declare const requiredBuildConfig: (partialBuildConfig: PartialBaseBuildConfig, context: ModuleContext) => Promise<BaseBuildConfig>;
+export declare const transformToAbsPath: (baseConfig: BaseBuildConfig, options: {
+  context: ModuleContext;
+  buildCmdOptions: BuildCommandOptions;
+}) => Promise<BaseBuildConfig>;
+export declare const checkConfig: (config: ModuleUserConfig) => Promise<void>;
+export declare const normalizeBuildConfig: (api: PluginAPI<ModuleTools>, context: ModuleContext, buildCmdOptions: BuildCommandOptions) => Promise<BaseBuildConfig[]>;

package/dist/config/normalize.js

@@ -0,0 +1,168 @@
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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());
+  });
+};
+var normalize_exports = {};
+__export(normalize_exports, {
+  checkConfig: () => checkConfig,
+  normalizeBuildConfig: () => normalizeBuildConfig,
+  requiredBuildConfig: () => requiredBuildConfig,
+  transformBuildConfigToBaseConfigs: () => transformBuildConfigToBaseConfigs,
+  transformBuildPresetToBaseConfigs: () => transformBuildPresetToBaseConfigs,
+  transformToAbsPath: () => transformToAbsPath
+});
+module.exports = __toCommonJS(normalize_exports);
+var import_path = __toESM(require("path"));
+const transformBuildPresetToBaseConfigs = (options, preset) => __async(void 0, null, function* () {
+  const { BuildInPreset, presetList } = yield Promise.resolve().then(() => __toESM(require("../constants/build-presets")));
+  const { addInputToPreset } = yield Promise.resolve().then(() => __toESM(require("../utils/input")));
+  if (typeof preset === "function") {
+    const partialBuildConfig = yield preset({ preset: BuildInPreset });
+    if (!partialBuildConfig) {
+      throw new Error(
+        "The `buildPreset` function does not allow no return value"
+      );
+    }
+    return transformBuildConfigToBaseConfigs(partialBuildConfig, options);
+  }
+  const inPresetList = (p) => p in presetList;
+  if (preset && inPresetList(preset)) {
+    return transformBuildConfigToBaseConfigs(
+      yield addInputToPreset(presetList[preset], options.context),
+      options
+    );
+  }
+  return transformBuildConfigToBaseConfigs(
+    yield addInputToPreset(presetList["base-config"], options.context),
+    options
+  );
+});
+const transformBuildConfigToBaseConfigs = (config, options) => __async(void 0, null, function* () {
+  const { validPartialBuildConfig } = yield Promise.resolve().then(() => __toESM(require("../utils/config")));
+  validPartialBuildConfig(config);
+  const { buildCmdOptions } = options;
+  const { ensureArray } = yield Promise.resolve().then(() => __toESM(require("@modern-js/utils")));
+  const { assignTsConfigPath } = yield Promise.resolve().then(() => __toESM(require("../utils/dts")));
+  const partialConfigs = ensureArray(config);
+  const configs = yield Promise.all(
+    partialConfigs.map((config2) => __async(void 0, null, function* () {
+      let newConfig = yield requiredBuildConfig(config2, options.context);
+      newConfig = yield assignTsConfigPath(newConfig, buildCmdOptions);
+      newConfig = yield transformToAbsPath(newConfig, options);
+      return newConfig;
+    }))
+  );
+  return configs;
+});
+const requiredBuildConfig = (partialBuildConfig, context) => __async(void 0, null, function* () {
+  const { mergeDefaultBaseConfig } = yield Promise.resolve().then(() => __toESM(require("../utils/config")));
+  const mergedConfig = yield mergeDefaultBaseConfig(
+    partialBuildConfig,
+    context
+  );
+  return mergedConfig;
+});
+const transformToAbsPath = (baseConfig, options) => __async(void 0, null, function* () {
+  const { slash } = yield Promise.resolve().then(() => __toESM(require("@modern-js/utils")));
+  const newConfig = baseConfig;
+  const { normalizeInput } = yield Promise.resolve().then(() => __toESM(require("../utils/input")));
+  const { context } = options;
+  newConfig.outdir = import_path.default.isAbsolute(newConfig.outdir) ? newConfig.outdir : import_path.default.join(context.appDirectory, newConfig.outdir);
+  newConfig.sourceDir = slash(
+    import_path.default.resolve(context.appDirectory, baseConfig.sourceDir)
+  );
+  newConfig.input = yield normalizeInput(newConfig, {
+    appDirectory: context.appDirectory
+  });
+  if (newConfig.dts) {
+    newConfig.dts.distPath = import_path.default.join(
+      newConfig.outdir,
+      newConfig.dts.distPath
+    );
+    newConfig.dts.tsconfigPath = import_path.default.join(
+      context.appDirectory,
+      newConfig.dts.tsconfigPath
+    );
+  }
+  return newConfig;
+});
+const checkConfig = (config) => __async(void 0, null, function* () {
+  const { buildConfig, buildPreset } = config;
+  if (buildConfig && buildPreset) {
+    const { logger } = yield Promise.resolve().then(() => __toESM(require("@modern-js/utils")));
+    logger.warn(
+      `因为同时出现 'buildConfig' 和 'buildPreset' 配置，因此仅 'buildConfig' 配置生效`
+    );
+  }
+});
+const normalizeBuildConfig = (api, context, buildCmdOptions) => __async(void 0, null, function* () {
+  const config = api.useResolvedConfigContext();
+  const { buildConfig, buildPreset } = config;
+  yield checkConfig(config);
+  let baseConfigs;
+  if (buildConfig) {
+    baseConfigs = yield transformBuildConfigToBaseConfigs(buildConfig, {
+      buildCmdOptions,
+      context
+    });
+  } else {
+    baseConfigs = yield transformBuildPresetToBaseConfigs(
+      {
+        context,
+        buildCmdOptions
+      },
+      buildPreset
+    );
+  }
+  return baseConfigs;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkConfig,
+  normalizeBuildConfig,
+  requiredBuildConfig,
+  transformBuildConfigToBaseConfigs,
+  transformBuildPresetToBaseConfigs,
+  transformToAbsPath
+});
+
+//# sourceMappingURL=normalize.js.map

package/dist/config/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":null,"mappings":"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","names":["config"],"sources":["../../src/config/normalize.ts"],"sourcesContent":["import path from 'path';\nimport type { PluginAPI } from '@modern-js/core';\nimport type {\n  ModuleUserConfig,\n  BaseBuildConfig,\n  BuildPreset,\n  PartialBuildConfig,\n  PartialBaseBuildConfig,\n  ModuleContext,\n  BuildCommandOptions,\n  ModuleTools,\n} from '../types';\n\nexport const transformBuildPresetToBaseConfigs = async (\n  options: {\n    context: ModuleContext;\n    buildCmdOptions: BuildCommandOptions;\n  },\n  preset?: BuildPreset,\n): Promise<BaseBuildConfig[]> => {\n  const { BuildInPreset, presetList } = await import(\n    '../constants/build-presets'\n  );\n  const { addInputToPreset } = await import('../utils/input');\n\n  if (typeof preset === 'function') {\n    const partialBuildConfig = await preset({ preset: BuildInPreset });\n\n    if (!partialBuildConfig) {\n      throw new Error(\n        'The `buildPreset` function does not allow no return value',\n      );\n    }\n\n    return transformBuildConfigToBaseConfigs(partialBuildConfig, options);\n  }\n\n  const inPresetList = (p: string): p is keyof typeof presetList =>\n    p in presetList;\n\n  if (preset && inPresetList(preset)) {\n    return transformBuildConfigToBaseConfigs(\n      await addInputToPreset(presetList[preset], options.context),\n      options,\n    );\n  }\n\n  // buildConfig and buildPreset is undefined\n  return transformBuildConfigToBaseConfigs(\n    await addInputToPreset(presetList['base-config'], options.context),\n    options,\n  );\n};\n\nexport const transformBuildConfigToBaseConfigs = async (\n  config: PartialBuildConfig,\n  options: {\n    buildCmdOptions: BuildCommandOptions;\n    context: ModuleContext;\n  },\n): Promise<BaseBuildConfig[]> => {\n  const { validPartialBuildConfig } = await import('../utils/config');\n  validPartialBuildConfig(config);\n  const { buildCmdOptions } = options;\n  const { ensureArray } = await import('@modern-js/utils');\n  const { assignTsConfigPath } = await import('../utils/dts');\n  const partialConfigs = ensureArray(config);\n  const configs = await Promise.all(\n    partialConfigs.map(async config => {\n      let newConfig = await requiredBuildConfig(config, options.context);\n      newConfig = await assignTsConfigPath(newConfig, buildCmdOptions);\n      newConfig = await transformToAbsPath(newConfig, options);\n      return newConfig;\n    }),\n  );\n  return configs;\n};\n\nexport const requiredBuildConfig = async (\n  partialBuildConfig: PartialBaseBuildConfig,\n  context: ModuleContext,\n): Promise<BaseBuildConfig> => {\n  const { mergeDefaultBaseConfig } = await import('../utils/config');\n  const mergedConfig = await mergeDefaultBaseConfig(\n    partialBuildConfig,\n    context,\n  );\n  return mergedConfig;\n};\n\nexport const transformToAbsPath = async (\n  baseConfig: BaseBuildConfig,\n  options: { context: ModuleContext; buildCmdOptions: BuildCommandOptions },\n) => {\n  const { slash } = await import('@modern-js/utils');\n  const newConfig = baseConfig;\n  const { normalizeInput } = await import('../utils/input');\n  const { context } = options;\n\n  newConfig.outdir = path.isAbsolute(newConfig.outdir)\n    ? newConfig.outdir\n    : path.join(context.appDirectory, newConfig.outdir);\n\n  newConfig.sourceDir = slash(\n    path.resolve(context.appDirectory, baseConfig.sourceDir),\n  );\n  newConfig.input = await normalizeInput(newConfig, {\n    appDirectory: context.appDirectory,\n  });\n\n  // dts path\n  if (newConfig.dts) {\n    newConfig.dts.distPath = path.join(\n      newConfig.outdir,\n      newConfig.dts.distPath,\n    );\n    newConfig.dts.tsconfigPath = path.join(\n      context.appDirectory,\n      newConfig.dts.tsconfigPath,\n    );\n  }\n\n  // Maybe need transform 'config.copy'\n\n  return newConfig;\n};\n\nexport const checkConfig = async (config: ModuleUserConfig) => {\n  const { buildConfig, buildPreset } = config;\n  if (buildConfig && buildPreset) {\n    const { logger } = await import('@modern-js/utils');\n    logger.warn(\n      `因为同时出现 'buildConfig' 和 'buildPreset' 配置，因此仅 'buildConfig' 配置生效`,\n    );\n  }\n};\n\nexport const normalizeBuildConfig = async (\n  api: PluginAPI<ModuleTools>,\n  context: ModuleContext,\n  buildCmdOptions: BuildCommandOptions,\n): Promise<BaseBuildConfig[]> => {\n  const config = api.useResolvedConfigContext() as unknown as ModuleUserConfig;\n  const { buildConfig, buildPreset } = config;\n\n  await checkConfig(config);\n\n  let baseConfigs: BaseBuildConfig[];\n\n  // buildConfig High priority\n  if (buildConfig) {\n    baseConfigs = await transformBuildConfigToBaseConfigs(buildConfig, {\n      buildCmdOptions,\n      context,\n    });\n  } else {\n    baseConfigs = await transformBuildPresetToBaseConfigs(\n      {\n        context,\n        buildCmdOptions,\n      },\n      buildPreset,\n    );\n  }\n\n  return baseConfigs;\n};\n"]}