@vitejs/plugin-rsc 0.4.10 → 0.4.11

package/dist/browser-D8OPzpF5.js

@@ -0,0 +1,35 @@
+import * as ReactClient from "@vitejs/plugin-rsc/vendor/react-server-dom/client.browser";
+
+//#region src/react/browser.ts
+function createFromReadableStream(stream, options = {}) {
+	return ReactClient.createFromReadableStream(stream, {
+		callServer,
+		findSourceMapURL,
+		...options
+	});
+}
+function createFromFetch(promiseForResponse, options = {}) {
+	return ReactClient.createFromFetch(promiseForResponse, {
+		callServer,
+		findSourceMapURL,
+		...options
+	});
+}
+const encodeReply = ReactClient.encodeReply;
+const createServerReference = ReactClient.createServerReference;
+function callServer(...args) {
+	return globalThis.__viteRscCallServer(...args);
+}
+function setServerCallback(fn) {
+	globalThis.__viteRscCallServer = fn;
+}
+const createTemporaryReferenceSet = ReactClient.createTemporaryReferenceSet;
+function findSourceMapURL(filename, environmentName) {
+	const url = new URL("/__vite_rsc_findSourceMapURL", window.location.origin);
+	url.searchParams.set("filename", filename);
+	url.searchParams.set("environmentName", environmentName);
+	return url.toString();
+}
+
+//#endregion
+export { callServer, createFromFetch, createFromReadableStream, createServerReference, createTemporaryReferenceSet, encodeReply, findSourceMapURL, setServerCallback };

package/dist/browser-DjnGtEmB.d.ts

@@ -0,0 +1,15 @@
+import { CallServerCallback } from "./index-BHqtj9tT.js";
+
+//#region src/react/browser.d.ts
+declare function createFromReadableStream<T>(stream: ReadableStream<Uint8Array>, options?: object): Promise<T>;
+declare function createFromFetch<T>(promiseForResponse: Promise<Response>, options?: object): Promise<T>;
+declare const encodeReply: (v: unknown[], options?: unknown) => Promise<string | FormData>;
+declare const createServerReference: (...args: any[]) => unknown;
+// use global instead of local variable  to tolerate duplicate modules
+// e.g. when `setServerCallback` is pre-bundled but `createServerReference` is not
+declare function callServer(...args: any[]): any;
+declare function setServerCallback(fn: CallServerCallback): void;
+declare const createTemporaryReferenceSet: () => unknown;
+declare function findSourceMapURL(filename: string, environmentName: string): string | null;
+//#endregion
+export { callServer, createFromFetch, createFromReadableStream, createServerReference, createTemporaryReferenceSet, encodeReply, findSourceMapURL, setServerCallback };

package/dist/browser-Dw18EFgE.d.ts

@@ -0,0 +1,6 @@
+//#region src/core/browser.d.ts
+declare function setRequireModule(options: {
+  load: (id: string) => Promise<unknown>;
+}): void;
+//#endregion
+export { setRequireModule };

package/dist/browser-LizIyxet.js

@@ -0,0 +1,17 @@
+import { setRequireModule } from "./browser-QWbIPyhO.js";
+import * as clientReferences from "virtual:vite-rsc/client-references";
+
+//#region src/browser.ts
+initialize();
+function initialize() {
+	setRequireModule({ load: async (id) => {
+		if (!import.meta.env.__vite_rsc_build__) return __vite_rsc_raw_import__(import.meta.env.BASE_URL + id.slice(1));
+		else {
+			const import_ = clientReferences.default[id];
+			if (!import_) throw new Error(`client reference not found '${id}'`);
+			return import_();
+		}
+	} });
+}
+
+//#endregion

package/dist/browser-QWbIPyhO.js

@@ -0,0 +1,17 @@
+import { memoize } from "./dist-DEF94lDJ.js";
+import { removeReferenceCacheTag, setInternalRequire } from "./shared-CEyKoKAb.js";
+
+//#region src/core/browser.ts
+let init = false;
+function setRequireModule(options) {
+	if (init) return;
+	init = true;
+	const requireModule = memoize((id) => {
+		return options.load(removeReferenceCacheTag(id));
+	});
+	globalThis.__vite_rsc_client_require__ = requireModule;
+	setInternalRequire();
+}
+
+//#endregion
+export { setRequireModule };

package/dist/browser.d.ts

@@ -0,0 +1,4 @@
+import { CallServerCallback } from "./index-BHqtj9tT.js";
+import { setRequireModule } from "./browser-Dw18EFgE.js";
+import { callServer, createFromFetch, createFromReadableStream, createServerReference, createTemporaryReferenceSet, encodeReply, findSourceMapURL, setServerCallback } from "./browser-DjnGtEmB.js";
+export { CallServerCallback, callServer, createFromFetch, createFromReadableStream, createServerReference, createTemporaryReferenceSet, encodeReply, findSourceMapURL, setRequireModule, setServerCallback };

package/dist/browser.js

