@modern-js/uni-builder 2.64.1 → 2.64.2

package/dist/shared/rsc/plugins/rspack-rsc-server-plugin.js

@@ -0,0 +1,240 @@
+"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_rsc_server_plugin_exports = {};
+__export(rspack_rsc_server_plugin_exports, {
+  RscServerPlugin: () => RscServerPlugin
+});
+module.exports = __toCommonJS(rspack_rsc_server_plugin_exports);
+var import_common = require("../common");
+const resourcePath2Entries = /* @__PURE__ */ new Map();
+class RscServerPlugin {
+  findModuleEntries(module2, compilation, resourcePath2Entries2, visited = /* @__PURE__ */ new Set()) {
+    if (!(module2 === null || module2 === void 0 ? void 0 : module2.resource) || visited.has(module2.resource)) {
+      return [];
+    }
+    visited.add(module2.resource);
+    const currentEntries = resourcePath2Entries2.get(module2.resource);
+    if (currentEntries && (currentEntries === null || currentEntries === void 0 ? void 0 : currentEntries.length) > 0) {
+      return currentEntries;
+    }
+    const issuer = (0, import_common.findRootIssuer)(compilation.moduleGraph, module2);
+    if (!issuer) {
+      return [];
+    }
+    const issuerEntries = this.findModuleEntries(issuer, compilation, resourcePath2Entries2, visited);
+    if (issuerEntries.length > 0) {
+      return issuerEntries;
+    }
+    if (issuer.resource) {
+      const entryName = this.entryPath2Name.get(issuer.resource);
+      if (entryName) {
+        return [
+          {
+            entryName,
+            entryPath: issuer.resource
+          }
+        ];
+      }
+    }
+    return [];
+  }
+  apply(compiler) {
+    const {
+      EntryPlugin,
+      WebpackError,
+      // dependencies: { NullDependency },
+      // util: {
+      //   runtime: { getEntryRuntime },
+      // },
+      sources: { RawSource }
+    } = compiler.webpack;
+    const includeModule = async (compilation, resource, resourceEntryNames, layer) => {
+      const entries = Array.from(compilation.entries.entries());
+      if (entries.length === 0) {
+        compilation.errors.push(new WebpackError(`Could not find an entry in the compilation.`));
+        return;
+      }
+      const includePromises = entries.filter(([entryName]) => resourceEntryNames === null || resourceEntryNames === void 0 ? void 0 : resourceEntryNames.includes(entryName)).map(([entryName]) => {
+        const dependency = EntryPlugin.createDependency(resource, {
+          name: resource
+        });
+        return new Promise((resolve, reject) => {
+          compilation.addInclude(compiler.context, dependency, {
+            name: entryName,
+            layer
+          }, (error, module2) => {
+            if (error) {
+              compilation.errors.push(error);
+              return reject(error);
+            }
+            if (!module2) {
+              const noModuleError = new WebpackError(`Module not added`);
+              noModuleError.file = resource;
+              compilation.errors.push(noModuleError);
+              return reject(noModuleError);
+            }
+            (0, import_common.setRscBuildInfo)(module2, {
+              __entryName: entryName
+            });
+            compilation.moduleGraph.getExportsInfo(module2).setUsedInUnknownWay(entryName);
+            resolve();
+          });
+        });
+      });
+      await Promise.all(includePromises);
+    };
+    let needsAdditionalPass = false;
+    compiler.hooks.finishMake.tapPromise(RscServerPlugin.name, async (compilation) => {
+      const processModules = (modules) => {
+        let hasChangeReference2 = false;
+        for (const module2 of modules) {
+          if ("resource" in module2 && (0, import_common.isCssModule)(module2)) {
+            this.styles.add(module2.resource);
+          }
+          const buildInfo = (0, import_common.getRscBuildInfo)(module2);
+          if (!buildInfo || !buildInfo.resourcePath) {
+            continue;
+          }
+          if (module2.layer && buildInfo.type === "server") {
+            import_common.sharedData.set(buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.resourcePath, buildInfo);
+          }
+          if (!module2.layer && buildInfo.type === "client") {
+            import_common.sharedData.set(buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.resourcePath, buildInfo);
+          }
+          const currentReference = (buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.type) === "client" ? this.clientReferencesMap.get(buildInfo.resourcePath) : this.serverReferencesMap.get(buildInfo.resourcePath);
+          if ((buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.type) === "client" && !currentReference) {
+            hasChangeReference2 = true;
+            this.clientReferencesMap.set(buildInfo.resourcePath, buildInfo.clientReferences);
+          } else if ((buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.type) === "server" && !currentReference) {
+            hasChangeReference2 = true;
+            this.serverReferencesMap.set(buildInfo.resourcePath, buildInfo.exportNames);
+          }
+          const entries = this.findModuleEntries(module2, compilation, resourcePath2Entries);
+          if (entries.length > 0) {
+            resourcePath2Entries.set(module2.resource, entries);
+          }
+        }
+        return hasChangeReference2;
+      };
+      this.serverManifest = {};
+      const clientReferences = [
+        ...this.clientReferencesMap.keys()
+      ];
+      const serverReferences = [
+        ...this.serverReferencesMap.keys()
+      ];
+      const referencesBefore = [
+        ...clientReferences,
+        ...serverReferences
+      ];
+      let hasChangeReference = false;
+      await Promise.all([
+        ...clientReferences.map(async (resource) => {
+          try {
+            var _resourcePath2Entries_get;
+            await includeModule(compilation, resource, ((_resourcePath2Entries_get = resourcePath2Entries.get(resource)) === null || _resourcePath2Entries_get === void 0 ? void 0 : _resourcePath2Entries_get.map((entry) => entry.entryName)) || []);
+          } catch (error) {
+            console.error(error);
+            hasChangeReference = true;
+            this.clientReferencesMap.delete(resource);
+          }
+        }),
+        ...serverReferences.map(async (resource) => {
+          try {
+            var _resourcePath2Entries_get;
+            await includeModule(compilation, resource, ((_resourcePath2Entries_get = resourcePath2Entries.get(resource)) === null || _resourcePath2Entries_get === void 0 ? void 0 : _resourcePath2Entries_get.map((entry) => entry.entryName)) || [], import_common.webpackRscLayerName);
+          } catch (error) {
+            console.error(error);
+            hasChangeReference = true;
+            this.serverReferencesMap.delete(resource);
+          }
+        })
+      ]);
+      hasChangeReference = processModules(compilation.modules);
+      const referencesAfter = [
+        ...this.clientReferencesMap.keys(),
+        ...this.serverReferencesMap.keys()
+      ];
+      if (referencesBefore.length !== referencesAfter.length || !referencesAfter.every((reference) => referencesBefore.includes(reference)) && hasChangeReference) {
+        needsAdditionalPass = true;
+      }
+    });
+    compiler.hooks.done.tap(RscServerPlugin.name, () => {
+      import_common.sharedData.set("serverReferencesMap", this.serverReferencesMap);
+      import_common.sharedData.set("clientReferencesMap", this.clientReferencesMap);
+      import_common.sharedData.set("styles", this.styles);
+    });
+    compiler.hooks.afterCompile.tap(RscServerPlugin.name, (compilation) => {
+      for (const module2 of compilation.modules) {
+        var _getRscBuildInfo;
+        const resource = module2.nameForCondition();
+        if (!resource) {
+          continue;
+        }
+        const moduleId = compilation.chunkGraph.getModuleId(module2);
+        if (moduleId === null) {
+          continue;
+        }
+        if (module2.layer !== import_common.webpackRscLayerName && this.clientReferencesMap.has(resource)) {
+          const clientReferences = this.clientReferencesMap.get(resource);
+          if (clientReferences) {
+            for (const clientReference of clientReferences) {
+              clientReference.ssrId = moduleId;
+            }
+          } else {
+            compilation.errors.push(new WebpackError(`Could not find client references info in \`clientReferencesMap\` for ${resource}.`));
+          }
+        } else if (module2.layer === import_common.webpackRscLayerName && ((_getRscBuildInfo = (0, import_common.getRscBuildInfo)(module2)) === null || _getRscBuildInfo === void 0 ? void 0 : _getRscBuildInfo.type) === "server") {
+          const serverReferencesModuleInfo = (0, import_common.getRscBuildInfo)(module2);
+          if (serverReferencesModuleInfo) {
+            serverReferencesModuleInfo.moduleId = moduleId;
+            for (const exportName of serverReferencesModuleInfo.exportNames) {
+              this.serverManifest[`${moduleId}#${exportName}`] = {
+                id: moduleId,
+                chunks: [],
+                name: exportName
+              };
+            }
+          } else {
+            compilation.errors.push(new WebpackError(`Could not find server references module info in \`serverReferencesMap\` for ${resource}.`));
+          }
+        }
+      }
+    });
+    compiler.hooks.thisCompilation.tap(RscServerPlugin.name, (compilation, { normalModuleFactory }) => {
+      compilation.hooks.needAdditionalPass.tap(RscServerPlugin.name, () => !(needsAdditionalPass = !needsAdditionalPass));
+      compilation.hooks.processAssets.tap(RscServerPlugin.name, () => {
+        compilation.emitAsset(this.serverManifestFilename, new RawSource(JSON.stringify(this.serverManifest, null, 2), false));
+      });
+    });
+  }
+  constructor(options) {
+    this.clientReferencesMap = /* @__PURE__ */ new Map();
+    this.serverReferencesMap = /* @__PURE__ */ new Map();
+    this.serverManifest = {};
+    this.entryPath2Name = /* @__PURE__ */ new Map();
+    this.styles = /* @__PURE__ */ new Set();
+    this.serverManifestFilename = (options === null || options === void 0 ? void 0 : options.serverManifestFilename) || `react-server-manifest.json`;
+    this.entryPath2Name = (options === null || options === void 0 ? void 0 : options.entryPath2Name) || /* @__PURE__ */ new Map();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RscServerPlugin
+});

