@modern-js/uni-builder 2.64.1 → 2.64.2

package/dist/index.d.ts

@@ -4,8 +4,8 @@ import type { CreateUniBuilderOptions } from './types';
 import { type UniBuilderWebpackInstance } from './webpack';
 export { HtmlWebpackPlugin };
 export type { CreateUniBuilderOptions, UniBuilderInstance, UniBuilderWebpackInstance, };
-export type { UniBuilderConfig, UniBuilderPlugin, LooseRsbuildPlugin, BundlerType, MetaOptions, Stats, MultiStats, RspackConfig, } from './types';
+export type { UniBuilderConfig, UniBuilderPlugin, LooseRsbuildPlugin, BundlerType, MetaOptions, Stats, MultiStats, RspackConfig, CacheGroup, } from './types';
 export declare function createUniBuilder(options: CreateUniBuilderOptions): Promise<UniBuilderInstance>;
-export { logger, type ConfigChain, type RsbuildPlugin, type ChainIdentifier, type RspackChain, type Rspack, type RsbuildContext, type RsbuildConfig, type RsbuildTarget, type NormalizedConfig, type CacheGroup, } from '@rsbuild/core';
+export { logger, type ConfigChain, type RsbuildPlugin, type ChainIdentifier, type RspackChain, type Rspack, type RsbuildContext, type RsbuildConfig, type RsbuildTarget, type NormalizedConfig, } from '@rsbuild/core';
 export type { webpack, WebpackConfig } from '@rsbuild/webpack';
 export { RUNTIME_CHUNK_NAME, SERVICE_WORKER_ENVIRONMENT_NAME, isHtmlDisabled, castArray, } from './shared/utils';

package/dist/rspack/index.js

@@ -35,9 +35,10 @@ module.exports = __toCommonJS(rspack_exports);
 var import_core = require("@rsbuild/core");
 var import_compatLegacyPlugin = require("../shared/compatLegacyPlugin");
 var import_parseCommonConfig = require("../shared/parseCommonConfig");