@@ -0,0 +1,7 @@
+import "./dist-DEF94lDJ.js";
+import "./shared-CEyKoKAb.js";
+import { setRequireModule } from "./browser-QWbIPyhO.js";
+import { callServer, createFromFetch, createFromReadableStream, createServerReference, createTemporaryReferenceSet, encodeReply, findSourceMapURL, setServerCallback } from "./browser-D8OPzpF5.js";
+import "./browser-LizIyxet.js";
+
+export { callServer, createFromFetch, createFromReadableStream, createServerReference, createTemporaryReferenceSet, encodeReply, findSourceMapURL, setRequireModule, setServerCallback };

package/dist/client-edAdk2GF.js

@@ -0,0 +1,23 @@
+//#region ../../node_modules/.pnpm/rsc-html-stream@0.0.6/node_modules/rsc-html-stream/client.js
+let encoder = new TextEncoder();
+let streamController;
+let rscStream = new ReadableStream({ start(controller) {
+	if (typeof window === "undefined") return;
+	let handleChunk = (chunk) => {
+		if (typeof chunk === "string") controller.enqueue(encoder.encode(chunk));
+		else controller.enqueue(chunk);
+	};
+	window.__FLIGHT_DATA ||= [];
+	window.__FLIGHT_DATA.forEach(handleChunk);
+	window.__FLIGHT_DATA.push = (chunk) => {
+		handleChunk(chunk);
+	};
+	streamController = controller;
+} });
+if (typeof document !== "undefined" && document.readyState === "loading") document.addEventListener("DOMContentLoaded", () => {
+	streamController?.close();
+});
+else streamController?.close();
+
+//#endregion
+export { rscStream };

package/dist/core/browser.d.ts

@@ -0,0 +1,2 @@
+import { setRequireModule } from "../browser-Dw18EFgE.js";
+export { setRequireModule };

package/dist/core/browser.js

@@ -0,0 +1,5 @@
+import "../dist-DEF94lDJ.js";
+import "../shared-CEyKoKAb.js";
+import { setRequireModule } from "../browser-QWbIPyhO.js";
+
+export { setRequireModule };

package/dist/core/plugin.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from "vite";
+
+//#region src/core/plugin.d.ts
+declare function vitePluginRscCore(): Plugin[];
+//#endregion
+export { vitePluginRscCore as default };

package/dist/core/plugin.js

@@ -0,0 +1,3 @@
+import { vitePluginRscCore } from "../plugin-CZbI4rhS.js";
+
+export { vitePluginRscCore as default };

package/dist/core/rsc.d.ts

@@ -0,0 +1,3 @@
+import "../index-BHqtj9tT.js";
+import { createClientManifest, createServerDecodeClientManifest, createServerManifest, loadServerAction, setRequireModule } from "../rsc-BOV3yNSd.js";
+export { createClientManifest, createServerDecodeClientManifest, createServerManifest, loadServerAction, setRequireModule };

package/dist/core/rsc.js

@@ -0,0 +1,5 @@
+import "../dist-DEF94lDJ.js";
+import "../shared-CEyKoKAb.js";
+import { createClientManifest, createServerDecodeClientManifest, createServerManifest, loadServerAction, setRequireModule } from "../rsc-DKA6wwTB.js";
+
+export { createClientManifest, createServerDecodeClientManifest, createServerManifest, loadServerAction, setRequireModule };

package/dist/core/ssr.d.ts

@@ -0,0 +1,3 @@
+import "../index-BHqtj9tT.js";
+import { createServerConsumerManifest, setRequireModule } from "../ssr-DgSrGrln.js";
+export { createServerConsumerManifest, setRequireModule };

package/dist/core/ssr.js

@@ -0,0 +1,5 @@
+import "../dist-DEF94lDJ.js";
+import "../shared-CEyKoKAb.js";
+import { createServerConsumerManifest, setRequireModule } from "../ssr-BOIYlvSn.js";
+
+export { createServerConsumerManifest, setRequireModule };

package/dist/dist-DEF94lDJ.js

@@ -0,0 +1,41 @@
+//#region ../../node_modules/.pnpm/@hiogawa+utils@1.7.0/node_modules/@hiogawa/utils/dist/index.js
+function tinyassert(value, message) {
+	if (value) return;
+	if (message instanceof Error) throw message;
+	throw new TinyAssertionError(message, tinyassert);
+}
+var TinyAssertionError = class extends Error {
+	constructor(message, stackStartFunction) {
+		super(message ?? "TinyAssertionError");
+		if (stackStartFunction && "captureStackTrace" in Error) Error.captureStackTrace(this, stackStartFunction);
+	}
+};
+function safeFunctionCast(f) {
+	return f;
+}
+function once(f) {
+	let result;
+	let called = false;
+	return safeFunctionCast(function(...args) {
+		if (!called) {
+			result = f.apply(this, args);
+			called = true;
+		}
+		return result;
+	});
+}
+function memoize(f, options) {
+	const keyFn = options?.keyFn ?? ((...args) => args[0]);
+	const cache = options?.cache ?? /* @__PURE__ */ new Map();
+	return safeFunctionCast(function(...args) {
+		const key = keyFn(...args);
+		const value = cache.get(key);
+		if (typeof value !== "undefined") return value;
+		const newValue = f.apply(this, args);
+		cache.set(key, newValue);
+		return newValue;
+	});
+}
+
+//#endregion
+export { memoize, once, tinyassert };

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-DS3S6m0g.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 };