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

package/dist/document.js

@@ -0,0 +1,328 @@
+import "./styles-shared.js";
+import pageHost from "virtual:vitest-plugin-rsc/page-host";
+import { releaseTimers, runnerTimers } from "@kasperpeulen/vitest-plugin-rsc/internal/timers";
+//#region src/document.ts
+const elements = (of) => [
+	of.documentElement,
+	of.head,
+	of.body
+];
+const attributesOf = (element) => Array.from(element.attributes, ({ name, value }) => [name, value]);
+let unload;
+const keptProperties = /* @__PURE__ */ new WeakMap();
+/**
+* Keeps the properties `keys` of `target`, the document or one of its
+* elements, as the pages are left, until it is called again: the marks of
+* React DOM on the root of an app that renders the pages after its first
+* (`renderAgain()` in client.tsx). Without `keys` they are no longer kept,
+* and the app that kept them removes them.
+*/
+function keepProperties(target, keys) {
+	if (keys) keptProperties.set(target, new Set(keys));
+	else keptProperties.delete(target);
+}
+const keptNodes = /* @__PURE__ */ new Set();
+let preloads = [];
+let runnerHref;
+/**
+* The URL of the document without the page that is open: the runner's, which
+* the page shows as its own while it is open.
+*/
+function documentUrl() {
+	return runnerHref ?? window.location.href;
+}
+const navigation = window.navigation;
+function activate() {
+	if (!navigation || !("activation" in navigation)) return () => {};
+	const activation = {
+		entry: navigation.currentEntry,
+		from: null,
+		navigationType: "push"
+	};
+	Object.defineProperty(navigation, "activation", {
+		configurable: true,
+		enumerable: true,
+		get: () => activation
+	});
+	return () => Reflect.deleteProperty(navigation, "activation");
+}
+function staysDuringPage(node) {
+	return node instanceof HTMLScriptElement || node instanceof HTMLStyleElement || isPreload(node);
+}
+function isPreload(node) {
+	return node instanceof HTMLLinkElement && (node.relList.contains("modulepreload") || node.relList.contains("preload") && node.as !== "style");
+}
+function isViteStyle(node) {
+	return node instanceof HTMLStyleElement && node.hasAttribute("data-vite-dev-id");
+}
+function isGraphStylesheet(node) {
+	return node instanceof HTMLLinkElement && node.hasAttribute("data-vitest-plugin-rsc-graph");
+}
+function elementsOf(parent, tag) {
+	return Array.from(parent.getElementsByTagName(tag));
+}
+const hasRel = (link, keyword) => link.rel.toLowerCase().split(/[\t\n\f\r ]+/).includes(keyword);
+function stylesheetsOf(parent, url) {
+	return elementsOf(parent, "link").filter((link) => hasRel(link, "stylesheet") && !link.relList.contains("alternate") && link.getAttribute("href") && (!link.type || link.type === "text/css") && URL.canParse(link.getAttribute("href"), url) && new URL(link.getAttribute("href"), url).origin === window.location.origin);
+}
+function stylesheetLoaded(link) {
+	return new Promise((resolve) => {
+		link.addEventListener("load", () => resolve(), { once: true });
+		link.addEventListener("error", () => resolve(), { once: true });
+	});
+}
+const globalsOfThePage = [
+	"next",
+	"nd",
+	"_N_E_STYLE_LOAD",
+	"__next_set_public_path__",
+	"__NEXT_HMR_CB",
+	"$RB",
+	"$RM",
+	"$RR",
+	"$RS",
+	"$RT",
+	"$RV",
+	"$RX"
+];
+const deleteGlobalsOfThePage = () => {
+	for (const name of globalsOfThePage) Reflect.deleteProperty(window, name);
+};
+const reactScript = /\$R[A-Z]\b/;
+function runInlineScript(code, timers) {
+	if (!reactScript.test(code)) {
+		(0, eval)(code);
+		return;
+	}
+	new Function("setTimeout", "clearTimeout", "requestAnimationFrame", "cancelAnimationFrame", code)(timers.setTimeout, timers.clearTimeout, timers.requestAnimationFrame, timers.cancelAnimationFrame);
+}
+const reactProperty = /^_+react/;
+function forgetReact(root) {
+	const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_COMMENT);
+	for (let node = root; node; node = walker.nextNode()) for (const key of Object.keys(node)) if (reactProperty.test(key)) Reflect.deleteProperty(node, key);
+}
+function setAttributes(element, attributes) {
+	for (const { name } of Array.from(element.attributes)) element.removeAttribute(name);
+	for (const [name, value] of attributes) element.setAttribute(name, value);
+}
+/**
+* Starts the files of the route of the page that loads next, as the server
+* renders it: `stylesheets` as Next links them, in the CORS mode of
+* `crossOrigin`, and `modules`. By their URLs. They go with that page.
+*/
+function preloadPage({ stylesheets, crossOrigin, modules }) {
+	const links = [...stylesheets.map((href) => ({
+		href,
+		rel: "preload",
+		as: "style",
+		crossOrigin
+	})), ...modules.map((href) => ({
+		href,
+		rel: "modulepreload",
+		as: "",
+		crossOrigin: ""
+	}))];
+	for (const { href, rel, as, crossOrigin } of links) {
+		if (preloads.some((link) => link.href === href)) continue;
+		const link = document.createElement("link");
+		link.rel = rel;
+		if (as) link.as = as;
+		if (crossOrigin !== void 0) link.crossOrigin = crossOrigin;
+		link.href = href;
+		document.head.append(link);
+		preloads.push(link);
+	}
+}
+/**
+* Replaces the page in this document with the one the server sent as `html`:
+* its `<head>` first, the rest once the stylesheets of the `<head>` have
+* loaded, and runs its inline scripts in document order once the stylesheets
+* of the rest have too. Resolves then, and without running them for a page
+* that was left in the meantime.
+*
+* The page is there in full before the app starts, so the document has loaded
+* by the time Next's client looks: it reads the Flight payload that Next's
+* inline scripts left in `self.__next_f`, and hydrates.
+*
+* With a `container`, the page is the one of a node, which renders no
+* `<html>` or `<body>`, and what is in the document stays the test's. What
+* the HTML parser puts in `<body>` goes in the container: the node, with the
+* scripts it renders, and after it the scripts of Next and React.
+*
+* The page takes the entry of the history that the document is at, or with
+* `after` gets one of its own, after that entry. With `inKeptApp`, leaving
+* the page leaves what the app added to the `<head>`: see `unloadKeptApp()`.
+* React's inline scripts get timers of the page's own, which leaving the
+* page clears.
+*
+* Returns what takes React DOM's properties off the nodes of this page,
+* before its root unmounts: React takes the nodes out of the document as it
+* does, and leaves its fiber on a text node. A node that outlives the page
+* then keeps no fiber of it: the one that an assertion of the test holds
+* until it ends, or the one under the pointer. Once the page is left, it
+* does nothing: leaving took them off already. Nothing for a page of a kept
+* app, whose root outlives the page.
+*/
+async function loadDocument(html, url, container, after, inKeptApp = false) {
+	leaveDocument();
+	const ownPreloads = new Set(preloads);
+	preloads = [];
+	const runnerUrl = window.location.href;
+	runnerHref = runnerUrl;
+	const runnerBody = document.body;
+	const runnerAttributes = elements(document).map(attributesOf);
+	const reactTargets = [
+		document,
+		document.documentElement,
+		document.head
+	];
+	if (container) reactTargets.push(container);
+	const runnerProperties = reactTargets.map((target) => new Set(Reflect.ownKeys(target)));
+	const runnerAdopted = Array.from(document.adoptedStyleSheets);
+	const runnerScripts = new Set(document.querySelectorAll("script"));
+	const before = new Set([...document.head.childNodes, ...runnerBody.childNodes].filter((node) => !ownPreloads.has(node) && !keptNodes.has(node)));
+	const brought = new Set(ownPreloads);
+	const parked = [];
+	const graphParked = /* @__PURE__ */ new Set();
+	const switchedOff = [];
+	const pageBody = document.createElement("body");
+	let leaveNow;
+	const left = new Promise((resolve) => leaveNow = resolve);
+	let deactivate = () => {};
+	const pageNodes = () => [...container ? Array.from(container.childNodes) : [], ...[document.head, pageBody].flatMap((parent) => Array.from(parent.childNodes).filter((node) => !before.has(node) && !isViteStyle(node) && !isGraphStylesheet(node)))];
+	const scriptTimers = runnerTimers(() => unload !== leave);
+	const leave = () => {
+		try {
+			leaveNow();
+			if (!inKeptApp) pageNodes().forEach(forgetReact);
+			container?.replaceChildren();
+			for (const parent of [document.head, pageBody]) for (const node of Array.from(parent.childNodes)) {
+				if (before.has(node) || isViteStyle(node) || isGraphStylesheet(node)) continue;
+				if (inKeptApp && parent === document.head && !brought.has(node)) keptNodes.add(node);
+				else node.remove();
+			}
+		} finally {
+			runnerHref = void 0;
+			deactivate();
+			if (window.location.href !== runnerUrl) window.history.replaceState(null, "", runnerUrl);
+		}
+		document.head.append(...parked.filter((node) => !graphParked.has(node) || isGraphStylesheet(node)));
+		for (const [style, media] of switchedOff) if (media === null) style.removeAttribute("media");
+		else style.media = media;
+		runnerBody.append(...pageBody.childNodes);
+		pageBody.replaceWith(runnerBody);
+		elements(document).forEach((element, index) => setAttributes(element, runnerAttributes[index]));
+		document.adoptedStyleSheets = runnerAdopted;
+		reactTargets.forEach((target, index) => {
+			for (const key of Reflect.ownKeys(target)) {
+				if (runnerProperties[index].has(key) || keptProperties.get(target)?.has(key)) continue;
+				Reflect.deleteProperty(target, key);
+			}
+		});
+		delete self.__next_f;
+		delete self.__next_s;
+		if (!inKeptApp) deleteGlobalsOfThePage();
+		releaseTimers(scriptTimers);
+	};
+	unload = leave;
+	const forget = () => {
+		if (!inKeptApp && unload === leave) pageNodes().forEach(forgetReact);
+	};
+	const page = new DOMParser().parseFromString(html, "text/html");
+	for (const redirect of elementsOf(page, "meta")) if (redirect.id === "__next-page-redirect") redirect.removeAttribute("http-equiv");
+	const urlOf = (element, name) => {
+		const value = element.getAttribute(name);
+		return value !== null && URL.canParse(value, url) ? new URL(value, url).href : void 0;
+	};
+	const sources = new Set(elementsOf(page, "script").map((script) => urlOf(script, "src")));
+	sources.delete(void 0);
+	for (const link of elementsOf(page, "link")) if (link.rel.toLowerCase() === "preload" && link.getAttribute("as") === "script") {
+		if (sources.has(urlOf(link, "href"))) link.remove();
+	}
+	const stylesheetsOfHead = stylesheetsOf(page.head, url);
+	const stylesheetsOfBody = stylesheetsOf(page.body, url);
+	const loaded = (stylesheets) => Promise.race([pageHost.loadsStylesheets ? Promise.all(stylesheets.filter((link) => !link.disabled).map(stylesheetLoaded)) : void 0, left]);
+	if (after) {
+		window.history.replaceState(after.state, "", after.url);
+		window.history.pushState(null, "", url);
+	} else window.history.replaceState(null, "", url);
+	deactivate = activate();
+	const head = Array.from(page.head.childNodes);
+	for (const node of head) brought.add(node);
+	document.head.append(...head);
+	await loaded(stylesheetsOfHead);
+	if (unload !== leave) return forget;
+	for (const node of runnerBody.childNodes) before.add(node);
+	for (const node of container ? [] : document.head.childNodes) {
+		if (!before.has(node)) continue;
+		if (isViteStyle(node)) switchedOff.push([node, node.getAttribute("media")]);
+		else if (!staysDuringPage(node)) parked.push(node);
+		if (isGraphStylesheet(node)) graphParked.add(node);
+	}
+	for (const node of parked) document.head.removeChild(node);
+	for (const [style] of switchedOff) style.media = "not all";
+	const staying = Array.from(runnerBody.childNodes).filter((node) => container || staysDuringPage(node));
+	setAttributes(pageBody, attributesOf(runnerBody));
+	document.documentElement.replaceChild(pageBody, runnerBody);
+	pageBody.append(...staying);
+	if (container) container.append(...page.body.childNodes);
+	else {
+		elements(page).forEach((element, index) => setAttributes(elements(document)[index], attributesOf(element)));
+		pageBody.append(...page.body.childNodes);
+	}
+	await loaded(stylesheetsOfBody);
+	if (unload !== leave) return forget;
+	for (const script of document.querySelectorAll("script")) {
+		if (runnerScripts.has(script) || script.src) continue;
+		if (!script.type || script.type === "text/javascript" || script.type === "module") try {
+			runInlineScript(script.textContent ?? "", scriptTimers);
+		} catch (error) {
+			reportError(error);
+		}
+	}
+	return forget;
+}
+let queueStreamedContent;
+/** `self.$RC` of a page. */
+const streamedContentQueue = {
+	configurable: true,
+	set: (queue) => queueStreamedContent = queue,
+	get: () => queueStreamedContent && ((...args) => {
+		queueStreamedContent(...args);
+		const { $RB: queued, $RV: reveal } = self;
+		try {
+			if (queued?.length && reveal) reveal(queued);
+		} catch (error) {
+			reportError(error);
+		}
+	})
+};
+function leaveDocument() {
+	const leave = unload;
+	unload = void 0;
+	leave?.();
+}
+/**
+* Takes back what the code of the kept app added to the `<head>` as its pages
+* were open, once the app is left: see `loadDocument()`. With `withGlobals`,
+* also the globals of Next and React on `window` that point into it.
+*/
+function unloadKeptApp(withGlobals = true) {
+	for (const node of keptNodes) if (node.parentNode === document.head) node.remove();
+	keptNodes.clear();
+	if (withGlobals) deleteGlobalsOfThePage();
+}
+/**
+* Leaves the page, and the one that was loading: the document is as it was
+* before the page, but for what a kept app keeps (`unloadKeptApp()`).
+*/
+function unloadDocument() {
+	try {
+		leaveDocument();
+	} finally {
+		for (const link of preloads) link.remove();
+		preloads = [];
+	}
+}
+//#endregion
+export { documentUrl, keepProperties, loadDocument, preloadPage, streamedContentQueue, unloadDocument, unloadKeptApp };

