@kasperpeulen/vitest-plugin-nextjs 0.0.0-alpha.0 → 0.1.0-alpha.0

package/dist/app-requests.js

@@ -0,0 +1,253 @@
+import { registry } from "./registry.js";
+import "./globals.js";
+import { speedFeature } from "./speed-features.js";
+import { PageStore } from "./page-store.js";
+import { takesRequest } from "./server-in-front.js";
+import { loadedSsrLayer, ssrLayer } from "./server-layers.js";
+//#region src/app-requests.ts
+const { Headers, Request: ServerNativeRequest } = globalThis;
+const isRequest = (value) => value instanceof ServerNativeRequest;
+async function handledByServer(...[request, options]) {
+	const layer = loadedSsrLayer() ?? await ssrLayer();
+	request.signal?.throwIfAborted();
+	return layer.handleRequest(request, options);
+}
+const nativeFetch = registry.network;
+async function networkFetch(input, init) {
+	if (!init?.body && !(isRequest(input) && input.body)) return nativeFetch(input, init);
+	const request = new ServerNativeRequest(input, init);
+	return nativeFetch(new ServerNativeRequest(request, { body: await request.arrayBuffer() }));
+}
+function sameOriginRequest(input, init) {
+	const request = isRequest(input) ? input : void 0;
+	const url = new URL(request ? request.url : String(input), window.location.href);
+	if (url.origin !== window.location.origin || url.protocol === "blob:") return;
+	const headers = new Headers(init?.headers ?? request?.headers);
+	return {
+		url,
+		method: (init?.method ?? request?.method ?? "GET").toUpperCase(),
+		headers,
+		marked: headers.has("rsc") || headers.has("next-action")
+	};
+}
+let page;
+let routerOutlivesPage = false;
+/** Says which page of the app is open, by its signal, which aborts as it is left. */
+function setOpenPage(signal) {
+	page = signal;
+}
+/** Says whether the router of the pages outlives them, from now on. */
+function setRouterOutlivesPage(outlives) {
+	routerOutlivesPage = outlives;
+}
+const pageLeft = () => new DOMException("The page was left.", "AbortError");
+const failsAsPageLeft = (action) => routerOutlivesPage && !action;
+function ofLeftPage(action) {
+	return failsAsPageLeft(action) ? Promise.reject(pageLeft()) : never();
+}
+function browserHeaders(headers, url, method, from, credentials = true) {
+	headers.set("host", url.host);
+	from.headers.forEach((value, name) => {
+		if (!headers.has(name)) headers.set(name, value);
+	});
+	if (!headers.has("user-agent")) headers.set("user-agent", navigator.userAgent);
+	if (method !== "GET" && method !== "HEAD" && !headers.has("origin")) headers.set("origin", url.origin);
+	if (credentials && !headers.has("cookie")) {
+		const cookie = from.cookieHeader();
+		if (cookie) headers.set("cookie", cookie);
+	}
+	return headers;
+}
+function leftTheApp(url) {
+	return /* @__PURE__ */ new Error(`vitest-plugin-rsc: the app navigated to another origin: ${url.href}. A browser would leave the app for it, which a test cannot do.`);
+}
+function unlessAborted(answer, signal, abandon) {
+	return new Promise((resolve, reject) => {
+		const abort = () => {
+			reject(signal.reason);
+			answer.catch(() => {});
+			abandon(answer);
+		};
+		if (signal.aborted) return abort();
+		signal.addEventListener("abort", abort, { once: true });
+		answer.then((response) => {
+			signal.removeEventListener("abort", abort);
+			resolve(response);
+		}, (error) => {
+			signal.removeEventListener("abort", abort);
+			reject(error);
+		});
+	});
+}
+async function sendRequest(request, { from, credentials = true, navigation, network, opened }) {
+	let url = new URL(request.url);
+	let method = request.method;
+	let sent = request.headers;
+	const own = from && credentials && sent.has("cookie") ? new PageStore() : void 0;
+	own?.seed(sent.get("cookie"));
+	let body = request.body ? new Uint8Array(await request.arrayBuffer()) : null;
+	let redirected = false;
+	let redirects = 0;
+	for (;;) {
+		const headers = from ? browserHeaders(new Headers(sent), url, method, from, credentials) : new Headers(sent);
+		const appOpened = opened ? {
+			...opened,
+			pathname: url.pathname
+		} : null;
+		const response = await unlessAborted(handledByServer({
+			url: url.href,
+			method,
+			headers,
+			body,
+			signal: request.signal
+		}, {
+			nested: !from,
+			unrouted: network ? "pass" : "not-found",
+			opened: navigation === "app" ? appOpened : redirected ? void 0 : opened,
+			pageLoad: navigation === "test"
+		}), request.signal, (answer) => void answer.then((late) => late?.body?.cancel()).catch(() => {}));
+		if (!response) return redirected ? nativeFetch(url, {
+			method,
+			headers: sent,
+			body,
+			signal: request.signal
+		}) : network();
+		if (credentials) from?.receive(response.headers.getSetCookie());
+		const location = response.headers.get("location");
+		if (response.status >= 300 && response.status < 400 && location) {
+			if (request.redirect === "manual") {
+				Object.defineProperties(response, { url: { value: url.href } });
+				return response;
+			}
+			if (request.redirect === "error") throw new TypeError("fetch failed", { cause: /* @__PURE__ */ new Error(`unexpected redirect of ${url.href} to ${location}`) });
+			if (!redirected) sent = new Headers(sent);
+			url = new URL(location, url);
+			const { status } = response;
+			if ((status === 301 || status === 302) && method === "POST" || status === 303 && method !== "GET" && method !== "HEAD") {
+				method = "GET";
+				body = null;
+				for (const name of [
+					"encoding",
+					"language",
+					"location",
+					"type"
+				]) sent.delete(`content-${name}`);
+			}
+			redirected = true;
+			if (++redirects > 20) throw new Error(`vitest-plugin-rsc: too many redirects for ${request.url}. The last one was to ${url.href}.`);
+			if (url.origin !== window.location.origin) {
+				if (navigation) throw leftTheApp(url);
+				sent.delete("authorization");
+				return nativeFetch(url, {
+					method,
+					headers: sent,
+					body,
+					signal: request.signal
+				});
+			}
+			if (own) {
+				own.receive(response.headers.getSetCookie());
+				sent.set("cookie", own.cookieHeader());
+			}
+			continue;
+		}
+		Object.defineProperties(response, {
+			url: { value: url.href },
+			redirected: { value: redirected }
+		});
+		return response;
+	}
+}
+function pageResponse(response) {
+	const { Response: PageResponse } = window;
+	if (response instanceof PageResponse && !response.headers.has("set-cookie")) return response;
+	const headers = [...response.headers].filter(([name]) => name !== "set-cookie");
+	const { status, statusText, url, redirected } = response;
+	const page = new PageResponse(response.body, {
+		status,
+		statusText,
+		headers
+	});
+	return Object.defineProperties(page, {
+		url: { value: url },
+		redirected: { value: redirected }
+	});
+}
+const appFetch = (store, network) => async (input, init, sent) => {
+	const server = !store;
+	const from = store?.();
+	if (!sent) return network()(input, init);
+	const credentials = (init?.credentials ?? (isRequest(input) ? input.credentials : void 0)) !== "omit";
+	if (!sent.marked) {
+		if (from) sent.headers.delete("cookie");
+		const headers = from ? browserHeaders(sent.headers, sent.url, sent.method, from, credentials) : sent.headers;
+		if (!await takesRequest({
+			url: sent.url.href,
+			headers
+		})) return network()(input, init);
+	}
+	if (server && sent.method === "GET" && sent.headers.get("rsc") === "1" && sent.headers.has("x-action-redirect") && registry.openedByRequest.getStore()?.rendersRedirect === false) return new registry.Response(null, { status: 204 });
+	const spare = isRequest(input) && input.body ? input.clone() : input;
+	const response = await sendRequest(server ? new registry.Request(input, init) : new Request(input, init), {
+		from,
+		credentials,
+		network: sent.marked ? void 0 : () => network()(spare, init)
+	});
+	return from && response ? pageResponse(response) : response;
+};
+const never = () => new Promise(() => {});
+function isPrefetch(sent, init) {
+	return sent.headers.has("rsc") && (sent.headers.has("next-router-prefetch") || init?.priority === "low");
+}
+const noPrefetch = () => new Response(null, { status: 204 });
+async function heardBy(sender, response, action) {
+	if (failsAsPageLeft(action)) return failsAsLeft(sender, response);
+	const answered = await response.catch(() => void 0);
+	if (!sender.aborted) return response;
+	answered?.body?.cancel().catch(() => {});
+	return ofLeftPage(action);
+}
+function failsAsLeft(sender, response) {
+	const left = new Promise((_, reject) => sender.addEventListener("abort", () => reject(pageLeft()), { once: true }));
+	left.catch(() => {});
+	response.then((answered) => {
+		if (sender.aborted) answered?.body?.cancel().catch(() => {});
+	}, () => {});
+	return Promise.race([response, left]);
+}
+/**
+* The browser's `fetch` while a browser context of the app is open: what
+* Next's client router and Client Components call. `store()` is the store of
+* the context, and `network()` the `fetch` the document had before it, which
+* gets every request that is not the app's, or, where the DOM hands over the
+* page's requests, one that answers none, for the DOM to send. Without a
+* context, `network()` gets every request: code that took this `fetch` in a
+* context has the document's own after it.
+*
+* Next marks the requests it sends for a page, with an `rsc` or a
+* `next-action` header. They belong to the page that is open as they are
+* sent. Its router is there only once its page is, so without a page that
+* page was left, and it sends nothing more. A test asks with
+* `handleRequest()`.
+*/
+function pageFetch(store, network) {
+	const browserFetch = appFetch(() => store(), network);
+	return async (input, init) => {
+		if (!store()) return network()(input, init);
+		const sent = sameOriginRequest(input, init);
+		if (!sent?.marked) return browserFetch(input, init, sent);
+		const action = sent.headers.has("next-action");
+		const sender = page;
+		if (!sender || sender.aborted) return ofLeftPage(action);
+		if (speedFeature("skipPrefetch") && isPrefetch(sent, init)) return noPrefetch();
+		return heardBy(sender, browserFetch(input, init, sent), action);
+	};
+}
+const serverFetch = appFetch(void 0, () => networkFetch);
+registry.fetch = async (input, init) => {
+	if (!isRequest(input) && !URL.canParse(String(input))) throw new TypeError(`Failed to parse URL from ${String(input)}`, { cause: /* @__PURE__ */ new TypeError("Invalid URL") });
+	return serverFetch(input, init, sameOriginRequest(input, init));
+};
+process.env.__NEXT_PRIVATE_ORIGIN = window.location.origin;
+//#endregion
+export { leftTheApp, pageFetch, sendRequest, setOpenPage, setRouterOutlivesPage, unlessAborted };

