@rsbuild/core 0.0.0-next-20231103091827

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

@@ -0,0 +1,55 @@
+"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 resolve_exports = {};
+__export(resolve_exports, {
+  pluginResolve: () => pluginResolve
+});
+module.exports = __toCommonJS(resolve_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginResolve = () => ({
+  name: "plugin-resolve",
+  setup(api) {
+    (0, import_shared.applyResolvePlugin)(api);
+    api.modifyBundlerChain(async (chain, { CHAIN_ID }) => {
+      const config = api.getNormalizedConfig();
+      if (chain.module.rules.get(CHAIN_ID.RULE.JS_DATA_URI) && config.source.compileJsDataURI) {
+        chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).resolve.set("fullySpecified", false);
+      }
+    });
+    api.modifyRspackConfig(async (rspackConfig, { isServer }) => {
+      const isTsProject = Boolean(api.context.tsconfigPath);
+      const config = api.getNormalizedConfig();
+      if (isTsProject && config.source.aliasStrategy === "prefer-tsconfig") {
+        (0, import_shared.setConfig)(
+          rspackConfig,
+          "resolve.tsConfigPath",
+          api.context.tsconfigPath
+        );
+      }
+      if (isServer) {
+        const nodeConditionNames = ["require", "node"];
+        (0, import_shared.setConfig)(rspackConfig, "resolve.conditionNames", nodeConditionNames);
+      }
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginResolve
+});

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

@@ -0,0 +1,4 @@
+import type { RsbuildPlugin } from '../types';
+import inspector from 'inspector';
+export declare const stopProfiler: (output: string, profileSession?: inspector.Session) => void;
+export declare const pluginRspackProfile: () => RsbuildPlugin;

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

@@ -0,0 +1,107 @@
+"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 rspack_profile_exports = {};
+__export(rspack_profile_exports, {
+  pluginRspackProfile: () => pluginRspackProfile,
+  stopProfiler: () => stopProfiler
+});
+module.exports = __toCommonJS(rspack_profile_exports);
+var import_path = __toESM(require("path"));
+var import_core = require("@rspack/core");
+var import_inspector = __toESM(require("inspector"));
+var import_fs_extra = require("@rsbuild/shared/fs-extra");
+var import_shared = require("@rsbuild/shared");
+const stopProfiler = (output, profileSession) => {
+  if (!profileSession) {
+    return;
+  }
+  profileSession.post("Profiler.stop", (error, param) => {
+    if (error) {
+      import_shared.logger.error("Failed to generate JS CPU profile:", error);
+      return;
+    }
+    import_fs_extra.fs.writeFileSync(output, JSON.stringify(param.profile));
+  });
+};
+const pluginRspackProfile = () => ({
+  name: "plugin-rspack-profile",
+  setup(api) {
+    var _a;
+    const RSPACK_PROFILE = (_a = process.env.RSPACK_PROFILE) == null ? void 0 : _a.toUpperCase();
+    if (!RSPACK_PROFILE) {
+      return;
+    }
+    const timestamp = Date.now();
+    const profileDir = import_path.default.join(
+      api.context.distPath,
+      `rspack-profile-${timestamp}`
+    );
+    let profileSession;
+    const enableProfileTrace = RSPACK_PROFILE === "ALL" || RSPACK_PROFILE.includes("TRACE");
+    const enableCPUProfile = RSPACK_PROFILE === "ALL" || RSPACK_PROFILE.includes("CPU");
+    const enableLogging = RSPACK_PROFILE === "ALL" || RSPACK_PROFILE.includes("LOGGING");
+    const traceFilePath = import_path.default.join(profileDir, "trace.json");
+    const cpuProfilePath = import_path.default.join(profileDir, "jscpuprofile.json");
+    const loggingFilePath = import_path.default.join(profileDir, "logging.json");
+    const onStart = () => {
+      import_fs_extra.fs.ensureDirSync(profileDir);
+      if (enableProfileTrace) {
+        (0, import_core.experimental_registerGlobalTrace)("trace", "chrome", traceFilePath);
+      }
+      if (enableCPUProfile) {
+        profileSession = new import_inspector.default.Session();
+        profileSession.connect();
+        profileSession.post("Profiler.enable");
+        profileSession.post("Profiler.start");
+      }
+    };
+    api.onBeforeBuild(onStart);
+    api.onBeforeStartDevServer(onStart);
+    api.onAfterBuild(async ({ stats }) => {
+      if (enableLogging && stats) {
+        const logging = stats.toJson({
+          all: false,
+          logging: "verbose",
+          loggingTrace: true
+        });
+        import_fs_extra.fs.writeFileSync(loggingFilePath, JSON.stringify(logging));
+      }
+    });
+    api.onExit(() => {
+      enableProfileTrace && (0, import_core.experimental_cleanupGlobalTrace)();
+      stopProfiler(cpuProfilePath, profileSession);
+      import_shared.logger.info(`Saved Rspack profile file to ${profileDir}`);
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginRspackProfile,
+  stopProfiler
+});

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

@@ -0,0 +1,2 @@
+import type { RsbuildPlugin } from '../types';
+export declare function pluginSass(): RsbuildPlugin;

package/dist/rspack-provider/plugins/sass.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 sass_exports = {};
+__export(sass_exports, {
+  pluginSass: () => pluginSass
+});
+module.exports = __toCommonJS(sass_exports);
+var import_shared = require("@rsbuild/shared");
+function pluginSass() {
+  return {
+    name: "plugin-sass",
+    async setup(api) {
+      api.onAfterCreateCompiler(({ compiler }) => {
+        (0, import_shared.patchCompilerGlobalLocation)(compiler);
+      });
+      api.modifyBundlerChain(async (chain, utils) => {
+        const config = api.getNormalizedConfig();
+        const { applyBaseCSSRule } = await Promise.resolve().then(() => __toESM(require("./css")));
+        const { excludes, options } = await (0, import_shared.getSassLoaderOptions)(
+          config.tools.sass,
+          // source-maps required for loaders preceding resolve-url-loader
+          true
+        );
+        const rule = chain.module.rule(utils.CHAIN_ID.RULE.SASS).test(import_shared.SASS_REGEX);
+        excludes.forEach((item) => {
+          rule.exclude.add(item);
+        });
+        await applyBaseCSSRule({
+          rule,
+          utils,
+          config,
+          context: api.context,
+          // postcss-loader, resolve-url-loader, sass-loader
+          importLoaders: 3
+        });
+        rule.use(utils.CHAIN_ID.USE.RESOLVE_URL_LOADER_FOR_SASS).loader(utils.getCompiledPath("resolve-url-loader")).options({
+          join: await (0, import_shared.getResolveUrlJoinFn)(),
+          // 'resolve-url-loader' relies on 'adjust-sourcemap-loader',
+          // it has performance regression issues in some scenarios,
+          // so we need to disable the sourceMap option.
+          sourceMap: false
+        }).end().use(utils.CHAIN_ID.USE.SASS).loader(utils.getCompiledPath("sass-loader")).options(options);
+      });
+      api.modifyRspackConfig(async (rspackConfig) => {
+        var _a;
+        const { applyCSSModuleRule } = await Promise.resolve().then(() => __toESM(require("./css")));
+        const config = api.getNormalizedConfig();
+        const rules = (_a = rspackConfig.module) == null ? void 0 : _a.rules;
+        applyCSSModuleRule(rules, import_shared.SASS_REGEX, config);
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginSass
+});

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

@@ -0,0 +1,7 @@
+import { type RsbuildTarget, type BuiltinSwcLoaderOptions } from '@rsbuild/shared';
+import type { RsbuildPlugin, NormalizedConfig } from '../types';
+export declare function getDefaultSwcConfig(config: NormalizedConfig, rootPath: string, target: RsbuildTarget): Promise<BuiltinSwcLoaderOptions>;
+/**
+ * Provide some swc configs of rspack
+ */
+export declare const pluginSwc: () => RsbuildPlugin;

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

@@ -0,0 +1,151 @@
+"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 swc_exports = {};
+__export(swc_exports, {
+  getDefaultSwcConfig: () => getDefaultSwcConfig,
+  pluginSwc: () => pluginSwc
+});
+module.exports = __toCommonJS(swc_exports);
+var import_shared = require("@rsbuild/shared");
+var import_lodash = require("lodash");
+var path = __toESM(require("path"));
+const builtinSwcLoaderName = "builtin:swc-loader";
+async function getDefaultSwcConfig(config, rootPath, target) {
+  return {
+    jsc: {
+      externalHelpers: true,
+      parser: {
+        tsx: true,
+        syntax: "typescript",
+        decorators: true
+      }
+      // TODO: Enabling it will cause performance degradation
+      // Avoid the webpack magic comment to be removed
+      // https://github.com/swc-project/swc/issues/6403
+      // preserveAllComments: true,
+    },
+    isModule: "unknown",
+    minify: false,
+    // for loader, we don't need to minify, we do minification using plugin
+    env: {
+      targets: await (0, import_shared.getBrowserslistWithDefault)(rootPath, config, target)
+    },
+    sourceMaps: (0, import_shared.isUseJsSourceMap)(config),
+    exclude: [],
+    inlineSourcesContent: true
+  };
+}
+const pluginSwc = () => ({
+  name: "plugin-swc",
+  setup(api) {
+    api.modifyBundlerChain(
+      async (chain, { CHAIN_ID, target, isServer, isServiceWorker }) => {
+        const config = api.getNormalizedConfig();
+        (0, import_shared.addCoreJsEntry)({
+          chain,
+          config,
+          isServer,
+          isServiceWorker
+        });
+        const rule = chain.module.rule(CHAIN_ID.RULE.JS).test((0, import_shared.mergeRegex)(import_shared.JS_REGEX, import_shared.TS_REGEX)).type("javascript/auto");
+        (0, import_shared.applyScriptCondition)({
+          rule,
+          config,
+          context: api.context,
+          includes: [],
+          excludes: []
+        });
+        const swcConfig = await getDefaultSwcConfig(
+          config,
+          api.context.rootPath,
+          target
+        );
+        applyTransformImport(swcConfig, config.source.transformImport);
+        applyDecorator(swcConfig, config.output.enableLatestDecorators);
+        if ((0, import_shared.isWebTarget)(target)) {
+          const polyfillMode = config.output.polyfill;
+          if (polyfillMode === "off" || polyfillMode === "ua") {
+            swcConfig.env.mode = void 0;
+          } else {
+            swcConfig.env.mode = polyfillMode;
+            await applyCoreJs(swcConfig, chain, rule, polyfillMode);
+          }
+        }
+        rule.use(CHAIN_ID.USE.SWC).loader(builtinSwcLoaderName).options(swcConfig);
+        if (config.source.compileJsDataURI) {
+          chain.module.rule(CHAIN_ID.RULE.JS_DATA_URI).mimetype({
+            or: ["text/javascript", "application/javascript"]
+          }).use(CHAIN_ID.USE.SWC).loader(builtinSwcLoaderName).options((0, import_lodash.cloneDeep)(swcConfig));
+        }
+      }
+    );
+    api.modifyRspackConfig(async (config) => {
+      (0, import_shared.setConfig)(
+        config,
+        "experiments.rspackFuture.disableTransformByDefault",
+        true
+      );
+    });
+  }
+});
+async function applyCoreJs(swcConfig, chain, rule, polyfillMode) {
+  const coreJsPath = require.resolve("core-js/package.json");
+  const version = (0, import_shared.getCoreJsVersion)(coreJsPath);
+  const coreJsDir = path.dirname(coreJsPath);
+  swcConfig.env.coreJs = version;
+  if (polyfillMode === "usage") {
+    swcConfig.env.shippedProposals = true;
+  }
+  chain.resolve.alias.merge({
+    "core-js": coreJsDir
+  });
+  rule.exclude.add(coreJsDir);
+}
+function applyTransformImport(swcConfig, pluginImport) {
+  var _a, _b, _c;
+  if (pluginImport !== false && pluginImport) {
+    (_a = swcConfig.rspackExperiments) != null ? _a : swcConfig.rspackExperiments = {};
+    (_c = (_b = swcConfig.rspackExperiments).import) != null ? _c : _b.import = [];
+    swcConfig.rspackExperiments.import.push(...pluginImport);
+  }
+}
+function applyDecorator(swcConfig, enableLatestDecorators) {
+  var _a, _b;
+  if (enableLatestDecorators) {
+    import_shared.logger.warn("Cannot use latestDecorator in Rspack mode.");
+  }
+  (_b = (_a = swcConfig.jsc).transform) != null ? _b : _a.transform = {};
+  swcConfig.jsc.transform.legacyDecorator = true;
+  swcConfig.jsc.transform.decoratorMetadata = true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDefaultSwcConfig,
+  pluginSwc
+});

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

@@ -0,0 +1,5 @@
+import type { RsbuildPlugin } from '../types';
+/**
+ * Provide some temporary configurations for Rspack early transition
+ */
+export declare const pluginTransition: () => RsbuildPlugin;

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

@@ -0,0 +1,42 @@
+"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 transition_exports = {};
+__export(transition_exports, {
+  pluginTransition: () => pluginTransition
+});
+module.exports = __toCommonJS(transition_exports);
+var import_shared = require("@rsbuild/shared");
+const pluginTransition = () => ({
+  name: "plugin-transition",
+  setup(api) {
+    process.env.RSPACK_CONFIG_VALIDATE = "loose-silent";
+    api.modifyBundlerChain(async (chain, { isProd }) => {
+      if (isProd) {
+        chain.optimization.chunkIds("deterministic");
+      }
+    });
+    api.modifyRspackConfig((config) => {
+      (0, import_shared.setConfig)(config, "experiments.rspackFuture.newResolver", true);
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pluginTransition
+});

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

@@ -0,0 +1,8 @@
+import { type RsbuildProvider, type RspackConfig, type RspackCompiler, type RspackMultiCompiler } from '@rsbuild/shared';
+import type { RsbuildConfig, NormalizedConfig } from './types';
+export type RspackProvider = RsbuildProvider<RsbuildConfig, RspackConfig, NormalizedConfig, RspackCompiler | RspackMultiCompiler>;
+export declare function rspackProvider({
+  rsbuildConfig: originalRsbuildConfig
+}: {
+  rsbuildConfig: RsbuildConfig;
+}): RspackProvider;

package/dist/rspack-provider/provider.js

@@ -0,0 +1,116 @@
+"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 provider_exports = {};
+__export(provider_exports, {
+  rspackProvider: () => rspackProvider
+});
+module.exports = __toCommonJS(provider_exports);
+var import_shared = require("@rsbuild/shared");
+var import_chalk = require("@rsbuild/shared/chalk");
+var import_createContext = require("./core/createContext");
+var import_initConfigs = require("./core/initConfigs");
+var import_initPlugins = require("./core/initPlugins");
+var import_plugin = require("./shared/plugin");
+var import_rspackVersion = require("./shared/rspackVersion");
+function rspackProvider({
+  rsbuildConfig: originalRsbuildConfig
+}) {
+  const rsbuildConfig = (0, import_shared.pickRsbuildConfig)(originalRsbuildConfig);
+  return async ({ pluginStore, rsbuildOptions, plugins }) => {
+    if (!await (0, import_rspackVersion.isSatisfyRspackMinimumVersion)()) {
+      throw new Error(
+        `The current Rspack version does not meet the requirements, the minimum supported version of Rspack is ${import_chalk.chalk.green(
+          import_rspackVersion.supportedRspackMinimumVersion
+        )}`
+      );
+    }
+    const context = await (0, import_createContext.createContext)(rsbuildOptions, rsbuildConfig);
+    const pluginAPI = (0, import_initPlugins.getPluginAPI)({ context, pluginStore });
+    context.pluginAPI = pluginAPI;
+    return {
+      bundler: "rspack",
+      pluginAPI,
+      publicContext: (0, import_shared.createPublicContext)(context),
+      async applyDefaultPlugins() {
+        pluginStore.addPlugins(await (0, import_plugin.applyDefaultPlugins)(plugins));
+      },
+      async createCompiler() {
+        const { createCompiler } = await Promise.resolve().then(() => __toESM(require("./core/createCompiler")));
+        const { rspackConfigs } = await (0, import_initConfigs.initConfigs)({
+          context,
+          pluginStore,
+          rsbuildOptions
+        });
+        return createCompiler({
+          context,
+          rspackConfigs
+        });
+      },
+      async startDevServer(options) {
+        const { startDevServer } = await Promise.resolve().then(() => __toESM(require("./core/startDevServer")));
+        return startDevServer(
+          { context, pluginStore, rsbuildOptions },
+          options
+        );
+      },
+      async preview() {
+        return (0, import_shared.startProdServer)(context, context.config);
+      },
+      async build(options) {
+        const { build: buildImpl, rspackBuild } = await Promise.resolve().then(() => __toESM(require("./core/build")));
+        return buildImpl(
+          { context, pluginStore, rsbuildOptions },
+          options,
+          rspackBuild
+        );
+      },
+      async initConfigs() {
+        const { rspackConfigs } = await (0, import_initConfigs.initConfigs)({
+          context,
+          pluginStore,
+          rsbuildOptions
+        });
+        return rspackConfigs;
+      },
+      async inspectConfig(inspectOptions) {
+        const { inspectConfig } = await Promise.resolve().then(() => __toESM(require("./core/inspectConfig")));
+        return inspectConfig({
+          context,
+          pluginStore,
+          rsbuildOptions,
+          inspectOptions
+        });
+      }
+    };
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rspackProvider
+});

package/dist/rspack-provider/rspackLoader/css-modules-typescript-pre-loader/index.d.ts

@@ -0,0 +1,6 @@
+import { CssModules } from '@rsbuild/shared';
+import type { LoaderContext } from '@rspack/core';
+export default function (this: LoaderContext<{
+  modules: Required<CssModules>;
+  mode: string;
+}>, content: string, ...input: any[]): Promise<any>;