package/dist/shared/rsc/rsc-client-loader.d.ts

@@ -0,0 +1,7 @@
+import type { LoaderContext } from 'webpack';
+import { type SourceMap } from './common';
+export type ClientLoaderOptions = {
+    callServerImport?: string;
+    registerImport?: string;
+};
+export default function rscClientLoader(this: LoaderContext<ClientLoaderOptions>, source: string, sourceMap: SourceMap): Promise<void>;

package/dist/shared/rsc/rsc-client-loader.js

@@ -0,0 +1,70 @@
+"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 rsc_client_loader_exports = {};
+__export(rsc_client_loader_exports, {
+  default: () => rscClientLoader
+});
+module.exports = __toCommonJS(rsc_client_loader_exports);
+var import_common = require("./common");
+async function rscClientLoader(source, sourceMap) {
+  this.cacheable(true);
+  const callback = this.async();
+  const ast = await (0, import_common.parseSource)(source);
+  const hasUseServerDirective = await (0, import_common.isServerModule)(ast);
+  if (!hasUseServerDirective) {
+    callback(null, source, sourceMap);
+    return;
+  }
+  const { callServerImport = `@modern-js/runtime/rsc/client`, registerImport = `@modern-js/runtime/rsc/client` } = this.getOptions();
+  const buildInfo = import_common.sharedData.get(this.resourcePath);
+  const moduleInfo = buildInfo ? {
+    moduleId: buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.moduleId,
+    exportNames: buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.exportNames
+  } : null;
+  if (!moduleInfo) {
+    this.emitError(new Error(`Could not find server module info in \`serverReferencesMap\` for ${this.resourcePath}.`));
+    callback(null, "");
+    return;
+  }
+  const { moduleId, exportNames } = moduleInfo;
+  if (!moduleId) {
+    this.emitError(new Error(`Could not find server module ID in \`serverReferencesMap\` for ${this.resourcePath}.`));
+    callback(null, "");
+    return;
+  }
+  if (!exportNames) {
+    callback(null, "");
+    return;
+  }
+  const importsCode = `
+    import { createServerReference } from "${registerImport}";
+    import { callServer } from "${callServerImport}";
+  `;
+  const exportsCode = exportNames.map((item) => {
+    const name = item;
+    if (name === "default") {
+      return `export default createServerReference("${moduleId}", callServer);`;
+    } else {
+      return `export const ${name} = createServerReference("${moduleId}#${name}", callServer);`;
+    }
+  }).join("\n");
+  callback(null, `${importsCode}
+${exportsCode}`);
+  return;
+}