package/dist/browser-context.d.ts

@@ -0,0 +1,24 @@
+import { PageStore } from "./page-store.js";
+import { PageStorage } from "./storage.js";
+
+//#region src/browser-context.d.ts
+/** A browser context of the app: its cookie jar, the headers of its requests, and its storage. */
+declare class BrowserContext {
+  readonly store: PageStore;
+  readonly storage: PageStorage;
+}
+/**
+ * Opens a browser context of the app, empty, unless one is open: the
+ * document has its cookies, storage, requests and navigations until
+ * `closeContext()`.
+ */
+declare function openContext(): BrowserContext;
+/**
+ * Closes the browser context that is open, and puts back what the document
+ * had wherever the context's own are in place. Also with none open: a patch
+ * over them that has gone since, like a spy that a test restored after
+ * `cleanup()`, put them back.
+ */
+declare function closeContext(): void;
+//#endregion
+export { BrowserContext, closeContext, openContext };

package/dist/browser-context.js

@@ -0,0 +1,157 @@
+import { registry } from "./registry.js";
+import { PageStore } from "./page-store.js";
+import { pageFetch } from "./app-requests.js";
+import { streamedContentQueue } from "./document.js";
+import { fromPage } from "./from-page.js";
+import { followNavigation } from "./document-loads.js";
+import { appHasNavigations } from "./host-document.js";
+import { PageStorage, itemsOfStorage, storageOf } from "./storage.js";
+import pageHost from "virtual:vitest-plugin-rsc/page-host";
+//#region src/browser-context.ts
+/** A browser context of the app: its cookie jar, the headers of its requests, and its storage. */
+var BrowserContext = class {
+	store = new PageStore();
+	storage = new PageStorage();
+};
+let opened;
+const saved = /* @__PURE__ */ new Map();
+const patched = /* @__PURE__ */ new Set();
+const savedOf = (binding) => saved.get(binding) ?? descriptorOf(Object.getPrototypeOf(binding.target), binding.name);
+function savedValue(binding) {
+	const descriptor = savedOf(binding);
+	return descriptor?.get ? descriptor.get.call(binding.target) : descriptor?.value;
+}
+function descriptorOf(target, name) {
+	for (; target; target = Object.getPrototypeOf(target)) {
+		const descriptor = Object.getOwnPropertyDescriptor(target, name);
+		if (descriptor) return descriptor;
+	}
+}
+const leftToDocument = /* @__PURE__ */ new WeakSet();
+const interceptedFetch = pageFetch(() => opened?.store, () => async () => void 0);
+const handsOver = pageHost.interceptRequests(async (request) => leftToDocument.has(request) ? void 0 : interceptedFetch(...fromPage(request)));
+const toDocument = (input, init) => () => {
+	const documentFetch = savedValue(fetchBinding) ?? registry.network;
+	if (!handsOver) return documentFetch;
+	return () => {
+		const request = new window.Request(input, init);
+		leftToDocument.add(request);
+		return documentFetch(request);
+	};
+};
+const fetchBinding = {
+	target: window,
+	name: "fetch",
+	own: {
+		configurable: true,
+		enumerable: true,
+		writable: true,
+		value: (input, init) => pageFetch(() => opened?.store, toDocument(input, init))(...fromPage(input, init))
+	}
+};
+const cookieBinding = {
+	target: document,
+	name: "cookie",
+	own: {
+		configurable: true,
+		get: () => opened ? opened.store.documentCookie() : savedValue(cookieBinding),
+		set(cookie) {
+			if (opened) opened.store.write(String(cookie));
+			else savedOf(cookieBinding)?.set?.call(document, cookie);
+		}
+	}
+};
+const storageBindings = ["localStorage", "sessionStorage"].map((name) => {
+	const binding = {
+		target: window,
+		name,
+		own: void 0
+	};
+	const items = () => opened ? opened.storage[name] : itemsOfStorage(savedValue(binding));
+	const storage = storageOf(items);
+	binding.own = {
+		configurable: true,
+		enumerable: true,
+		get: () => storage
+	};
+	return binding;
+});
+const bindings = [
+	fetchBinding,
+	cookieBinding,
+	...[
+		"cookieStore",
+		"CookieStore",
+		"CookieChangeEvent"
+	].map((name) => ({
+		target: window,
+		name,
+		own: void 0
+	})),
+	...storageBindings,
+	{
+		target: self,
+		name: "$RC",
+		own: streamedContentQueue
+	}
+];
+function same(one, other) {
+	if (!one || !other) return one === other;
+	return one.get === other.get && one.set === other.set && one.value === other.value;
+}
+const ownOf = ({ target, name }) => Object.getOwnPropertyDescriptor(target, name);
+const original = new Map(bindings.map((binding) => [binding, ownOf(binding)]));
+const isDocuments = (binding, descriptor) => saved.has(binding) && same(descriptor, saved.get(binding)) || same(descriptor, original.get(binding));
+const { navigation } = pageHost;
+const followed = (event) => {
+	if (opened) followNavigation(event, opened.store);
+};
+/**
+* Opens a browser context of the app, empty, unless one is open: the
+* document has its cookies, storage, requests and navigations until
+* `closeContext()`.
+*/
+function openContext() {
+	if (opened) return opened;
+	for (const binding of bindings) {
+		const { target, name, own } = binding;
+		const descriptor = ownOf(binding);
+		if (same(descriptor, own)) continue;
+		if (patched.has(binding) && !isDocuments(binding, descriptor)) continue;
+		patched.delete(binding);
+		saved.set(binding, descriptor);
+		if (own) Object.defineProperty(target, name, own);
+		else Reflect.deleteProperty(target, name);
+	}
+	navigation?.addEventListener("navigate", followed);
+	appHasNavigations(true);
+	return opened = new BrowserContext();
+}
+/**
+* Closes the browser context that is open, and puts back what the document
+* had wherever the context's own are in place. Also with none open: a patch
+* over them that has gone since, like a spy that a test restored after
+* `cleanup()`, put them back.
+*/
+function closeContext() {
+	const closing = opened !== void 0;
+	opened = void 0;
+	navigation?.removeEventListener("navigate", followed);
+	appHasNavigations(false);
+	for (const binding of bindings) {
+		const { target, name, own } = binding;
+		const descriptor = ownOf(binding);
+		if (!same(descriptor, own)) {
+			if (isDocuments(binding, descriptor)) patched.delete(binding);
+			else if (closing) patched.add(binding);
+			continue;
+		}
+		patched.delete(binding);
+		if (!saved.has(binding)) continue;
+		const put = saved.get(binding);
+		if (put) Object.defineProperty(target, name, put);
+		else Reflect.deleteProperty(target, name);
+	}
+}
+//#endregion
+export { BrowserContext, closeContext, openContext };

