@modern-js/module-tools 2.35.1 → 2.36.0

package/dist/constants/preset.js

@@ -1,67 +1,42 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  targets: function() {
-    return targets;
-  },
-  npmLibraryPresetConfig: function() {
-    return npmLibraryPresetConfig;
-  },
-  npmLibraryWithUmdPresetConfig: function() {
-    return npmLibraryWithUmdPresetConfig;
-  },
-  npmComponentPresetConfig: function() {
-    return npmComponentPresetConfig;
-  },
-  npmComponentWithUmdPresetConfig: function() {
-    return npmComponentWithUmdPresetConfig;
-  },
-  libraryPreset: function() {
-    return libraryPreset;
-  },
-  libraryPresetWithTarget: function() {
-    return libraryPresetWithTarget;
-  },
-  libraryUmdPreset: function() {
-    return libraryUmdPreset;
-  },
-  libraryUmdPresetWithTarget: function() {
-    return libraryUmdPresetWithTarget;
-  },
-  componentPreset: function() {
-    return componentPreset;
-  },
-  componentPresetWithTarget: function() {
-    return componentPresetWithTarget;
-  },
-  componentUmdPreset: function() {
-    return componentUmdPreset;
-  },
-  componentUmdPresetWithTarget: function() {
-    return componentUmdPresetWithTarget;
-  },
-  nodeBuildConfig: function() {
-    return nodeBuildConfig;
-  },
-  universalBuildConfig: function() {
-    return universalBuildConfig;
-  },
-  presetList: function() {
-    return presetList;
-  },
-  internalPreset: function() {
-    return internalPreset;
+    __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 preset_exports = {};
+__export(preset_exports, {
+  componentPreset: () => componentPreset,
+  componentPresetWithTarget: () => componentPresetWithTarget,
+  componentUmdPreset: () => componentUmdPreset,
+  componentUmdPresetWithTarget: () => componentUmdPresetWithTarget,
+  internalPreset: () => internalPreset,
+  libraryPreset: () => libraryPreset,
+  libraryPresetWithTarget: () => libraryPresetWithTarget,
+  libraryUmdPreset: () => libraryUmdPreset,
+  libraryUmdPresetWithTarget: () => libraryUmdPresetWithTarget,
+  nodeBuildConfig: () => nodeBuildConfig,
+  npmComponentPresetConfig: () => npmComponentPresetConfig,
+  npmComponentWithUmdPresetConfig: () => npmComponentWithUmdPresetConfig,
+  npmLibraryPresetConfig: () => npmLibraryPresetConfig,
+  npmLibraryWithUmdPresetConfig: () => npmLibraryWithUmdPresetConfig,
+  presetList: () => presetList,
+  targets: () => targets,
+  universalBuildConfig: () => universalBuildConfig
 });
+module.exports = __toCommonJS(preset_exports);
 const targets = [
   "es5",
   "es6",
@@ -313,5 +288,23 @@ const internalPreset = {
   "modern-js-node": nodeBuildConfig,
   "modern-js-universal": universalBuildConfig
 };
-
-//# sourceMappingURL=preset.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  componentPreset,
+  componentPresetWithTarget,
+  componentUmdPreset,
+  componentUmdPresetWithTarget,
+  internalPreset,
+  libraryPreset,
+  libraryPresetWithTarget,
+  libraryUmdPreset,
+  libraryUmdPresetWithTarget,
+  nodeBuildConfig,
+  npmComponentPresetConfig,
+  npmComponentWithUmdPresetConfig,
+  npmLibraryPresetConfig,
+  npmLibraryWithUmdPresetConfig,
+  presetList,
+  targets,
+  universalBuildConfig
+});

package/dist/debug.d.ts

@@ -0,0 +1,4 @@
+import { debug as Debugger } from '@modern-js/utils';
+export declare const debug: Debugger.Debugger;
+export declare const label: (info: string) => string;
+export declare const debugResolve: Debugger.Debugger;

