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

package/dist/node-server.js

@@ -0,0 +1,193 @@
+import { registry } from "./registry.js";
+import { restoreIncrementalCache } from "./cache.js";
+import { MockedResponse, fromNodeOutgoingHttpHeaders, isDynamicServerError, toNodeOutgoingHttpHeaders } from "./compat/ssr/node-server.js";
+import { Readable } from "@kasperpeulen/vitest-plugin-nextjs/node/stream";
+//#region src/node-server.ts
+const nativeSetTimeout = globalThis.setTimeout;
+const leftBeforeSent = () => new DOMException("The page was left before the server had sent it.", "AbortError");
+/** The `http.IncomingMessage` of a request: a stream of its body, with what Next reads of it. */
+function createNodeRequest(request) {
+	const url = new URL(request.url);
+	const { body } = request;
+	const stream = body instanceof Uint8Array ? Readable.from([body]) : body && Readable.fromWeb(body);
+	return Object.assign(stream || Readable.from([]), {
+		method: request.method,
+		url: url.pathname + url.search,
+		headers: {
+			host: url.host,
+			...toNodeOutgoingHttpHeaders(request.headers)
+		},
+		httpVersion: "1.1",
+		socket: { encrypted: url.protocol === "https:" }
+	});
+}
+const writings = /* @__PURE__ */ new WeakMap();
+/** The `Writing` of a response of `handleRequest()` with a body. */
+const writingOf = (response) => writings.get(response);
+/**
+* The `http.ServerResponse` of a request, which is Next's own stand-in for
+* one, and the `Response` the browser gets of it: once its head is there, while
+* Next goes on to write the body.
+*
+* A request that is left before its head has no response. It lasts until
+* Next's handler is done with it, which can be much later, when the data it
+* waited for comes: its stores have to be there until then.
+*/
+function createNodeResponse(request) {
+	let controller;
+	let headSent = false;
+	let wrote = false;
+	let finished = false;
+	let cancelled = false;
+	let sendHead;
+	const head = new Promise((resolve) => sendHead = resolve).then(() => headSent = true);
+	const encoder = new TextEncoder();
+	let ended;
+	const bodyWritten = new Promise((resolve) => ended = resolve);
+	const body = new ReadableStream({
+		start: (c) => void (controller = c),
+		cancel() {
+			cancelled = true;
+			res.destroy();
+			ended();
+		}
+	});
+	const stop = () => {
+		cancelled = true;
+		controller.error(AbortSignal.abort().reason);
+		res.destroy();
+		ended();
+	};
+	const res = new MockedResponse({ resWriter(chunk) {
+		if (res.destroyed) return false;
+		sendHead();
+		wrote = headSent = res.headersSent = true;
+		controller.enqueue(typeof chunk === "string" ? encoder.encode(chunk) : new Uint8Array(chunk));
+		return true;
+	} });
+	const appendHeader = res.appendHeader.bind(res);
+	res.appendHeader = (name, value) => name.toLowerCase() === "location" && res.getHeader(name) === value ? res : appendHeader(name, value);
+	const end = res.end.bind(res);
+	res.end = ((...args) => {
+		end(...args);
+		if (res.destroyed) return res;
+		if (!wrote) finished = true;
+		headSent = res.headersSent = true;
+		sendHead();
+		return res;
+	});
+	res._writableState.autoDestroy = false;
+	res.on("finish", () => {
+		finished = true;
+		Object.defineProperty(res, "writableFinished", {
+			value: true,
+			configurable: true
+		});
+		controller.close();
+		ended();
+		nativeSetTimeout(() => res.destroy());
+	});
+	let failure;
+	res.on("error", (error) => failure ??= error);
+	res.on("close", () => {
+		if (!headSent || finished || cancelled) return;
+		controller.error(failure ?? leftBeforeSent());
+		ended();
+	});
+	res.hasStreamed.catch(() => {});
+	const { signal } = request;
+	const leave = () => res.destroy();
+	signal?.addEventListener("abort", leave, { once: true });
+	res.once("close", () => signal?.removeEventListener("abort", leave));
+	const response = (written) => {
+		const sent = head.then(() => {
+			const empty = finished && !wrote || [
+				101,
+				204,
+				205,
+				304
+			].includes(res.statusCode);
+			const answer = new registry.Response(empty ? null : body, {
+				status: res.statusCode,
+				statusText: res.statusMessage,
+				headers: fromNodeOutgoingHttpHeaders(res.getHeaders())
+			});
+			if (!empty) writings.set(answer, {
+				written: bodyWritten,
+				stop
+			});
+			return answer;
+		});
+		const settled = written.then(() => {
+			if (headSent) return sent;
+			res.destroy();
+			throw failure ?? leftBeforeSent();
+		}, (error) => {
+			if (!headSent) {
+				res.destroy();
+				throw error;
+			}
+			res.destroy(error ?? /* @__PURE__ */ new Error("The request handler failed."));
+			return sent;
+		});
+		return Promise.race([sent, settled]);
+	};
+	return {
+		res,
+		response
+	};
+}
+const staticToDynamic = "Page changed from static to dynamic at runtime ";
+const isPrerenderBailout = (error) => isDynamicServerError(error) || error instanceof Error && error.message.startsWith(staticToDynamic);
+const prerenders = [];
+const routerServerContexts = Symbol.for("@next/router-server-methods");
+globalThis[routerServerContexts] = { "": { logErrorWithOriginalStack(error) {
+	const prerender = prerenders.at(-1);
+	if (!isPrerenderBailout(error)) console.error(error);
+	else if (prerender) prerender.bailouts++;
+} } };
+/**
+* Counts the bail-outs that Next's handler reports for the prerender that
+* starts now: also those it answers with its error page itself, where its
+* render of a page recovers from the error (`app-page-runtime.js:1133-1224`).
+* The function it returns ends the count and answers it, once: a count that
+* stays would get the bail-outs of the prerenders after it.
+*/
+function countBailouts() {
+	const prerender = { bailouts: 0 };
+	prerenders.push(prerender);
+	return () => {
+		const at = prerenders.lastIndexOf(prerender);
+		if (at !== -1) prerenders.splice(at, 1);
+		return prerender.bailouts;
+	};
+}
+function requestMetaOf(request, routed = {}) {
+	return {
+		...routed.params && { params: routed.params },
+		...routed.query && { query: routed.query },
+		initURL: request.url,
+		initProtocol: new URL(request.url).protocol.slice(0, -1)
+	};
+}
+/**
+* One request, by the request handler Next's build makes for its route:
+* `templates/app-page-runtime` for a page and `templates/app-route` for a
+* route handler, as `next start` calls them.
+*/
+async function handleRequest(request, context, handler, routed, { statusCode, headers } = {}) {
+	const { res, response } = createNodeResponse(request);
+	if (statusCode !== void 0) res.statusCode = statusCode;
+	headers?.forEach((value, name) => {
+		if (name !== "set-cookie") res.setHeader(name, value);
+	});
+	return response(handler(createNodeRequest(request), res, {
+		waitUntil: context.waitUntil,
+		requestMeta: {
+			...requestMetaOf(request, routed),
+			incrementalCache: globalThis.__incrementalCache
+		}
+	}).finally(restoreIncrementalCache));
+}
+//#endregion
+export { countBailouts, handleRequest, isPrerenderBailout, writingOf };