package/dist/shared/rsc/rsc-css-loader.d.ts

@@ -0,0 +1,2 @@
+import type { LoaderContext } from 'webpack';
+export default function rscCssLoader(this: LoaderContext<unknown>, source: string): string;

package/dist/shared/rsc/rsc-css-loader.js

@@ -0,0 +1,30 @@
+"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 rsc_css_loader_exports = {};
+__export(rsc_css_loader_exports, {
+  default: () => rscCssLoader
+});
+module.exports = __toCommonJS(rsc_css_loader_exports);
+var import_common = require("./common");
+function rscCssLoader(source) {
+  this._module && (0, import_common.setRscBuildInfo)(this._module, {
+    isCssModule: true
+  });
+  return source;
+}

package/dist/shared/rsc/rsc-server-loader.d.ts

@@ -0,0 +1,6 @@
+import type { LoaderContext } from 'webpack';
+export type RscServerLoaderOptions = {
+    appDir: string;
+    runtimePath?: string;
+};
+export default function rscServerLoader(this: LoaderContext<RscServerLoaderOptions>, source: string): Promise<void>;

package/dist/shared/rsc/rsc-server-loader.js

@@ -0,0 +1,94 @@
+"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 rsc_server_loader_exports = {};
+__export(rsc_server_loader_exports, {
+  default: () => rscServerLoader
+});
+module.exports = __toCommonJS(rsc_server_loader_exports);
+var import_path = __toESM(require("path"));
+var import_core = require("@swc/core");
+var import_common = require("./common");
+function extractMetadata(code) {
+  const metadataRegex = /\/\* @modern-js-rsc-metadata\n([\s\S]*?)\*\//;
+  const match = code.match(metadataRegex);
+  if (!match)
+    return null;
+  try {
+    const metadata = JSON.parse(match[1]);
+    return metadata;
+  } catch (e) {
+    console.error("Failed to parse metadata:", e);
+    return null;
+  }
+}
+async function rscServerLoader(source) {
+  this.cacheable(true);
+  const callback = this.async();
+  const { appDir, runtimePath = "@modern-js/runtime/rsc/server" } = this.getOptions();
+  const result = await (0, import_core.transform)(source, {
+    filename: this.resourcePath,
+    jsc: {
+      target: "es2020",
+      experimental: {
+        cacheRoot: import_path.default.resolve(appDir, "node_modules/.swc"),
+        plugins: [
+          [
+            require.resolve("@modern-js/flight-server-transform-plugin"),
+            {
+              appDir,
+              runtimePath
+            }
+          ]
+        ]
+      }
+    }
+  });
+  const { code, map } = result;
+  const metadata = extractMetadata(code);
+  if ((metadata === null || metadata === void 0 ? void 0 : metadata.directive) && metadata.directive === "client") {
+    const { exportNames } = metadata;
+    if (exportNames.length > 0) {
+      (0, import_common.setRscBuildInfo)(this._module, {
+        type: "client",
+        resourcePath: this.resourcePath,
+        clientReferences: exportNames
+      });
+    }
+  } else if (metadata) {
+    const { exportNames } = metadata;
+    if (exportNames.length > 0) {
+      (0, import_common.setRscBuildInfo)(this._module, {
+        type: "server",
+        resourcePath: this.resourcePath,
+        exportNames: exportNames.map((item) => item.exportName)
+      });
+    }
+  }
+  return callback(null, code, map);
+}