package/dist/debug.js

@@ -0,0 +1,37 @@
+"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 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 debug_exports = {};
+__export(debug_exports, {
+  debug: () => debug,
+  debugResolve: () => debugResolve,
+  label: () => label
+});
+module.exports = __toCommonJS(debug_exports);
+var import_utils = require("@modern-js/utils");
+const debug = (0, import_utils.debug)("module");
+const label = (info) => {
+  return import_utils.chalk.blue(`[${info.toUpperCase()}]`);
+};
+const debugResolve = (0, import_utils.debug)("module:resolve");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debug,
+  debugResolve,
+  label
+});

package/dist/dev.js

@@ -1,27 +1,41 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  showMenu: function() {
-    return showMenu;
-  },
-  dev: function() {
-    return dev;
+    __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 dev_exports = {};
+__export(dev_exports, {
+  dev: () => dev,
+  showMenu: () => showMenu
 });
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _utils = require("@modern-js/utils");
+module.exports = __toCommonJS(dev_exports);
+var import_utils = require("@modern-js/utils");
 const showMenu = async (metas, devCmdOptions, api, context) => {
   const runner = api.useHookRunners();
-  const menuTitle = _utils.chalk.rgb(255, 153, 0);
+  const menuTitle = import_utils.chalk.rgb(255, 153, 0);
   const choices = metas.map((meta) => meta.menuItem).filter((menuItem) => typeof menuItem === "object");
   const questions = [
     {
@@ -32,7 +46,7 @@ const showMenu = async (metas, devCmdOptions, api, context) => {
     }
   ];
   const newQuestions = await runner.beforeDevMenu(questions);
-  const result = await _utils.inquirer.prompt(newQuestions.length !== 0 ? newQuestions : questions);
+  const result = await import_utils.inquirer.prompt(newQuestions.length !== 0 ? newQuestions : questions);
   await runner.afterDevMenu({
     result,
     devTools: metas
@@ -49,18 +63,18 @@ const showMenu = async (metas, devCmdOptions, api, context) => {
   }
 };
 const dev = async (options, metas, api, context) => {
-  const { green } = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("./constants/color")));
+  const { green } = await Promise.resolve().then(() => __toESM(require("./constants/color")));
   const runner = api.useHookRunners();
   if (metas.length === 0) {
-    const local = await Promise.resolve().then(() => /* @__PURE__ */ _interop_require_wildcard._(require("./locale")));
+    const local = await Promise.resolve().then(() => __toESM(require("./locale")));
     const noDevToolsLog = await runner.noDevTools(local.i18n.t(local.localeKeys.log.dev.noDevtools));
-    _utils.logger.info(noDevToolsLog);
+    import_utils.logger.info(noDevToolsLog);
     process.exit(0);
   }
   if (metas.length === 1) {
     var _metas__menuItem;
     var _metas__menuItem_name;
-    _utils.logger.info(_utils.chalk.rgb(...green)(`Only one dev tooling is currently detected as available, run it directly [${(_metas__menuItem_name = (_metas__menuItem = metas[0].menuItem) === null || _metas__menuItem === void 0 ? void 0 : _metas__menuItem.name) !== null && _metas__menuItem_name !== void 0 ? _metas__menuItem_name : metas[0].name}]`));
+    import_utils.logger.info(import_utils.chalk.rgb(...green)(`Only one dev tooling is currently detected as available, run it directly [${(_metas__menuItem_name = (_metas__menuItem = metas[0].menuItem) === null || _metas__menuItem === void 0 ? void 0 : _metas__menuItem.name) !== null && _metas__menuItem_name !== void 0 ? _metas__menuItem_name : metas[0].name}]`));
     const meta = metas[0];
     await runner.beforeDevTask(meta);
     await meta.action(options, {
@@ -70,5 +84,8 @@ const dev = async (options, metas, api, context) => {
     await showMenu(metas, options, api, context);
   }
 };
-
-//# sourceMappingURL=dev.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dev,
+  showMenu
+});

package/dist/error.js

@@ -1,36 +1,33 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  padSpaceWith: function() {
-    return padSpaceWith;
-  },
-  InternalBuildError: function() {
-    return InternalBuildError;
-  },
-  InternalDTSError: function() {
-    return InternalDTSError;
-  },
-  ModuleBuildError: function() {
-    return ModuleBuildError;
-  },
-  isInternalError: function() {
-    return isInternalError;
-  },
-  isExecaError: function() {
-    return isExecaError;
+    __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 error_exports = {};
+__export(error_exports, {
+  InternalBuildError: () => InternalBuildError,
+  InternalDTSError: () => InternalDTSError,
+  ModuleBuildError: () => ModuleBuildError,
+  isExecaError: () => isExecaError,
+  isInternalError: () => isInternalError,
+  padSpaceWith: () => padSpaceWith
 });
-const _define_property = require("@swc/helpers/_/_define_property");
-const _utils = require("@modern-js/utils");
+module.exports = __toCommonJS(error_exports);
+var import_define_property = require("@swc/helpers/_/_define_property");
+var import_utils = require("@modern-js/utils");
 const padSpaceWith = (str, targetL, opts = {}) => {
   const { endStr = "|", style } = opts;
   const l = str.length;
@@ -57,7 +54,7 @@ class InternalBuildError extends Error {
     const { e, buildType, target, format } = this;
     const textL = 25;
     const title = `│ ${padSpaceWith(`${buildType} failed:`, textL - 2, {
-      style: _utils.chalk.red.underline,
+      style: import_utils.chalk.red.underline,
       endStr: "│"
     })}`;
     const formatMsg = padSpaceWith(`│  - format is "${format}"`, textL, {
@@ -72,18 +69,21 @@ class InternalBuildError extends Error {
     const endLine = padSpaceWith("╰".padEnd(textL - 1, "─"), textL, {
       endStr: "╯"
     });
-    msgs.push(startLine, title, formatMsg, targetMsg, endLine, _utils.chalk.blue.bold.underline(`
+    msgs.push(startLine, title, formatMsg, targetMsg, endLine, import_utils.chalk.blue.bold.underline(`
 Detailed Information: `));
-    msgs.push(e.toString());
-    msgs.push(e.stack || "");
+    if (e.stack) {
+      msgs.push(e.stack);
+    } else {
+      msgs.push(e.message);
+    }
     return msgs;
   }
   constructor(e, opts) {
     super(e.message);
-    _define_property._(this, "buildType", void 0);
-    _define_property._(this, "target", void 0);
-    _define_property._(this, "format", void 0);
-    _define_property._(this, "e", void 0);
+    (0, import_define_property._)(this, "buildType", void 0);
+    (0, import_define_property._)(this, "target", void 0);
+    (0, import_define_property._)(this, "format", void 0);
+    (0, import_define_property._)(this, "e", void 0);
     Error.captureStackTrace(this, this.constructor);
     this.e = e;
     this.buildType = opts.buildType;
@@ -98,7 +98,7 @@ class InternalDTSError extends Error {
   formatError() {
     const msgs = [];
     const { e, buildType } = this;
-    msgs.push(_utils.chalk.red.bold(`${buildType} DTS failed:`));
+    msgs.push(import_utils.chalk.red.bold(`${buildType} DTS failed:`));
     if (isExecaError(e)) {
       if (e.stack) {
         var _e_stack;
@@ -111,8 +111,8 @@ class InternalDTSError extends Error {
   }
   constructor(e, opts) {
     super(e.message);
-    _define_property._(this, "buildType", void 0);
-    _define_property._(this, "e", void 0);
+    (0, import_define_property._)(this, "buildType", void 0);
+    (0, import_define_property._)(this, "e", void 0);
     Error.captureStackTrace(this, this.constructor);
     this.e = e;
     this.buildType = opts.buildType;
@@ -139,5 +139,12 @@ const isExecaError = (e) => {
   }
   return false;
 };
-
-//# sourceMappingURL=error.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  InternalBuildError,
+  InternalDTSError,
+  ModuleBuildError,
+  isExecaError,
+  isInternalError,
+  padSpaceWith
+});

package/dist/hooks/build.d.ts

@@ -1,7 +1,6 @@
 import type { RegisterBuildPlatformResult } from '@modern-js/core';
 import { BuildCommandOptions } from '../types';
-import type { BuildConfig, BaseBuildConfig } from '../types/config';
-import type { BuildTaskResult, BuildResult, BuildPlatformResult, WatchDtsHookContext, WatchJsHookContext } from '../types/hooks';
+import type { BuildTaskResult, BuildResult, BuildPlatformResult, WatchDtsHookContext, WatchJsHookContext, BuildConfig, BaseBuildConfig } from '../types';
 export declare const buildHooks: {
   beforeBuild: import("@modern-js/plugin").ParallelWorkflow<{
     config: BuildConfig;

package/dist/hooks/build.js

@@ -1,36 +1,44 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-function _export(target, all) {
+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)
-    Object.defineProperty(target, name, {
-      enumerable: true,
-      get: all[name]
-    });
-}
-_export(exports, {
-  buildHooks: function() {
-    return buildHooks;
-  },
-  buildWatchHooks: function() {
-    return buildWatchHooks;
+    __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 build_exports = {};
+__export(build_exports, {
+  buildHooks: () => buildHooks,
+  buildWatchHooks: () => buildWatchHooks
 });
-const _plugin = require("@modern-js/plugin");
+module.exports = __toCommonJS(build_exports);
+var import_plugin = require("@modern-js/plugin");
 const buildHooks = {
-  beforeBuild: (0, _plugin.createParallelWorkflow)(),
-  beforeBuildTask: (0, _plugin.createAsyncWaterfall)(),
-  afterBuildTask: (0, _plugin.createParallelWorkflow)(),
-  afterBuild: (0, _plugin.createParallelWorkflow)(),
-  registerBuildPlatform: (0, _plugin.createParallelWorkflow)(),
-  beforeBuildPlatform: (0, _plugin.createParallelWorkflow)(),
-  buildPlatform: (0, _plugin.createParallelWorkflow)(),
-  afterBuildPlatform: (0, _plugin.createParallelWorkflow)()
+  beforeBuild: (0, import_plugin.createParallelWorkflow)(),
+  beforeBuildTask: (0, import_plugin.createAsyncWaterfall)(),
+  afterBuildTask: (0, import_plugin.createParallelWorkflow)(),
+  afterBuild: (0, import_plugin.createParallelWorkflow)(),
+  registerBuildPlatform: (0, import_plugin.createParallelWorkflow)(),
+  beforeBuildPlatform: (0, import_plugin.createParallelWorkflow)(),
+  buildPlatform: (0, import_plugin.createParallelWorkflow)(),
+  afterBuildPlatform: (0, import_plugin.createParallelWorkflow)()
 };
 const buildWatchHooks = {
-  buildWatchJs: (0, _plugin.createParallelWorkflow)(),
-  buildWatchDts: (0, _plugin.createParallelWorkflow)()
+  buildWatchJs: (0, import_plugin.createParallelWorkflow)(),
+  buildWatchDts: (0, import_plugin.createParallelWorkflow)()
 };
-
-//# sourceMappingURL=build.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildHooks,
+  buildWatchHooks
+});

package/dist/hooks/dev.js

@@ -1,23 +1,38 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "devHooks", {
-  enumerable: true,
-  get: function() {
-    return devHooks;
+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 dev_exports = {};
+__export(dev_exports, {
+  devHooks: () => devHooks
 });
-const _plugin = require("@modern-js/plugin");
+module.exports = __toCommonJS(dev_exports);
+var import_plugin = require("@modern-js/plugin");
 const devHooks = {
-  registerDev: (0, _plugin.createParallelWorkflow)(),
-  beforeDev: (0, _plugin.createParallelWorkflow)(),
-  beforeDevMenu: (0, _plugin.createAsyncWaterfall)(),
-  afterDevMenu: (0, _plugin.createParallelWorkflow)(),
-  beforeDevTask: (0, _plugin.createParallelWorkflow)(),
-  afterDev: (0, _plugin.createParallelWorkflow)(),
+  registerDev: (0, import_plugin.createParallelWorkflow)(),
+  beforeDev: (0, import_plugin.createParallelWorkflow)(),
+  beforeDevMenu: (0, import_plugin.createAsyncWaterfall)(),
+  afterDevMenu: (0, import_plugin.createParallelWorkflow)(),
+  beforeDevTask: (0, import_plugin.createParallelWorkflow)(),
+  afterDev: (0, import_plugin.createParallelWorkflow)(),
   // Special and rarely used hooks
-  noDevTools: (0, _plugin.createAsyncWaterfall)()
+  noDevTools: (0, import_plugin.createAsyncWaterfall)()
 };
-
-//# sourceMappingURL=dev.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  devHooks
+});

package/dist/hooks/index.d.ts

@@ -2,7 +2,7 @@ export declare const registerHook: {
   buildWatchJs: import("@modern-js/plugin").ParallelWorkflow<import("..").WatchJsHookContext, void>;
   buildWatchDts: import("@modern-js/plugin").ParallelWorkflow<import("..").WatchDtsHookContext, void>;
   addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
-  modifyLibuild: import("@modern-js/plugin").AsyncPipeline<import("@modern-js/libuild").CLIConfig, import("@modern-js/libuild").CLIConfig>;
+  modifyLibuild: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
   registerDev: import("@modern-js/plugin").ParallelWorkflow<void, import("..").DevToolData>;
   beforeDev: import("@modern-js/plugin").ParallelWorkflow<import("..").DevToolData[], void>;
   beforeDevMenu: import("@modern-js/plugin").AsyncWaterfall<any>;

package/dist/hooks/index.js

@@ -1,21 +1,36 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "registerHook", {
-  enumerable: true,
-  get: function() {
-    return registerHook;
+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 hooks_exports = {};
+__export(hooks_exports, {
+  registerHook: () => registerHook
 });
-const _build = require("./build");
-const _dev = require("./dev");
-const _misc = require("./misc");
+module.exports = __toCommonJS(hooks_exports);
+var import_build = require("./build");
+var import_dev = require("./dev");
+var import_misc = require("./misc");
 const registerHook = {
-  ..._build.buildHooks,
-  ..._dev.devHooks,
-  ..._misc.miscHooks,
-  ..._build.buildWatchHooks
+  ...import_build.buildHooks,
+  ...import_dev.devHooks,
+  ...import_misc.miscHooks,
+  ...import_build.buildWatchHooks
 };
-
-//# sourceMappingURL=index.js.map
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerHook
+});

package/dist/hooks/misc.d.ts

@@ -1,5 +1,8 @@
-import type { CLIConfig } from '@modern-js/libuild';
 export declare const miscHooks: {
   addRuntimeExports: import("@modern-js/plugin").AsyncWaterfall<void>;
-  modifyLibuild: import("@modern-js/plugin").AsyncPipeline<CLIConfig, CLIConfig>;
+  /**
+   * @deprecated
+   * use buildConfig.hooks and buildConfig.esbuildOptions instead.
+   */
+  modifyLibuild: import("@modern-js/plugin").AsyncPipeline<unknown, unknown>;
 };