@rsbuild/core 0.0.0-next-20231103091827

package/dist/rspack-provider/rspackLoader/css-modules-typescript-pre-loader/index.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 css_modules_typescript_pre_loader_exports = {};
+__export(css_modules_typescript_pre_loader_exports, {
+  default: () => css_modules_typescript_pre_loader_default
+});
+module.exports = __toCommonJS(css_modules_typescript_pre_loader_exports);
+var import_css_modules_typescript_loader = __toESM(require("@rsbuild/shared/css-modules-typescript-loader"));
+var import_shared = require("@rsbuild/shared");
+async function processCss(inputSource, {
+  exportLocalsConvention
+}) {
+  const { default: postcss } = await Promise.resolve().then(() => __toESM(require("postcss")));
+  const { default: localByDefault } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/postcss-modules-local-by-default")));
+  const { default: modulesScope } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/postcss-modules-scope")));
+  const { default: postcssICSSExtractPlugin } = await Promise.resolve().then(() => __toESM(require("./postcss-icss-extract-plugin")));
+  const { default: extractImports } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/postcss-modules-extract-imports")));
+  const { default: modulesValues } = await Promise.resolve().then(() => __toESM(require("@rsbuild/shared/postcss-modules-values")));
+  const parserOptions = {
+    exportLocalsConvention
+  };
+  const pipeline = postcss([
+    localByDefault({
+      mode: "local"
+    }),
+    extractImports(),
+    modulesValues,
+    modulesScope({
+      // scopedName is not important in this scenario
+      generateScopedName: (exportName) => exportName,
+      exportGlobals: false
+    }),
+    postcssICSSExtractPlugin(parserOptions)
+  ]);
+  await pipeline.process(inputSource, {
+    from: `/fake-css-modules-loader`,
+    to: void 0
+  });
+  return {
+    cssModuleKeys: parserOptions.cssModuleKeys
+  };
+}
+async function css_modules_typescript_pre_loader_default(content, ...input) {
+  if (this.cacheable) {
+    this.cacheable();
+  }
+  const filename = this.resourcePath;
+  const { modules } = this.getOptions() || {};
+  const callback = this.async();
+  if (!(0, import_shared.isCssModules)(filename, modules) || (0, import_shared.isInNodeModules)(filename)) {
+    return callback(null, content, ...input);
+  }
+  const { cssModuleKeys } = await processCss(content, {
+    exportLocalsConvention: modules.exportLocalsConvention
+  });
+  this.cssModuleKeys = cssModuleKeys;
+  return import_css_modules_typescript_loader.default.call(this, content, ...input);
+}

package/dist/rspack-provider/rspackLoader/css-modules-typescript-pre-loader/postcss-icss-extract-plugin.d.ts

@@ -0,0 +1,11 @@
+import type { CssModuleLocalsConvention } from '@rsbuild/shared';
+import type { AcceptedPlugin as PostCSSPlugin } from 'postcss';
+export type PostcssParsePluginOptions = {
+  exportLocalsConvention: CssModuleLocalsConvention;
+  cssModuleKeys: string[];
+};
+declare const plugin: {
+  (options: PostcssParsePluginOptions): PostCSSPlugin;
+  postcss: boolean;
+};
+export default plugin;

package/dist/rspack-provider/rspackLoader/css-modules-typescript-pre-loader/postcss-icss-extract-plugin.js

@@ -0,0 +1,67 @@
+"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 postcss_icss_extract_plugin_exports = {};
+__export(postcss_icss_extract_plugin_exports, {
+  default: () => postcss_icss_extract_plugin_default
+});
+module.exports = __toCommonJS(postcss_icss_extract_plugin_exports);
+var import_icss_utils = require("@rsbuild/shared/icss-utils");
+var import_lodash = require("lodash");
+const dashesCamelCase = (str) => str.replace(/-+(\w)/g, (_match, firstLetter) => firstLetter.toUpperCase());
+const getExportLocalsConvention = (name, exportLocalsConventionType) => {
+  switch (exportLocalsConventionType) {
+    case "camelCase": {
+      const camelName = (0, import_lodash.camelCase)(name);
+      return camelName === name ? [name] : [name, (0, import_lodash.camelCase)(name)];
+    }
+    case "camelCaseOnly": {
+      return [(0, import_lodash.camelCase)(name)];
+    }
+    case "dashes": {
+      const dashesCamelName = dashesCamelCase(name);
+      return dashesCamelName === name ? [name] : [name, dashesCamelCase(name)];
+    }
+    case "dashesOnly": {
+      return [dashesCamelCase(name)];
+    }
+    case "asIs":
+    default:
+      return [name];
+  }
+};
+const plugin = (options) => {
+  return {
+    postcssPlugin: "postcss-icss-extract",
+    OnceExit(root) {
+      const { icssExports } = (0, import_icss_utils.extractICSS)(root);
+      const cssModuleKeys = Object.keys(icssExports).reduce(
+        (total, key) => {
+          total.push(
+            ...getExportLocalsConvention(key, options.exportLocalsConvention)
+          );
+          return total;
+        },
+        []
+      );
+      options.cssModuleKeys = cssModuleKeys;
+    }
+  };
+};
+plugin.postcss = true;
+var postcss_icss_extract_plugin_default = plugin;

