@vitejs/plugin-rsc 0.4.10-alpha.1

package/dist/encryption-utils-BDwwcMVT.js

@@ -0,0 +1,73 @@
+//#region src/utils/encryption-utils.ts
+function arrayBufferToString(buffer) {
+	const bytes = new Uint8Array(buffer);
+	const len = bytes.byteLength;
+	if (len < 65535) return String.fromCharCode.apply(null, bytes);
+	let binary = "";
+	for (let i = 0; i < len; i++) binary += String.fromCharCode(bytes[i]);
+	return binary;
+}
+function stringToUint8Array(binary) {
+	const len = binary.length;
+	const arr = new Uint8Array(len);
+	for (let i = 0; i < len; i++) arr[i] = binary.charCodeAt(i);
+	return arr;
+}
+function concatArray(chunks) {
+	let total = 0;
+	for (const chunk of chunks) total += chunk.length;
+	const result = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
+}
+async function concatArrayStream(stream) {
+	const chunks = [];
+	await stream.pipeTo(new WritableStream({ write(chunk) {
+		chunks.push(chunk);
+	} }));
+	return concatArray(chunks);
+}
+function arrayToStream(data) {
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(data);
+		controller.close();
+	} });
+}
+function toBase64(buffer) {
+	return btoa(arrayBufferToString(buffer));
+}
+function fromBase64(data) {
+	return stringToUint8Array(atob(data));
+}
+async function generateEncryptionKey() {
+	const key = await crypto.subtle.generateKey({
+		name: "AES-GCM",
+		length: 256
+	}, true, ["encrypt", "decrypt"]);
+	const exported = await crypto.subtle.exportKey("raw", key);
+	return new Uint8Array(exported);
+}
+async function encryptBuffer(data, key) {
+	const iv = crypto.getRandomValues(new Uint8Array(16));
+	const encrypted = await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv
+	}, key, data);
+	return toBase64(concatArray([iv, new Uint8Array(encrypted)]));
+}
+async function decryptBuffer(encryptedString, key) {
+	const concatenated = fromBase64(encryptedString);
+	const iv = concatenated.slice(0, 16);
+	const encrypted = concatenated.slice(16);
+	return crypto.subtle.decrypt({
+		name: "AES-GCM",
+		iv
+	}, key, encrypted);
+}
+
+//#endregion
+export { arrayToStream, concatArrayStream, decryptBuffer, encryptBuffer, fromBase64, generateEncryptionKey, toBase64 };

package/dist/extra/browser.d.ts

@@ -0,0 +1,7 @@
+import { RscPayload } from "../rsc-Cmvt9txp.js";
+
+//#region src/extra/browser.d.ts
+declare function hydrate(): Promise<void>;
+declare function fetchRSC(request: string | URL | Request): Promise<RscPayload["root"]>;
+//#endregion
+export { fetchRSC, hydrate };

package/dist/extra/browser.js

