@rsbuild/core 0.0.0-next-20231103091827

package/dist/plugins/wasm.js

@@ -0,0 +1,51 @@
+"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 wasm_exports = {};
+__export(wasm_exports, {
+  pluginWasm: () => pluginWasm
+});
+module.exports = __toCommonJS(wasm_exports);
+var import_path = require("path");
+var import_shared = require("@rsbuild/shared");
+const pluginWasm = () => ({
+  name: "plugin-wasm",
+  setup(api) {
+    api.modifyBundlerChain(async (chain, { CHAIN_ID }) => {
+      const config = api.getNormalizedConfig();
+      const distPath = (0, import_shared.getDistPath)(config.output, "wasm");
+      chain.experiments({
+        ...chain.get("experiments"),
+        asyncWebAssembly: true
+      });
+      const wasmFilename = (0, import_path.join)(distPath, "[hash].module.wasm");
+      chain.output.merge({
+        webassemblyModuleFilename: wasmFilename
+      });
+      chain.module.rule(CHAIN_ID.RULE.WASM).test(/\.wasm$/).merge({
+        dependency: "url"
+      }).type("asset/resource").set("generator", {
+        filename: wasmFilename
+      });
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginWasm
+});

package/dist/plugins/yaml.d.ts

@@ -0,0 +1,2 @@
+import { DefaultRsbuildPlugin } from '@rsbuild/shared';
+export declare const pluginYaml: () => DefaultRsbuildPlugin;

package/dist/plugins/yaml.js

@@ -0,0 +1,36 @@
+"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 yaml_exports = {};
+__export(yaml_exports, {
+  pluginYaml: () => pluginYaml
+});
+module.exports = __toCommonJS(yaml_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginYaml = () => ({
+  name: "plugin-yaml",
+  setup(api) {
+    api.modifyBundlerChain((chain, { CHAIN_ID }) => {
+      chain.module.rule(CHAIN_ID.RULE.YAML).type("javascript/auto").test(/\.ya?ml$/).use(CHAIN_ID.USE.YAML).loader((0, import_shared.getSharedPkgCompiledPath)("yaml-loader"));
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginYaml
+});

package/dist/rspack-provider/config/defaults.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildConfig } from '../types';
+export declare const createDefaultConfig: () => RsbuildConfig;
+export declare const withDefaultConfig: (config: RsbuildConfig) => RsbuildConfig;

package/dist/rspack-provider/config/defaults.js

@@ -0,0 +1,40 @@
+"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 defaults_exports = {};
+__export(defaults_exports, {
+  createDefaultConfig: () => createDefaultConfig,
+  withDefaultConfig: () => withDefaultConfig
+});
+module.exports = __toCommonJS(defaults_exports);
+var import_shared = require("@rsbuild/shared");
+const createDefaultConfig = () => ({
+  dev: (0, import_shared.getDefaultDevConfig)(),
+  html: (0, import_shared.getDefaultHtmlConfig)(),
+  source: (0, import_shared.getDefaultSourceConfig)(),
+  output: (0, import_shared.getDefaultOutputConfig)(),
+  tools: (0, import_shared.getDefaultToolsConfig)(),
+  security: (0, import_shared.getDefaultSecurityConfig)(),
+  performance: (0, import_shared.getDefaultPerformanceConfig)()
+});
+const withDefaultConfig = (config) => (0, import_shared.mergeRsbuildConfig)(createDefaultConfig(), config);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDefaultConfig,
+  withDefaultConfig
+});

package/dist/rspack-provider/config/normalize.d.ts

@@ -0,0 +1,7 @@
+import { RsbuildConfig, NormalizedConfig } from '../types';
+/** #__PURE__
+ * 1. May used by multiple plugins.
+ * 2. Object value that should not be empty.
+ * 3. Meaningful and can be filled by constant value.
+ */
+export declare const normalizeConfig: (config: RsbuildConfig) => NormalizedConfig;

package/dist/rspack-provider/config/normalize.js

@@ -0,0 +1,33 @@
+"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 normalize_exports = {};
+__export(normalize_exports, {
+  normalizeConfig: () => normalizeConfig
+});
+module.exports = __toCommonJS(normalize_exports);
+var import_shared = require("@rsbuild/shared");
+var import_defaults = require("./defaults");
+const normalizeConfig = (config) => (0, import_shared.mergeRsbuildConfig)(
+  (0, import_defaults.createDefaultConfig)(),
+  config
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  normalizeConfig
+});

package/dist/rspack-provider/core/build.d.ts

@@ -0,0 +1,19 @@
+import { InitConfigsOptions } from './initConfigs';
+import type { Stats, MultiStats, BuildOptions, RspackCompiler, RspackMultiCompiler } from '@rsbuild/shared';
+export type BuildExecuter = {
+  (compiler: RspackCompiler): Promise<{
+    stats?: Stats;
+  }>;
+  (compiler: RspackMultiCompiler): Promise<{
+    stats?: MultiStats;
+  }>;
+  (compiler: RspackCompiler | RspackMultiCompiler): Promise<{
+    stats?: Stats | MultiStats;
+  }>;
+};
+export declare const rspackBuild: BuildExecuter;
+export declare const build: (initOptions: InitConfigsOptions, {
+  mode,
+  watch,
+  compiler: customCompiler
+}?: BuildOptions, executer?: BuildExecuter) => Promise<void>;

package/dist/rspack-provider/core/build.js

@@ -0,0 +1,79 @@
+"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 build_exports = {};
+__export(build_exports, {
+  build: () => build,
+  rspackBuild: () => rspackBuild
+});
+module.exports = __toCommonJS(build_exports);
+var import_createCompiler = require("./createCompiler");
+var import_initConfigs = require("./initConfigs");
+var import_shared = require("@rsbuild/shared");
+const rspackBuild = async (compiler) => {
+  return new Promise((resolve, reject) => {
+    compiler.run((err, stats) => {
+      if (err || (stats == null ? void 0 : stats.hasErrors())) {
+        const buildError = err || new Error("Rspack build failed!");
+        reject(buildError);
+      } else {
+        compiler.close(() => {
+          resolve({ stats });
+        });
+      }
+    });
+  });
+};
+const build = async (initOptions, { mode = "production", watch, compiler: customCompiler } = {}, executer) => {
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = mode;
+  }
+  const { context } = initOptions;
+  let compiler;
+  let bundlerConfigs;
+  if (customCompiler) {
+    compiler = customCompiler;
+  } else {
+    const { rspackConfigs } = await (0, import_initConfigs.initConfigs)(initOptions);
+    compiler = await (0, import_createCompiler.createCompiler)({
+      context,
+      rspackConfigs
+    });
+    bundlerConfigs = rspackConfigs;
+  }
+  await context.hooks.onBeforeBuildHook.call({
+    bundlerConfigs
+  });
+  if (watch) {
+    compiler.watch({}, (err) => {
+      if (err) {
+        import_shared.logger.error(err);
+      }
+    });
+  } else {
+    const executeResult = await (executer == null ? void 0 : executer(compiler));
+    await context.hooks.onAfterBuildHook.call({
+      stats: executeResult == null ? void 0 : executeResult.stats
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  rspackBuild
+});

package/dist/rspack-provider/core/createCompiler.d.ts

@@ -0,0 +1,9 @@
+import { type RspackConfig } from '@rsbuild/shared';
+import type { Context } from '../types';
+export declare function createCompiler({
+  context,
+  rspackConfigs
+}: {
+  context: Context;
+  rspackConfigs: RspackConfig[];
+}): Promise<import("@rspack/core").MultiCompiler>;

package/dist/rspack-provider/core/createCompiler.js

@@ -0,0 +1,83 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createCompiler_exports = {};
+__export(createCompiler_exports, {
+  createCompiler: () => createCompiler
+});
+module.exports = __toCommonJS(createCompiler_exports);
+var import_shared = require("@rsbuild/shared");
+async function createCompiler({
+  context,
+  rspackConfigs
+}) {
+  (0, import_shared.debug)("create compiler");
+  await context.hooks.onBeforeCreateCompilerHook.call({
+    bundlerConfigs: rspackConfigs
+  });
+  const { rspack } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
+  const compiler = rspack(rspackConfigs);
+  let isFirstCompile = true;
+  compiler.hooks.done.tap("done", async (stats) => {
+    var _a;
+    const obj = stats.toJson({
+      all: false,
+      timings: true
+    });
+    if (!stats.hasErrors()) {
+      (_a = obj.children) == null ? void 0 : _a.forEach((c, index) => {
+        if (c.time) {
+          const time = (0, import_shared.prettyTime)([0, c.time * 10 ** 6]);
+          const target = Array.isArray(context.target) ? context.target[index] : context.target;
+          const name = import_shared.TARGET_ID_MAP[target || "web"];
+          import_shared.logger.ready(`${name} compiled in ${time}`);
+        }
+      });
+    }
+    const { message, level } = (0, import_shared.formatStats)(stats);
+    if (level === "error") {
+      import_shared.logger.error(message);
+    }
+    if (level === "warning") {
+      import_shared.logger.warn(message);
+    }
+    if ((0, import_shared.isDev)()) {
+      await context.hooks.onDevCompileDoneHook.call({
+        isFirstCompile
+      });
+    }
+    isFirstCompile = false;
+  });
+  await context.hooks.onAfterCreateCompilerHook.call({ compiler });
+  (0, import_shared.debug)("create compiler done");
+  return compiler;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCompiler
+});

package/dist/rspack-provider/core/createContext.d.ts

@@ -0,0 +1,7 @@
+import { type CreateRsbuildOptions } from '@rsbuild/shared';
+import type { Context, RsbuildConfig } from '../types';
+/**
+ * Generate the actual context used in the build,
+ * which can have a lot of overhead and take some side effects.
+ */
+export declare function createContext(options: Required<CreateRsbuildOptions>, userRsbuildConfig: RsbuildConfig): Promise<Context>;

package/dist/rspack-provider/core/createContext.js

@@ -0,0 +1,47 @@
+"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 createContext_exports = {};
+__export(createContext_exports, {
+  createContext: () => createContext
+});
+module.exports = __toCommonJS(createContext_exports);
+var import_path = require("path");
+var import_shared = require("@rsbuild/shared");
+var import_initHooks = require("./initHooks");
+var import_defaults = require("../config/defaults");
+async function createContext(options, userRsbuildConfig) {
+  const rsbuildConfig = (0, import_defaults.withDefaultConfig)(userRsbuildConfig);
+  const context = (0, import_shared.createContextByConfig)(
+    options,
+    rsbuildConfig.output,
+    "rspack"
+  );
+  const tsconfigPath = (0, import_path.join)(context.rootPath, import_shared.TS_CONFIG_FILE);
+  return {
+    ...context,
+    hooks: (0, import_initHooks.initHooks)(),
+    config: { ...rsbuildConfig },
+    originalConfig: userRsbuildConfig,
+    tsconfigPath: await (0, import_shared.isFileExists)(tsconfigPath) ? tsconfigPath : void 0
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContext
+});

package/dist/rspack-provider/core/devMiddleware.d.ts

@@ -0,0 +1,5 @@
+import type { ModernDevServerOptions } from '@modern-js/server';
+import type { Compiler, MultiCompiler } from '@rspack/core';
+type DevMiddlewareOptions = ModernDevServerOptions['devMiddleware'];
+export declare const getDevMiddleware: (multiCompiler: Compiler | MultiCompiler) => NonNullable<DevMiddlewareOptions>;
+export {};

package/dist/rspack-provider/core/devMiddleware.js

@@ -0,0 +1,65 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var devMiddleware_exports = {};
+__export(devMiddleware_exports, {
+  getDevMiddleware: () => getDevMiddleware
+});
+module.exports = __toCommonJS(devMiddleware_exports);
+var import_webpack_dev_middleware = __toESM(require("@rsbuild/shared/webpack-dev-middleware"));
+var import_shared = require("@rsbuild/shared");
+function applyHMREntry(compiler, clientPath) {
+  if (!(0, import_shared.isClientCompiler)(compiler)) {
+    return;
+  }
+  for (const key in compiler.options.entry) {
+    compiler.options.entry[key].import = [
+      clientPath,
+      ...compiler.options.entry[key].import || []
+    ];
+  }
+}
+const getDevMiddleware = (multiCompiler) => (options) => {
+  const { hmrClientPath, callbacks, ...restOptions } = options;
+  const setupCompiler = (compiler) => {
+    if (hmrClientPath) {
+      applyHMREntry(compiler, hmrClientPath);
+    }
+    (0, import_shared.setupServerHooks)(compiler, callbacks);
+  };
+  if (multiCompiler.compilers) {
+    multiCompiler.compilers.forEach(setupCompiler);
+  } else {
+    setupCompiler(multiCompiler);
+  }
+  return (0, import_webpack_dev_middleware.default)(multiCompiler, restOptions);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDevMiddleware
+});

package/dist/rspack-provider/core/initConfigs.d.ts

@@ -0,0 +1,14 @@
+import { type PluginStore, type CreateRsbuildOptions } from '@rsbuild/shared';
+import type { Context } from '../types';
+export type InitConfigsOptions = {
+  context: Context;
+  pluginStore: PluginStore;
+  rsbuildOptions: Required<CreateRsbuildOptions>;
+};
+export declare function initConfigs({
+  context,
+  pluginStore,
+  rsbuildOptions
+}: InitConfigsOptions): Promise<{
+  rspackConfigs: import("@rsbuild/shared").RspackConfig[];
+}>;

package/dist/rspack-provider/core/initConfigs.js

@@ -0,0 +1,76 @@
+"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 initConfigs_exports = {};
+__export(initConfigs_exports, {
+  initConfigs: () => initConfigs
+});
+module.exports = __toCommonJS(initConfigs_exports);
+var import_shared = require("@rsbuild/shared");
+var import_inspectConfig = require("./inspectConfig");
+var import_rspackConfig = require("./rspackConfig");
+var import_normalize = require("../config/normalize");
+async function modifyRsbuildConfig(context) {
+  (0, import_shared.debug)("modify Rsbuild config");
+  const [modified] = await context.hooks.modifyRsbuildConfigHook.call(
+    context.config,
+    { mergeRsbuildConfig: import_shared.mergeRsbuildConfig }
+  );
+  context.config = modified;
+  (0, import_shared.debug)("modify Rsbuild config done");
+}
+async function initConfigs({
+  context,
+  pluginStore,
+  rsbuildOptions
+}) {
+  await (0, import_shared.initPlugins)({
+    pluginAPI: context.pluginAPI,
+    pluginStore
+  });
+  await modifyRsbuildConfig(context);
+  context.normalizedConfig = (0, import_normalize.normalizeConfig)(context.config);
+  const targets = (0, import_shared.castArray)(rsbuildOptions.target);
+  const rspackConfigs = await Promise.all(
+    targets.map((target) => (0, import_rspackConfig.generateRspackConfig)({ target, context }))
+  );
+  if ((0, import_shared.isDebug)()) {
+    const inspect = () => {
+      const inspectOptions = {
+        verbose: true,
+        writeToDisk: true
+      };
+      (0, import_inspectConfig.inspectConfig)({
+        context,
+        pluginStore,
+        inspectOptions,
+        rsbuildOptions,
+        bundlerConfigs: rspackConfigs
+      });
+    };
+    context.hooks.onBeforeBuildHook.tap(inspect);
+    context.hooks.onBeforeStartDevServerHook.tap(inspect);
+  }
+  return {
+    rspackConfigs
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initConfigs
+});

package/dist/rspack-provider/core/initHooks.d.ts

@@ -0,0 +1,18 @@
+import { OnExitFn, OnAfterBuildFn, OnBeforeBuildFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, OnAfterStartDevServerFn, OnBeforeStartDevServerFn, OnAfterCreateCompilerFn, OnBeforeCreateCompilerFn, ModifyBundlerChainFn, type RspackConfig } from '@rsbuild/shared';
+import type { RsbuildConfig, ModifyRspackConfigFn } from '../types';
+export declare function initHooks(): {
+  /** parameters are not bundler-related */
+  onExitHook: import("@rsbuild/shared").AsyncHook<OnExitFn>;
+  onDevCompileDoneHook: import("@rsbuild/shared").AsyncHook<OnDevCompileDoneFn>;
+  onAfterStartDevServerHook: import("@rsbuild/shared").AsyncHook<OnAfterStartDevServerFn>;
+  onBeforeStartDevServerHook: import("@rsbuild/shared").AsyncHook<OnBeforeStartDevServerFn>;
+  /** parameters are bundler-related */
+  onAfterBuildHook: import("@rsbuild/shared").AsyncHook<OnAfterBuildFn>;
+  onBeforeBuildHook: import("@rsbuild/shared").AsyncHook<OnBeforeBuildFn<RspackConfig>>;
+  modifyRspackConfigHook: import("@rsbuild/shared").AsyncHook<ModifyRspackConfigFn>;
+  modifyRsbuildConfigHook: import("@rsbuild/shared").AsyncHook<ModifyRsbuildConfigFn<RsbuildConfig>>;
+  onAfterCreateCompilerHook: import("@rsbuild/shared").AsyncHook<OnAfterCreateCompilerFn<import("@rspack/core/dist/Compiler").Compiler | import("@rspack/core").MultiCompiler>>;
+  onBeforeCreateCompilerHook: import("@rsbuild/shared").AsyncHook<OnBeforeCreateCompilerFn<RspackConfig>>;
+  modifyBundlerChainHook: import("@rsbuild/shared").AsyncHook<ModifyBundlerChainFn>;
+};
+export type Hooks = ReturnType<typeof initHooks>;

package/dist/rspack-provider/core/initHooks.js

@@ -0,0 +1,45 @@
+"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 initHooks_exports = {};
+__export(initHooks_exports, {
+  initHooks: () => initHooks
+});
+module.exports = __toCommonJS(initHooks_exports);
+var import_shared = require("@rsbuild/shared");
+function initHooks() {
+  return {
+    /** parameters are not bundler-related */
+    onExitHook: (0, import_shared.createAsyncHook)(),
+    onDevCompileDoneHook: (0, import_shared.createAsyncHook)(),
+    onAfterStartDevServerHook: (0, import_shared.createAsyncHook)(),
+    onBeforeStartDevServerHook: (0, import_shared.createAsyncHook)(),
+    /** parameters are bundler-related */
+    onAfterBuildHook: (0, import_shared.createAsyncHook)(),
+    onBeforeBuildHook: (0, import_shared.createAsyncHook)(),
+    modifyRspackConfigHook: (0, import_shared.createAsyncHook)(),
+    modifyRsbuildConfigHook: (0, import_shared.createAsyncHook)(),
+    onAfterCreateCompilerHook: (0, import_shared.createAsyncHook)(),
+    onBeforeCreateCompilerHook: (0, import_shared.createAsyncHook)(),
+    modifyBundlerChainHook: (0, import_shared.createAsyncHook)()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initHooks
+});