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

package/dist/server-layers.js

@@ -0,0 +1,33 @@
+import "./globals.js";
+import { createEnvironmentRunner, environmentModule } from "@kasperpeulen/vitest-plugin-rsc/internal/utils";
+//#region src/server-layers.ts
+/**
+* The rsc layer: Server Components, Server Actions, route handlers and the
+* Flight encoder, see rsc.ts. The document's own module graph.
+*/
+function rscLayer() {
+	return import("./rsc.js");
+}
+let loading;
+let loaded;
+/**
+* The ssr layer: Next's request handler and HTML renderer, see ssr.ts, with
+* the rsc layer, which a request needs too. It starts to load the first time
+* something asks for it: a request that the server handles, or the entry of
+* the server's API as it evaluates. The server in front of the app needs
+* neither layer: see server-in-front.ts. A build fetches the layer's file
+* when its runner asks for it: see built-layers.ts.
+*/
+function ssrLayer() {
+	if (!loading) {
+		loading = Promise.all([rscLayer(), createEnvironmentRunner("next_ssr").import(environmentModule("next_ssr", "@kasperpeulen/vitest-plugin-nextjs/ssr"))]).then(([, layer]) => loaded = layer);
+		loading.catch(() => {});
+	}
+	return loading;
+}
+/** The ssr layer once it has loaded: until then there is nothing of it to settle or reset. */
+function loadedSsrLayer() {
+	return loaded;
+}
+//#endregion
+export { loadedSsrLayer, rscLayer, ssrLayer };

package/dist/setup-browser.d.ts

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

package/dist/setup-browser.js

@@ -0,0 +1,8 @@
+import { findOnEveryChange } from "./speed-features.js";
+import { setUpTestFiles } from "./setup.js";
+import { page, server } from "vitest/browser";
+//#region src/setup-browser.ts
+await setUpTestFiles(server.config.setupFiles);
+findOnEveryChange(page.getByText(""));
+//#endregion
+export {};

package/dist/setup-node.d.ts

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

package/dist/setup-node.js

@@ -0,0 +1,6 @@
+import { setUpTestFiles } from "./setup.js";
+import { inject } from "vitest";
+//#region src/setup-node.ts
+await setUpTestFiles(inject("vitest-plugin-rsc:setup-files"));
+//#endregion
+export {};

package/dist/setup.d.ts

@@ -0,0 +1,8 @@
+//#region src/setup.d.ts
+/**
+ * The hooks of every test file, whose setup files are `setupFiles`, as the
+ * config of the run has them. Resolves once the ssr layer has loaded.
+ */
+declare function setUpTestFiles(setupFiles: readonly string[]): Promise<void>;
+//#endregion
+export { setUpTestFiles };

package/dist/setup.js

@@ -0,0 +1,62 @@
+import { registry } from "./registry.js";
+import { pollOnEveryChange } from "./speed-features.js";
+import { ssrLayer } from "./server-layers.js";
+import { forgetClientFiles, linkStylesheetsOf, loadedAsClientFile } from "./client-graph.js";
+import { leaveKeptAppWithPage, noRouter } from "./page.js";
+import { keepHostDocument } from "./host-document.js";
+import { cleanup, newBrowserContext } from "./index.js";
+import { routesAheadEvent } from "./routes-ahead-shared.js";
+import { askDevServer, forgetHeardVersions } from "@kasperpeulen/vitest-plugin-rsc/internal/utils";
+import { afterAll, afterEach, beforeAll, beforeEach, expect, vi } from "vitest";
+import "virtual:vitest-plugin-rsc/next-fast-crypto";
+//#region src/setup.ts
+/**
+* The hooks of every test file, whose setup files are `setupFiles`, as the
+* config of the run has them. Resolves once the ssr layer has loaded.
+*/
+async function setUpTestFiles(setupFiles) {
+	forgetClientFiles();
+	forgetHeardVersions();
+	let nodeFiles = [...setupFiles];
+	registry.nodeFiles = () => nodeFiles;
+	let clientFile = false;
+	let keptDocument;
+	beforeAll(async ({}, suite) => {
+		nodeFiles = [...setupFiles, suite.file.filepath];
+		clientFile = loadedAsClientFile(suite.file.filepath);
+		if (clientFile) keptDocument = keepHostDocument((url) => reportError(noRouter(url)));
+		await linkStylesheetsOf(nodeFiles);
+		compileRoutesAhead(suite.file.filepath);
+	}, 0);
+	afterAll(async () => {
+		try {
+			await leaveKeptAppWithPage("the end of the test file");
+		} finally {
+			keptDocument?.();
+		}
+	});
+	await ssrLayer();
+	afterEach(() => cleanup());
+	beforeEach(async () => {
+		await (clientFile ? cleanup() : newBrowserContext());
+		await linkStylesheetsOf(nodeFiles);
+	});
+	pollOnEveryChange(expect, () => vi.isFakeTimers());
+}
+function compileRoutesAhead(testFile) {
+	const tell = (news) => {
+		askDevServer(routesAheadEvent, news).catch(() => {});
+	};
+	tell({ testFile });
+	const opened = /* @__PURE__ */ new Set();
+	registry.routeOpened = (entry) => {
+		if (opened.has(entry)) return;
+		opened.add(entry);
+		tell({
+			testFile,
+			opened: entry
+		});
+	};
+}
+//#endregion
+export { setUpTestFiles };