@@ -0,0 +1,83 @@
+import "../dist-DEF94lDJ.js";
+import "../shared-CEyKoKAb.js";
+import "../browser-QWbIPyhO.js";
+import { createFromFetch, createFromReadableStream, createTemporaryReferenceSet, encodeReply, setServerCallback } from "../browser-D8OPzpF5.js";
+import "../browser-LizIyxet.js";
+import { rscStream } from "../client-edAdk2GF.js";
+import React from "react";
+import ReactDomClient from "react-dom/client";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/extra/browser.tsx
+async function hydrate() {
+	const callServer = async (id, args) => {
+		const url = new URL(window.location.href);
+		const temporaryReferences = createTemporaryReferenceSet();
+		const payload = await createFromFetch(fetch(url, {
+			method: "POST",
+			body: await encodeReply(args, { temporaryReferences }),
+			headers: { "x-rsc-action": id }
+		}), { temporaryReferences });
+		setPayload(payload);
+		return payload.returnValue;
+	};
+	setServerCallback(callServer);
+	async function onNavigation() {
+		const url = new URL(window.location.href);
+		const payload = await createFromFetch(fetch(url));
+		setPayload(payload);
+	}
+	const initialPayload = await createFromReadableStream(rscStream);
+	let setPayload;
+	function BrowserRoot() {
+		const [payload, setPayload_] = React.useState(initialPayload);
+		React.useEffect(() => {
+			setPayload = (v) => React.startTransition(() => setPayload_(v));
+		}, [setPayload_]);
+		React.useEffect(() => {
+			return listenNavigation(() => onNavigation());
+		}, []);
+		return payload.root;
+	}
+	const browserRoot = /* @__PURE__ */ jsx(React.StrictMode, { children: /* @__PURE__ */ jsx(BrowserRoot, {}) });
+	ReactDomClient.hydrateRoot(document, browserRoot, { formState: initialPayload.formState });
+	if (import.meta.hot) import.meta.hot.on("rsc:update", () => {
+		window.history.replaceState({}, "", window.location.href);
+	});
+}
+async function fetchRSC(request) {
+	const payload = await createFromFetch(fetch(request));
+	return payload.root;
+}
+function listenNavigation(onNavigation) {
+	window.addEventListener("popstate", onNavigation);
+	const oldPushState = window.history.pushState;
+	window.history.pushState = function(...args) {
+		const res = oldPushState.apply(this, args);
+		onNavigation();
+		return res;
+	};
+	const oldReplaceState = window.history.replaceState;
+	window.history.replaceState = function(...args) {
+		const res = oldReplaceState.apply(this, args);
+		onNavigation();
+		return res;
+	};
+	function onClick(e) {
+		let link = e.target.closest("a");
+		if (link && link instanceof HTMLAnchorElement && link.href && (!link.target || link.target === "_self") && link.origin === location.origin && !link.hasAttribute("download") && e.button === 0 && !e.metaKey && !e.ctrlKey && !e.altKey && !e.shiftKey && !e.defaultPrevented) {
+			e.preventDefault();
+			history.pushState(null, "", link.href);
+		}
+	}
+	document.addEventListener("click", onClick);
+	return () => {
+		document.removeEventListener("click", onClick);
+		window.removeEventListener("popstate", onNavigation);
+		window.history.pushState = oldPushState;
+		window.history.replaceState = oldReplaceState;
+	};
+}
+
+//#endregion
+export { fetchRSC, hydrate };

package/dist/extra/rsc.d.ts

@@ -0,0 +1,2 @@
+import { RscPayload, renderRequest } from "../rsc-Cmvt9txp.js";
+export { RscPayload, renderRequest };

package/dist/extra/rsc.js

@@ -0,0 +1,60 @@
+import "../dist-DEF94lDJ.js";
+import "../shared-CEyKoKAb.js";
+import "../encryption-utils-BDwwcMVT.js";
+import { loadServerAction } from "../rsc-DKA6wwTB.js";
+import { createTemporaryReferenceSet, decodeAction, decodeFormState, decodeReply, renderToReadableStream } from "../rsc-DHfL29FT.js";
+import "../rsc-DmPsJrxF.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/extra/rsc.tsx
+async function renderRequest(request, root, options) {
+	function RscRoot() {
+		const nonceMeta = options?.nonce && /* @__PURE__ */ jsx("meta", {
+			property: "csp-nonce",
+			nonce: options.nonce
+		});
+		return /* @__PURE__ */ jsxs(Fragment, { children: [nonceMeta, root] });
+	}
+	const url = new URL(request.url);
+	const isAction = request.method === "POST";
+	const isRscRequest = !request.headers.get("accept")?.includes("text/html") && !url.searchParams.has("__html") || url.searchParams.has("__rsc");
+	let returnValue;
+	let formState;
+	let temporaryReferences;
+	if (isAction) {
+		const actionId = request.headers.get("x-rsc-action");
+		if (actionId) {
+			const contentType = request.headers.get("content-type");
+			const body = contentType?.startsWith("multipart/form-data") ? await request.formData() : await request.text();
+			temporaryReferences = createTemporaryReferenceSet();
+			const args = await decodeReply(body, { temporaryReferences });
+			const action = await loadServerAction(actionId);
+			returnValue = await action.apply(null, args);
+		} else {
+			const formData = await request.formData();
+			const decodedAction = await decodeAction(formData);
+			const result = await decodedAction();
+			formState = await decodeFormState(result, formData);
+		}
+	}
+	const rscPayload = {
+		root: /* @__PURE__ */ jsx(RscRoot, {}),
+		formState,
+		returnValue
+	};
+	const rscOptions = { temporaryReferences };
+	const rscStream = renderToReadableStream(rscPayload, rscOptions);
+	if (isRscRequest) return new Response(rscStream, { headers: {
+		"content-type": "text/x-component;charset=utf-8",
+		vary: "accept"
+	} });
+	const ssrEntry = await import.meta.viteRsc.loadModule("ssr", "index");
+	return ssrEntry.renderHtml(rscStream, {
+		formState,
+		nonce: options?.nonce,
+		debugNoJs: url.searchParams.has("__nojs")
+	});
+}
+
+//#endregion
+export { renderRequest };

