@modern-js/plugin-v2 2.64.0 → 2.64.1-alpha.0

package/dist/cjs/cli/run/config/loadConfig.js

@@ -35,8 +35,8 @@ __export(loadConfig_exports, {
 });
 module.exports = __toCommonJS(loadConfig_exports);
 var import_path = __toESM(require("path"));
-var import_node_bundle_require = require("@modern-js/node-bundle-require");
 var import_utils = require("@modern-js/utils");
+var import_jiti = __toESM(require("jiti"));
 const getPackageConfig = (appDirectory, packageJsonConfig) => {
   const json = JSON.parse(import_utils.fs.readFileSync(import_path.default.resolve(appDirectory, "./package.json"), "utf8"));
   return json[packageJsonConfig];
@@ -64,19 +64,19 @@ const clearFilesOverTime = async (targetDir, overtime) => {
   } catch (err) {
   }
 };
-const bundleRequireWithCatch = async (configFile, { appDirectory }) => {
+function loadConfigContent(configFile) {
+  const _require = (0, import_jiti.default)(__filename, {
+    esmResolve: true,
+    // disable require cache to support restart CLI and read the new config
+    requireCache: false,
+    interopDefault: true
+  });
+  if (!import_utils.fs.existsSync(configFile)) {
+    throw new Error(`Configuration file does not exist: ${configFile}`);
+  }
   try {
-    const mod = await (0, import_node_bundle_require.bundleRequire)(configFile, {
-      autoClear: false,
-      getOutputFile: async (filePath) => {
-        const defaultOutputFileName = import_path.default.basename(await (0, import_node_bundle_require.defaultGetOutputFile)(filePath));
-        const outputPath = import_path.default.join(appDirectory, import_utils.CONFIG_CACHE_DIR);
-        const timeLimit = 10 * 60;
-        await clearFilesOverTime(outputPath, timeLimit);
-        return import_path.default.join(outputPath, defaultOutputFileName);
-      }
-    });
-    return mod;
+    const config = _require(configFile);
+    return config.default || config;
   } catch (e) {
     if (e instanceof Error) {
       e.message = `Get Error while loading config file: ${configFile}, please check it and retry.
@@ -84,7 +84,7 @@ ${e.message || ""}`;
     }
     throw e;
   }
-};
+}
 const loadConfig = async (appDirectory, configFile, packageJsonConfig) => {
   let pkgConfig;
   if (packageJsonConfig) {
@@ -93,11 +93,7 @@ const loadConfig = async (appDirectory, configFile, packageJsonConfig) => {
   const packageName = require(import_path.default.resolve(appDirectory, "./package.json")).name;
   let config;
   if (configFile) {
-    delete require.cache[configFile];
-    const mod = await bundleRequireWithCatch(configFile, {
-      appDirectory
-    });
-    config = mod.default || mod;
+    config = loadConfigContent(configFile);
   }
   return {
     packageName,

package/dist/cjs/cli/run/create.js

@@ -37,6 +37,23 @@ const debug = (0, import_utils.createDebugger)("plugin-v2");
 const createCli = () => {
   let initOptions;
   const pluginManager = (0, import_manager.createPluginManager)();
+  const existListenerMap = /* @__PURE__ */ new Map();
+  function createExistListener(event, context) {
+    return async function(err) {
+      await context.hooks.onBeforeExit.call();
+      let hasError = false;
+      if (err instanceof Error) {
+        import_utils.logger.error(err.stack);
+        hasError = true;
+      } else if (err && (event === "unhandledRejection" || event === "uncaughtException")) {
+        console.trace("Unknown Error", err);
+        hasError = true;
+      }
+      process.nextTick(() => {
+        process.exit(hasError ? 1 : 0);
+      });
+    };
+  }
   async function init(options) {
     var _context_hooks_onAfterPrepare, _context_hooks;
     pluginManager.clear();
@@ -84,20 +101,12 @@ const createCli = () => {
       "unhandledRejection",
       "uncaughtException"
     ].forEach((event) => {
-      process.on(event, async (err) => {
-        await context.hooks.onBeforeExit.call();
-        let hasError = false;
-        if (err instanceof Error) {
-          import_utils.logger.error(err.stack);
-          hasError = true;
-        } else if (err && (event === "unhandledRejection" || event === "uncaughtException")) {
-          console.trace("Unknown Error", err);
-          hasError = true;
-        }
-        process.nextTick(() => {
-          process.exit(hasError ? 1 : 0);
-        });
-      });
+      if (existListenerMap.get(event)) {
+        process.off(event, existListenerMap.get(event));
+      }
+      const existListener = createExistListener(event, context);
+      existListenerMap.set(event, existListener);
+      process.on(event, existListener);
     });
     const extraConfigs = await context.hooks.config.call();
     const normalizedConfig = await (0, import_createResolvedConfig.createResolveConfig)(loaded, extraConfigs);

package/dist/esm/cli/run/config/loadConfig.js

@@ -2,8 +2,8 @@ import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _instanceof } from "@swc/helpers/_/_instanceof";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
-import { bundleRequire, defaultGetOutputFile } from "@modern-js/node-bundle-require";
-import { fs, CONFIG_CACHE_DIR, globby } from "@modern-js/utils";
+import { fs, globby } from "@modern-js/utils";
+import jiti from "jiti";
 var getPackageConfig = function(appDirectory, packageJsonConfig) {
   var json = JSON.parse(fs.readFileSync(path.resolve(appDirectory, "./package.json"), "utf8"));
   return json[packageJsonConfig];
@@ -81,121 +81,46 @@ var clearFilesOverTime = function() {
     return _ref.apply(this, arguments);
   };
 }();
-var bundleRequireWithCatch = function() {
-  var _ref = _async_to_generator(function(configFile, param) {
-    var appDirectory, mod, e;
-    return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          appDirectory = param.appDirectory;
-          _state.label = 1;
-        case 1:
-          _state.trys.push([
-            1,
-            3,
-            ,
-            4
-          ]);
-          return [
-            4,
-            bundleRequire(configFile, {
-              autoClear: false,
-              getOutputFile: function() {
-                var _ref2 = _async_to_generator(function(filePath) {
-                  var defaultOutputFileName, _, outputPath, timeLimit;
-                  return _ts_generator(this, function(_state2) {
-                    switch (_state2.label) {
-                      case 0:
-                        _ = path.basename;
-                        return [
-                          4,
-                          defaultGetOutputFile(filePath)
-                        ];
-                      case 1:
-                        defaultOutputFileName = _.apply(path, [
-                          _state2.sent()
-                        ]);
-                        outputPath = path.join(appDirectory, CONFIG_CACHE_DIR);
-                        timeLimit = 10 * 60;
-                        return [
-                          4,
-                          clearFilesOverTime(outputPath, timeLimit)
-                        ];
-                      case 2:
-                        _state2.sent();
-                        return [
-                          2,
-                          path.join(outputPath, defaultOutputFileName)
-                        ];
-                    }
-                  });
-                });
-                return function(filePath) {
-                  return _ref2.apply(this, arguments);
-                };
-              }()
-            })
-          ];
-        case 2:
-          mod = _state.sent();
-          return [
-            2,
-            mod
-          ];
-        case 3:
-          e = _state.sent();
-          if (_instanceof(e, Error)) {
-            e.message = "Get Error while loading config file: ".concat(configFile, ", please check it and retry.\n").concat(e.message || "");
-          }
-          throw e;
-        case 4:
-          return [
-            2
-          ];
-      }
-    });
+function loadConfigContent(configFile) {
+  var _require = jiti(__filename, {
+    esmResolve: true,
+    // disable require cache to support restart CLI and read the new config
+    requireCache: false,
+    interopDefault: true
   });
-  return function bundleRequireWithCatch2(configFile, _) {
-    return _ref.apply(this, arguments);
-  };
-}();
+  if (!fs.existsSync(configFile)) {
+    throw new Error("Configuration file does not exist: ".concat(configFile));
+  }
+  try {
+    var config = _require(configFile);
+    return config.default || config;
+  } catch (e) {
+    if (_instanceof(e, Error)) {
+      e.message = "Get Error while loading config file: ".concat(configFile, ", please check it and retry.\n").concat(e.message || "");
+    }
+    throw e;
+  }
+}
 var loadConfig = function() {
   var _ref = _async_to_generator(function(appDirectory, configFile, packageJsonConfig) {
-    var pkgConfig, packageName, config, mod;
+    var pkgConfig, packageName, config;
     return _ts_generator(this, function(_state) {
-      switch (_state.label) {
-        case 0:
-          if (packageJsonConfig) {
-            pkgConfig = getPackageConfig(appDirectory, packageJsonConfig);
-          }
-          packageName = require(path.resolve(appDirectory, "./package.json")).name;
-          if (!configFile)
-            return [
-              3,
-              2
-            ];
-          delete require.cache[configFile];
-          return [
-            4,
-            bundleRequireWithCatch(configFile, {
-              appDirectory
-            })
-          ];
-        case 1:
-          mod = _state.sent();
-          config = mod.default || mod;
-          _state.label = 2;
-        case 2:
-          return [
-            2,
-            {
-              packageName,
-              configFile,
-              config,
-              pkgConfig
-            }
-          ];
+      if (packageJsonConfig) {
+        pkgConfig = getPackageConfig(appDirectory, packageJsonConfig);
+      }
+      packageName = require(path.resolve(appDirectory, "./package.json")).name;
+      if (configFile) {
+        config = loadConfigContent(configFile);
       }
+      return [
+        2,
+        {
+          packageName,
+          configFile,
+          config,
+          pkgConfig
+        }
+      ];
     });
   });
   return function loadConfig2(appDirectory, configFile, packageJsonConfig) {

package/dist/esm/cli/run/create.js

@@ -16,6 +16,41 @@ import { initAppDir } from "./utils/initAppDir";
 import { loadEnv } from "./utils/loadEnv";
 var debug = createDebugger("plugin-v2");
 var createCli = function() {
+  var createExistListener = function createExistListener2(event, context) {
+    return function() {
+      var _ref = _async_to_generator(function(err) {
+        var hasError;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              return [
+                4,
+                context.hooks.onBeforeExit.call()
+              ];
+            case 1:
+              _state.sent();
+              hasError = false;
+              if (_instanceof(err, Error)) {
+                logger.error(err.stack);
+                hasError = true;
+              } else if (err && (event === "unhandledRejection" || event === "uncaughtException")) {
+                console.trace("Unknown Error", err);
+                hasError = true;
+              }
+              process.nextTick(function() {
+                process.exit(hasError ? 1 : 0);
+              });
+              return [
+                2
+              ];
+          }
+        });
+      });
+      return function(err) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+  };
   var init = function init2(options) {
     return _init.apply(this, arguments);
   };
@@ -24,6 +59,7 @@ var createCli = function() {
   };
   var initOptions;
   var pluginManager = createPluginManager();
+  var existListenerMap = /* @__PURE__ */ new Map();
   function _init() {
     _init = _async_to_generator(function(options) {
       var _context_hooks_onAfterPrepare, _context_hooks, _options_metaName, metaName, configFile, config, command, version, packageJsonConfig, internalPlugins, handleSetupResult, appDirectory, loaded, allPlugins, plugins, context, pluginAPI, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, plugin, _plugin_setup, setupResult, err, extraConfigs, normalizedConfig, resolved;
@@ -158,39 +194,12 @@ var createCli = function() {
               "unhandledRejection",
               "uncaughtException"
             ].forEach(function(event) {
-              process.on(event, function() {
-                var _ref = _async_to_generator(function(err2) {
-                  var hasError;
-                  return _ts_generator(this, function(_state2) {
-                    switch (_state2.label) {
-                      case 0:
-                        return [
-                          4,
-                          context.hooks.onBeforeExit.call()
-                        ];
-                      case 1:
-                        _state2.sent();
-                        hasError = false;
-                        if (_instanceof(err2, Error)) {
-                          logger.error(err2.stack);
-                          hasError = true;
-                        } else if (err2 && (event === "unhandledRejection" || event === "uncaughtException")) {
-                          console.trace("Unknown Error", err2);
-                          hasError = true;
-                        }
-                        process.nextTick(function() {
-                          process.exit(hasError ? 1 : 0);
-                        });
-                        return [
-                          2
-                        ];
-                    }
-                  });
-                });
-                return function(err2) {
-                  return _ref.apply(this, arguments);
-                };
-              }());
+              if (existListenerMap.get(event)) {
+                process.off(event, existListenerMap.get(event));
+              }
+              var existListener = createExistListener(event, context);
+              existListenerMap.set(event, existListener);
+              process.on(event, existListener);
             });
             return [
               4,

package/dist/esm-node/cli/run/config/loadConfig.js

@@ -1,6 +1,6 @@
 import path from "path";
-import { bundleRequire, defaultGetOutputFile } from "@modern-js/node-bundle-require";
-import { fs, CONFIG_CACHE_DIR, globby } from "@modern-js/utils";
+import { fs, globby } from "@modern-js/utils";
+import jiti from "jiti";
 const getPackageConfig = (appDirectory, packageJsonConfig) => {
   const json = JSON.parse(fs.readFileSync(path.resolve(appDirectory, "./package.json"), "utf8"));
   return json[packageJsonConfig];
@@ -28,19 +28,19 @@ const clearFilesOverTime = async (targetDir, overtime) => {
   } catch (err) {
   }
 };
-const bundleRequireWithCatch = async (configFile, { appDirectory }) => {
+function loadConfigContent(configFile) {
+  const _require = jiti(__filename, {
+    esmResolve: true,
+    // disable require cache to support restart CLI and read the new config
+    requireCache: false,
+    interopDefault: true
+  });
+  if (!fs.existsSync(configFile)) {
+    throw new Error(`Configuration file does not exist: ${configFile}`);
+  }
   try {
-    const mod = await bundleRequire(configFile, {
-      autoClear: false,
-      getOutputFile: async (filePath) => {
-        const defaultOutputFileName = path.basename(await defaultGetOutputFile(filePath));
-        const outputPath = path.join(appDirectory, CONFIG_CACHE_DIR);
-        const timeLimit = 10 * 60;
-        await clearFilesOverTime(outputPath, timeLimit);
-        return path.join(outputPath, defaultOutputFileName);
-      }
-    });
-    return mod;
+    const config = _require(configFile);
+    return config.default || config;
   } catch (e) {
     if (e instanceof Error) {
       e.message = `Get Error while loading config file: ${configFile}, please check it and retry.
@@ -48,7 +48,7 @@ ${e.message || ""}`;
     }
     throw e;
   }
-};
+}
 const loadConfig = async (appDirectory, configFile, packageJsonConfig) => {
   let pkgConfig;
   if (packageJsonConfig) {
@@ -57,11 +57,7 @@ const loadConfig = async (appDirectory, configFile, packageJsonConfig) => {
   const packageName = require(path.resolve(appDirectory, "./package.json")).name;
   let config;
   if (configFile) {
-    delete require.cache[configFile];
-    const mod = await bundleRequireWithCatch(configFile, {
-      appDirectory
-    });
-    config = mod.default || mod;
+    config = loadConfigContent(configFile);
   }
   return {
     packageName,

package/dist/esm-node/cli/run/create.js

@@ -14,6 +14,23 @@ const debug = createDebugger("plugin-v2");
 const createCli = () => {
   let initOptions;
   const pluginManager = createPluginManager();
+  const existListenerMap = /* @__PURE__ */ new Map();
+  function createExistListener(event, context) {
+    return async function(err) {
+      await context.hooks.onBeforeExit.call();
+      let hasError = false;
+      if (err instanceof Error) {
+        logger.error(err.stack);
+        hasError = true;
+      } else if (err && (event === "unhandledRejection" || event === "uncaughtException")) {
+        console.trace("Unknown Error", err);
+        hasError = true;
+      }
+      process.nextTick(() => {
+        process.exit(hasError ? 1 : 0);
+      });
+    };
+  }
   async function init(options) {
     var _context_hooks_onAfterPrepare, _context_hooks;
     pluginManager.clear();
@@ -61,20 +78,12 @@ const createCli = () => {
       "unhandledRejection",
       "uncaughtException"
     ].forEach((event) => {
-      process.on(event, async (err) => {
-        await context.hooks.onBeforeExit.call();
-        let hasError = false;
-        if (err instanceof Error) {
-          logger.error(err.stack);
-          hasError = true;
-        } else if (err && (event === "unhandledRejection" || event === "uncaughtException")) {
-          console.trace("Unknown Error", err);
-          hasError = true;
-        }
-        process.nextTick(() => {
-          process.exit(hasError ? 1 : 0);
-        });
-      });
+      if (existListenerMap.get(event)) {
+        process.off(event, existListenerMap.get(event));
+      }
+      const existListener = createExistListener(event, context);
+      existListenerMap.set(event, existListener);
+      process.on(event, existListener);
     });
     const extraConfigs = await context.hooks.config.call();
     const normalizedConfig = await createResolveConfig(loaded, extraConfigs);

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

@@ -2,7 +2,7 @@ import type { OnAfterBuildFn, OnAfterCreateCompilerFn, OnBeforeBuildFn, OnBefore
 import type { AddCommandFn, AddWatchFilesFn, ConfigFn, ModifyBundlerChainFn, ModifyConfigFn, ModifyHtmlPartialsFn, ModifyResolvedConfigFn, ModifyRsbuildConfigFn, ModifyRspackConfigFn, ModifyWebpackChainFn, ModifyWebpackConfigFn, OnAfterDeployFn, OnAfterDevFn, OnBeforeDeployFn, OnBeforeDevFn, OnBeforeExitFn, OnBeforeRestartFn, OnFileChangedFn, OnPrepareFn } from '../types/cli/hooks';
 import type { DeepPartial } from '../types/utils';
 export type { OnAfterBuildFn, OnAfterCreateCompilerFn, OnBeforeBuildFn, OnBeforeCreateCompilerFn, OnDevCompileDoneFn, AddCommandFn, AddWatchFilesFn, ConfigFn, ModifyBundlerChainFn, ModifyConfigFn, ModifyHtmlPartialsFn, ModifyResolvedConfigFn, ModifyRsbuildConfigFn, ModifyRspackConfigFn, ModifyWebpackChainFn, ModifyWebpackConfigFn, OnAfterDeployFn, OnBeforeDeployFn, OnBeforeDevFn, OnAfterDevFn, OnBeforeExitFn, OnBeforeRestartFn, OnFileChangedFn, OnPrepareFn, };
-export declare function initHooks<Config, NormalizedConfig, ExtendBuildUtils>(): {
+export declare function initHooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils>(): {
     /**
      * add config for this cli plugin
      */
@@ -11,11 +11,11 @@ export declare function initHooks<Config, NormalizedConfig, ExtendBuildUtils>():
      * @private
      * modify config for this cli plugin
      */
-    modifyConfig: import("..").AsyncHook<ModifyConfigFn<Config>>;
+    modifyConfig: import("..").AsyncHook<ModifyConfigFn<Config, ExtendConfigUtils>>;
     /**
      * modify final config
      */
-    modifyResolvedConfig: import("..").AsyncHook<ModifyResolvedConfigFn<NormalizedConfig>>;
+    modifyResolvedConfig: import("..").AsyncHook<ModifyResolvedConfigFn<NormalizedConfig, ExtendConfigUtils>>;
     modifyRsbuildConfig: import("..").AsyncHook<ModifyRsbuildConfigFn<ExtendBuildUtils>>;
     modifyBundlerChain: import("..").AsyncHook<ModifyBundlerChainFn<ExtendBuildUtils>>;
     modifyRspackConfig: import("..").AsyncHook<ModifyRspackConfigFn<ExtendBuildUtils>>;
@@ -38,4 +38,4 @@ export declare function initHooks<Config, NormalizedConfig, ExtendBuildUtils>():
     onAfterDeploy: import("..").AsyncHook<OnAfterDeployFn>;
     onBeforeExit: import("..").AsyncHook<OnBeforeExitFn>;
 };
-export type Hooks<Config, NormalizedConfig, ExtendBuildUtils> = ReturnType<typeof initHooks<Config, NormalizedConfig, ExtendBuildUtils>>;
+export type Hooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils> = ReturnType<typeof initHooks<Config, NormalizedConfig, ExtendBuildUtils, ExtendConfigUtils>>;

package/dist/types/cli/run/create.d.ts

@@ -1,8 +1,9 @@
+import type { InternalContext } from '../../types/cli/context';
 import type { CLIPluginExtends } from '../../types/cli/plugin';
 import type { CLIRunOptions } from './types';
 export declare const createCli: <Extends extends CLIPluginExtends>() => {
     init: (options: CLIRunOptions<Extends>) => Promise<{
-        appContext: import("../..").InternalContext<Extends>;
+        appContext: InternalContext<Extends>;
     }>;
     run: (options: CLIRunOptions<Extends>) => Promise<void>;
     getPrevInitOptions: () => CLIRunOptions<Extends>;

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

@@ -3,9 +3,9 @@ export { createLoadedConfig } from './config/createLoadedConfig';
 export { initAppDir } from './utils/initAppDir';
 export { createCli };
 export declare const cli: {
-    init: (options: import("./types").CLIRunOptions<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}>>) => Promise<{
-        appContext: import("../..").InternalContext<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}>>;
+    init: (options: import("./types").CLIRunOptions<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>) => Promise<{
+        appContext: import("../..").InternalContext<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>;
     }>;
-    run: (options: import("./types").CLIRunOptions<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}>>) => Promise<void>;
-    getPrevInitOptions: () => import("./types").CLIRunOptions<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}>>;
+    run: (options: import("./types").CLIRunOptions<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>) => Promise<void>;
+    getPrevInitOptions: () => import("./types").CLIRunOptions<import("../..").CLIPluginExtends<{}, {}, {}, {}, {}, {}, {}>>;
 };

package/dist/types/types/cli/api.d.ts

@@ -13,11 +13,11 @@ export type CLIPluginAPI<Extends extends CLIPluginExtends> = Readonly<{
     getAppContext: () => Readonly<AppContext<Extends> & Extends['extendContext']>;
     getConfig: () => Readonly<Extends['config']>;
     getNormalizedConfig: () => Readonly<Extends['normalizedConfig']>;
-    getHooks: () => Readonly<Hooks<Extends['config'], Extends['normalizedConfig'], Extends['extendBuildUtils']> & Extends['extendHooks']>;
+    getHooks: () => Readonly<Hooks<Extends['config'], Extends['normalizedConfig'], Extends['extendBuildUtils'], Extends['extendConfigUtils']> & Extends['extendHooks']>;
     updateAppContext: (appContext: DeepPartial<AppContext<Extends> & Extends['extendContext']>) => void;
     config: PluginHookTap<ConfigFn<DeepPartial<Extends['config']>>>;
-    modifyConfig: PluginHookTap<ModifyConfigFn<Extends['config']>>;
-    modifyResolvedConfig: PluginHookTap<ModifyResolvedConfigFn<Extends['normalizedConfig']>>;
+    modifyConfig: PluginHookTap<ModifyConfigFn<Extends['config'], Extends['extendConfigUtils']>>;
+    modifyResolvedConfig: PluginHookTap<ModifyResolvedConfigFn<Extends['normalizedConfig'], Extends['extendConfigUtils']>>;
     modifyRsbuildConfig: PluginHookTap<ModifyRsbuildConfigFn<Extends['extendBuildUtils']>>;
     modifyBundlerChain: PluginHookTap<ModifyBundlerChainFn<Extends['extendBuildUtils']>>;
     /** Only works when bundler is Rspack */

package/dist/types/types/cli/context.d.ts

@@ -28,7 +28,7 @@ export type AppContext<Extends extends CLIPluginExtends> = {
 /** The inner context. */
 export type InternalContext<Extends extends CLIPluginExtends> = AppContext<Extends> & {
     /** All hooks. */
-    hooks: Hooks<Extends['config'], Extends['normalizedConfig'], Extends['extendBuildUtils']> & Extends['extendHooks'];
+    hooks: Hooks<Extends['config'], Extends['normalizedConfig'], Extends['extendBuildUtils'], Extends['extendConfigUtils']> & Extends['extendHooks'];
     /** All plugin registry hooks */
     extendsHooks: Extends['extendHooks'];
     /** Current App config. */

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

@@ -1,7 +1,6 @@
 import type { WebpackConfig } from '@modern-js/uni-builder';
 import type { Command } from '@modern-js/utils/commander';
 import type { ModifyBundlerChainUtils, ModifyRspackConfigUtils, ModifyWebpackChainUtils, ModifyWebpackConfigUtils, RsbuildConfig, Rspack, RspackChain } from '@rsbuild/core';
-import type { TransformFunction } from '../plugin';
 import type { MaybePromise } from '../utils';
 import type { Entrypoint } from './context';
 declare module '@modern-js/utils/commander' {
@@ -10,8 +9,8 @@ declare module '@modern-js/utils/commander' {
     }
 }
 export type ConfigFn<Config> = () => Config;
-export type ModifyConfigFn<Config> = TransformFunction<Config>;
-export type ModifyResolvedConfigFn<NormalizedConfig> = TransformFunction<NormalizedConfig>;
+export type ModifyConfigFn<Config, ExtendConfigUtils> = (arg: Config, utils?: ExtendConfigUtils) => Config | Promise<Config>;
+export type ModifyResolvedConfigFn<NormalizedConfig, ExtendConfigUtils> = (arg: NormalizedConfig, utils?: ExtendConfigUtils) => NormalizedConfig | Promise<NormalizedConfig>;
 type IPartialMethod = (...script: string[]) => void;
 export interface PartialMethod {
     append: IPartialMethod;
@@ -44,8 +43,8 @@ export type OnBeforeDevFn = () => Promise<void> | void;
 export type OnAfterDevFn = (params: {
     port: number;
 }) => Promise<void> | void;
-export type OnBeforeDeployFn = (options: Record<string, any>) => Promise<void> | void;
-export type OnAfterDeployFn = (options: Record<string, any>) => Promise<void> | void;
+export type OnBeforeDeployFn = (options?: Record<string, any>) => Promise<void> | void;
+export type OnAfterDeployFn = (options?: Record<string, any>) => Promise<void> | void;
 export type OnBeforeExitFn = () => void;
 export type ModifyBundlerChainFn<ExtendsUtils> = (chain: RspackChain, utils: ModifyBundlerChainUtils & ExtendsUtils) => MaybePromise<void>;
 export type ModifyRsbuildConfigUtils = {

package/dist/types/types/cli/plugin.d.ts

@@ -2,13 +2,14 @@ import type { PluginHook } from '../hooks';
 import type { Plugin } from '../plugin';
 import type { CLIPluginAPI } from './api';
 import type { AppContext } from './context';
-export interface CLIPluginExtends<Config extends Record<string, any> = {}, NormalizedConfig extends Record<string, any> = {}, ExtendContext extends Record<string, any> = {}, ExtendAPI extends Record<string, any> = {}, ExtendHook extends Record<string, PluginHook<(...args: any[]) => any>> = {}, ExtendBuildUtils extends Record<string, any> = {}> {
+export interface CLIPluginExtends<Config extends Record<string, any> = {}, NormalizedConfig extends Record<string, any> = {}, ExtendContext extends Record<string, any> = {}, ExtendAPI extends Record<string, any> = {}, ExtendHook extends Record<string, PluginHook<(...args: any[]) => any>> = {}, ExtendBuildUtils extends Record<string, any> = {}, ExtendConfigUtils extends Record<string, any> = {}> {
     config?: Config;
     normalizedConfig?: NormalizedConfig;
     extendContext?: ExtendContext;
     extendApi?: ExtendAPI;
     extendHooks?: ExtendHook;
     extendBuildUtils?: ExtendBuildUtils;
+    extendConfigUtils?: ExtendConfigUtils;
 }
 /**
  * The type of the CLI plugin object.

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

@@ -5,11 +5,11 @@ export type SyncHook<Callback extends (...args: any[]) => any> = {
 };
 export type AsyncHook<Callback extends (...args: any[]) => any> = {
     tap: (cb: Callback) => void;
-    call: (...args: Parameters<Callback>) => Promise<ReturnType<Callback>>;
+    call: (...args: Parameters<Callback>) => Promise<ReturnType<UnwrapPromise<Callback>>>;
 };
 export type AsyncInterruptHook<Callback extends (...args: any[]) => any> = {
     tap: (cb: Callback) => void;
-    call: (...args: Tail<Parameters<Callback>>) => Promise<ReturnType<Callback>>;
+    call: (...args: Tail<Parameters<Callback>>) => Promise<ReturnType<UnwrapPromise<Callback>>>;
 };
 export type CollectAsyncHook<Callback extends (...params: any[]) => any> = {
     tap: (cb: Callback) => void;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.64.0",
+  "version": "2.64.1-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -63,8 +63,8 @@
     }
   },
   "dependencies": {
+    "jiti": "1.21.7",
     "@swc/helpers": "0.5.13",
-    "@modern-js/node-bundle-require": "2.64.0",
     "@modern-js/utils": "2.64.0",
     "@modern-js/runtime-utils": "2.64.0"
   },
@@ -75,16 +75,15 @@
     "@types/node": "^14",
     "jest": "^29",
     "typescript": "^5",
-    "@modern-js/types": "2.64.0",
     "@modern-js/uni-builder": "2.64.0",
     "@scripts/build": "2.64.0",
+    "@modern-js/types": "2.64.0",
     "@scripts/jest-config": "2.64.0"
   },
   "sideEffects": false,
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
-    "access": "public",
-    "provenance": true
+    "access": "public"
   },
   "scripts": {
     "new": "modern-lib new",