package/dist/rspack-provider/rspackPlugin/removeCssSourcemapPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { Compiler } from '@rspack/core';
+import type HtmlPlugin from 'html-webpack-plugin';
+export declare class RemoveCssSourcemapPlugin {
+  name: string;
+  htmlPlugin: typeof HtmlPlugin;
+  constructor(htmlPlugin: typeof HtmlPlugin);
+  apply(compiler: Compiler): void;
+}

package/dist/rspack-provider/rspackPlugin/removeCssSourcemapPlugin.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 removeCssSourcemapPlugin_exports = {};
+__export(removeCssSourcemapPlugin_exports, {
+  RemoveCssSourcemapPlugin: () => RemoveCssSourcemapPlugin
+});
+module.exports = __toCommonJS(removeCssSourcemapPlugin_exports);
+var import_shared = require("@rsbuild/shared");
+class RemoveCssSourcemapPlugin {
+  constructor(htmlPlugin) {
+    this.name = "RemoveCssSourcemapPlugin";
+    this.htmlPlugin = htmlPlugin;
+  }
+  apply(compiler) {
+    compiler.hooks.compilation.tap(this.name, (compilation) => {
+      compilation.hooks.processAssets.tap(
+        {
+          name: this.name,
+          stage: import_shared.COMPILATION_PROCESS_STAGE.PROCESS_ASSETS_STAGE_SUMMARIZE
+        },
+        () => {
+          Object.keys(compilation.assets).forEach((name) => {
+            if (name.endsWith(".css.map")) {
+              compilation.deleteAsset(name);
+            }
+          });
+        }
+      );
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RemoveCssSourcemapPlugin
+});

package/dist/rspack-provider/shared/constants.d.ts

@@ -0,0 +1 @@
+export declare const BUILTIN_LOADER = "builtin:";

package/dist/rspack-provider/shared/constants.js

@@ -0,0 +1,28 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  BUILTIN_LOADER: () => BUILTIN_LOADER
+});
+module.exports = __toCommonJS(constants_exports);
+const BUILTIN_LOADER = "builtin:";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUILTIN_LOADER
+});

package/dist/rspack-provider/shared/fs.d.ts

@@ -0,0 +1 @@
+export declare const getCompiledPath: (packageName: string) => string;

package/dist/rspack-provider/shared/fs.js

@@ -0,0 +1,38 @@
+"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 fs_exports = {};
+__export(fs_exports, {
+  getCompiledPath: () => getCompiledPath
+});
+module.exports = __toCommonJS(fs_exports);
+var import_path = require("path");
+var import_shared = require("@rsbuild/shared");
+var import_fs_extra = require("@rsbuild/shared/fs-extra");
+const getCompiledPath = (packageName) => {
+  const providerCompilerPath = (0, import_path.join)(__dirname, "../../compiled", packageName);
+  if (import_fs_extra.fs.existsSync(providerCompilerPath)) {
+    return providerCompilerPath;
+  } else {
+    return (0, import_shared.getSharedPkgCompiledPath)(packageName);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCompiledPath
+});

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

@@ -0,0 +1,3 @@
+export * from './fs';
+export * from './constants';
+export * from './rspackVersion';

package/dist/rspack-provider/shared/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var shared_exports = {};
+module.exports = __toCommonJS(shared_exports);
+__reExport(shared_exports, require("./fs"), module.exports);
+__reExport(shared_exports, require("./constants"), module.exports);
+__reExport(shared_exports, require("./rspackVersion"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./fs"),
+  ...require("./constants"),
+  ...require("./rspackVersion")
+});

package/dist/rspack-provider/shared/plugin.d.ts

