@rsbuild/core 0.0.0-next-20231103091827

package/dist/rspack-provider/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/rspack-provider/core/initPlugins.js

@@ -0,0 +1,82 @@
+"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,
+    modifyRspackConfig: hooks.modifyRspackConfigHook.tap,
+    modifyRsbuildConfig: hooks.modifyRsbuildConfigHook.tap,
+    modifyBundlerChain: hooks.modifyBundlerChainHook.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/rspack-provider/core/inspectConfig.d.ts

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

package/dist/rspack-provider/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 rspackConfigs = bundlerConfigs || (await (0, import_initConfigs.initConfigs)({
+    context,
+    pluginStore,
+    rsbuildOptions
+  })).rspackConfigs;
+  const rawRsbuildConfig = await (0, import_shared.stringifyConfig)(
+    context.config,
+    inspectOptions.verbose
+  );
+  const rawBundlerConfigs = await Promise.all(
+    rspackConfigs.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: "rspack"
+    });
+  }
+  return {
+    rsbuildConfig: rawRsbuildConfig,
+    bundlerConfigs: rawBundlerConfigs,
+    origin: {
+      rsbuildConfig: context.config,
+      bundlerConfigs: rspackConfigs
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inspectConfig
+});

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

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

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

@@ -0,0 +1,137 @@
+"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 rspackConfig_exports = {};
+__export(rspackConfig_exports, {
+  generateRspackConfig: () => generateRspackConfig
+});
+module.exports = __toCommonJS(rspackConfig_exports);
+var import_shared = require("@rsbuild/shared");
+var import_shared2 = require("../shared");
+async function modifyRspackConfig(context, rspackConfig, utils) {
+  var _a;
+  (0, import_shared.debug)("modify Rspack config");
+  let [modifiedConfig] = await context.hooks.modifyRspackConfigHook.call(
+    rspackConfig,
+    utils
+  );
+  if ((_a = context.config.tools) == null ? void 0 : _a.rspack) {
+    modifiedConfig = (0, import_shared.mergeChainedOptions)(
+      modifiedConfig,
+      context.config.tools.rspack,
+      utils,
+      utils.mergeConfig
+    );
+  }
+  (0, import_shared.debug)("modify Rspack config done");
+  return modifiedConfig;
+}
+async function getConfigUtils(config, chainUtils) {
+  const { merge } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/webpack-merge")));
+  const { default: rspack } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
+  return {
+    ...chainUtils,
+    rspack,
+    mergeConfig: merge,
+    addRules(rules) {
+      const ruleArr = (0, import_shared.castArray)(rules);
+      if (!config.module) {
+        config.module = {};
+      }
+      if (!config.module.rules) {
+        config.module.rules = [];
+      }
+      config.module.rules.unshift(...ruleArr);
+    },
+    prependPlugins(plugins) {
+      const pluginArr = (0, import_shared.castArray)(plugins);
+      if (!config.plugins) {
+        config.plugins = [];
+      }
+      config.plugins.unshift(...pluginArr);
+    },
+    appendPlugins(plugins) {
+      const pluginArr = (0, import_shared.castArray)(plugins);
+      if (!config.plugins) {
+        config.plugins = [];
+      }
+      config.plugins.push(...pluginArr);
+    },
+    removePlugin(pluginName) {
+      if (config.plugins) {
+        config.plugins = config.plugins.filter((p) => p.name !== pluginName);
+      }
+    }
+  };
+}
+async function getChainUtils(target) {
+  const nodeEnv = process.env.NODE_ENV;
+  const { default: HtmlPlugin } = await Promise.resolve().then(() => __toESM(require("html-webpack-plugin")));
+  const { default: webpack } = await Promise.resolve().then(() => __toESM(require("webpack")));
+  return {
+    env: nodeEnv,
+    target,
+    isProd: nodeEnv === "production",
+    isServer: target === "node",
+    isServiceWorker: target === "service-worker",
+    isWebWorker: target === "web-worker",
+    getCompiledPath: import_shared2.getCompiledPath,
+    CHAIN_ID: import_shared.CHAIN_ID,
+    HtmlPlugin,
+    webpack
+  };
+}
+const convertToRspackConfig = (config) => {
+  return config;
+};
+async function generateRspackConfig({
+  target,
+  context
+}) {
+  const chainUtils = await getChainUtils(target);
+  const { BannerPlugin, DefinePlugin, ProvidePlugin } = await Promise.resolve().then(() => __toESM(require("@rspack/core")));
+  const chain = await (0, import_shared.modifyBundlerChain)(context, {
+    ...chainUtils,
+    bundler: {
+      BannerPlugin,
+      DefinePlugin,
+      ProvidePlugin
+    }
+  });
+  let rspackConfig = convertToRspackConfig(chain.toConfig());
+  rspackConfig = await modifyRspackConfig(
+    context,
+    rspackConfig,
+    await getConfigUtils(rspackConfig, chainUtils)
+  );
+  return rspackConfig;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateRspackConfig
+});

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

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

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