package/dist/shared/rsc/rsc-ssr-loader.d.ts

@@ -0,0 +1,6 @@
+import type { LoaderContext } from 'webpack';
+import { type SourceMap } from './common';
+export type RscSsrLoaderOptions = {
+    entryPath2Name: Map<string, string>;
+};
+export default function rscSsrLoader(this: LoaderContext<RscSsrLoaderOptions>, source: string, sourceMap: SourceMap): Promise<void>;

package/dist/shared/rsc/rsc-ssr-loader.js

@@ -0,0 +1,59 @@
+"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 rsc_ssr_loader_exports = {};
+__export(rsc_ssr_loader_exports, {
+  default: () => rscSsrLoader
+});
+module.exports = __toCommonJS(rsc_ssr_loader_exports);
+var import_common = require("./common");
+async function rscSsrLoader(source, sourceMap) {
+  this.cacheable(true);
+  const callback = this.async();
+  const { entryPath2Name } = this.getOptions();
+  const ast = await (0, import_common.parseSource)(source);
+  const hasDeclareServerDirective = await (0, import_common.isServerModule)(ast);
+  const resourcePath = this.resourcePath;
+  if (!hasDeclareServerDirective) {
+    callback(null, source, sourceMap);
+    return;
+  }
+  const exportedNames = await (0, import_common.getExportNames)(ast, true);
+  const importsCode = `
+    'use server';
+  `;
+  const exportsCode = exportedNames.map((name) => {
+    if (name === "default") {
+      return `export default () => {throw new Error("Server actions must not be called during server-side rendering.")}`;
+    } else {
+      return `export const ${name} = () => {
+          throw new Error("Server actions must not be called during server-side rendering.")
+        }`;
+    }
+  }).join("\n");
+  if (exportedNames.length > 0) {
+    (0, import_common.setRscBuildInfo)(this._module, {
+      type: "server",
+      resourcePath,
+      exportNames: exportedNames
+    });
+  }
+  callback(null, `${importsCode}
+${exportsCode}`, sourceMap);
+  return;
+}

package/dist/types.d.ts

@@ -17,6 +17,7 @@ import type { Options as HTMLPluginOptions } from 'html-webpack-plugin';
 import type TerserPlugin from 'terser-webpack-plugin';
 import type { PluginTsLoaderOptions } from './webpack/plugins/tsLoader';
 type ArrayOrNot<T> = T | T[];