package/dist/not-found-page.d.ts

@@ -0,0 +1,19 @@
+import { Plugin } from "vite";
+
+//#region src/not-found-page.d.ts
+/**
+ * A script that loads the host's document of the last page of a static build
+ * that this browser opened, when the expression `when` holds: in place of a
+ * document that the static host has at the URL of that page. Nothing when no
+ * page was opened, or the host is at this URL itself.
+ */
+declare function returnToHostScript(when?: string): string;
+/**
+ * An expression of a script for `returnToHostScript()`: whether the host's
+ * document of the last page that this tab opened was the tab's own, not in
+ * a frame.
+ */
+declare const topLevelHost: string;
+declare function notFoundPagePlugin(environment: string): Plugin;
+//#endregion
+export { notFoundPagePlugin, returnToHostScript, topLevelHost };

package/dist/not-found-page.js

@@ -0,0 +1,74 @@
+import { hostKey, topLevelHostKey } from "./host-return-shared.js";
+import path from "node:path";
+import fs from "node:fs";
+import { getPluginApi } from "@vitejs/plugin-rsc/plugin";
+//#region src/not-found-page.ts
+/**
+* A script that loads the host's document of the last page of a static build
+* that this browser opened, when the expression `when` holds: in place of a
+* document that the static host has at the URL of that page. Nothing when no
+* page was opened, or the host is at this URL itself.
+*/
+function returnToHostScript(when = "true") {
+	const key = JSON.stringify(hostKey);
+	return `(function () {
+  if (!(${when})) return;
+  var host;
+  try {
+    host = sessionStorage.getItem(${key}) || localStorage.getItem(${key});
+  } catch (error) {}
+  if (!host) return;
+  var url = new URL(host, location.href);
+  if (url.origin !== location.origin || url.pathname === location.pathname) return;
+  // What the document started to load is not needed.
+  window.stop();
+  location.replace(url.href);
+})();`;
+}
+/**
+* An expression of a script for `returnToHostScript()`: whether the host's
+* document of the last page that this tab opened was the tab's own, not in
+* a frame.
+*/
+const topLevelHost = `(function () {
+  try {
+    return sessionStorage.getItem(${JSON.stringify(topLevelHostKey)}) === "1";
+  } catch (error) {
+    return false;
+  }
+})()`;
+const notFoundPage = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="robots" content="noindex" />
+    <title>404: This page could not be found.</title>
+    <script>
+${returnToHostScript()}
+    <\/script>
+  </head>
+  <body>
+    <p>404: This page could not be found.</p>
+  </body>
+</html>
+`;
+function notFoundPagePlugin(environment) {
+	return {
+		name: "vitest-plugin-rsc:next-not-found-page",
+		apply: "build",
+		generateBundle(_options, bundle) {
+			if (this.environment.name !== environment) return;
+			if (getPluginApi(this.environment.config)?.manager.isScanBuild) return;
+			const { publicDir } = this.environment.config;
+			if ("404.html" in bundle) return;
+			if (publicDir && fs.existsSync(path.join(publicDir, "404.html"))) return;
+			this.emitFile({
+				type: "asset",
+				fileName: "404.html",
+				source: notFoundPage
+			});
+		}
+	};
+}
+//#endregion
+export { notFoundPagePlugin, returnToHostScript, topLevelHost };

package/dist/optimizer-cache-key.d.ts

@@ -0,0 +1,26 @@
+import { NextLayer, NextProject } from "./project.js";
+
+//#region src/optimizer-cache-key.d.ts
+type OptimizerInputs = Pick<NextProject, "aliases" | "appAliases" | "dependencyCompileOptions" | "newExports" | "version">;
+/**
+ * What the project gives the optimizer's plugins of a layer: Next's alias
+ * table and the app's, which the resolver picks from by the importer, and the
+ * options of Next's transform for a dependency. The tables in their order,
+ * not sorted: the resolver takes the first entry that matches, and a prefix
+ * like `next` can match where a later one would. The order is the code's,
+ * the same for every run. And the stubs of the stand-ins, of the version of
+ * Next.
+ */
+declare function projectKey(project: OptimizerInputs, layer: NextLayer): string;
+/**
+ * The code of a directory of the plugin: the contents of every file of it.
+ * The contents, not the version, which a build of this repository keeps, and
+ * not the times of the files, which every build changes. All of the code,
+ * not just the modules that compile a dependency: a bundle of `dist` mixes
+ * modules, and what those import is just as much the compile.
+ */
+declare function codeKey(dir: string): string;
+/** For the `define` of the optimizer of a layer, which Vite keys its cache on. */
+declare function optimizerCacheKey(project: OptimizerInputs, layer: NextLayer): Record<string, string>;
+//#endregion
+export { codeKey, optimizerCacheKey, projectKey };

package/dist/optimizer-cache-key.js

@@ -0,0 +1,73 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/optimizer-cache-key.ts
+const hash = (text) => createHash("sha256").update(text).digest("hex").slice(0, 16);
+/**
+* What the project gives the optimizer's plugins of a layer: Next's alias
+* table and the app's, which the resolver picks from by the importer, and the
+* options of Next's transform for a dependency. The tables in their order,
+* not sorted: the resolver takes the first entry that matches, and a prefix
+* like `next` can match where a later one would. The order is the code's,
+* the same for every run. And the stubs of the stand-ins, of the version of
+* Next.
+*/
+function projectKey(project, layer) {
+	return hash(JSON.stringify([
+		Object.entries(project.aliases[layer]),
+		Object.entries(project.appAliases[layer]),
+		project.dependencyCompileOptions[layer],
+		project.newExports,
+		project.version
+	]));
+}
+const isCode = (file) => /\.[cm]?[jt]sx?$/.test(file) && !/\.test\.[cm]?[jt]sx?$/.test(file) && !/\.d\.[cm]?ts$/.test(file);
+/**
+* The code of a directory of the plugin: the contents of every file of it.
+* The contents, not the version, which a build of this repository keeps, and
+* not the times of the files, which every build changes. All of the code,
+* not just the modules that compile a dependency: a bundle of `dist` mixes
+* modules, and what those import is just as much the compile.
+*/
+function codeKey(dir) {
+	const content = createHash("sha256");
+	const files = fs.readdirSync(dir, {
+		recursive: true,
+		encoding: "utf8"
+	}).map((file) => file.split(path.sep).join("/")).filter(isCode).sort();
+	for (const file of files) {
+		const full = path.join(dir, file);
+		if (!fs.statSync(full).isFile()) continue;
+		content.update(`${file}\0`).update(fs.readFileSync(full)).update("\0");
+	}
+	return content.digest("hex").slice(0, 16);
+}
+function ownCodeDirs() {
+	const file = fileURLToPath(import.meta.url);
+	for (let dir = path.dirname(file); dir !== path.dirname(dir); dir = path.dirname(dir)) {
+		const manifest = path.join(dir, "package.json");
+		if (!fs.existsSync(manifest)) continue;
+		const { name } = JSON.parse(fs.readFileSync(manifest, "utf8"));
+		if (name !== "@kasperpeulen/vitest-plugin-nextjs") return [];
+		const core = path.dirname(createRequire(import.meta.url).resolve("@kasperpeulen/vitest-plugin-rsc/package.json"));
+		return [dir, core].flatMap((pkg) => ["src", "dist"].map((code) => path.join(pkg, code))).filter((code) => fs.statSync(code, { throwIfNoEntry: false })?.isDirectory());
+	}
+	return [];
+}
+let ownCodeKey;
+/** For the `define` of the optimizer of a layer, which Vite keys its cache on. */
+function optimizerCacheKey(project, layer) {
+	if (ownCodeKey === void 0) try {
+		ownCodeKey = hash(ownCodeDirs().map((dir) => `${path.basename(dir)}:${codeKey(dir)}`).join(","));
+	} catch {
+		ownCodeKey = "";
+	}
+	return {
+		__vitest_plugin_rsc_project__: JSON.stringify(projectKey(project, layer)),
+		__vitest_plugin_rsc_code__: JSON.stringify(ownCodeKey)
+	};
+}
+//#endregion
+export { codeKey, optimizerCacheKey, projectKey };

package/dist/own-package.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/own-package.js

@@ -0,0 +1,6 @@
+import { fileURLToPath } from "node:url";
+import { addOwnPackage } from "@kasperpeulen/vitest-plugin-rsc/internal/own-packages";
+//#region src/own-package.ts
+addOwnPackage("@kasperpeulen/vitest-plugin-nextjs", fileURLToPath(new URL("./", import.meta.url)));
+//#endregion
+export {};

package/dist/page-store.d.ts

@@ -0,0 +1,33 @@
+//#region src/page-store.d.ts
+type Cookie = {
+  value: string;
+  httpOnly: boolean;
+};
+/**
+ * What the browser's requests to the app carry, besides what a browser adds
+ * itself. One for the document, from what the test opened until the test
+ * ends: `cleanup()` makes a new one.
+ */
+declare class PageStore {
+  #private;
+  /** The `headers` of what the test opened, until it opens something else. */
+  headers: Headers;
+  /** The app's cookies, by name, with the values the server wrote. */
+  readonly cookies: Map<string, Cookie>;
+  /** Sets the cookies of a `cookie` header, as a `Set-Cookie` of each would. */
+  seed(cookie: string): void;
+  /** Sets and deletes cookies by the `Set-Cookie` headers of a response of the app. */
+  receive(setCookies: Iterable<string>): void;
+  /**
+   * Sets or deletes a cookie as a script of the page does, with
+   * `document.cookie`. As in a browser, a script cannot write an `HttpOnly`
+   * cookie, nor change or delete one.
+   */
+  write(setCookie: string): void;
+  /** The `cookie` header of a request: empty without cookies. */
+  cookieHeader(): string;
+  /** What `document.cookie` has: the cookies that are not `HttpOnly`. */
+  documentCookie(): string;
+}
+//#endregion
+export { PageStore };

package/dist/page-store.js

@@ -0,0 +1,80 @@
+//#region src/page-store.ts
+/** A name and a value: of a `cookie` header, or of a `Set-Cookie` before its first `;`. */
+function pairOf(text) {
+	const at = text.indexOf("=");
+	return at === -1 ? ["", text.trim()] : [text.slice(0, at).trim(), text.slice(at + 1).trim()];
+}
+/** The name of an attribute of a `Set-Cookie`, in lower case, and its value. */
+function attributeOf(text) {
+	const at = text.indexOf("=");
+	return at === -1 ? [text.trim().toLowerCase(), ""] : [text.slice(0, at).trim().toLowerCase(), text.slice(at + 1).trim()];
+}
+function expiresAt(value) {
+	if (!/\d{1,2}:\d{1,2}:\d{1,2}/.test(value)) return void 0;
+	if (!/jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec/i.test(value)) return void 0;
+	const time = Date.parse(value);
+	return Number.isNaN(time) ? void 0 : time;
+}
+function deletes(attributes) {
+	let maxAge;
+	let expires;
+	for (const [name, value] of attributes.map(attributeOf)) {
+		if (name === "max-age" && /^-?\d+$/.test(value)) maxAge = Number(value);
+		if (name === "expires") expires = expiresAt(value) ?? expires;
+	}
+	if (maxAge !== void 0) return maxAge <= 0;
+	return expires !== void 0 && expires <= Date.now();
+}
+/** The cookies as a `cookie` header, or as `document.cookie` has them. */
+function serialize(cookies) {
+	return Array.from(cookies, ([name, { value }]) => name ? `${name}=${value}` : value).join("; ");
+}
+/**
+* What the browser's requests to the app carry, besides what a browser adds
+* itself. One for the document, from what the test opened until the test
+* ends: `cleanup()` makes a new one.
+*/
+var PageStore = class {
+	/** The `headers` of what the test opened, until it opens something else. */
+	headers = new Headers();
+	/** The app's cookies, by name, with the values the server wrote. */
+	cookies = /* @__PURE__ */ new Map();
+	/** Sets the cookies of a `cookie` header, as a `Set-Cookie` of each would. */
+	seed(cookie) {
+		this.receive(cookie.split(";"));
+	}
+	/** Sets and deletes cookies by the `Set-Cookie` headers of a response of the app. */
+	receive(setCookies) {
+		for (const setCookie of setCookies) this.#set(setCookie, false);
+	}
+	/**
+	* Sets or deletes a cookie as a script of the page does, with
+	* `document.cookie`. As in a browser, a script cannot write an `HttpOnly`
+	* cookie, nor change or delete one.
+	*/
+	write(setCookie) {
+		this.#set(setCookie, true);
+	}
+	/** The `cookie` header of a request: empty without cookies. */
+	cookieHeader() {
+		return serialize(this.cookies);
+	}
+	/** What `document.cookie` has: the cookies that are not `HttpOnly`. */
+	documentCookie() {
+		return serialize(Array.from(this.cookies).filter(([, { httpOnly }]) => !httpOnly));
+	}
+	#set(setCookie, byScript) {
+		const [pair = "", ...attributes] = setCookie.split(";");
+		const [name, value] = pairOf(pair);
+		if (!name && !value) return;
+		const httpOnly = attributes.some((attribute) => attributeOf(attribute)[0] === "httponly");
+		if (byScript && (httpOnly || this.cookies.get(name)?.httpOnly)) return;
+		if (deletes(attributes)) this.cookies.delete(name);
+		else this.cookies.set(name, {
+			value,
+			httpOnly
+		});
+	}
+};
+//#endregion
+export { PageStore };

package/dist/page-timers.d.ts

@@ -0,0 +1,22 @@
+import { Plugin } from "vite";
+
+//#region src/page-timers.d.ts
+/**
+ * Those uses, to the module runner's. Also for the dependency optimizer of
+ * the browser layer, by its `transform.define`: the bundler replaces them in
+ * every module of the pre-bundle, natively and in parallel, and the result
+ * stays on disk, where the plugin below would compile each pre-bundled file
+ * again in every run. None of them is a file of the host, and the packages
+ * of the host are not in it (`vitest-plugin-rsc:next-host-packages`).
+ */
+declare const pageTimersDefine: {
+  [k: string]: string;
+};
+/**
+ * For the modules of the browser layer, by the name of its environment, but
+ * those of a file that `isHostFile()`, and the pre-bundled dependencies,
+ * which have `pageTimersDefine`.
+ */
+declare function pageTimersPlugin(environment: string, isHostFile: (file: string) => boolean): Plugin;
+//#endregion
+export { pageTimersDefine, pageTimersPlugin };

package/dist/page-timers.js

@@ -0,0 +1,47 @@
+import { fileOfModule } from "./client-files.js";
+import { runnerGlobalNames, timersKey } from "@kasperpeulen/vitest-plugin-rsc/internal/timers";
+import { normalizePath, transformWithOxc } from "vite";
+import { ssrImportMetaKey } from "vite/module-runner";
+//#region src/page-timers.ts
+/**
+* Those uses, to the module runner's. Also for the dependency optimizer of
+* the browser layer, by its `transform.define`: the bundler replaces them in
+* every module of the pre-bundle, natively and in parallel, and the result
+* stays on disk, where the plugin below would compile each pre-bundled file
+* again in every run. None of them is a file of the host, and the packages
+* of the host are not in it (`vitest-plugin-rsc:next-host-packages`).
+*/
+const pageTimersDefine = Object.fromEntries(runnerGlobalNames.map((name) => [name, `${ssrImportMetaKey}.${timersKey}.${name}`]));
+const mentionsTimer = new RegExp(`\\b(?:${runnerGlobalNames.join("|")})\\b`);
+/**
+* For the modules of the browser layer, by the name of its environment, but
+* those of a file that `isHostFile()`, and the pre-bundled dependencies,
+* which have `pageTimersDefine`.
+*/
+function pageTimersPlugin(environment, isHostFile) {
+	return {
+		name: "vitest-plugin-rsc:next-page-timers",
+		enforce: "post",
+		applyToEnvironment: ({ name }) => name === environment,
+		transform: {
+			filter: { code: mentionsTimer },
+			async handler(code, id) {
+				const { environment } = this;
+				if (environment.mode === "dev" && environment.depsOptimizer?.isOptimizedDepFile(id)) return;
+				const file = fileOfModule(id);
+				if (file !== void 0 && isHostFile(file)) return;
+				try {
+					return await transformWithOxc(code, normalizePath(id), {
+						lang: "js",
+						define: pageTimersDefine
+					});
+				} catch (error) {
+					const reason = String(error instanceof Error ? error.message : error);
+					this.warn(`vitest-plugin-rsc: the timers of ${id} keep running after its page is left, it does not parse as JavaScript. ${reason.replace(/\s+/g, " ")}`);
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { pageTimersDefine, pageTimersPlugin };