@vitejs/plugin-rsc 0.5.10 → 0.5.11

package/README.md

@@ -224,11 +224,13 @@ The plugin provides an additional helper for multi environment interaction.
 
 #### `import.meta.viteRsc.loadModule`
 
-- Type: `(environmentName: "ssr" | "rsc", entryName: string) => Promise<T>`
+- Type: `(environmentName: "ssr" | "rsc", entryName?: string) => Promise<T>`
 
-This allows importing `ssr` environment module specified by `environments.ssr.build.rollupOptions.input[entryName]` inside `rsc` environment and vice versa.
+This allows importing `ssr` environment module specified by `environments.ssr.build.rollupOptions.input[entryName]` inside `rsc` environment and vice versa. When `entryName` is omitted, the function automatically uses the single entry from the target environment's `rollupOptions.input`.
 
-During development, by default, this API assumes both `rsc` and `ssr` environments execute under the main Vite process. When enabling `rsc({ loadModuleDevProxy: true })` plugin option, the loaded module is implemented as a proxy with `fetch`-based RPC to call in node environment on the main Vite process, which for example, allows `rsc` environment inside cloudflare workers to access `ssr` environment on the main Vite process. This proxy mechanism uses [turbo-stream](https://github.com/jacob-ebey/turbo-stream) for serializing data types beyond JSON, with custom encoders/decoders to additionally support `Request` and `Response` instances.
+During development, by default, this API assumes both `rsc` and `ssr` environments execute under the main Vite process as `RunnableDevEnvironment`. Internally, `loadModule` uses the global `__VITE_ENVIRONMENT_RUNNER_IMPORT__` function to import modules in the target environment (see [`__VITE_ENVIRONMENT_RUNNER_IMPORT__`](#__vite_environment_runner_import__) below).
+
+When enabling `rsc({ loadModuleDevProxy: true })` plugin option, the loaded module is implemented as a proxy with `fetch`-based RPC to call in node environment on the main Vite process, which for example, allows `rsc` environment inside cloudflare workers to access `ssr` environment on the main Vite process. This proxy mechanism uses [turbo-stream](https://github.com/jacob-ebey/turbo-stream) for serializing data types beyond JSON, with custom encoders/decoders to additionally support `Request` and `Response` instances.
 
 During production build, this API will be rewritten into a static import of the specified entry of other environment build and the modules are executed inside the same runtime.
 
@@ -327,6 +329,35 @@ import.meta.hot.on('rsc:update', async () => {
 })
 ```
 
+### Global API
+
+#### `__VITE_ENVIRONMENT_RUNNER_IMPORT__`
+
+- Type: `(environmentName: string, id: string) => Promise<any>`
+
+This global function provides a standardized way to import a module in a given environment during development. It is used internally by `import.meta.viteRsc.loadModule` to execute modules in the target environment.
+
+By default, the plugin sets this global to import via the environment's module runner:
+
+```js
+globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__ = async (environmentName, id) => {
+  return server.environments[environmentName].runner.import(id)
+}
+```
+
+**Custom Environment Integration:**
+
+Frameworks with custom environment setups (e.g., environments running in separate workers or with custom module loading) can override this global to provide their own module import logic.
+
+```js
+// Custom logic to import module between multiple environments inside worker
+globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__ = async (environmentName, id) => {
+  return myWorkerRunners[environmentname].import(id)
+}
+```
+
+This allows `import.meta.viteRsc.loadModule` to work seamlessly with different runtime configurations without requiring changes to user code.
+
 ## Plugin API
 
 ### `@vitejs/plugin-rsc`
@@ -519,7 +550,7 @@ Types for global API are defined in `@vitejs/plugin-rsc/types`. For example, you
 ```ts
 import.meta.viteRsc.loadModule
 //                  ^^^^^^^^^^
-// <T>(environmentName: string, entryName: string) => Promise<T>
+// <T>(environmentName: string, entryName?: string) => Promise<T>
 ```
 
 See also [Vite documentation](https://vite.dev/guide/api-hmr.html#intellisense-for-typescript) for `vite/client` types.

package/dist/index.js

@@ -1,6 +1,6 @@
 import "./transforms-BcLQCXiC.js";
 import "./rpc-CRpYrgKq.js";
-import { r as vitePluginRsc, t as getPluginApi } from "./plugin-DNlyqBiD.js";
+import { r as vitePluginRsc, t as getPluginApi } from "./plugin-BcfVRLx-.js";
 import "./cjs-DHD_0drE.js";
 
 export { vitePluginRsc as default, getPluginApi };

package/dist/{plugin-DNlyqBiD.js → plugin-BcfVRLx-.js}

@@ -128,10 +128,27 @@ function normalizeRelativePath(s) {
 	s = normalizePath(s);
 	return s[0] === "." ? s : "./" + s;
 }
-function getEntrySource(config, name = "index") {
+function getEntrySource(config, name) {
 	const input = config.build.rollupOptions.input;
-	assert(typeof input === "object" && !Array.isArray(input) && name in input && typeof input[name] === "string", `[vite-rsc:getEntrySource] expected 'build.rollupOptions.input' to be an object with a '${name}' property that is a string, but got ${JSON.stringify(input)}`);
-	return input[name];
+	if (!name) return getFallbackRollupEntry(input).source;
+	if (typeof input === "object" && !Array.isArray(input) && name in input && typeof input[name] === "string") return input[name];
+	throw new Error(`[vite-rsc:getEntrySource] expected 'build.rollupOptions.input' to be an object with a '${name}' property that is a string, but got ${JSON.stringify(input)}`);
+}
+function getFallbackRollupEntry(input = {}) {
+	const inputEntries = Object.entries(normalizeRollupOpitonsInput(input));
+	if (inputEntries.length === 1) {
+		const [name, source] = inputEntries[0];
+		return {
+			name,
+			source
+		};
+	}
+	throw new Error(`[vite-rsc] cannot determine fallback entry name from multiple entries, please specify the entry name explicitly`);
+}
+function normalizeRollupOpitonsInput(input = {}) {
+	if (typeof input === "string") input = [input];
+	if (Array.isArray(input)) return Object.fromEntries(input.map((file) => [path.basename(file).slice(0, -path.extname(file).length), file]));
+	return input;
 }
 function hashString(v) {
 	return createHash("sha256").update(v).digest().toString("hex").slice(0, 12);
@@ -554,7 +571,12 @@ function vitePluginRsc(rscPluginOptions = {}) {
 				if (rscPluginOptions.useBuildAppHook) await buildApp(builder);
 			} },
 			configureServer(server) {
-				globalThis.__viteRscDevServer = server;
+				globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__ = async function(environmentName, id) {
+					const environment$1 = server.environments[environmentName];
+					if (!environment$1) throw new Error(`[vite-rsc] unknown environment '${environmentName}'`);
+					if (!vite.isRunnableDevEnvironment(environment$1)) throw new Error(`[vite-rsc] environment '${environmentName}' is not runnable`);
+					return environment$1.runner.import(id);
+				};
 				const oldSend = server.environments.client.hot.send;
 				server.environments.client.hot.send = async function(...args) {
 					const e = args[0];
@@ -698,8 +720,16 @@ function vitePluginRsc(rscPluginOptions = {}) {
 						const source = getEntrySource(environment.config, entryName);
 						const resolved = await environment.pluginContainer.resolveId(source);
 						assert(resolved, `[vite-rsc] failed to resolve entry '${source}'`);
-						replacement = `globalThis.__viteRscDevServer.environments[${JSON.stringify(environmentName)}].runner.import(${JSON.stringify(resolved.id)})`;
-					} else replacement = JSON.stringify(`__vite_rsc_load_module:${this.environment.name}:${environmentName}:${entryName}`);
+						replacement = `globalThis.__VITE_ENVIRONMENT_RUNNER_IMPORT__(${JSON.stringify(environmentName)}, ${JSON.stringify(resolved.id)})`;
+					} else {
+						const environment = manager.config.environments[environmentName];
+						const targetName = entryName || getFallbackRollupEntry(environment.build.rollupOptions.input).name;
+						replacement = JSON.stringify(`__vite_rsc_load_module_start__:` + JSON.stringify({
+							fromEnv: this.environment.name,
+							toEnv: environmentName,
+							targetFileName: `${targetName}.js`
+						}) + `:__vite_rsc_load_module_end__`);
+					}
 					const [start, end] = match.indices[0];
 					s.overwrite(start, end, replacement);
 				}
@@ -712,9 +742,10 @@ function vitePluginRsc(rscPluginOptions = {}) {
 				if (!code.includes("__vite_rsc_load_module")) return;
 				const { config } = manager;
 				const s = new MagicString(code);
-				for (const match of code.matchAll(/['"]__vite_rsc_load_module:(\w+):(\w+):(\w+)['"]/dg)) {
-					const [fromEnv, toEnv, entryName] = match.slice(1);
-					const importPath = normalizeRelativePath(path.relative(path.join(config.environments[fromEnv].build.outDir, chunk.fileName, ".."), path.join(config.environments[toEnv].build.outDir, `${entryName}.js`)));
+				for (const match of code.matchAll(/[`'"]__vite_rsc_load_module_start__:([\s\S]*?):__vite_rsc_load_module_end__[`'"]/dg)) {
+					const markerString = evalValue(match[0]);
+					const { fromEnv, toEnv, targetFileName } = JSON.parse(markerString.slice(31, -29));
+					const importPath = normalizeRelativePath(path.relative(path.join(config.environments[fromEnv].build.outDir, chunk.fileName, ".."), path.join(config.environments[toEnv].build.outDir, targetFileName)));
 					const replacement = `(import(${JSON.stringify(importPath)}))`;
 					const [start, end] = match.indices[0];
 					s.overwrite(start, end, replacement);
@@ -732,7 +763,6 @@ function vitePluginRsc(rscPluginOptions = {}) {
 				async function createHandler(url) {
 					const { environmentName, entryName } = Object.fromEntries(url.searchParams);
 					assert(environmentName);
-					assert(entryName);
 					const environment = server.environments[environmentName];
 					const source = getEntrySource(environment.config, entryName);
 					const resolvedEntry = await environment.pluginContainer.resolveId(source);

package/dist/plugin.d.ts

@@ -112,6 +112,9 @@ type PluginApi = {
 declare function getPluginApi(config: Pick<ResolvedConfig, "plugins">): PluginApi | undefined;
 /** @experimental */
 declare function vitePluginRscMinimal(rscPluginOptions?: RscPluginOptions, manager?: RscPluginManager): Plugin[];
+declare global {
+  function __VITE_ENVIRONMENT_RUNNER_IMPORT__(environmentName: string, id: string): Promise<any>;
+}
 declare function vitePluginRsc(rscPluginOptions?: RscPluginOptions): Plugin[];
 declare class RuntimeAsset {
   runtime: string;

package/dist/plugin.js

@@ -1,6 +1,6 @@
 import "./transforms-BcLQCXiC.js";
 import "./rpc-CRpYrgKq.js";
-import { i as vitePluginRscMinimal, n as transformRscCssExport, r as vitePluginRsc, t as getPluginApi } from "./plugin-DNlyqBiD.js";
+import { i as vitePluginRscMinimal, n as transformRscCssExport, r as vitePluginRsc, t as getPluginApi } from "./plugin-BcfVRLx-.js";
 import "./cjs-DHD_0drE.js";
 
 export { vitePluginRsc as default, getPluginApi, transformRscCssExport, vitePluginRscMinimal };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitejs/plugin-rsc",
-  "version": "0.5.10",
+  "version": "0.5.11",
   "description": "React Server Components (RSC) support for Vite.",
   "keywords": [
     "vite",

package/types/index.d.ts

@@ -2,7 +2,7 @@ declare global {
   interface ImportMeta {
     readonly viteRsc: {
       loadCss: (importer?: string) => import('react').ReactNode
-      loadModule: <T>(environmentName: string, entryName: string) => Promise<T>
+      loadModule: <T>(environmentName: string, entryName?: string) => Promise<T>
       loadBootstrapScriptContent: (entryName: string) => Promise<string>
     }
   }