package/dist/extra/ssr.d.ts

@@ -0,0 +1,10 @@
+import { ReactFormState } from "react-dom/client";
+
+//#region src/extra/ssr.d.ts
+declare function renderHtml(rscStream: ReadableStream<Uint8Array>, options?: {
+  formState?: ReactFormState;
+  nonce?: string;
+  debugNoJs?: boolean;
+}): Promise<Response>;
+//#endregion
+export { renderHtml };

package/dist/extra/ssr.js

@@ -0,0 +1,35 @@
+import "../dist-DEF94lDJ.js";
+import "../shared-CEyKoKAb.js";
+import "../ssr-BOIYlvSn.js";
+import { createFromReadableStream } from "../ssr-D5pxP29F.js";
+import "../ssr-Do_Ok_bB.js";
+import { injectRSCPayload } from "../server-DGTepepH.js";
+import React from "react";
+import { jsx } from "react/jsx-runtime";
+import ReactDomServer from "react-dom/server.edge";
+
+//#region src/extra/ssr.tsx
+async function renderHtml(rscStream, options) {
+	const [rscStream1, rscStream2] = rscStream.tee();
+	let payload;
+	function SsrRoot() {
+		payload ??= createFromReadableStream(rscStream1, { nonce: options?.nonce });
+		const root = React.use(payload).root;
+		return root;
+	}
+	const bootstrapScriptContent = await import.meta.viteRsc.loadBootstrapScriptContent("index");
+	const htmlStream = await ReactDomServer.renderToReadableStream(/* @__PURE__ */ jsx(SsrRoot, {}), {
+		bootstrapScriptContent: options?.debugNoJs ? void 0 : bootstrapScriptContent,
+		nonce: options?.nonce,
+		formState: options?.formState
+	});
+	let responseStream = htmlStream;
+	if (!options?.debugNoJs) responseStream = responseStream.pipeThrough(injectRSCPayload(rscStream2, { nonce: options?.nonce }));
+	return new Response(responseStream, { headers: {
+		"content-type": "text/html;charset=utf-8",
+		vary: "accept"
+	} });
+}
+
+//#endregion
+export { renderHtml };

package/dist/index-BHqtj9tT.d.ts

@@ -0,0 +1,26 @@
+//#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 { BundlerConfig, CallServerCallback, ModuleMap, ServerConsumerManifest };

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { RscPluginOptions, vitePluginRsc } from "./plugin-Dg2agPFN.js";
+import MagicString from "magic-string";
+import { Program } from "estree";
+
+//#region src/transforms/hoist.d.ts
+declare function transformHoistInlineDirective(input: string, ast: Program, {
+  runtime,
+  directive,
+  rejectNonAsyncFunction,
+  ...options
+}: {
+  runtime: (value: string, name: string) => string;
+  directive: string;
+  rejectNonAsyncFunction?: boolean;
+  encode?: (value: string) => string;
+  decode?: (value: string) => string;
+  noExport?: boolean;
+}): {
+  output: MagicString;
+  names: string[];
+};
+//#endregion
+export { RscPluginOptions, vitePluginRsc as default, transformHoistInlineDirective };

package/dist/index.js

@@ -0,0 +1,8 @@
+import "./dist-DEF94lDJ.js";
+import "./plugin-CZbI4rhS.js";
+import { transformHoistInlineDirective, vitePluginRsc } from "./plugin-BZEsXXjV.js";
+import "./encryption-utils-BDwwcMVT.js";
+import "./rpc-tGuLT8PD.js";
+import "./vite-utils-CcqBE-C4.js";
+
+export { vitePluginRsc as default, transformHoistInlineDirective };