@@ -0,0 +1,84 @@
+"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_devMiddleware = require("./devMiddleware");
+var import_initConfigs = require("./initConfigs");
+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 { rspackConfigs } = await (0, import_initConfigs.initConfigs)(options);
+    compiler = await (0, import_createCompiler.createCompiler)({
+      context: options.context,
+      rspackConfigs
+    });
+  }
+  (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,
+    (options2, port, serverOptions, compiler) => createDevServer(
+      options2,
+      port,
+      serverOptions,
+      compiler
+    ),
+    startDevServerOptions
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDevServer,
+  startDevServer
+});

package/dist/rspack-provider/index.d.ts

@@ -0,0 +1,5 @@
+export { getRspackVersion } from './shared/rspackVersion';
+export { rspackProvider } from './provider';
+export type { RspackProvider } from './provider';
+export type { RsbuildConfig, NormalizedConfig, ModifyRspackConfigFn, RsbuildPluginAPI } from './types';
+export type { Rspack, RspackConfig } from '@rsbuild/shared';

package/dist/rspack-provider/index.js

@@ -0,0 +1,31 @@
+"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 rspack_provider_exports = {};
+__export(rspack_provider_exports, {
+  getRspackVersion: () => import_rspackVersion.getRspackVersion,
+  rspackProvider: () => import_provider.rspackProvider
+});
+module.exports = __toCommonJS(rspack_provider_exports);
+var import_rspackVersion = require("./shared/rspackVersion");
+var import_provider = require("./provider");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRspackVersion,
+  rspackProvider
+});

package/dist/rspack-provider/plugins/basic.d.ts

@@ -0,0 +1,5 @@
+import type { RsbuildPlugin } from '../types';
+/**
+ * Provide some basic configs of rspack
+ */
+export declare const pluginBasic: () => RsbuildPlugin;

package/dist/rspack-provider/plugins/basic.js

@@ -0,0 +1,34 @@
+"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 basic_exports = {};
+__export(basic_exports, {
+  pluginBasic: () => pluginBasic
+});
+module.exports = __toCommonJS(basic_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginBasic = () => ({
+  name: "plugin-basic",
+  setup(api) {
+    (0, import_shared.applyBasicPlugin)(api);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginBasic
+});

package/dist/rspack-provider/plugins/css.d.ts

@@ -0,0 +1,29 @@
+import { type BundlerChain, type Context, type RspackRule, type ModifyBundlerChainUtils } from '@rsbuild/shared';
+import type { RsbuildPlugin, NormalizedConfig } from '../types';
+export declare const enableNativeCss: (config: NormalizedConfig) => boolean;
+export declare function applyBaseCSSRule({
+  rule,
+  config,
+  context,
+  utils: {
+    target,
+    isProd,
+    isServer,
+    isWebWorker,
+    CHAIN_ID
+  },
+  importLoaders
+}: {
+  rule: ReturnType<BundlerChain['module']['rule']>;
+  config: NormalizedConfig;
+  context: Context;
+  utils: ModifyBundlerChainUtils;
+  importLoaders?: number;
+}): Promise<void>;
+/**
+ * Use type: "css/module" rule instead of css-loader modules.auto config
+ *
+ * applyCSSModuleRule in modifyRspackConfig, so that other plugins can easily adjust css rule in Chain.
+ */
+export declare const applyCSSModuleRule: (rules: RspackRule[] | undefined, ruleTest: RegExp, config: NormalizedConfig) => void;
+export declare const pluginCss: () => RsbuildPlugin;