@modern-js/uni-builder 2.64.1 → 2.64.3

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

@@ -0,0 +1,20 @@
+import type Webpack from 'webpack';
+export interface RscServerPluginOptions {
+    readonly serverManifestFilename?: string;
+    readonly entryPath2Name: Map<string, string>;
+}
+export interface ModuleExportsInfo {
+    readonly moduleResource: string;
+    readonly exportName: string;
+}
+export declare class RscServerPlugin {
+    private clientReferencesMap;
+    private serverReferencesMap;
+    private serverManifest;
+    private serverManifestFilename;
+    private entryPath2Name;
+    private styles;
+    constructor(options: RscServerPluginOptions);
+    private findModuleEntries;
+    apply(compiler: Webpack.Compiler): void;
+}

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

@@ -0,0 +1,272 @@
+"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_server_plugin_exports = {};
+__export(rsc_server_plugin_exports, {
+  RscServerPlugin: () => RscServerPlugin
+});
+module.exports = __toCommonJS(rsc_server_plugin_exports);
+var import_webpack = require("webpack");
+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 }, sources: { RawSource }, RuntimeGlobals } = compiler.webpack;
+    class ServerReferenceDependency extends NullDependency {
+      get type() {
+        return `server-reference`;
+      }
+    }
+    ServerReferenceDependency.Template = class ServerReferenceDependencyTemplate extends NullDependency.Template {
+      apply(_dependency, _source, { runtimeRequirements }) {
+        runtimeRequirements.add(RuntimeGlobals.moduleId);
+      }
+    };
+    function hasServerReferenceDependency(module2) {
+      return module2.dependencies.some((dependency) => dependency instanceof ServerReferenceDependency);
+    }
+    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);
+          }
+          if (module2 instanceof import_webpack.NormalModule) {
+            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.thisCompilation.tap(RscServerPlugin.name, (compilation, { normalModuleFactory }) => {
+      compilation.dependencyFactories.set(ServerReferenceDependency, normalModuleFactory);
+      compilation.dependencyTemplates.set(ServerReferenceDependency, new ServerReferenceDependency.Template());
+      const onNormalModuleFactoryParser = (parser) => {
+        parser.hooks.program.tap(RscServerPlugin.name, () => {
+          const { module: module2 } = parser.state;
+          const { resource } = module2;
+          const buildInfo = (0, import_common.getRscBuildInfo)(module2);
+          const isClientModule = (buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.type) === "client";
+          const isServerModule = (buildInfo === null || buildInfo === void 0 ? void 0 : buildInfo.type) === "server";
+          if (isServerModule && isClientModule) {
+            compilation.errors.push(new WebpackError(`Cannot use both 'use server' and 'use client' in the same module ${resource}.`));
+            return;
+          }
+          if (module2.layer === import_common.webpackRscLayerName && isServerModule && !hasServerReferenceDependency(module2)) {
+            module2.addDependency(new ServerReferenceDependency());
+          }
+        });
+        parser.hooks.expression.for(RuntimeGlobals.moduleId).tap(RscServerPlugin.name, () => {
+          parser.state.module.buildInfo.moduleArgument = RuntimeGlobals.module;
+          return true;
+        });
+      };
+      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.needAdditionalPass.tap(RscServerPlugin.name, () => !(needsAdditionalPass = !needsAdditionalPass));
+      compilation.hooks.afterOptimizeModuleIds.tap(RscServerPlugin.name, (modules) => {
+        for (const module2 of modules) {
+          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 (hasServerReferenceDependency(module2)) {
+            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}.`));
+            }
+          }
+        }
+      });
+      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/plugins/rspack-rsc-client-plugin.d.ts

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

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

@@ -0,0 +1,238 @@
+"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_rsc_client_plugin_exports = {};
+__export(rspack_rsc_client_plugin_exports, {
+  RspackRscClientPlugin: () => RspackRscClientPlugin
+});
+module.exports = __toCommonJS(rspack_rsc_client_plugin_exports);
+var import_path = __toESM(require("path"));
+var import_common = require("../common");
+const hasExtension = (filePath) => {
+  return import_path.default.extname(filePath) !== "";
+};
+class RspackRscClientPlugin {
+  apply(compiler) {
+    const {
+      EntryPlugin,
+      // AsyncDependenciesBlock,
+      RuntimeGlobals,
+      RuntimeModule,
+      WebpackError,
+      // dependencies: { ModuleDependency, NullDependency },
+      sources: { RawSource }
+    } = compiler.webpack;
+    const ssrManifest = {
+      moduleMap: {},
+      moduleLoading: null,
+      styles: []
+    };
+    const getEntryModule = (compilation) => {
+      const entryModules = [];
+      for (const [, entryValue] of compilation.entries.entries()) {
+        const entryDependency = entryValue.dependencies[0];
+        if (!entryDependency) {
+          compilation.errors.push(new WebpackError(`Could not find an entry dependency.`));
+          continue;
+        }
+        const resolvedModule = compilation.moduleGraph.getModule(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 = (compilation, entryModule, callback) => {
+      const promises = [];
+      [
+        ...this.clientReferencesMap.keys()
+      ].forEach((resourcePath, index) => {
+        const dependency = EntryPlugin.createDependency(resourcePath, {
+          name: resourcePath
+        });
+        const entries = compilation.entries.entries();
+        for (const [entryName, entry] of entries) {
+          if (hasExtension(entryName)) {
+            continue;
+          }
+          promises.push(new Promise((resolve, reject) => {
+            compilation.addInclude(compiler.context, dependency, {
+              name: entryName
+            }, (error, module2) => {
+              if (error) {
+                reject(error);
+              } else {
+                this.dependencies.push(dependency);
+                resolve(void 0);
+              }
+            });
+          }));
+        }
+      });
+      if (this.styles && this.styles.size > 0) {
+        for (const style of this.styles) {
+          const dependency = EntryPlugin.createDependency(style, {
+            name: style
+          });
+          promises.push(new Promise((resolve, reject) => {
+            compilation.addInclude(compiler.context, dependency, {
+              name: void 0
+            }, (error, module2) => {
+              if (error) {
+                reject(error);
+              } else {
+                this.dependencies.push(dependency);
+                resolve(void 0);
+              }
+            });
+          }));
+        }
+      }
+      Promise.all(promises).then(() => callback(null)).catch((error) => callback(error));
+    };
+    compiler.hooks.finishMake.tapAsync(RspackRscClientPlugin.name, (compilation, callback) => {
+      const entryModules = getEntryModule(compilation);
+      for (const entryModule of entryModules) {
+        if (entryModule) {
+          addClientReferencesChunks(compilation, entryModule, callback);
+        }
+      }
+    });
+    compiler.hooks.compilation.tap(RspackRscClientPlugin.name, (compilation, { normalModuleFactory }) => {
+      class EntryNameRuntimeModule extends 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(RspackRscClientPlugin.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(RspackRscClientPlugin.name, (compilation, { normalModuleFactory }) => {
+      this.styles = import_common.sharedData.get("styles");
+      this.clientReferencesMap = import_common.sharedData.get("clientReferencesMap");
+      compilation.hooks.additionalTreeRuntimeRequirements.tap(RspackRscClientPlugin.name, (_chunk, runtimeRequirements) => {
+        runtimeRequirements.add(RuntimeGlobals.ensureChunkHandlers);
+        runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+        runtimeRequirements.add(RuntimeGlobals.compatGetDefaultExport);
+      });
+      compilation.hooks.processAssets.tap(RspackRscClientPlugin.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) {
+                  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.dependencies = [];
+    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 = {
+  RspackRscClientPlugin
+});

package/dist/shared/rsc/plugins/rspack-rsc-server-plugin.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The plugin is developing, ignore it now
+ */
+import type Webpack from 'webpack';
+export interface RscServerPluginOptions {
+    readonly serverManifestFilename?: string;
+    readonly entryPath2Name: Map<string, string>;
+}
+export interface ModuleExportsInfo {
+    readonly moduleResource: string;
+    readonly exportName: string;
+}
+export declare class RscServerPlugin {
+    private clientReferencesMap;
+    private serverReferencesMap;
+    private serverManifest;
+    private serverManifestFilename;
+    private entryPath2Name;
+    private styles;
+    constructor(options: RscServerPluginOptions);
+    private findModuleEntries;
+    apply(compiler: Webpack.Compiler): void;
+}