@@ -0,0 +1,3 @@
+import { RsbuildPlugin } from '../types';
+import { Plugins } from '@rsbuild/shared';
+export declare const applyDefaultPlugins: (plugins: Plugins) => import("@rsbuild/shared").AwaitableGetter<RsbuildPlugin>;

package/dist/rspack-provider/shared/plugin.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 plugin_exports = {};
+__export(plugin_exports, {
+  applyDefaultPlugins: () => applyDefaultPlugins
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_shared = require("@rsbuild/shared");
+const applyDefaultPlugins = (plugins) => (0, import_shared.awaitableGetter)([
+  Promise.resolve().then(() => __toESM(require("../plugins/transition"))).then((m) => m.pluginTransition()),
+  Promise.resolve().then(() => __toESM(require("../plugins/basic"))).then((m) => m.pluginBasic()),
+  plugins.entry(),
+  // plugins.cache(),
+  plugins.target(),
+  Promise.resolve().then(() => __toESM(require("../plugins/output"))).then((m) => m.pluginOutput()),
+  plugins.devtool(),
+  Promise.resolve().then(() => __toESM(require("../plugins/resolve"))).then((m) => m.pluginResolve()),
+  plugins.fileSize(),
+  // cleanOutput plugin should before the html plugin
+  plugins.cleanOutput(),
+  plugins.font(),
+  plugins.image(),
+  plugins.media(),
+  plugins.svg(),
+  plugins.html(),
+  plugins.wasm(),
+  plugins.moment(),
+  plugins.nodeAddons(),
+  plugins.define(),
+  Promise.resolve().then(() => __toESM(require("../plugins/css"))).then((m) => m.pluginCss()),
+  Promise.resolve().then(() => __toESM(require("../plugins/less"))).then((m) => m.pluginLess()),
+  Promise.resolve().then(() => __toESM(require("../plugins/sass"))).then((m) => m.pluginSass()),
+  Promise.resolve().then(() => __toESM(require("../plugins/minimize"))).then((m) => m.pluginMinimize()),
+  Promise.resolve().then(() => __toESM(require("../plugins/manifest"))).then((m) => m.pluginManifest()),
+  plugins.rem(),
+  Promise.resolve().then(() => __toESM(require("../plugins/hmr"))).then((m) => m.pluginHMR()),
+  Promise.resolve().then(() => __toESM(require("../plugins/progress"))).then((m) => m.pluginProgress()),
+  Promise.resolve().then(() => __toESM(require("../plugins/swc"))).then((m) => m.pluginSwc()),
+  plugins.externals(),
+  plugins.toml(),
+  plugins.yaml(),
+  plugins.splitChunks(),
+  plugins.startUrl(),
+  plugins.inlineChunk(),
+  plugins.bundleAnalyzer(),
+  plugins.assetsRetry(),
+  plugins.networkPerformance(),
+  plugins.preloadOrPrefetch(),
+  plugins.performance(),
+  Promise.resolve().then(() => __toESM(require("../plugins/rspack-profile"))).then((m) => m.pluginRspackProfile()),
+  Promise.resolve().then(() => __toESM(require("../plugins/fallback"))).then((m) => m.pluginFallback())
+  // fallback should be the last plugin
+]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyDefaultPlugins
+});

package/dist/rspack-provider/shared/rspackVersion.d.ts

@@ -0,0 +1,3 @@
+export declare const getRspackVersion: () => Promise<string>;
+export declare const supportedRspackMinimumVersion = "0.3.6";
+export declare const isSatisfyRspackMinimumVersion: (customVersion?: string) => Promise<boolean>;

package/dist/rspack-provider/shared/rspackVersion.js

@@ -0,0 +1,61 @@
+"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 rspackVersion_exports = {};
+__export(rspackVersion_exports, {
+  getRspackVersion: () => getRspackVersion,
+  isSatisfyRspackMinimumVersion: () => isSatisfyRspackMinimumVersion,
+  supportedRspackMinimumVersion: () => supportedRspackMinimumVersion
+});
+module.exports = __toCommonJS(rspackVersion_exports);
+var import_path = __toESM(require("path"));
+const getRspackVersion = async () => {
+  try {
+    const core = require.resolve("@rspack/core");
+    const pkg = await Promise.resolve().then(() => __toESM(require(import_path.default.join(core, "../../package.json"))));
+    return pkg == null ? void 0 : pkg.version;
+  } catch (err) {
+    console.error(err);
+    return "";
+  }
+};
+const supportedRspackMinimumVersion = "0.3.6";
+const isSatisfyRspackMinimumVersion = async (customVersion) => {
+  let version = customVersion || await getRspackVersion();
+  const semver = await Promise.resolve().then(() => __toESM(require("semver")));
+  if (version.includes("-canary")) {
+    version = version.split("-canary")[0];
+  }
+  return version ? semver.lte(supportedRspackMinimumVersion, version) : true;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRspackVersion,
+  isSatisfyRspackMinimumVersion,
+  supportedRspackMinimumVersion
+});