package/dist/speed-features.d.ts

@@ -0,0 +1,13 @@
+import { SpeedFeature } from "./mode.js";
+
+//#region src/speed-features.d.ts
+/** Whether a speed feature is on in the page. */
+declare function speedFeature(feature: SpeedFeature): boolean;
+/** With `watchDom`, has `locator` (a Locator of `vitest/browser`) look on every change of the document. */
+declare function findOnEveryChange(locator: object): void;
+/** With `watchDom`, has `expect.poll()`, and so `expect.element()`, look again on the next change of the document. */
+declare function pollOnEveryChange(expect: {
+  poll?: unknown;
+}, fakeTimers: () => boolean): void;
+//#endregion
+export { findOnEveryChange, pollOnEveryChange, speedFeature };

package/dist/speed-features.js

@@ -0,0 +1,95 @@
+import { registry } from "./registry.js";
+//#region src/speed-features.ts
+/** Whether a speed feature is on in the page. */
+function speedFeature(feature) {
+	return registry.speedFeatures?.[feature] === true;
+}
+const findInterval = 5;
+const setTimeout = globalThis.setTimeout;
+const clearTimeout = globalThis.clearTimeout;
+const changeEvents = [
+	"input",
+	"change",
+	"focusin",
+	"focusout",
+	"load",
+	"error",
+	"transitionend",
+	"animationend"
+];
+const observed = {
+	subtree: true,
+	childList: true,
+	attributes: true,
+	characterData: true
+};
+/**
+* Resolves on the next change of the document from now on: a mutation of the
+* DOM, one of `changeEvents`, or `findInterval` for what changes without
+* either, like a value that a script sets.
+*/
+function nextChange() {
+	return new Promise((resolve) => {
+		const done = () => {
+			observer.disconnect();
+			clearTimeout(timer);
+			for (const type of changeEvents) document.removeEventListener(type, done, true);
+			resolve();
+		};
+		const observer = new MutationObserver(done);
+		observer.observe(document, observed);
+		for (const type of changeEvents) document.addEventListener(type, done, true);
+		const timer = setTimeout(done, findInterval);
+	});
+}
+const onEveryChange = Symbol.for("vitest-plugin-rsc:find-on-every-change");
+/** With `watchDom`, has `locator` (a Locator of `vitest/browser`) look on every change of the document. */
+function findOnEveryChange(locator) {
+	if (!speedFeature("watchDom")) return;
+	let proto = Object.getPrototypeOf(locator);
+	while (proto && !Object.prototype.hasOwnProperty.call(proto, "findElement")) proto = Object.getPrototypeOf(proto);
+	if (!proto || typeof proto.findElement !== "function" || onEveryChange in proto.findElement) return;
+	const vitests = proto.findElement;
+	const vitest = () => globalThis.__vitest_browser_runner__;
+	async function find(options = {}) {
+		const strict = options.strict ?? true;
+		const timeout = options.timeout ?? vitest()?.runner?._deadline?.derive() ?? 6e4;
+		const start = performance.now();
+		for (;;) {
+			const elements = this.elements();
+			if (elements.length === 1 || elements.length > 1 && !strict) return elements[0];
+			if (elements.length > 1 || performance.now() - start >= timeout) return vitests.call(this, {
+				...options,
+				timeout: 0
+			});
+			await nextChange();
+		}
+	}
+	proto.findElement = Object.assign(find, { [onEveryChange]: true });
+}
+const pollsOnEveryChange = Symbol.for("vitest-plugin-rsc:poll-on-every-change");
+/** With `watchDom`, has `expect.poll()`, and so `expect.element()`, look again on the next change of the document. */
+function pollOnEveryChange(expect, fakeTimers) {
+	if (!speedFeature("watchDom")) return;
+	const vitests = expect.poll;
+	if (typeof vitests !== "function" || pollsOnEveryChange in vitests) return;
+	function poll(fn, options) {
+		if (options?.interval !== void 0 || fakeTimers()) return vitests.call(this, fn, options);
+		let changed;
+		async function polled(...args) {
+			if (changed) await changed;
+			try {
+				return await fn.apply(this, args);
+			} finally {
+				changed = nextChange();
+			}
+		}
+		return vitests.call(this, polled, {
+			...options,
+			interval: 0
+		});
+	}
+	expect.poll = Object.assign(poll, { [pollsOnEveryChange]: true });
+}
+//#endregion
+export { findOnEveryChange, pollOnEveryChange, speedFeature };

