@modern-js/builder 2.46.1 → 3.0.0-alpha.0

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

@@ -0,0 +1,290 @@
+"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 {
+  isValidModule(module2) {
+    return Boolean(module2 === null || module2 === void 0 ? void 0 : module2.resource);
+  }
+  hasValidEntries(entries) {
+    return Boolean(entries && entries.length > 0);
+  }
+  getEntryNameFromIssuer(issuer) {
+    return issuer.resource ? this.entryPath2Name.get(issuer.resource) : void 0;
+  }
+  createEntryFromIssuer(issuer, entryName) {
+    return {
+      entryName,
+      entryPath: issuer.resource
+    };
+  }
+  buildModuleToEntriesMapping(compilation) {
+    this.moduleToEntries.clear();
+    for (const [entryName, entryDependency] of compilation.entries.entries()) {
+      const entryModule = compilation.moduleGraph.getModule(entryDependency.dependencies[0]);
+      if (!entryModule)
+        continue;
+      this.traverseModulesFromEntry(entryModule, entryName, compilation.moduleGraph, /* @__PURE__ */ new Set());
+    }
+  }
+  traverseModulesFromEntry(module2, entryName, moduleGraph, visited) {
+    if (!(module2 === null || module2 === void 0 ? void 0 : module2.resource) || visited.has(module2.resource)) {
+      return;
+    }
+    visited.add(module2.resource);
+    if (!this.moduleToEntries.has(module2.resource)) {
+      this.moduleToEntries.set(module2.resource, /* @__PURE__ */ new Set());
+    }
+    this.moduleToEntries.get(module2.resource).add(entryName);
+    for (const connection of moduleGraph.getOutgoingConnections(module2)) {
+      if (connection.module && "resource" in connection.module) {
+        this.traverseModulesFromEntry(connection.module, entryName, moduleGraph, visited);
+      }
+    }
+  }
+  findModuleEntries(module2, compilation, resourcePath2Entries2, visited = /* @__PURE__ */ new Set()) {
+    if (!this.isValidModule(module2) || visited.has(module2.resource)) {
+      return [];
+    }
+    visited.add(module2.resource);
+    const currentEntries = resourcePath2Entries2.get(module2.resource);
+    if (this.hasValidEntries(currentEntries)) {
+      return currentEntries;
+    }
+    const entryNames = this.moduleToEntries.get(module2.resource);
+    if (entryNames && entryNames.size > 0) {
+      const entries = [];
+      for (const entryName2 of entryNames) {
+        const entryPath = this.getEntryPathByName(entryName2, compilation);
+        if (entryPath) {
+          entries.push({
+            entryName: entryName2,
+            entryPath
+          });
+        }
+      }
+      return entries;
+    }
+    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;
+    }
+    const entryName = this.getEntryNameFromIssuer(issuer);
+    if (entryName) {
+      return [
+        this.createEntryFromIssuer(issuer, entryName)
+      ];
+    }
+    return [];
+  }
+  getEntryPathByName(entryName, compilation) {
+    const entryDependency = compilation.entries.get(entryName);
+    if (entryDependency && entryDependency.dependencies.length > 0) {
+      const firstDep = entryDependency.dependencies[0];
+      if ("request" in firstDep && typeof firstDep.request === "string") {
+        return firstDep.request;
+      }
+    }
+    return void 0;
+  }
+  apply(compiler) {
+    const { EntryPlugin, WebpackError, sources: { RawSource } } = compiler.rspack;
+    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);
+        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) => {
+      this.buildModuleToEntriesMapping(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.rspackRscLayerName);
+          } 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.rspackRscLayerName && 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.rspackRscLayerName && ((_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) => {
+      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.moduleToEntries = /* @__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/rsc/rsc-client-loader.d.ts

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

package/dist/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/rsc/rsc-css-loader.d.ts

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

package/dist/{plugins/yaml.js → rsc/rsc-css-loader.js}

@@ -16,21 +16,15 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var yaml_exports = {};
-__export(yaml_exports, {
-  builderPluginYaml: () => builderPluginYaml
-});
-module.exports = __toCommonJS(yaml_exports);
-var import_builder_shared = require("@modern-js/builder-shared");
-const builderPluginYaml = () => ({
-  name: "builder-plugin-yaml",
-  setup(api) {
-    api.modifyBundlerChain((chain, { CHAIN_ID }) => {
-      chain.module.rule(CHAIN_ID.RULE.YAML).type("javascript/auto").test(/\.ya?ml$/).use(CHAIN_ID.USE.YAML).loader((0, import_builder_shared.getSharedPkgCompiledPath)("yaml-loader"));
-    });
-  }
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  builderPluginYaml
+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/rsc/rsc-server-loader.d.ts

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

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

@@ -0,0 +1,95 @@
+"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
+            }
+          ]
+        ]
+      }
+    },
+    isModule: true
+  });
+  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/rsc/rsc-ssr-loader.d.ts

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

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

@@ -0,0 +1,58 @@
+"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 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/shared/devServer.d.ts

@@ -0,0 +1,6 @@
+import type { DevConfig, ServerConfig } from '@rsbuild/core';
+import type { BuilderConfig, ToolsDevServerConfig } from '../types';
+export declare const transformToRsbuildServerOptions: (dev: NonNullable<BuilderConfig["dev"]>, devServer: ToolsDevServerConfig, server?: BuilderConfig["server"]) => {
+    rsbuildDev: DevConfig;
+    rsbuildServer: ServerConfig;
+};

package/dist/shared/devServer.js

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var devServer_exports = {};
+__export(devServer_exports, {
+  transformToRsbuildServerOptions: () => transformToRsbuildServerOptions
+});
+module.exports = __toCommonJS(devServer_exports);
+var import_utils = require("@modern-js/utils");
+var import_ts_deepmerge = require("ts-deepmerge");
+const defaultDevConfig = {
+  writeToDisk: (file) => !file.includes(".hot-update."),
+  hmr: true,
+  liveReload: true,
+  progressBar: true,
+  client: {
+    path: "/webpack-hmr",
+    overlay: false,
+    port: "<port>"
+  }
+};
+const transformToRsbuildServerOptions = (dev, devServer, server) => {
+  const { host, https, startUrl, beforeStartUrl, server: devServerConfig, ...devConfig } = dev;
+  var _server_port;
+  const port = process.env.PORT ? Number(process.env.PORT) : (_server_port = server === null || server === void 0 ? void 0 : server.port) !== null && _server_port !== void 0 ? _server_port : 8080;
+  const rsbuildDev = (0, import_ts_deepmerge.merge)(defaultDevConfig, devConfig);
+  delete rsbuildDev.setupMiddlewares;
+  const legacyServerConfig = (0, import_utils.applyOptionsChain)({}, devServer, {}, import_ts_deepmerge.merge);
+  var _devServerConfig_compress, _devServerConfig_headers, _devServerConfig_historyApiFallback, _devServerConfig_proxy;
+  const serverCofig = {
+    compress: (_devServerConfig_compress = devServerConfig === null || devServerConfig === void 0 ? void 0 : devServerConfig.compress) !== null && _devServerConfig_compress !== void 0 ? _devServerConfig_compress : legacyServerConfig.compress,
+    headers: (_devServerConfig_headers = devServerConfig === null || devServerConfig === void 0 ? void 0 : devServerConfig.headers) !== null && _devServerConfig_headers !== void 0 ? _devServerConfig_headers : legacyServerConfig.headers,
+    historyApiFallback: (_devServerConfig_historyApiFallback = devServerConfig === null || devServerConfig === void 0 ? void 0 : devServerConfig.historyApiFallback) !== null && _devServerConfig_historyApiFallback !== void 0 ? _devServerConfig_historyApiFallback : legacyServerConfig.historyApiFallback,
+    proxy: (_devServerConfig_proxy = devServerConfig === null || devServerConfig === void 0 ? void 0 : devServerConfig.proxy) !== null && _devServerConfig_proxy !== void 0 ? _devServerConfig_proxy : legacyServerConfig.proxy
+  };
+  const rsbuildServer = (0, import_utils.isProd)() ? {
+    publicDir: false,
+    htmlFallback: false,
+    printUrls: false
+  } : {
+    publicDir: false,
+    htmlFallback: false,
+    printUrls: false,
+    compress: serverCofig.compress,
+    headers: serverCofig.headers,
+    historyApiFallback: serverCofig.historyApiFallback,
+    proxy: serverCofig.proxy,
+    host,
+    port,
+    https: https ? https : void 0,
+    middlewareMode: true,
+    cors: server === null || server === void 0 ? void 0 : server.cors
+  };
+  if (!(0, import_utils.isProd)() && startUrl) {
+    rsbuildServer.open = beforeStartUrl ? {
+      target: startUrl === true ? "//localhost:<port>" : startUrl,
+      before: beforeStartUrl
+    } : startUrl;
+  }
+  return {
+    rsbuildDev,
+    rsbuildServer
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformToRsbuildServerOptions
+});

package/dist/shared/getCssSupport.d.ts

@@ -0,0 +1 @@
+export declare function getCssSupport(projectBrowserslist: string[]): Record<"customProperties" | "initial" | "pageBreak" | "fontVariant" | "mediaMinmax", boolean>;