package/dist/build-output.d.ts

@@ -0,0 +1,68 @@
+import { Stylesheets } from "./styles-shared.js";
+import { PrerenderVerdict } from "./registry.js";
+import { PrerenderManifest } from "./compat/ssr/build-output.js";
+
+//#region src/build-output.d.ts
+declare function setStylesheets(of: Stylesheets): void;
+declare function setServerActions(ids: Iterable<string>): void;
+declare let prerenderManifest: PrerenderManifest;
+type Route = {
+  kind: "page" | "route";
+  page: string;
+  pathname: string;
+};
+/**
+ * Lists what Next's build prerenders of a route, by its verdict: the entries
+ * of the prerender manifest that Next's handler reads. With them the handler
+ * prerenders a pathname at its first request, keeps it, and serves it from
+ * then on, as `next start` serves what the build prerendered. Without the
+ * `revalidate` the build writes: Next's cache reads it for a page the build
+ * prerendered, and here every page is first prerendered by the handler,
+ * which keeps the `revalidate` of the render with it.
+ */
+declare function recordRoute(route: Route, verdict: PrerenderVerdict | undefined): void;
+/** Forgets what the build kept, as the server's cache forgets its entries. */
+declare function forgetBuilt(): void;
+/**
+ * A page as the build keeps it, which Next's handler is about to keep for
+ * `pathname`, at the first prerender of that pathname in this `generation`
+ * of the cache. The build keeps a page of a parallel route's slot without a
+ * status (`export/routes/app-page.js:126-141`), which `next start` serves
+ * with 200: a page whose other slots have no page for its path renders the
+ * not-found page there, which a page load shows, and a navigation, which
+ * keeps the other slots as they are, does not. Next's handler would keep
+ * the status of its render, 404, and Next's router takes a navigation that
+ * answers 404 for a page load. So the entry gets 200, in place: the handler
+ * answers the request of its prerender with the status of the entry it
+ * keeps, and otherwise with the one its render set. `route` is the source
+ * of the entry, the page, as Next's response cache hands it to the cache.
+ */
+declare function keptAsBuilt(pathname: string, value: {
+  kind: string;
+  status?: number;
+} | null, {
+  route
+}: {
+  route?: {
+    sourceRoute?: string;
+  };
+}, generation: number): void;
+/**
+ * Hands Next's handler a manifest without `route` for `respond()`, the
+ * response of a prefetch: Next reads the manifest as it starts a request.
+ */
+declare function withoutRoute<T>(route: Route, respond: () => Promise<T>): Promise<T>;
+/** Whether the build prerenders a route, or a pathname of it. */
+declare function isPrerendered(route: Route): boolean;
+/**
+ * Takes a route out of what the build prerenders: for a render that read the
+ * request, which the build would have found as it prerendered the route.
+ * All of its pathnames: of a route with `generateStaticParams`, the build
+ * keeps those that did not read it, and here the others are not rendered yet.
+ */
+declare function demoteRoute(route: Route): void;
+/** A file of `.next/`, by its path, as Next's `loadManifest()` reads it. */
+declare function loadManifest(file: string): unknown;
+declare const nodeRouteDistDir = ".next/vitest-plugin-rsc-node";
+//#endregion
+export { demoteRoute, forgetBuilt, isPrerendered, keptAsBuilt, loadManifest, nodeRouteDistDir, prerenderManifest, recordRoute, setServerActions, setStylesheets, withoutRoute };