package/dist/rspack-provider/types/context.d.ts

@@ -0,0 +1,16 @@
+import type { Context as BaseContext, RsbuildConfig, NormalizedConfig } from '@rsbuild/shared';
+import type { Hooks } from '../core/initHooks';
+import type { RsbuildPluginAPI } from './plugin';
+/** The inner context. */
+export type Context = BaseContext & {
+  /** All hooks. */
+  hooks: Readonly<Hooks>;
+  /** Current Rsbuild config. */
+  config: Readonly<RsbuildConfig>;
+  /** The original Rsbuild config passed from the createRsbuild method. */
+  originalConfig: Readonly<RsbuildConfig>;
+  /** The normalized Rsbuild config. */
+  normalizedConfig?: NormalizedConfig;
+  /** The plugin API. */
+  pluginAPI?: RsbuildPluginAPI;
+};

package/dist/rspack-provider/types/context.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 context_exports = {};
+module.exports = __toCommonJS(context_exports);

package/dist/rspack-provider/types/hooks.d.ts

@@ -0,0 +1,3 @@
+import type { ModifyRspackConfigUtils } from '@rsbuild/shared';
+import type { RspackConfig } from '@rsbuild/shared';
+export type ModifyRspackConfigFn = (config: RspackConfig, utils: ModifyRspackConfigUtils) => Promise<RspackConfig | void> | RspackConfig | void;

package/dist/rspack-provider/types/hooks.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 hooks_exports = {};
+module.exports = __toCommonJS(hooks_exports);

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

@@ -0,0 +1,4 @@
+export * from './hooks';
+export * from './plugin';
+export * from './context';
+export type { RsbuildConfig, NormalizedConfig, DevConfig, HtmlConfig, ToolsConfig, SourceConfig, OutputConfig, SecurityConfig, PerformanceConfig, NormalizedDevConfig, NormalizedHtmlConfig, NormalizedToolsConfig, NormalizedSourceConfig, NormalizedOutputConfig, NormalizedSecurityConfig, NormalizedPerformanceConfig } from '@rsbuild/shared';

package/dist/rspack-provider/types/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./hooks"), module.exports);
+__reExport(types_exports, require("./plugin"), module.exports);
+__reExport(types_exports, require("./context"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./hooks"),
+  ...require("./plugin"),
+  ...require("./context")
+});

package/dist/rspack-provider/types/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { RsbuildConfig, NormalizedConfig, DefaultRsbuildPluginAPI, RsbuildPlugin as BaseRsbuildPlugin } from '@rsbuild/shared';
+import type { ModifyRspackConfigFn } from './hooks';
+import type { RspackConfig, RspackCompiler, RspackMultiCompiler } from '@rsbuild/shared';
+export interface RsbuildPluginAPI extends DefaultRsbuildPluginAPI<RsbuildConfig, NormalizedConfig, RspackConfig, RspackCompiler | RspackMultiCompiler> {
+  modifyRspackConfig: (fn: ModifyRspackConfigFn) => void;
+}
+export type RsbuildPlugin = BaseRsbuildPlugin<RsbuildPluginAPI>;

package/dist/rspack-provider/types/plugin.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 plugin_exports = {};
+module.exports = __toCommonJS(plugin_exports);

package/dist/utils/generateMetaTags.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Copyright JS Foundation and other contributors.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file at
+ * https://github.com/jantimon/html-webpack-plugin/blob/main/LICENSE
+ *
+ * Modified from https://github.com/jantimon/html-webpack-plugin/blob/2f5de7ab9e8bca60e9e200f2e4b4cfab90db28d4/index.js#L800
+ */
+import type { MetaOptions } from '@rsbuild/shared';
+import type { HtmlTagObject } from 'html-webpack-plugin';
+export declare const generateMetaTags: (metaOptions?: MetaOptions) => HtmlTagObject[];