+export type CacheGroup = Rspack.OptimizationSplitChunksCacheGroup;
 export type Stats = Omit<Rspack.Stats, '#private' | 'hash' | 'startTime' | 'endTime'>;
 export type RspackConfig = Rspack.Configuration;
 export type MultiStats = Rspack.MultiStats;
@@ -38,9 +39,13 @@ export type CreateBuilderCommonOptions = {
     frameworkConfigPath?: string;
     /** The root path of current project. */
     cwd: string;
+    rscClientRuntimePath?: string;
+    rscServerRuntimePath?: string;
 };
 export type BundlerType = 'rspack' | 'webpack';
 export type CreateUniBuilderOptions = {
+    rscClientRuntimePath?: string;
+    rscServerRuntimePath?: string;
     bundlerType: BundlerType;
     config: UniBuilderConfig;
 } & Partial<CreateBuilderCommonOptions>;
@@ -373,6 +378,9 @@ export type UniBuilderConfig = {
         polyfill?: Polyfill | 'ua';
         distPath?: DistPath;
     };
+    server?: {
+        rsc?: boolean;
+    };
     performance?: RsbuildConfig['performance'];
     security?: Omit<SecurityConfig, 'sri'>;
     tools?: Omit<ToolsConfig, 'htmlPlugin'>;

package/dist/webpack/index.js

@@ -36,12 +36,13 @@ var import_core = require("@rsbuild/core");
 var import_compatLegacyPlugin = require("../shared/compatLegacyPlugin");
 var import_parseCommonConfig = require("../shared/parseCommonConfig");
 var import_postcss = require("../shared/plugins/postcss");
+var import_rsbuild_rsc_plugin = require("../shared/rsc/plugins/rsbuild-rsc-plugin");
 var import_utils = require("../shared/utils");
 var import_babel = require("./plugins/babel");
 var import_moduleScopes = require("./plugins/moduleScopes");
 var import_react = require("./plugins/react");
 async function parseConfig(uniBuilderConfig, options) {
-  var _uniBuilderConfig_tools, _uniBuilderConfig_tools1, _uniBuilderConfig_output, _uniBuilderConfig_security, _uniBuilderConfig_experiments, _uniBuilderConfig_tools2, _uniBuilderConfig_source;
+  var _uniBuilderConfig_tools, _uniBuilderConfig_server, _uniBuilderConfig_tools1, _uniBuilderConfig_output, _uniBuilderConfig_security, _uniBuilderConfig_experiments, _uniBuilderConfig_tools2, _uniBuilderConfig_source;
   const { rsbuildConfig, rsbuildPlugins } = await (0, import_parseCommonConfig.parseCommonConfig)(uniBuilderConfig, options);
   rsbuildPlugins.push((0, import_postcss.pluginPostcss)({
     autoprefixer: (_uniBuilderConfig_tools = uniBuilderConfig.tools) === null || _uniBuilderConfig_tools === void 0 ? void 0 : _uniBuilderConfig_tools.autoprefixer
@@ -96,6 +97,17 @@ async function parseConfig(uniBuilderConfig, options) {
     }));
   }
   rsbuildPlugins.push((0, import_react.pluginReact)());
+  var _uniBuilderConfig_server_rsc;
+  const enableRsc = (_uniBuilderConfig_server_rsc = (_uniBuilderConfig_server = uniBuilderConfig.server) === null || _uniBuilderConfig_server === void 0 ? void 0 : _uniBuilderConfig_server.rsc) !== null && _uniBuilderConfig_server_rsc !== void 0 ? _uniBuilderConfig_server_rsc : false;
+  if (enableRsc) {
+    const { rscClientRuntimePath, rscServerRuntimePath } = options;
+    rsbuildPlugins.push((0, import_rsbuild_rsc_plugin.rsbuildRscPlugin)({
+      appDir: options.cwd,
+      isRspack: false,
+      rscClientRuntimePath,
+      rscServerRuntimePath
+    }));
+  }
   if ((_uniBuilderConfig_tools1 = uniBuilderConfig.tools) === null || _uniBuilderConfig_tools1 === void 0 ? void 0 : _uniBuilderConfig_tools1.tsLoader) {
     const { pluginTsLoader } = await Promise.resolve().then(() => __toESM(require("./plugins/tsLoader")));
     rsbuildPlugins.push(pluginTsLoader(uniBuilderConfig.tools.tsLoader, uniBuilderConfig.tools.babel));