+var import_rsbuild_rsc_plugin = require("../shared/rsc/plugins/rsbuild-rsc-plugin");
 var import_utils = require("../shared/utils");
 async function parseConfig(uniBuilderConfig, options) {
-  var _uniBuilderConfig_experiments, _uniBuilderConfig_tools, _uniBuilderConfig_tools1;
+  var _uniBuilderConfig_experiments, _uniBuilderConfig_tools, _uniBuilderConfig_tools1, _uniBuilderConfig_server;
   const { rsbuildConfig, rsbuildPlugins } = await (0, import_parseCommonConfig.parseCommonConfig)(uniBuilderConfig, options);
   if ((_uniBuilderConfig_experiments = uniBuilderConfig.experiments) === null || _uniBuilderConfig_experiments === void 0 ? void 0 : _uniBuilderConfig_experiments.lazyCompilation) {
     rsbuildConfig.dev.lazyCompilation = uniBuilderConfig.experiments.lazyCompilation;
@@ -119,13 +120,24 @@ async function parseConfig(uniBuilderConfig, options) {
     }
     rsbuildPlugins.push(pluginStyledComponents(options2));
   }
+  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: true,
+      rscClientRuntimePath,
+      rscServerRuntimePath
+    }));
+  }
   return {
     rsbuildConfig,
     rsbuildPlugins
   };
 }
 async function createRspackBuilder(options) {
-  const { cwd = process.cwd(), config, ...rest } = options;
+  const { cwd = process.cwd(), config, rscClientRuntimePath, rscServerRuntimePath, ...rest } = options;
   const { rsbuildConfig, rsbuildPlugins } = await parseConfig(config, {
     ...rest,
     cwd

package/dist/shared/plugins/frameworkConfig.js

@@ -36,13 +36,22 @@ const pluginFrameworkConfig = (configPath) => ({
   name: "uni-builder:framework-config",
   setup(api) {
     api.modifyBundlerChain((chain) => {
-      if (!import_node_fs.default.existsSync(configPath)) {
+      if (!import_node_fs.default.existsSync(configPath) || api.context.bundlerType !== "webpack") {
         return;
       }
       const cache = chain.get("cache");
       if (!cache) {
         return;
       }
+      if (cache === true) {
+        chain.cache({
+          buildDependencies: {
+            frameworkConfig: [
+              configPath
+            ]
+          }
+        });
+      }
       cache.buildDependencies = {
         ...cache.buildDependencies,
         frameworkConfig: [

package/dist/shared/rsc/common.d.ts

@@ -0,0 +1,22 @@
+export type { ClientReference, ImportManifestEntry, ModuleLoading, SSRManifest, SSRModuleMap, ClientReferencesMap, ServerReferencesMap, ServerManifest, ServerReferencesModuleInfo, ClientManifest, } from '@modern-js/types/server';
+import { type Module } from '@swc/core';
+import type { LoaderDefinitionFunction, ModuleGraph, NormalModule, Module as WebpackModule } from 'webpack';
+export declare const webpackRscLayerName = "react-server";
+export type SourceMap = Parameters<LoaderDefinitionFunction>[1];
+export declare const MODERN_RSC_INFO = "modernRscInfo";
+export declare const sharedData: {
+    store: Map<string, any>;
+    get<T>(key: string): T | undefined;
+    set<T_1>(key: string, value: T_1): void;
+    clear(): void;
+};
+export declare function setBuildInfo(mod: WebpackModule, property: Record<string, any>): void;
+export declare function setRscBuildInfo(mod: WebpackModule, property: Record<string, any>): void;
+export declare function removeRscBuildInfo(mod: WebpackModule): void;
+export declare function getRscBuildInfo(mod: WebpackModule): any;
+export declare function isCssModule(mod: WebpackModule): any;
+export declare const parseSource: (source: string) => Promise<Module>;
+export declare const getExportNames: (ast: Module, collectFuncOnly?: boolean) => Promise<string[]>;
+export declare const isServerModule: (ast: Module) => Promise<boolean>;
+export declare const isClientModule: (ast: Module) => Promise<boolean>;
+export declare function findRootIssuer(modulegraph: ModuleGraph, module: NormalModule): NormalModule;

package/dist/shared/rsc/common.js

@@ -0,0 +1,170 @@
+"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 common_exports = {};
+__export(common_exports, {
+  MODERN_RSC_INFO: () => MODERN_RSC_INFO,
+  findRootIssuer: () => findRootIssuer,
+  getExportNames: () => getExportNames,
+  getRscBuildInfo: () => getRscBuildInfo,
+  isClientModule: () => isClientModule,
+  isCssModule: () => isCssModule,
+  isServerModule: () => isServerModule,
+  parseSource: () => parseSource,
+  removeRscBuildInfo: () => removeRscBuildInfo,
+  setBuildInfo: () => setBuildInfo,
+  setRscBuildInfo: () => setRscBuildInfo,
+  sharedData: () => sharedData,
+  webpackRscLayerName: () => webpackRscLayerName
+});
+module.exports = __toCommonJS(common_exports);
+var import_utils = require("@modern-js/utils");
+var import_core = require("@swc/core");
+const webpackRscLayerName = `react-server`;
+const MODERN_RSC_INFO = "modernRscInfo";
+const sharedData = {
+  store: /* @__PURE__ */ new Map(),
+  get(key) {
+    return this.store.get(key);
+  },
+  set(key, value) {
+    this.store.set(key, value);
+  },
+  clear() {
+    this.store.clear();
+  }
+};
+function setBuildInfo(mod, property) {
+  mod.buildInfo = mod.buildInfo || {};
+  Object.assign(mod.buildInfo, property);
+}
+function setRscBuildInfo(mod, property) {
+  mod.buildInfo = mod.buildInfo || {};
+  const rscBuildInfo = mod.buildInfo[MODERN_RSC_INFO] || {};
+  Object.assign(rscBuildInfo, property);
+  setBuildInfo(mod, {
+    [MODERN_RSC_INFO]: rscBuildInfo
+  });
+}
+function removeRscBuildInfo(mod) {
+  var _mod_buildInfo;
+  (_mod_buildInfo = mod.buildInfo) === null || _mod_buildInfo === void 0 ? true : delete _mod_buildInfo[MODERN_RSC_INFO];
+}
+function getRscBuildInfo(mod) {
+  var _mod_buildInfo;
+  return (_mod_buildInfo = mod.buildInfo) === null || _mod_buildInfo === void 0 ? void 0 : _mod_buildInfo[MODERN_RSC_INFO];
+}
+function isCssModule(mod) {
+  var _getRscBuildInfo;
+  if (!mod)
+    return false;
+  return (_getRscBuildInfo = getRscBuildInfo(mod)) === null || _getRscBuildInfo === void 0 ? void 0 : _getRscBuildInfo.isCssModule;
+}
+const parseSource = async (source) => {
+  return await (0, import_core.parse)(source, {
+    syntax: "typescript",
+    tsx: true,
+    dynamicImport: true
+  });
+};
+const getExportNames = async (ast, collectFuncOnly = false) => {
+  const exportNames = [];
+  ast.body.forEach((node) => {
+    if (node.type === "ExportNamedDeclaration") {
+      const namedExport = node;
+      namedExport.specifiers.forEach((specifier) => {
+        if (specifier.type === "ExportSpecifier") {
+          var _specifier_exported;
+          exportNames.push(((_specifier_exported = specifier.exported) === null || _specifier_exported === void 0 ? void 0 : _specifier_exported.value) || specifier.orig.value);
+        }
+      });
+    }
+    if (node.type === "ExportDeclaration") {
+      if (node.declaration.type === "VariableDeclaration") {
+        node.declaration.declarations.forEach((decl) => {
+          if (decl.id.type === "Identifier") {
+            if (!collectFuncOnly) {
+              exportNames.push(decl.id.value);
+            } else {
+              var _decl_init, _decl_init1;
+              if (((_decl_init = decl.init) === null || _decl_init === void 0 ? void 0 : _decl_init.type) === "FunctionExpression" || ((_decl_init1 = decl.init) === null || _decl_init1 === void 0 ? void 0 : _decl_init1.type) === "ArrowFunctionExpression") {
+                exportNames.push(decl.id.value);
+              }
+            }
+          }
+        });
+      }
+      if (node.declaration.type === "ClassDeclaration" || node.declaration.type === "FunctionDeclaration") {
+        if (node.declaration.identifier) {
+          exportNames.push(node.declaration.identifier.value);
+        }
+      }
+    }
+    if (node.type === "ExportDefaultExpression" || node.type === "ExportDefaultDeclaration") {
+      exportNames.push("default");
+    }
+  });
+  return exportNames;
+};
+const checkDirective = async (ast, directive) => {
+  try {
+    for (let i = 0; i < ast.body.length; i++) {
+      const node = ast.body[i];
+      if (node.type !== "ExpressionStatement") {
+        break;
+      }
+      if (node.expression.type === "StringLiteral" && node.expression.value === directive) {
+        return true;
+      }
+    }
+  } catch (e) {
+    import_utils.logger.error(e);
+    return false;
+  }
+  return false;
+};
+const isServerModule = async (ast) => {
+  return checkDirective(ast, "use server");
+};
+const isClientModule = async (ast) => {
+  return checkDirective(ast, "use client");
+};
+function findRootIssuer(modulegraph, module2) {
+  const currentModule = module2;
+  const issuer = modulegraph.getIssuer(currentModule);
+  if (!issuer) {
+    return currentModule;
+  }
+  return findRootIssuer(modulegraph, issuer);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MODERN_RSC_INFO,
+  findRootIssuer,
+  getExportNames,
+  getRscBuildInfo,
+  isClientModule,
+  isCssModule,
+  isServerModule,
+  parseSource,
+  removeRscBuildInfo,
+  setBuildInfo,
+  setRscBuildInfo,
+  sharedData,
+  webpackRscLayerName
+});

package/dist/shared/rsc/index.d.ts

@@ -0,0 +1,2 @@
+export { RscClientPlugin } from './plugins/rsc-client-plugin';
+export { RscServerPlugin } from './plugins/rsc-server-plugin';

package/dist/shared/rsc/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rsc_exports = {};
+__export(rsc_exports, {
+  RscClientPlugin: () => import_rsc_client_plugin.RscClientPlugin,
+  RscServerPlugin: () => import_rsc_server_plugin.RscServerPlugin
+});
+module.exports = __toCommonJS(rsc_exports);
+var import_rsc_client_plugin = require("./plugins/rsc-client-plugin");
+var import_rsc_server_plugin = require("./plugins/rsc-server-plugin");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RscClientPlugin,
+  RscServerPlugin
+});

package/dist/shared/rsc/plugins/rsbuild-rsc-plugin.d.ts

@@ -0,0 +1,7 @@
+import type { RsbuildPlugin } from '@rsbuild/core';
+export declare const rsbuildRscPlugin: ({ appDir, isRspack, rscClientRuntimePath, rscServerRuntimePath, }: {
+    appDir: string;
+    isRspack?: boolean | undefined;
+    rscClientRuntimePath?: string | undefined;
+    rscServerRuntimePath?: string | undefined;
+}) => RsbuildPlugin;

package/dist/shared/rsc/plugins/rsbuild-rsc-plugin.js

@@ -0,0 +1,138 @@
+"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 rsbuild_rsc_plugin_exports = {};
+__export(rsbuild_rsc_plugin_exports, {
+  rsbuildRscPlugin: () => rsbuildRscPlugin
+});
+module.exports = __toCommonJS(rsbuild_rsc_plugin_exports);
+var import_common = require("../common");
+var import_rsc_client_plugin = require("./rsc-client-plugin");
+var import_rsc_server_plugin = require("./rsc-server-plugin");
+var import_rspack_rsc_client_plugin = require("./rspack-rsc-client-plugin");
+var import_rspack_rsc_server_plugin = require("./rspack-rsc-server-plugin");
+const CSS_RULE_NAMES = [
+  "less",
+  "css",
+  "scss",
+  "sass"
+];
+const rsbuildRscPlugin = ({ appDir, isRspack = true, rscClientRuntimePath, rscServerRuntimePath }) => ({
+  name: "uni-builder:rsc-rsbuild-plugin",
+  setup(api) {
+    api.modifyBundlerChain({
+      handler: async (chain, { isServer, CHAIN_ID }) => {
+        const entryPath2Name = /* @__PURE__ */ new Map();
+        for (const [name, entry] of Object.entries(chain.entryPoints.entries())) {
+          entry.values().forEach((value) => {
+            entryPath2Name.set(value, name);
+          });
+        }
+        const jsHandler = () => {
+          const originalJsRule = chain.module.rules.get(CHAIN_ID.RULE.JS);
+          const useBabel = originalJsRule.uses.has(CHAIN_ID.USE.BABEL);
+          const JSRule = useBabel ? CHAIN_ID.USE.BABEL : CHAIN_ID.USE.SWC;
+          if (originalJsRule) {
+            const jsLoaderOptions = originalJsRule.use(JSRule).get("options");
+            const jsLoaderPath = originalJsRule.use(JSRule).get("loader");
+            originalJsRule.uses.delete(JSRule);
+            chain.module.rule(CHAIN_ID.RULE.JS).oneOf("rsc-server").issuerLayer(import_common.webpackRscLayerName).use("rsc-server-loader").loader(require.resolve("../rsc-server-loader")).options({
+              entryPath2Name,
+              appDir,
+              runtimePath: rscServerRuntimePath
+            }).end().use(JSRule).loader(jsLoaderPath).options(jsLoaderOptions).end().end().oneOf("rsc-ssr").use("rsc-ssr-loader").loader(require.resolve("../rsc-ssr-loader")).options({
+              entryPath2Name
+            }).end().use(JSRule).loader(jsLoaderPath).options(jsLoaderOptions).end().end();
+          }
+        };
+        const layerHandler = () => {
+          chain.experiments({
+            ...chain.experiments,
+            layers: true
+          });
+          chain.module.rule("server-module").resource([
+            /render[/\\].*[/\\]server[/\\]rsc/,
+            /AppProxy/
+          ]).layer(import_common.webpackRscLayerName).end();
+          chain.module.rule(import_common.webpackRscLayerName).issuerLayer(import_common.webpackRscLayerName).resolve.conditionNames.add(import_common.webpackRscLayerName).add("...");
+        };
+        const flightCssHandler = () => {
+          CSS_RULE_NAMES.forEach((ruleName) => {
+            const rule = chain.module.rules.get(ruleName);
+            if (rule) {
+              chain.module.rule(ruleName).use("custom-loader").before("ignore-css").loader(require.resolve("../rsc-css-loader"));
+            }
+          });
+        };
+        const addServerRscPlugin = () => {
+          const ServerPlugin = isRspack ? import_rspack_rsc_server_plugin.RscServerPlugin : import_rsc_server_plugin.RscServerPlugin;
+          chain.plugin("rsc-server-plugin").use(ServerPlugin, [
+            {
+              entryPath2Name
+            }
+          ]);
+        };
+        const addRscClientLoader = () => {
+          chain.module.rule("js").use("rsc-client-loader").loader(require.resolve("../rsc-client-loader")).before("babel").options({
+            callServerImport: rscClientRuntimePath,
+            registerImport: rscClientRuntimePath
+          }).end();
+        };
+        const addRscClientPlugin = () => {
+          const ClientPlugin = isRspack ? import_rspack_rsc_client_plugin.RspackRscClientPlugin : import_rsc_client_plugin.RscClientPlugin;
+          chain.plugin("rsc-client-plugin").use(ClientPlugin);
+        };
+        const configureRuntimeChunk = () => {
+          chain.optimization.runtimeChunk({
+            name: (entrypoint) => `runtime-${entrypoint.name}`
+          });
+        };
+        if (isServer) {
+          chain.name("server");
+          layerHandler();
+          flightCssHandler();
+          jsHandler();
+          addServerRscPlugin();
+        } else {
+          chain.name("client");
+          chain.dependencies([
+            "server"
+          ]);
+          addRscClientLoader();
+          addRscClientPlugin();
+          configureRuntimeChunk();
+        }
+      },
+      order: "post"
+    });
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rsbuildRscPlugin
+});

package/dist/shared/rsc/plugins/rsc-client-plugin.d.ts

@@ -0,0 +1,13 @@
+import type Webpack from 'webpack';
+export interface RscClientPluginOptions {
+    readonly clientManifestFilename?: string;
+    readonly ssrManifestFilename?: string;
+}
+export declare class RscClientPlugin {
+    private clientReferencesMap;
+    private clientManifestFilename;
+    private ssrManifestFilename;
+    private styles?;
+    constructor(options?: RscClientPluginOptions);
+    apply(compiler: Webpack.Compiler): void;
+}

package/dist/shared/rsc/plugins/rsc-client-plugin.js

@@ -0,0 +1,205 @@
+"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_plugin_exports = {};
+__export(rsc_client_plugin_exports, {
+  RscClientPlugin: () => RscClientPlugin
+});
+module.exports = __toCommonJS(rsc_client_plugin_exports);
+var import_common = require("../common");
+class RscClientPlugin {
+  apply(compiler) {
+    const { AsyncDependenciesBlock, RuntimeGlobals, WebpackError, dependencies: { ModuleDependency, NullDependency }, sources: { RawSource } } = compiler.webpack;
+    const ssrManifest = {
+      moduleMap: {},
+      moduleLoading: null,
+      styles: []
+    };
+    class ClientReferenceDependency extends ModuleDependency {
+      get type() {
+        return `client-reference`;
+      }
+    }
+    const getEntryModule = (compilation) => {
+      const entryModules = [];
+      for (const [, entryValue] of compilation.entries.entries()) {
+        const entryDependency = entryValue.dependencies.find((dependency) => dependency.constructor.name === `EntryDependency`);
+        if (!entryDependency) {
+          compilation.errors.push(new WebpackError(`Could not find an entry dependency.`));
+          continue;
+        }
+        const resolvedModule = compilation.moduleGraph.getResolvedModule(entryDependency);
+        if (resolvedModule) {
+          entryModules.push(resolvedModule);
+        }
+      }
+      if (entryModules.length === 0) {
+        compilation.errors.push(new WebpackError(`Could not find any entries in the compilation.`));
+        return [];
+      }
+      return entryModules;
+    };
+    const addClientReferencesChunks = (entryModule) => {
+      [
+        ...this.clientReferencesMap.keys()
+      ].forEach((resourcePath, index) => {
+        const chunkName = `client${index}`;
+        const block = new AsyncDependenciesBlock({
+          name: chunkName
+        }, void 0, resourcePath);
+        block.addDependency(new ClientReferenceDependency(resourcePath));
+        entryModule.addBlock(block);
+      });
+      if (this.styles && this.styles.size > 0) {
+        for (const style of this.styles) {
+          const dep = new ClientReferenceDependency(style);
+          entryModule.addDependency(dep);
+        }
+      }
+    };
+    compiler.hooks.finishMake.tap(RscClientPlugin.name, (compilation) => {
+      if (compiler.watchMode) {
+        const entryModules = getEntryModule(compilation);
+        for (const entryModule of entryModules) {
+          entryModule.blocks = entryModule.blocks.filter((block) => block.dependencies.some((dependency) => !(dependency instanceof ClientReferenceDependency) || this.clientReferencesMap.has(dependency.request)));
+          addClientReferencesChunks(entryModule);
+        }
+      }
+    });
+    compiler.hooks.compilation.tap(RscClientPlugin.name, (compilation, { normalModuleFactory }) => {
+      compilation.dependencyFactories.set(ClientReferenceDependency, normalModuleFactory);
+      compilation.dependencyTemplates.set(ClientReferenceDependency, new NullDependency.Template());
+      class EntryNameRuntimeModule extends compiler.webpack.RuntimeModule {
+        generate() {
+          return `window.__MODERN_JS_ENTRY_NAME="${this.entryName}";`;
+        }
+        constructor(entryName) {
+          super("entry-name", 10);
+          this.entryName = entryName;
+        }
+      }
+      compilation.hooks.runtimeRequirementInTree.for(RuntimeGlobals.ensureChunk).tap(RscClientPlugin.name, (chunk, set) => {
+        Array.from(compilation.entrypoints.entries()).forEach(([entryName, entrypoint]) => {
+          if (entrypoint.chunks.includes(chunk)) {
+            compilation.addRuntimeModule(chunk, new EntryNameRuntimeModule(entryName));
+          }
+        });
+      });
+    });
+    compiler.hooks.thisCompilation.tap(RscClientPlugin.name, (compilation, { normalModuleFactory }) => {
+      this.styles = import_common.sharedData.get("styles");
+      this.clientReferencesMap = import_common.sharedData.get("clientReferencesMap");
+      const onNormalModuleFactoryParser = (parser) => {
+        parser.hooks.program.tap(RscClientPlugin.name, () => {
+          const entryModules = getEntryModule(compilation);
+          for (const entryModule of entryModules) {
+            if (entryModule === parser.state.module) {
+              addClientReferencesChunks(entryModule);
+            }
+          }
+        });
+      };
+      normalModuleFactory.hooks.parser.for(`javascript/auto`).tap(`HarmonyModulesPlugin`, onNormalModuleFactoryParser);
+      normalModuleFactory.hooks.parser.for(`javascript/dynamic`).tap(`HarmonyModulesPlugin`, onNormalModuleFactoryParser);
+      normalModuleFactory.hooks.parser.for(`javascript/esm`).tap(`HarmonyModulesPlugin`, onNormalModuleFactoryParser);
+      compilation.hooks.additionalTreeRuntimeRequirements.tap(RscClientPlugin.name, (_chunk, runtimeRequirements) => {
+        runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+        runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
+      });
+      compilation.hooks.processAssets.tap(RscClientPlugin.name, () => {
+        const clientManifest = {};
+        const { chunkGraph, moduleGraph, modules } = compilation;
+        for (const module2 of modules) {
+          const resourcePath = module2.nameForCondition();
+          const clientReferences = resourcePath ? this.clientReferencesMap.get(resourcePath) : void 0;
+          if (clientReferences) {
+            const moduleId = chunkGraph.getModuleId(module2);
+            const ssrModuleMetaData = {};
+            for (const { id, exportName, ssrId } of clientReferences) {
+              const clientExportName = exportName;
+              const ssrExportName = exportName;
+              const chunksSet = /* @__PURE__ */ new Set();
+              for (const chunk of chunkGraph.getModuleChunksIterable(module2)) {
+                chunksSet.add(chunk);
+              }
+              for (const connection of moduleGraph.getOutgoingConnections(module2)) {
+                for (const chunk of chunkGraph.getModuleChunksIterable(connection.module)) {
+                  chunksSet.add(chunk);
+                }
+              }
+              const chunks = [];
+              const styles = [];
+              for (const chunk of chunksSet) {
+                if (chunk.id && !chunk.isOnlyInitial()) {
+                  for (const file of chunk.files) {
+                    if (file.endsWith(".js")) {
+                      chunks.push(chunk.id, file);
+                    }
+                  }
+                }
+              }
+              clientManifest[id] = {
+                id: moduleId,
+                name: clientExportName,
+                chunks,
+                styles
+              };
+              if (ssrId) {
+                ssrModuleMetaData[clientExportName] = {
+                  id: ssrId,
+                  name: ssrExportName,
+                  chunks: []
+                };
+              }
+            }
+            ssrManifest.moduleMap[moduleId] = ssrModuleMetaData;
+          }
+        }
+        compilation.emitAsset(this.clientManifestFilename, new RawSource(JSON.stringify(clientManifest, null, 2), false));
+        const { crossOriginLoading, publicPath = `` } = compilation.outputOptions;
+        var _compilation_hash;
+        ssrManifest.moduleLoading = {
+          // https://github.com/webpack/webpack/blob/87660921808566ef3b8796f8df61bd79fc026108/lib/runtime/PublicPathRuntimeModule.js#L30-L32
+          prefix: compilation.getPath(publicPath, {
+            hash: (_compilation_hash = compilation.hash) !== null && _compilation_hash !== void 0 ? _compilation_hash : `XXXX`
+          }),
+          crossOrigin: crossOriginLoading ? crossOriginLoading === `use-credentials` ? crossOriginLoading : `` : void 0
+        };
+        if (this.styles && this.styles.size > 0) {
+          const assets = compilation.getAssets();
+          const cssAsset = assets.find((asset) => {
+            return asset.name.endsWith(".css");
+          });
+          if (cssAsset) {
+            ssrManifest.styles.push(cssAsset.name);
+          }
+        }
+        compilation.emitAsset(this.ssrManifestFilename, new RawSource(JSON.stringify(ssrManifest, null, 2), false));
+      });
+    });
+  }
+  constructor(options) {
+    this.clientReferencesMap = /* @__PURE__ */ new Map();
+    this.clientManifestFilename = (options === null || options === void 0 ? void 0 : options.clientManifestFilename) || `react-client-manifest.json`;
+    this.ssrManifestFilename = (options === null || options === void 0 ? void 0 : options.ssrManifestFilename) || `react-ssr-manifest.json`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RscClientPlugin
+});