@rsbuild/webpack 0.0.0-next-20231103091827

package/dist/core/createCompiler.d.ts

@@ -0,0 +1,8 @@
+import type { Context, WebpackConfig } from '../types';
+export declare function createCompiler({
+  context,
+  webpackConfigs
+}: {
+  context: Context;
+  webpackConfigs: WebpackConfig[];
+}): Promise<import("webpack").Compiler | import("webpack").MultiCompiler>;

package/dist/core/createCompiler.js

@@ -0,0 +1,68 @@
+"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,
+  webpackConfigs
+}) {
+  (0, import_shared.debug)("create compiler");
+  await context.hooks.onBeforeCreateCompilerHook.call({
+    bundlerConfigs: webpackConfigs
+  });
+  const { default: webpack } = await Promise.resolve().then(() => __toESM(require("webpack")));
+  const compiler = webpackConfigs.length === 1 ? webpack(webpackConfigs[0]) : webpack(webpackConfigs);
+  let isFirstCompile = true;
+  compiler.hooks.done.tap("done", async (stats) => {
+    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/core/createContext.d.ts

@@ -0,0 +1,13 @@
+import { type CreateRsbuildOptions } from '@rsbuild/shared';
+import type { Context, RsbuildConfig } from '../types';
+/**
+ * Create primary context.
+ * It will be assembled into a normal context or a stub for testing as needed.
+ * Usually it would be a pure function
+ */
+export declare function createPrimaryContext(options: Required<CreateRsbuildOptions>, userRsbuildConfig: RsbuildConfig): Context;
+/**
+ * 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>, rsbuildConfig: RsbuildConfig): Promise<Context>;

package/dist/core/createContext.js

@@ -0,0 +1,56 @@
+"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,
+  createPrimaryContext: () => createPrimaryContext
+});
+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");
+function createPrimaryContext(options, userRsbuildConfig) {
+  const rsbuildConfig = (0, import_defaults.withDefaultConfig)(userRsbuildConfig);
+  const context = (0, import_shared.createContextByConfig)(
+    options,
+    rsbuildConfig.output,
+    "webpack"
+  );
+  return {
+    ...context,
+    hooks: (0, import_initHooks.initHooks)(),
+    config: { ...rsbuildConfig },
+    originalConfig: userRsbuildConfig
+  };
+}
+async function createContext(options, rsbuildConfig) {
+  (0, import_shared.debug)("create context");
+  const ctx = createPrimaryContext(options, rsbuildConfig);
+  const tsconfigPath = (0, import_path.join)(ctx.rootPath, import_shared.TS_CONFIG_FILE);
+  if (await (0, import_shared.isFileExists)(tsconfigPath)) {
+    ctx.tsconfigPath = tsconfigPath;
+  }
+  return ctx;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createContext,
+  createPrimaryContext
+});

package/dist/core/devMiddleware.d.ts

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

package/dist/core/devMiddleware.js

@@ -0,0 +1,73 @@
+"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");
+const applyHMREntry = (compiler, clientPath) => {
+  const applyEntry = (clientEntry, compiler2) => {
+    if ((0, import_shared.isClientCompiler)(compiler2)) {
+      new compiler2.webpack.EntryPlugin(compiler2.context, clientEntry, {
+        name: void 0
+      }).apply(compiler2);
+    }
+  };
+  if (compiler.compilers) {
+    compiler.compilers.forEach((target) => {
+      applyEntry(clientPath, target);
+    });
+  } else {
+    applyEntry(clientPath, compiler);
+  }
+};
+const setupHooks = (compiler, hookCallbacks) => {
+  if (compiler.compilers) {
+    compiler.compilers.forEach(
+      (compiler2) => (0, import_shared.setupServerHooks)(compiler2, hookCallbacks)
+    );
+  } else {
+    (0, import_shared.setupServerHooks)(compiler, hookCallbacks);
+  }
+};
+const getDevMiddleware = (compiler) => (options) => {
+  const { hmrClientPath, callbacks, ...restOptions } = options;
+  hmrClientPath && applyHMREntry(compiler, hmrClientPath);
+  setupHooks(compiler, callbacks);
+  return (0, import_webpack_dev_middleware.default)(
+    compiler,
+    restOptions
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDevMiddleware
+});

package/dist/core/initConfigs.d.ts

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

package/dist/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_webpackConfig = require("./webpackConfig");
+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 webpackConfigs = await Promise.all(
+    targets.map((target) => (0, import_webpackConfig.generateWebpackConfig)({ target, context }))
+  );
+  if ((0, import_shared.isDebug)()) {
+    const inspect = () => {
+      const inspectOptions = {
+        verbose: true,
+        writeToDisk: true
+      };
+      (0, import_inspectConfig.inspectConfig)({
+        context,
+        pluginStore,
+        inspectOptions,
+        rsbuildOptions,
+        bundlerConfigs: webpackConfigs
+      });
+    };
+    context.hooks.onBeforeBuildHook.tap(inspect);
+    context.hooks.onBeforeStartDevServerHook.tap(inspect);
+  }
+  return {
+    webpackConfigs
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initConfigs
+});

package/dist/core/initHooks.d.ts

@@ -0,0 +1,19 @@
+import { OnExitFn, OnAfterBuildFn, OnBeforeBuildFn, OnDevCompileDoneFn, ModifyRsbuildConfigFn, OnAfterStartDevServerFn, OnBeforeStartDevServerFn, OnAfterCreateCompilerFn, OnBeforeCreateCompilerFn } from '@rsbuild/shared';
+import type { ModifyBundlerChainFn } from '@rsbuild/shared';
+import type { Compiler, MultiCompiler } from 'webpack';
+import type { WebpackConfig, RsbuildConfig, ModifyWebpackChainFn, ModifyWebpackConfigFn } from '../types';
+export declare function initHooks(): {
+  onExitHook: import("@rsbuild/shared").AsyncHook<OnExitFn>;
+  onAfterBuildHook: import("@rsbuild/shared").AsyncHook<OnAfterBuildFn>;
+  onBeforeBuildHook: import("@rsbuild/shared").AsyncHook<OnBeforeBuildFn<WebpackConfig>>;
+  onDevCompileDoneHook: import("@rsbuild/shared").AsyncHook<OnDevCompileDoneFn>;
+  modifyWebpackChainHook: import("@rsbuild/shared").AsyncHook<ModifyWebpackChainFn>;
+  modifyWebpackConfigHook: import("@rsbuild/shared").AsyncHook<ModifyWebpackConfigFn>;
+  modifyRsbuildConfigHook: import("@rsbuild/shared").AsyncHook<ModifyRsbuildConfigFn<RsbuildConfig>>;
+  onAfterCreateCompilerHook: import("@rsbuild/shared").AsyncHook<OnAfterCreateCompilerFn<Compiler | MultiCompiler>>;
+  onBeforeCreateCompilerHook: import("@rsbuild/shared").AsyncHook<OnBeforeCreateCompilerFn<WebpackConfig>>;
+  onAfterStartDevServerHook: import("@rsbuild/shared").AsyncHook<OnAfterStartDevServerFn>;
+  onBeforeStartDevServerHook: import("@rsbuild/shared").AsyncHook<OnBeforeStartDevServerFn>;
+  modifyBundlerChainHook: import("@rsbuild/shared").AsyncHook<ModifyBundlerChainFn>;
+};
+export type Hooks = ReturnType<typeof initHooks>;

package/dist/core/initHooks.js

@@ -0,0 +1,44 @@
+"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 {
+    onExitHook: (0, import_shared.createAsyncHook)(),
+    onAfterBuildHook: (0, import_shared.createAsyncHook)(),
+    onBeforeBuildHook: (0, import_shared.createAsyncHook)(),
+    onDevCompileDoneHook: (0, import_shared.createAsyncHook)(),
+    modifyWebpackChainHook: (0, import_shared.createAsyncHook)(),
+    modifyWebpackConfigHook: (0, import_shared.createAsyncHook)(),
+    modifyRsbuildConfigHook: (0, import_shared.createAsyncHook)(),
+    onAfterCreateCompilerHook: (0, import_shared.createAsyncHook)(),
+    onBeforeCreateCompilerHook: (0, import_shared.createAsyncHook)(),
+    onAfterStartDevServerHook: (0, import_shared.createAsyncHook)(),
+    onBeforeStartDevServerHook: (0, import_shared.createAsyncHook)(),
+    modifyBundlerChainHook: (0, import_shared.createAsyncHook)()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initHooks
+});

package/dist/core/initPlugins.d.ts

@@ -0,0 +1,9 @@
+import { type PluginStore } from '@rsbuild/shared';
+import type { Context, RsbuildPluginAPI } from '../types';
+export declare function getPluginAPI({
+  context,
+  pluginStore
+}: {
+  context: Context;
+  pluginStore: PluginStore;
+}): RsbuildPluginAPI;

package/dist/core/initPlugins.js

@@ -0,0 +1,83 @@
+"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 initPlugins_exports = {};
+__export(initPlugins_exports, {
+  getPluginAPI: () => getPluginAPI
+});
+module.exports = __toCommonJS(initPlugins_exports);
+var import_shared = require("@rsbuild/shared");
+function getPluginAPI({
+  context,
+  pluginStore
+}) {
+  const { hooks } = context;
+  const publicContext = (0, import_shared.createPublicContext)(context);
+  const getRsbuildConfig = () => {
+    if (!context.normalizedConfig) {
+      throw new Error(
+        "Cannot access Rsbuild config until modifyRsbuildConfig is called."
+      );
+    }
+    return context.config;
+  };
+  const getNormalizedConfig = () => {
+    if (!context.normalizedConfig) {
+      throw new Error(
+        "Cannot access normalized config until modifyRsbuildConfig is called."
+      );
+    }
+    return context.normalizedConfig;
+  };
+  const getHTMLPaths = () => {
+    return Object.keys(context.entry).reduce(
+      (prev, key) => {
+        prev[key] = (0, import_shared.getHTMLPathByEntry)(key, getNormalizedConfig());
+        return prev;
+      },
+      {}
+    );
+  };
+  (0, import_shared.onExitProcess)(() => {
+    hooks.onExitHook.call();
+  });
+  return {
+    context: publicContext,
+    getHTMLPaths,
+    getRsbuildConfig,
+    getNormalizedConfig,
+    isPluginExists: pluginStore.isPluginExists,
+    // Hooks
+    onExit: hooks.onExitHook.tap,
+    onAfterBuild: hooks.onAfterBuildHook.tap,
+    onBeforeBuild: hooks.onBeforeBuildHook.tap,
+    onDevCompileDone: hooks.onDevCompileDoneHook.tap,
+    modifyBundlerChain: hooks.modifyBundlerChainHook.tap,
+    modifyWebpackChain: hooks.modifyWebpackChainHook.tap,
+    modifyWebpackConfig: hooks.modifyWebpackConfigHook.tap,
+    modifyRsbuildConfig: hooks.modifyRsbuildConfigHook.tap,
+    onAfterCreateCompiler: hooks.onAfterCreateCompilerHook.tap,
+    onBeforeCreateCompiler: hooks.onBeforeCreateCompilerHook.tap,
+    onAfterStartDevServer: hooks.onAfterStartDevServerHook.tap,
+    onBeforeStartDevServer: hooks.onBeforeStartDevServerHook.tap
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPluginAPI
+});

package/dist/core/inspectConfig.d.ts

@@ -0,0 +1,20 @@
+import { InitConfigsOptions } from './initConfigs';
+import { InspectConfigOptions } from '@rsbuild/shared';
+import type { WebpackConfig } from '../types';
+export declare function inspectConfig({
+  context,
+  pluginStore,
+  rsbuildOptions,
+  bundlerConfigs,
+  inspectOptions
+}: InitConfigsOptions & {
+  inspectOptions?: InspectConfigOptions;
+  bundlerConfigs?: WebpackConfig[];
+}): Promise<{
+  rsbuildConfig: string;
+  bundlerConfigs: string[];
+  origin: {
+    rsbuildConfig: Readonly<import("../types").RsbuildConfig>;
+    bundlerConfigs: WebpackConfig[];
+  };
+}>;

package/dist/core/inspectConfig.js

@@ -0,0 +1,81 @@
+"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 inspectConfig_exports = {};
+__export(inspectConfig_exports, {
+  inspectConfig: () => inspectConfig
+});
+module.exports = __toCommonJS(inspectConfig_exports);
+var import_path = require("path");
+var import_initConfigs = require("./initConfigs");
+var import_shared = require("@rsbuild/shared");
+async function inspectConfig({
+  context,
+  pluginStore,
+  rsbuildOptions,
+  bundlerConfigs,
+  inspectOptions = {}
+}) {
+  if (inspectOptions.env) {
+    process.env.NODE_ENV = inspectOptions.env;
+  } else if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = "development";
+  }
+  const webpackConfigs = bundlerConfigs || (await (0, import_initConfigs.initConfigs)({
+    context,
+    pluginStore,
+    rsbuildOptions
+  })).webpackConfigs;
+  const rawRsbuildConfig = await (0, import_shared.stringifyConfig)(
+    context.config,
+    inspectOptions.verbose
+  );
+  const rawBundlerConfigs = await Promise.all(
+    webpackConfigs.map(
+      (config) => (0, import_shared.stringifyConfig)(config, inspectOptions.verbose)
+    )
+  );
+  let outputPath = inspectOptions.outputPath || context.distPath;
+  if (!(0, import_path.isAbsolute)(outputPath)) {
+    outputPath = (0, import_path.join)(context.rootPath, outputPath);
+  }
+  if (inspectOptions.writeToDisk) {
+    await (0, import_shared.outputInspectConfigFiles)({
+      rsbuildConfig: rawRsbuildConfig,
+      bundlerConfigs: rawBundlerConfigs,
+      inspectOptions: {
+        ...inspectOptions,
+        outputPath
+      },
+      rsbuildOptions,
+      configType: "webpack"
+    });
+  }
+  return {
+    rsbuildConfig: rawRsbuildConfig,
+    bundlerConfigs: rawBundlerConfigs,
+    origin: {
+      rsbuildConfig: context.config,
+      bundlerConfigs: webpackConfigs
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inspectConfig
+});

package/dist/core/startDevServer.d.ts

@@ -0,0 +1,5 @@
+import { StartDevServerOptions } from '@rsbuild/shared';
+import { InitConfigsOptions } from './initConfigs';
+import type { Compiler, MultiCompiler } from 'webpack';
+export declare function createDevServer(options: InitConfigsOptions, port: number, serverOptions: Exclude<StartDevServerOptions['serverOptions'], undefined>, customCompiler?: Compiler | MultiCompiler): Promise<import("@modern-js/server").Server>;
+export declare function startDevServer(options: InitConfigsOptions, startDevServerOptions?: StartDevServerOptions): Promise<import("@rsbuild/shared").StartServerResult>;

package/dist/core/startDevServer.js

@@ -0,0 +1,75 @@
+"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 startDevServer_exports = {};
+__export(startDevServer_exports, {
+  createDevServer: () => createDevServer,
+  startDevServer: () => startDevServer
+});
+module.exports = __toCommonJS(startDevServer_exports);
+var import_shared = require("@rsbuild/shared");
+var import_createCompiler = require("./createCompiler");
+var import_initConfigs = require("./initConfigs");
+var import_devMiddleware = require("./devMiddleware");
+async function createDevServer(options, port, serverOptions, customCompiler) {
+  const { Server } = await Promise.resolve().then(() => __toESM(require("@modern-js/server")));
+  let compiler;
+  if (customCompiler) {
+    compiler = customCompiler;
+  } else {
+    const { webpackConfigs } = await (0, import_initConfigs.initConfigs)(options);
+    compiler = await (0, import_createCompiler.createCompiler)({
+      context: options.context,
+      webpackConfigs
+    });
+  }
+  (0, import_shared.debug)("create dev server");
+  const rsbuildConfig = options.context.config;
+  const { config, devConfig } = await (0, import_shared.getDevServerOptions)({
+    rsbuildConfig,
+    serverOptions,
+    port
+  });
+  const server = new Server({
+    pwd: options.context.rootPath,
+    devMiddleware: (0, import_devMiddleware.getDevMiddleware)(compiler),
+    ...serverOptions,
+    dev: devConfig,
+    config
+  });
+  (0, import_shared.debug)("create dev server done");
+  return server;
+}
+async function startDevServer(options, startDevServerOptions = {}) {
+  return (0, import_shared.startDevServer)(options, createDevServer, startDevServerOptions);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDevServer,
+  startDevServer
+});

package/dist/core/webpackConfig.d.ts

@@ -0,0 +1,9 @@
+import { type RsbuildTarget } from '@rsbuild/shared';
+import type { Context, WebpackConfig } from '../types';
+export declare function generateWebpackConfig({
+  target,
+  context
+}: {
+  target: RsbuildTarget;
+  context: Context;
+}): Promise<WebpackConfig>;