package/dist/ssr.d.ts

@@ -0,0 +1,70 @@
+import { Opened, ServerRequest } from "./registry.js";
+import { resetCaches } from "./cache.js";
+
+//#region src/ssr.d.ts
+declare namespace ssr_d_exports {
+  export { HandleOptions, ShellErrorAnswer, handleRequest, resetCaches, settleRequests, shellErrorAnswer };
+}
+type HandleOptions = {
+  /**
+   * For a request the server makes to itself while it handles one, which
+   * cannot wait for that one to finish.
+   */
+  nested?: boolean;
+  /**
+   * What a request gets that the server has nothing for: no route, and no
+   * redirect or rewrite, after the middleware has let it through. The
+   * not-found page of the app, or with `"pass"` no response: a deployment
+   * looks for a file then, which here is the network's to answer.
+   */
+  unrouted?: "not-found" | "pass";
+  /**
+   * What the request opens, in place of what `renderServer()` opened: the
+   * route of a node of its own, for this request only, or with `null`
+   * nothing.
+   */
+  opened?: Opened | null;
+  /**
+   * Whether the request loads a page into the document, which starts the
+   * files of its route as the server renders it: see `preloadRoute()` of the
+   * registry.
+   */
+  pageLoad?: boolean;
+};
+/** The Next.js server of this app. Without a response only with `unrouted: "pass"`. */
+declare function handleRequest(request: ServerRequest, options?: HandleOptions & {
+  unrouted?: "not-found";
+}): Promise<Response>;
+declare function handleRequest(request: ServerRequest, options: HandleOptions): Promise<Response | undefined>;
+/** How the server answers the document of a page whose render failed: see `shellErrorAnswer()`. */
+type ShellErrorAnswer = {
+  status: number;
+  location?: string;
+};
+/**
+ * How Next's server answers the document of a page when an error fails the
+ * render of its HTML before any of it is out, by the digest of the error, as
+ * Next's renderer does in the `catch` of `renderToStream()` (app-render.js):
+ * the status of a `notFound()`, `forbidden()` or `unauthorized()`, the 307 or
+ * 308 of a `redirect()` and where it goes, without the app's `basePath`, and
+ * 500 for any other error. For a page that the server renders no HTML of: see
+ * `renderFailureOf()` in page.ts.
+ */
+declare function shellErrorAnswer(digest: string): ShellErrorAnswer;
+/**
+ * Ends the requests the server is still handling, when a page is left.
+ *
+ * A request that has its answer is writing the body: a short wait, then a
+ * stop. A test can end while a page streams, on data that will never come.
+ *
+ * A request that has no answer yet runs code of the app, like a Server Action
+ * or a route handler, and nothing can stop that. So it is waited for, and
+ * then for the body it writes. So is what requests do after their response,
+ * like `after()`. What comes next is not to run while any of that still reads
+ * or sets the stores of a request, which would be the ones of the requests
+ * that come next. A request that is sent in the meantime waits for all of
+ * that, and is dropped: it is one of the page that was left.
+ */
+declare function settleRequests(): Promise<void>;
+//#endregion
+export { HandleOptions, ShellErrorAnswer, handleRequest, resetCaches, settleRequests, shellErrorAnswer, ssr_d_exports };