@modern-js/plugin-v2 2.63.7 → 2.63.8-alpha.1

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

@@ -0,0 +1,72 @@
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { createPluginManager } from "../../manager";
+import { initPluginAPI } from "../../runtime/api";
+import { createRuntimeContext, initRuntimeContext } from "../../runtime/context";
+var createRuntime = function() {
+  var init = function init2(options) {
+    pluginManager.clear();
+    initOptions = options;
+    var allPlugins = options.plugins, handleSetupResult = options.handleSetupResult;
+    pluginManager.addPlugins(allPlugins);
+    var plugins = pluginManager.getPlugins();
+    var context = createRuntimeContext({
+      runtimeContext: initRuntimeContext(),
+      config: initOptions.config,
+      plugins
+    });
+    var pluginAPI = initPluginAPI({
+      context,
+      pluginManager,
+      plugins
+    });
+    context.pluginAPI = pluginAPI;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
+    try {
+      for (var _iterator = plugins[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var plugin = _step.value;
+        var _plugin_setup;
+        var setupResult = (_plugin_setup = plugin.setup) === null || _plugin_setup === void 0 ? void 0 : _plugin_setup.call(plugin, pluginAPI);
+        if (handleSetupResult) {
+          handleSetupResult(setupResult, pluginAPI);
+        }
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+    return {
+      runtimeContext: context
+    };
+  };
+  var run = function run2(options) {
+    var runtimeContext = init(options).runtimeContext;
+    var configs = runtimeContext.hooks.modifyRuntimeConfig.call(runtimeContext.config).filter(function(config) {
+      return Boolean(config);
+    });
+    runtimeContext.config = merge.apply(void 0, [
+      {}
+    ].concat(_to_consumable_array(configs)));
+    return {
+      runtimeContext
+    };
+  };
+  var initOptions;
+  var pluginManager = createPluginManager();
+  return {
+    run
+  };
+};
+export {
+  createRuntime
+};

package/dist/esm/runtime/run/index.js

@@ -0,0 +1,5 @@
+import { createRuntime } from "./create";
+var runtime = createRuntime();
+export {
+  runtime
+};

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

@@ -1,4 +1,4 @@
-import { logger } from "@modern-js/utils";
+import { createDebugger, logger } from "@modern-js/utils";
 import { program } from "@modern-js/utils/commander";
 import { createPluginManager } from "../../manager";
 import { initPluginAPI } from "../api";
@@ -10,9 +10,27 @@ import { initCommandsMap, setProgramVersion } from "./utils/commander";
 import { createFileWatcher } from "./utils/createFileWatcher";
 import { initAppDir } from "./utils/initAppDir";
 import { loadEnv } from "./utils/loadEnv";
+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();
@@ -30,6 +48,7 @@ const createCli = () => {
     checkIsDuplicationPlugin(allPlugins.map((plugin) => plugin.name), loaded.config.autoLoadPlugins);
     pluginManager.addPlugins(allPlugins);
     const plugins = await pluginManager.getPlugins();
+    debug("CLI Plugins:", plugins.map((p) => p.name));
     const context = await createContext({
       appContext: initAppContext({
         packageName: loaded.packageName,
@@ -59,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/esm-node/hooks.js

@@ -1,3 +1,49 @@
+function createAsyncInterruptHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = async (...params) => {
+    let interrupted = false;
+    let interruptResult;
+    const interrupt = (info) => {
+      interrupted = true;
+      interruptResult = info;
+    };
+    for (const callback of callbacks) {
+      if (interrupted)
+        break;
+      const result = await callback(...params, interrupt);
+      if (result !== void 0) {
+        params[0] = result;
+      }
+    }
+    return interrupted ? interruptResult : params[0] || [];
+  };
+  return {
+    tap,
+    call
+  };
+}
+function createSyncHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = (...params) => {
+    for (const callback of callbacks) {
+      const result = callback(...params);
+      if (result !== void 0) {
+        params[0] = result;
+      }
+    }
+    return params[0];
+  };
+  return {
+    tap,
+    call
+  };
+}
 function createAsyncHook() {
   const callbacks = [];
   const tap = (cb) => {
@@ -37,7 +83,30 @@ function createCollectAsyncHook() {
     call
   };
 }
+function createCollectSyncHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = (...params) => {
+    const results = [];
+    for (const callback of callbacks) {
+      const result = callback(params);
+      if (result !== void 0) {
+        results.push(result);
+      }
+    }
+    return results;
+  };
+  return {
+    tap,
+    call
+  };
+}
 export {
   createAsyncHook,
-  createCollectAsyncHook
+  createAsyncInterruptHook,
+  createCollectAsyncHook,
+  createCollectSyncHook,
+  createSyncHook
 };

package/dist/esm-node/index.js

@@ -1,7 +1,10 @@
 import { createPluginManager } from "./manager";
-import { createAsyncHook, createCollectAsyncHook } from "./hooks";
+import { createSyncHook, createAsyncHook, createCollectSyncHook, createCollectAsyncHook, createAsyncInterruptHook } from "./hooks";
 export {
   createAsyncHook,
+  createAsyncInterruptHook,
   createCollectAsyncHook,
-  createPluginManager
+  createCollectSyncHook,
+  createPluginManager,
+  createSyncHook
 };

package/dist/esm-node/manager.js

@@ -1,5 +1,4 @@
-import { isFunction, logger } from "@modern-js/utils";
-import { debug } from "./cli/run/utils/debug";
+const isFunction = (obj) => typeof obj === "function";
 function validatePlugin(plugin) {
   const type = typeof plugin;
   if (type !== "object" || plugin === null) {
@@ -47,7 +46,7 @@ function createPluginManager() {
     validatePlugin(newPlugin);
     const { name, usePlugins = [], pre = [], post = [] } = newPlugin;
     if (plugins.has(name)) {
-      logger.warn(`Plugin ${name} already exists.`);
+      console.warn(`Plugin ${name} already exists.`);
       return;
     }
     plugins.set(name, newPlugin);
@@ -112,7 +111,6 @@ function createPluginManager() {
       visit(name);
     });
     result = result.filter((result2) => result2);
-    debug("CLI Plugins:", result.map((p) => p.name));
     return result;
   };
   const clear = () => {

package/dist/esm-node/runtime/api.js

@@ -0,0 +1,55 @@
+import { merge } from "@modern-js/runtime-utils/merge";
+function initPluginAPI({ context, plugins }) {
+  const { hooks, extendsHooks } = context;
+  function getRuntimeContext() {
+    if (context) {
+      const { hooks: hooks2, extendsHooks: extendsHooks2, config, pluginAPI, ...runtimeContext } = context;
+      runtimeContext._internalContext = context;
+      return runtimeContext;
+    }
+    throw new Error("Cannot access context");
+  }
+  function updateRuntimeContext(updateContext) {
+    context = merge(context, updateContext);
+  }
+  function getHooks() {
+    return {
+      ...hooks,
+      ...extendsHooks
+    };
+  }
+  function getRuntimeConfig() {
+    if (context.config) {
+      return context.config;
+    }
+    throw new Error("Cannot access config");
+  }
+  const extendsPluginApi = {};
+  plugins.forEach((plugin) => {
+    const { _registryApi } = plugin;
+    if (_registryApi) {
+      const apis = _registryApi(getRuntimeContext, updateRuntimeContext);
+      Object.keys(apis).forEach((apiName) => {
+        extendsPluginApi[apiName] = apis[apiName];
+      });
+    }
+  });
+  if (extendsHooks) {
+    Object.keys(extendsHooks).forEach((hookName) => {
+      extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+    });
+  }
+  return {
+    updateRuntimeContext,
+    getHooks,
+    getRuntimeConfig,
+    modifyRuntimeConfig: hooks.modifyRuntimeConfig.tap,
+    onBeforeRender: hooks.onBeforeRender.tap,
+    wrapRoot: hooks.wrapRoot.tap,
+    pickContext: hooks.pickContext.tap,
+    ...extendsPluginApi
+  };
+}
+export {
+  initPluginAPI
+};

package/dist/esm-node/runtime/context.js

@@ -0,0 +1,26 @@
+import { initHooks } from "./hooks";
+function initRuntimeContext() {
+  return {};
+}
+function createRuntimeContext({ runtimeContext, config, plugins }) {
+  const extendsHooks = {};
+  plugins.forEach((plugin) => {
+    const { registryHooks = {} } = plugin;
+    Object.keys(registryHooks).forEach((hookName) => {
+      extendsHooks[hookName] = registryHooks[hookName];
+    });
+  });
+  return {
+    ...runtimeContext,
+    hooks: {
+      ...initHooks(),
+      ...extendsHooks
+    },
+    extendsHooks,
+    config
+  };
+}
+export {
+  createRuntimeContext,
+  initRuntimeContext
+};

package/dist/esm-node/runtime/hooks.js

@@ -0,0 +1,12 @@
+import { createAsyncInterruptHook, createCollectSyncHook, createSyncHook } from "../hooks";
+function initHooks() {
+  return {
+    onBeforeRender: createAsyncInterruptHook(),
+    wrapRoot: createSyncHook(),
+    pickContext: createSyncHook(),
+    modifyRuntimeConfig: createCollectSyncHook()
+  };
+}
+export {
+  initHooks
+};

package/dist/esm-node/runtime/index.js

@@ -0,0 +1,11 @@
+import { initPluginAPI } from "./api";
+import { initRuntimeContext, createRuntimeContext } from "./context";
+import { initHooks } from "./hooks";
+import { runtime } from "./run";
+export {
+  createRuntimeContext,
+  initHooks,
+  initPluginAPI,
+  initRuntimeContext,
+  runtime
+};

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

@@ -0,0 +1,50 @@
+import { merge } from "@modern-js/runtime-utils/merge";
+import { createPluginManager } from "../../manager";
+import { initPluginAPI } from "../../runtime/api";
+import { createRuntimeContext, initRuntimeContext } from "../../runtime/context";
+const createRuntime = () => {
+  let initOptions;
+  const pluginManager = createPluginManager();
+  function init(options) {
+    pluginManager.clear();
+    initOptions = options;
+    const { plugins: allPlugins, handleSetupResult } = options;
+    pluginManager.addPlugins(allPlugins);
+    const plugins = pluginManager.getPlugins();
+    const context = createRuntimeContext({
+      runtimeContext: initRuntimeContext(),
+      config: initOptions.config,
+      plugins
+    });
+    const pluginAPI = initPluginAPI({
+      context,
+      pluginManager,
+      plugins
+    });
+    context.pluginAPI = pluginAPI;
+    for (const plugin of plugins) {
+      var _plugin_setup;
+      const setupResult = (_plugin_setup = plugin.setup) === null || _plugin_setup === void 0 ? void 0 : _plugin_setup.call(plugin, pluginAPI);
+      if (handleSetupResult) {
+        handleSetupResult(setupResult, pluginAPI);
+      }
+    }
+    return {
+      runtimeContext: context
+    };
+  }
+  function run(options) {
+    const { runtimeContext } = init(options);
+    const configs = runtimeContext.hooks.modifyRuntimeConfig.call(runtimeContext.config).filter((config) => Boolean(config));
+    runtimeContext.config = merge({}, ...configs);
+    return {
+      runtimeContext
+    };
+  }
+  return {
+    run
+  };
+};
+export {
+  createRuntime
+};

package/dist/esm-node/runtime/run/index.js

@@ -0,0 +1,5 @@
+import { createRuntime } from "./create";
+const runtime = createRuntime();
+export {
+  runtime
+};

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,7 +11,7 @@ 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
      */
@@ -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/hooks.d.ts

@@ -1,3 +1,6 @@
-import type { AsyncHook, CollectAsyncHook } from './types/hooks';
+import type { AsyncHook, AsyncInterruptHook, CollectAsyncHook, CollectSyncHook, SyncHook } from './types/hooks';
+export declare function createAsyncInterruptHook<Callback extends (...args: any[]) => any>(): AsyncInterruptHook<Callback>;
+export declare function createSyncHook<Callback extends (...args: any[]) => any>(): SyncHook<Callback>;
 export declare function createAsyncHook<Callback extends (...args: any[]) => any>(): AsyncHook<Callback>;
 export declare function createCollectAsyncHook<Callback extends (...params: any[]) => any>(): CollectAsyncHook<Callback>;
+export declare function createCollectSyncHook<Callback extends (...params: any[]) => any>(): CollectSyncHook<Callback>;

package/dist/types/index.d.ts

@@ -1,5 +1,6 @@
 export { createPluginManager } from './manager';
-export { createAsyncHook, createCollectAsyncHook } from './hooks';
+export { createSyncHook, createAsyncHook, createCollectSyncHook, createCollectAsyncHook, createAsyncInterruptHook, } from './hooks';
 export type { Plugin, PluginManager, TransformFunction, } from './types/plugin';
 export type { CLIPluginAPI, AppContext, InternalContext, Entrypoint, CLIPlugin, CLIPluginExtends, } from './types/cli';
+export type { RuntimePluginAPI, RuntimeContext, InternalRuntimeContext, RuntimePlugin, RuntimePluginExtends, } from './types/runtime';
 export type { AsyncHook, CollectAsyncHook, PluginHook, PluginHookTap, } from './types/hooks';

package/dist/types/manager.d.ts

@@ -1,2 +1,5 @@
+/**
+ * NOTE: This file will be used in both Node.js and runtime environments. Please avoid importing Node.js-specific APIs.
+ */
 import type { PluginManager } from './types/plugin';
 export declare function createPluginManager(): PluginManager;

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

@@ -0,0 +1,9 @@
+import type { PluginManager } from '../types/plugin';
+import type { RuntimePluginAPI } from '../types/runtime/api';
+import type { InternalRuntimeContext } from '../types/runtime/context';
+import type { RuntimePlugin, RuntimePluginExtends } from '../types/runtime/plugin';
+export declare function initPluginAPI<Extends extends RuntimePluginExtends>({ context, plugins, }: {
+    context: InternalRuntimeContext<Extends>;
+    pluginManager: PluginManager;
+    plugins: RuntimePlugin<Extends>[];
+}): RuntimePluginAPI<Extends>;

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

@@ -0,0 +1,11 @@
+import type { InternalRuntimeContext, RuntimeContext } from '../types/runtime/context';
+import type { RuntimePlugin, RuntimePluginExtends } from '../types/runtime/plugin';
+export interface RuntimeConfig<Extends extends RuntimePluginExtends> {
+    plugins?: RuntimePlugin<Extends>[];
+}
+export declare function initRuntimeContext(): RuntimeContext;
+export declare function createRuntimeContext<Extends extends RuntimePluginExtends>({ runtimeContext, config, plugins, }: {
+    runtimeContext: RuntimeContext & Extends['extendContext'];
+    config: Extends['config'];
+    plugins: RuntimePlugin<Extends>[];
+}): InternalRuntimeContext<Extends>;

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

@@ -0,0 +1,2 @@
+import type { Hooks } from '../types/runtime/hooks';
+export declare function initHooks<RuntimeConfig, RuntimeContext>(): Hooks<RuntimeConfig, RuntimeContext>;

package/dist/types/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export { initPluginAPI } from './api';
+export { initRuntimeContext, createRuntimeContext } from './context';
+export { initHooks } from './hooks';
+export { runtime } from './run';
+export type { RuntimePluginAPI, RuntimeContext, InternalRuntimeContext, RuntimePlugin, RuntimePluginExtends, Hooks, } from '../types/runtime';

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

@@ -0,0 +1,7 @@
+import type { RuntimePluginExtends } from '../../types/runtime/plugin';
+import type { RuntimeRunOptions } from './types';
+export declare const createRuntime: <Extends extends RuntimePluginExtends>() => {
+    run: (options: RuntimeRunOptions) => {
+        runtimeContext: import("..").InternalRuntimeContext<Extends>;
+    };
+};

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

@@ -0,0 +1,5 @@
+export declare const runtime: {
+    run: (options: import("./types").RuntimeRunOptions) => {
+        runtimeContext: import("..").InternalRuntimeContext<import("..").RuntimePluginExtends<{}, {}, {}, {}>>;
+    };
+};

package/dist/types/runtime/run/types.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '../../types/plugin';
+export type RuntimeRunOptions = {
+    config: Record<string, any>;
+    plugins: Plugin[];
+    handleSetupResult?: (params: any, api: Record<string, any>) => Promise<void> | void;
+};

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

@@ -13,10 +13,10 @@ 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']>>;
+    modifyConfig: PluginHookTap<ModifyConfigFn<Extends['config'], Extends['extendConfigUtils']>>;
     modifyResolvedConfig: PluginHookTap<ModifyResolvedConfigFn<Extends['normalizedConfig']>>;
     modifyRsbuildConfig: PluginHookTap<ModifyRsbuildConfigFn<Extends['extendBuildUtils']>>;
     modifyBundlerChain: PluginHookTap<ModifyBundlerChainFn<Extends['extendBuildUtils']>>;

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. */