@vitejs/plugin-rsc 0.5.21 → 0.5.22

package/dist/transforms/index.js

@@ -1,3 +1,367 @@
-import { a as hasDirective, c as transformHoistInlineDirective, i as getExportNames, n as transformDirectiveProxyExport, o as transformWrapExport, r as transformProxyExport, s as findDirectives, t as transformServerActionServer } from "../server-action-JkEy-6yW.js";
-
-export { findDirectives, getExportNames, hasDirective, transformDirectiveProxyExport, transformHoistInlineDirective, transformProxyExport, transformServerActionServer, transformWrapExport };
+import { i as tinyassert } from "../dist-rz-Bnebz.js";
+import { a as hasDirective, i as getExportNames, n as extractIdentifiers, o as validateNonAsyncFunction, r as extractNames, t as buildScopeTree } from "../scope-DKCDtt0O.js";
+import MagicString from "magic-string";
+import { walk } from "estree-walker";
+//#region src/transforms/hoist.ts
+function transformHoistInlineDirective(input, ast, { runtime, rejectNonAsyncFunction, ...options }) {
+	if (!input.endsWith("\n")) input += "\n";
+	const output = new MagicString(input);
+	const directive = typeof options.directive === "string" ? exactRegex(options.directive) : options.directive;
+	const scopeTree = buildScopeTree(ast);
+	const names = [];
+	walk(ast, { enter(node, parent) {
+		if ((node.type === "FunctionExpression" || node.type === "FunctionDeclaration" || node.type === "ArrowFunctionExpression") && node.body.type === "BlockStatement") {
+			const match = matchDirective(node.body.body, directive)?.match;
+			if (!match) return;
+			if (!node.async && rejectNonAsyncFunction) throw Object.assign(/* @__PURE__ */ new Error(`"${directive}" doesn't allow non async function`), { pos: node.start });
+			const declName = node.type === "FunctionDeclaration" && node.id.name;
+			const originalName = declName || parent?.type === "VariableDeclarator" && parent.id.type === "Identifier" && parent.id.name || "anonymous_server_function";
+			const bindVars = getBindVars(node, scopeTree);
+			let newParams = [...bindVars.map((b) => b.root), ...node.params.map((n) => input.slice(n.start, n.end))].join(", ");
+			if (bindVars.length > 0 && options.decode) {
+				newParams = ["$$hoist_encoded", ...node.params.map((n) => input.slice(n.start, n.end))].join(", ");
+				output.appendLeft(node.body.body[0].start, `const [${bindVars.map((b) => b.root).join(",")}] = ${options.decode("$$hoist_encoded")};\n`);
+			}
+			const newName = `$$hoist_${names.length}` + (originalName ? `_${originalName}` : "");
+			names.push(newName);
+			output.update(node.start, node.body.start, `\n;${options.noExport ? "" : "export "}${node.async ? "async " : ""}function ${newName}(${newParams}) `);
+			output.appendLeft(node.end, `;\n/* #__PURE__ */ Object.defineProperty(${newName}, "name", { value: ${JSON.stringify(originalName)} });\n`);
+			output.move(node.start, node.end, input.length);
+			let newCode = `/* #__PURE__ */ ${runtime(newName, newName, { directiveMatch: match })}`;
+			if (bindVars.length > 0) {
+				const bindArgs = options.encode ? options.encode("[" + bindVars.map((b) => b.expr).join(", ") + "]") : bindVars.map((b) => b.expr).join(", ");
+				newCode = `${newCode}.bind(null, ${bindArgs})`;
+			}
+			if (declName) {
+				newCode = `const ${declName} = ${newCode};`;
+				if (parent?.type === "ExportDefaultDeclaration") {
+					output.remove(parent.start, node.start);
+					newCode = `${newCode}\nexport default ${declName};`;
+				}
+			}
+			output.appendLeft(node.start, newCode);
+		}
+	} });
+	return {
+		output,
+		names
+	};
+}
+const exactRegex = (s) => new RegExp("^" + s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&") + "$");
+function matchDirective(body, directive) {
+	for (const stmt of body) if (stmt.type === "ExpressionStatement" && stmt.expression.type === "Literal" && typeof stmt.expression.value === "string") {
+		const match = stmt.expression.value.match(directive);
+		if (match) return {
+			match,
+			node: stmt.expression
+		};
+	}
+}
+function findDirectives(ast, directive) {
+	const directiveRE = exactRegex(directive);
+	const nodes = [];
+	walk(ast, { enter(node) {
+		if (node.type === "Program" || node.type === "BlockStatement") {
+			const match = matchDirective(node.body, directiveRE);
+			if (match) nodes.push(match.node);
+		}
+	} });
+	return nodes;
+}
+function getBindVars(fn, scopeTree) {
+	const fnScope = scopeTree.nodeScope.get(fn);
+	const ancestorScopes = fnScope.getAncestorScopes();
+	const bindReferences = (scopeTree.scopeToReferences.get(fnScope) ?? []).filter((id) => {
+		const scope = scopeTree.referenceToDeclaredScope.get(id);
+		return scope && scope !== scopeTree.moduleScope && ancestorScopes.has(scope);
+	});
+	const accessMap = {};
+	for (const id of bindReferences) {
+		const name = id.name;
+		const node = scopeTree.referenceToNode.get(id);
+		if (node.type === "Identifier") {
+			accessMap[name] = { kind: "bare" };
+			continue;
+		}
+		accessMap[name] ??= {
+			kind: "paths",
+			paths: []
+		};
+		const entry = accessMap[name];
+		if (entry.kind === "paths") {
+			const path = memberExpressionToPath(node);
+			if (!entry.paths.some((existing) => existing.key === path.key)) entry.paths.push(path);
+		}
+	}
+	const result = [];
+	for (const [root, entry] of Object.entries(accessMap)) {
+		if (entry.kind === "bare") {
+			result.push({
+				root,
+				expr: root
+			});
+			continue;
+		}
+		result.push({
+			root,
+			expr: synthesizePartialObject(root, entry.paths)
+		});
+	}
+	return result;
+}
+function memberExpressionToPath(node) {
+	const segments = [];
+	let current = node;
+	while (current.type === "MemberExpression") {
+		tinyassert(current.property.type === "Identifier");
+		segments.unshift(current.property.name);
+		tinyassert(current.object.type === "Identifier" || current.object.type === "MemberExpression");
+		current = current.object;
+	}
+	return {
+		key: segments.join("."),
+		segments
+	};
+}
+function synthesizePartialObject(root, bindPaths) {
+	const trie = /* @__PURE__ */ new Map();
+	const paths = dedupeByPrefix(bindPaths.map((p) => p.segments));
+	for (const path of paths) {
+		let node = trie;
+		for (let i = 0; i < path.length; i++) {
+			const segment = path[i];
+			let child = node.get(segment);
+			if (!child) {
+				child = /* @__PURE__ */ new Map();
+				node.set(segment, child);
+			}
+			node = child;
+		}
+	}
+	function serialize(node, segments) {
+		if (node.size === 0) return root + segments.map((segment) => `.${segment}`).join("");
+		const entries = [];
+		for (const [key, child] of node) {
+			const safeKey = key === "__proto__" ? `["__proto__"]` : key;
+			entries.push(`${safeKey}: ${serialize(child, [...segments, key])}`);
+		}
+		return `{ ${entries.join(", ")} }`;
+	}
+	return serialize(trie, []);
+}
+function dedupeByPrefix(paths) {
+	const sorted = [...paths].sort((a, b) => a.length - b.length);
+	const result = [];
+	for (const path of sorted) if (!result.some((existingPath) => existingPath.every((segment, i) => segment === path[i]))) result.push(path);
+	return result;
+}
+//#endregion
+//#region src/transforms/wrap-export.ts
+function transformWrapExport(input, ast, options) {
+	const output = new MagicString(input);
+	const exportNames = [];
+	const toAppend = [];
+	const filter = options.filter ?? (() => true);
+	function wrapSimple(start, end, exports) {
+		exportNames.push(...exports.map((e) => e.name));
+		const newCode = exports.map((e) => [filter(e.name, e.meta) && `${e.name} = /* #__PURE__ */ ${options.runtime(e.name, e.name, e.meta)};\n`, `export { ${e.name} };\n`]).flat().filter(Boolean).join("");
+		output.update(start, end, newCode);
+		output.move(start, end, input.length);
+	}
+	function wrapExport(name, exportName, meta = {}) {
+		exportNames.push(exportName);
+		if (!filter(exportName, meta)) {
+			toAppend.push(`export { ${name} as ${exportName} }`);
+			return;
+		}
+		toAppend.push(`const $$wrap_${name} = /* #__PURE__ */ ${options.runtime(name, exportName, meta)}`, `export { $$wrap_${name} as ${exportName} }`);
+	}
+	for (const node of ast.body) {
+		if (node.type === "ExportNamedDeclaration") if (node.declaration) if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
+			/**
+			* export function foo() {}
+			*/
+			validateNonAsyncFunction(options, node.declaration);
+			const name = node.declaration.id.name;
+			wrapSimple(node.start, node.declaration.start, [{
+				name,
+				meta: {
+					isFunction: true,
+					declName: name
+				}
+			}]);
+		} else if (node.declaration.type === "VariableDeclaration") {
+			/**
+			* export const foo = 1, bar = 2
+			*/
+			for (const decl of node.declaration.declarations) if (decl.init) validateNonAsyncFunction(options, decl.init);
+			if (node.declaration.kind === "const") output.update(node.declaration.start, node.declaration.start + 5, "let");
+			const names = node.declaration.declarations.flatMap((decl) => extractNames(decl.id));
+			let isFunction = false;
+			if (node.declaration.declarations.length === 1) {
+				const decl = node.declaration.declarations[0];
+				isFunction = decl.id.type === "Identifier" && (decl.init?.type === "ArrowFunctionExpression" || decl.init?.type === "FunctionExpression");
+			}
+			wrapSimple(node.start, node.declaration.start, names.map((name) => ({
+				name,
+				meta: {
+					isFunction,
+					declName: name
+				}
+			})));
+		} else node.declaration;
+		else if (node.source) {
+			/**
+			* export { foo, bar as car } from './foo'
+			*/
+			output.remove(node.start, node.end);
+			for (const spec of node.specifiers) {
+				tinyassert(spec.local.type === "Identifier");
+				tinyassert(spec.exported.type === "Identifier");
+				const name = spec.local.name;
+				toAppend.push(`import { ${name} as $$import_${name} } from ${node.source.raw}`);
+				wrapExport(`$$import_${name}`, spec.exported.name);
+			}
+		} else {
+			/**
+			* export { foo, bar as car }
+			*/
+			output.remove(node.start, node.end);
+			for (const spec of node.specifiers) {
+				tinyassert(spec.local.type === "Identifier");
+				tinyassert(spec.exported.type === "Identifier");
+				wrapExport(spec.local.name, spec.exported.name);
+			}
+		}
+		/**
+		* export * from './foo'
+		*/
+		if (!options.ignoreExportAllDeclaration && node.type === "ExportAllDeclaration") throw Object.assign(/* @__PURE__ */ new Error("unsupported ExportAllDeclaration"), { pos: node.start });
+		/**
+		* export default function foo() {}
+		* export default class Foo {}
+		* export default () => {}
+		*/
+		if (node.type === "ExportDefaultDeclaration") {
+			validateNonAsyncFunction(options, node.declaration);
+			let localName;
+			let isFunction = false;
+			let declName;
+			let defaultExportIdentifierName;
+			if ((node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") && node.declaration.id) {
+				localName = node.declaration.id.name;
+				output.remove(node.start, node.declaration.start);
+				isFunction = node.declaration.type === "FunctionDeclaration";
+				declName = node.declaration.id.name;
+			} else {
+				localName = "$$default";
+				output.update(node.start, node.declaration.start, "const $$default = ");
+				if (node.declaration.type === "Identifier") defaultExportIdentifierName = node.declaration.name;
+			}
+			wrapExport(localName, "default", {
+				isFunction,
+				declName,
+				defaultExportIdentifierName
+			});
+		}
+	}
+	if (toAppend.length > 0) output.append([
+		"",
+		...toAppend,
+		""
+	].join(";\n"));
+	return {
+		exportNames,
+		output
+	};
+}
+//#endregion
+//#region src/transforms/proxy-export.ts
+function transformDirectiveProxyExport(ast, options) {
+	if (!hasDirective(ast.body, options.directive)) return;
+	return transformProxyExport(ast, options);
+}
+function transformProxyExport(ast, options) {
+	if (options.keep && typeof options.code !== "string") throw new Error("`keep` option requires `code`");
+	const output = new MagicString(options.code ?? " ".repeat(ast.end));
+	const exportNames = [];
+	function createExport(node, names) {
+		exportNames.push(...names);
+		const newCode = names.map((name) => (name === "default" ? `export default` : `export const ${name} =`) + ` /* #__PURE__ */ ${options.runtime(name)};\n`).join("");
+		output.update(node.start, node.end, newCode);
+	}
+	for (const node of ast.body) {
+		if (node.type === "ExportNamedDeclaration") {
+			if (node.declaration) if (node.declaration.type === "FunctionDeclaration" || node.declaration.type === "ClassDeclaration") {
+				/**
+				* export function foo() {}
+				*/
+				validateNonAsyncFunction(options, node.declaration);
+				createExport(node, [node.declaration.id.name]);
+			} else if (node.declaration.type === "VariableDeclaration") {
+				/**
+				* export const foo = 1, bar = 2
+				*/
+				for (const decl of node.declaration.declarations) if (decl.init) validateNonAsyncFunction(options, decl.init);
+				if (options.keep && options.code) {
+					if (node.declaration.declarations.length === 1) {
+						const decl = node.declaration.declarations[0];
+						if (decl.id.type === "Identifier" && decl.init) {
+							const name = decl.id.name;
+							const value = options.code.slice(decl.init.start, decl.init.end);
+							const newCode = `export const ${name} = /* #__PURE__ */ ${options.runtime(name, { value })};`;
+							output.update(node.start, node.end, newCode);
+							exportNames.push(name);
+							continue;
+						}
+					}
+				}
+				createExport(node, node.declaration.declarations.flatMap((decl) => extractNames(decl.id)));
+			} else node.declaration;
+			else {
+				/**
+				* export { foo, bar as car } from './foo'
+				* export { foo, bar as car }
+				*/
+				const names = [];
+				for (const spec of node.specifiers) {
+					tinyassert(spec.exported.type === "Identifier");
+					names.push(spec.exported.name);
+				}
+				createExport(node, names);
+			}
+			continue;
+		}
+		/**
+		* export * from './foo'
+		*/
+		if (!options.ignoreExportAllDeclaration && node.type === "ExportAllDeclaration") throw new Error("unsupported ExportAllDeclaration");
+		/**
+		* export default function foo() {}
+		* export default class Foo {}
+		* export default () => {}
+		*/
+		if (node.type === "ExportDefaultDeclaration") {
+			validateNonAsyncFunction(options, node.declaration);
+			createExport(node, ["default"]);
+			continue;
+		}
+		if (options.keep) continue;
+		output.remove(node.start, node.end);
+	}
+	return {
+		exportNames,
+		output
+	};
+}
+//#endregion
+//#region src/transforms/server-action.ts
+function transformServerActionServer(input, ast, options) {
+	if (hasDirective(ast.body, "use server")) return transformWrapExport(input, ast, options);
+	return transformHoistInlineDirective(input, ast, {
+		...options,
+		directive: "use server"
+	});
+}
+//#endregion
+export { extractIdentifiers, extractNames, findDirectives, getExportNames, hasDirective, transformDirectiveProxyExport, transformHoistInlineDirective, transformProxyExport, transformServerActionServer, transformWrapExport, validateNonAsyncFunction };

package/dist/utils/encryption-runtime.js

@@ -1,8 +1,7 @@
-import { r as once } from "../dist-yW9-EeG1.js";
-import { a as fromBase64, i as encryptBuffer, n as concatArrayStream, r as decryptBuffer, t as arrayToStream } from "../encryption-utils-Bk5eKdu6.js";
+import { r as once } from "../dist-rz-Bnebz.js";
+import { a as fromBase64, i as encryptBuffer, n as concatArrayStream, r as decryptBuffer, t as arrayToStream } from "../encryption-utils-BblioYEx.js";
 import { createFromReadableStream, renderToReadableStream } from "../react/rsc.js";
 import encryptionKeySource from "virtual:vite-rsc/encryption-key";
-
 //#region src/utils/encryption-runtime.ts
 async function encryptActionBoundArgs(originalValue) {
 	return encryptBuffer(await concatArrayStream(renderToReadableStream(originalValue)), await getEncryptionKey());
@@ -15,6 +14,5 @@ const getEncryptionKey = /* @__PURE__ */ once(async () => {
 	const resolved = await encryptionKeySource();
 	return await crypto.subtle.importKey("raw", fromBase64(resolved), { name: "AES-GCM" }, true, ["encrypt", "decrypt"]);
 });
-
 //#endregion
-export { decryptActionBoundArgs, encryptActionBoundArgs };
+export { decryptActionBoundArgs, encryptActionBoundArgs };

package/dist/utils/rpc.js

@@ -1,5 +1,4 @@
 import { decode, encode } from "turbo-stream";
-
 //#region src/utils/rpc.ts
 const decodePlugins = [(type, ...rest) => {
 	switch (type) {
@@ -86,6 +85,5 @@ function createRpcClient(options) {
 		return (...args) => callRpc(p, args);
 	} });
 }
-
 //#endregion
-export { createRpcClient, createRpcServer };
+export { createRpcClient, createRpcServer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitejs/plugin-rsc",
-  "version": "0.5.21",
+  "version": "0.5.22",
   "description": "React Server Components (RSC) support for Vite.",
   "keywords": [
     "react",
@@ -39,22 +39,21 @@
     "prepack": "tsdown"
   },
   "dependencies": {
-    "@rolldown/pluginutils": "1.0.0-rc.5",
+    "@rolldown/pluginutils": "1.0.0-rc.13",
     "es-module-lexer": "^2.0.0",
     "estree-walker": "^3.0.3",
     "magic-string": "^0.30.21",
-    "periscopic": "^4.0.2",
-    "srvx": "^0.11.7",
+    "srvx": "^0.11.15",
     "strip-literal": "^3.1.0",
-    "turbo-stream": "^3.1.0",
-    "vitefu": "^1.1.1"
+    "turbo-stream": "^3.2.0",
+    "vitefu": "^1.1.3"
   },
   "devDependencies": {
     "@hiogawa/utils": "^1.7.0",
-    "@playwright/test": "^1.58.2",
+    "@playwright/test": "^1.59.1",
     "@tsconfig/strictest": "^2.0.8",
     "@types/estree": "^1.0.8",
-    "@types/node": "^24.10.13",
+    "@types/node": "^24.12.2",
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "workspace:*",
@@ -64,8 +63,8 @@
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "react-server-dom-webpack": "^19.2.4",
-    "tinyexec": "^1.0.2",
-    "tsdown": "^0.20.3"
+    "tinyexec": "^1.0.4",
+    "tsdown": "^0.21.7"
   },
   "peerDependencies": {
     "react": "*",

package/dist/cjs-v2jRTNln.js

@@ -1,59 +0,0 @@
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import MagicString from "magic-string";
-import { walk } from "estree-walker";
-import { analyze } from "periscopic";
-
-//#region src/transforms/cjs.ts
-function __cjs_interop__(m) {
-	return m.__cjs_module_runner_transform || "default" in m && Object.keys(m).every((k) => k === "default" || m[k] === m.default[k]) ? m.default : m;
-}
-const CJS_INTEROP_HELPER = __cjs_interop__.toString().replace(/\n\s*/g, "");
-function transformCjsToEsm(code, ast, options) {
-	const output = new MagicString(code);
-	const analyzed = analyze(ast);
-	const parentNodes = [];
-	const hoistedCodes = [];
-	let hoistIndex = 0;
-	walk(ast, {
-		enter(node) {
-			parentNodes.push(node);
-			if (node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "require" && node.arguments.length === 1) {
-				let isTopLevel = true;
-				for (const parent of parentNodes) {
-					if (parent.type === "FunctionExpression" || parent.type === "FunctionDeclaration" || parent.type === "ArrowFunctionExpression") isTopLevel = false;
-					const scope = analyzed.map.get(parent);
-					if (scope && scope.declarations.has("require")) return;
-				}
-				if (isTopLevel) {
-					output.update(node.start, node.callee.end, "(__cjs_interop__(await import");
-					output.appendRight(node.end, "))");
-				} else {
-					const hoisted = `__cjs_to_esm_hoist_${hoistIndex}`;
-					const importee = code.slice(node.arguments[0].start, node.arguments[0].end);
-					hoistedCodes.push(`const ${hoisted} = __cjs_interop__(await import(${importee}));\n`);
-					output.update(node.start, node.end, hoisted);
-					hoistIndex++;
-				}
-			}
-		},
-		leave() {
-			parentNodes.pop();
-		}
-	});
-	for (const hoisted of hoistedCodes.reverse()) output.prepend(hoisted);
-	if (output.hasChanged()) output.prepend(`${CJS_INTEROP_HELPER}\n`);
-	output.prepend(`let exports = {}; const module = { exports };\n`);
-	const __filename = fileURLToPath(pathToFileURL(options.id).href);
-	const __dirname = path.dirname(__filename);
-	output.prepend(`let __filename = ${JSON.stringify(__filename)}; let __dirname = ${JSON.stringify(__dirname)};\n`);
-	output.append(`
-;__vite_ssr_exportAll__(module.exports);
-export default module.exports;
-export const __cjs_module_runner_transform = true;
-`);
-	return { output };
-}
-
-//#endregion
-export { transformCjsToEsm as t };

package/dist/import-environment-B994HXEc.d.ts

@@ -1,11 +0,0 @@
-import { Plugin, ResolvedConfig } from "vite";
-
-//#region src/plugins/import-environment.d.ts
-type EnvironmentImportMeta = {
-  resolvedId: string;
-  targetEnv: string;
-  sourceEnv: string;
-  specifier: string;
-};
-//#endregion
-export { EnvironmentImportMeta as t };

package/dist/index-BIbdRBfk.d.ts

@@ -1,26 +0,0 @@
-//#region src/types/index.d.ts
-interface ImportManifestEntry {
-  id: string;
-  name: string;
-  chunks: string[];
-  async?: boolean;
-}
-interface BundlerConfig {
-  [bundlerId: string]: ImportManifestEntry;
-}
-type ModuleMap = {
-  [id: string]: {
-    [exportName: string]: ImportManifestEntry;
-  };
-};
-interface ServerConsumerManifest {
-  moduleMap?: ModuleMap;
-  serverModuleMap?: BundlerConfig;
-  moduleLoading?: {
-    prefix: string;
-    crossOriign?: string;
-  };
-}
-type CallServerCallback = (id: string, args: unknown[]) => unknown;
-//#endregion
-export { ServerConsumerManifest as i, CallServerCallback as n, ModuleMap as r, BundlerConfig as t };