package/dist/downloads.d.ts

@@ -0,0 +1,15 @@
+//#region src/downloads.d.ts
+/**
+ * The name a browser saves the answer to a navigation as, or none when it
+ * shows the answer. `requested` is the navigation's `downloadRequest`: the
+ * `download` attribute of a link, `""` without a value.
+ */
+declare function downloadName(response: Response, requested: string | null): string | undefined;
+/**
+ * Hands the answer to the browser as a download, as `name`: the browser
+ * saves the body of a Blob URL that an `<a download>` links, and the URL goes
+ * once it has. An answer that is not ok is no file, as in a browser.
+ */
+declare function download(response: Response, name: string, signal: AbortSignal): Promise<void>;
+//#endregion
+export { download, downloadName };

package/dist/downloads.js

@@ -0,0 +1,71 @@
+//#region src/downloads.ts
+/**
+* The name a browser saves the answer to a navigation as, or none when it
+* shows the answer. `requested` is the navigation's `downloadRequest`: the
+* `download` attribute of a link, `""` without a value.
+*/
+function downloadName(response, requested) {
+	const disposition = response.headers.get("content-disposition") ?? "";
+	const type = /^\s*([^\s;=]*)\s*(?:;|$)/.exec(disposition)?.[1]?.toLowerCase();
+	if (requested === null && (!type || type === "inline")) return void 0;
+	const fromUrl = decode(percentDecoded(new URL(response.url).pathname.split("/").pop()), "utf-8");
+	return filenameOf(disposition) || requested || fromUrl || "download";
+}
+function filenameOf(disposition) {
+	const parameters = /* @__PURE__ */ new Map();
+	for (const [, name, value] of disposition.matchAll(/;\s*([^\s=;]+)\s*=\s*("(?:[^"\\]|\\.)*"|[^;]*)/g)) {
+		const unquoted = value.startsWith("\"") ? value.slice(1, -1).replace(/\\(.)/g, "$1") : value;
+		if (!parameters.has(name.toLowerCase())) parameters.set(name.toLowerCase(), unquoted.trim());
+	}
+	const extended = /^([\w!#$%&+^`{}~-]+)'[^']*'(.*)$/.exec(parameters.get("filename*") ?? "");
+	if (extended) {
+		const decoded = decode(percentDecoded(extended[2]), extended[1]);
+		if (decoded) return decoded;
+	}
+	const plain = parameters.get("filename");
+	if (!plain) return void 0;
+	const text = decode(Uint8Array.from(plain, (char) => char.charCodeAt(0) & 255), "utf-8") ?? plain;
+	return /^[\x20-\x7e]*%[\da-f]{2}[\x20-\x7e]*$/i.test(text) ? decode(percentDecoded(text), "utf-8") ?? text : text;
+}
+function percentDecoded(text) {
+	const bytes = [];
+	for (let at = 0; at < text.length; at++) {
+		const escaped = /^%([\da-f]{2})/i.exec(text.slice(at, at + 3));
+		if (escaped) {
+			bytes.push(parseInt(escaped[1], 16));
+			at += 2;
+		} else bytes.push(text.charCodeAt(at) & 255);
+	}
+	return Uint8Array.from(bytes);
+}
+function decode(bytes, charset) {
+	try {
+		return new TextDecoder(charset, { fatal: true }).decode(bytes);
+	} catch {
+		return;
+	}
+}
+/**
+* Hands the answer to the browser as a download, as `name`: the browser
+* saves the body of a Blob URL that an `<a download>` links, and the URL goes
+* once it has. An answer that is not ok is no file, as in a browser.
+*/
+async function download(response, name, signal) {
+	if (!response.ok) {
+		await response.body?.cancel();
+		throw new Error(`vitest-plugin-rsc: the download of ${response.url} failed: it responded with ${response.status}. A browser saves no file for it.`);
+	}
+	const blob = await response.blob();
+	signal.throwIfAborted();
+	const url = URL.createObjectURL(blob);
+	try {
+		const link = document.createElement("a");
+		link.href = url;
+		link.download = name;
+		link.click();
+	} finally {
+		URL.revokeObjectURL(url);
+	}
+}
+//#endregion
+export { download, downloadName };

package/dist/esm-require.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "vite";
+
+//#region src/esm-require.d.ts
+/**
+ * The plugin of the optimizer that makes `__toCommonJS` of Rolldown's runtime
+ * return one object per module. A runtime that does not have it as above is
+ * left as it is.
+ */
+declare function esmRequirePlugin(): Plugin;
+//#endregion
+export { esmRequirePlugin };

package/dist/esm-require.js

@@ -0,0 +1,32 @@
+//#region src/esm-require.ts
+const declaration = /^(?:export )?var __toCommonJS = /m;
+const copy = /__copyProps\(\s*__defProp\(\s*\{\s*\}\s*,\s*(["'])__esModule\1\s*,\s*\{\s*value:\s*true\s*\}\s*\)\s*,\s*mod\s*\)/y;
+/**
+* The plugin of the optimizer that makes `__toCommonJS` of Rolldown's runtime
+* return one object per module. A runtime that does not have it as above is
+* left as it is.
+*/
+function esmRequirePlugin() {
+	return {
+		name: "vitest-plugin-rsc:esm-require",
+		transform: {
+			filter: { id: /rolldown\/runtime\.js$/ },
+			handler(code) {
+				const start = code.search(declaration);
+				if (start === -1) return;
+				const end = code.indexOf(";", start);
+				const at = code.indexOf("__copyProps(", start);
+				copy.lastIndex = at;
+				const copied = at !== -1 && at < end ? copy.exec(code)?.[0] : void 0;
+				if (!copied) return;
+				const cached = `(__toCommonJSOf.get(mod) ?? __toCommonJSOf.set(mod, ${copied}).get(mod))`;
+				return {
+					code: `${code.slice(0, start)}var __toCommonJSOf = new WeakMap();\n${code.slice(start, at)}${cached}${code.slice(at + copied.length)}`,
+					map: null
+				};
+			}
+		}
+	};
+}
+//#endregion
+export { esmRequirePlugin };