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

package/dist/compat/ssr/cache.d.ts

@@ -0,0 +1,6 @@
+import { NEXT_CACHE_IMPLICIT_TAG_ID } from "next/dist/lib/constants.js";
+import { IncrementalCache } from "next/dist/server/lib/incremental-cache/index.js";
+import { tagsManifest } from "next/dist/server/lib/incremental-cache/tags-manifest.external";
+import { nodeFs } from "next/dist/server/lib/node-fs-methods.js";
+import { initializeCacheHandlers, registerCustomCacheHandlers, setCacheHandler } from "next/dist/server/use-cache/handlers.js";
+export { IncrementalCache, NEXT_CACHE_IMPLICIT_TAG_ID, initializeCacheHandlers, nodeFs, registerCustomCacheHandlers, setCacheHandler, tagsManifest };

package/dist/compat/ssr/cache.js

@@ -0,0 +1,6 @@
+import { NEXT_CACHE_IMPLICIT_TAG_ID } from "next/dist/lib/constants.js";
+import { IncrementalCache } from "next/dist/server/lib/incremental-cache/index.js";
+import { tagsManifest } from "next/dist/server/lib/incremental-cache/tags-manifest.external";
+import { nodeFs } from "next/dist/server/lib/node-fs-methods.js";
+import { initializeCacheHandlers, registerCustomCacheHandlers, setCacheHandler } from "next/dist/server/use-cache/handlers.js";
+export { IncrementalCache, NEXT_CACHE_IMPLICIT_TAG_ID, initializeCacheHandlers, nodeFs, registerCustomCacheHandlers, setCacheHandler, tagsManifest };

package/dist/compat/ssr/handler.d.ts

@@ -0,0 +1,8 @@
+import { normalizeNextQueryParam } from "next/dist/server/web/utils.js";
+import { NEXT_REWRITTEN_PATH_HEADER, NEXT_REWRITTEN_QUERY_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_RSC_UNION_QUERY, RSC_HEADER } from "next/dist/client/components/app-router-headers.js";
+import { isRSCRequestHeader } from "next/dist/server/lib/is-rsc-request.js";
+import * as appPageModule from "next/dist/server/route-modules/app-page/module.js";
+import { getIsPossibleServerAction } from "next/dist/server/lib/server-action-request-meta.js";
+import { getRouteMatcher } from "next/dist/shared/lib/router/utils/route-matcher.js";
+import { getRouteRegex } from "next/dist/shared/lib/router/utils/route-regex.js";
+export { NEXT_REWRITTEN_PATH_HEADER, NEXT_REWRITTEN_QUERY_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_RSC_UNION_QUERY, RSC_HEADER, appPageModule, getIsPossibleServerAction, getRouteMatcher, getRouteRegex, isRSCRequestHeader, normalizeNextQueryParam };

package/dist/compat/ssr/handler.js

@@ -0,0 +1,8 @@
+import { normalizeNextQueryParam } from "next/dist/server/web/utils.js";
+import { NEXT_REWRITTEN_PATH_HEADER, NEXT_REWRITTEN_QUERY_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_RSC_UNION_QUERY, RSC_HEADER } from "next/dist/client/components/app-router-headers.js";
+import { isRSCRequestHeader } from "next/dist/server/lib/is-rsc-request.js";
+import * as appPageModule from "next/dist/server/route-modules/app-page/module.js";
+import { getIsPossibleServerAction } from "next/dist/server/lib/server-action-request-meta.js";
+import { getRouteMatcher } from "next/dist/shared/lib/router/utils/route-matcher.js";
+import { getRouteRegex } from "next/dist/shared/lib/router/utils/route-regex.js";
+export { NEXT_REWRITTEN_PATH_HEADER, NEXT_REWRITTEN_QUERY_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_RSC_UNION_QUERY, RSC_HEADER, appPageModule, getIsPossibleServerAction, getRouteMatcher, getRouteRegex, isRSCRequestHeader, normalizeNextQueryParam };

package/dist/compat/ssr/node-server.d.ts

@@ -0,0 +1,5 @@
+import { fromNodeOutgoingHttpHeaders, toNodeOutgoingHttpHeaders } from "next/dist/server/web/utils.js";
+import { isDynamicServerError } from "next/dist/client/components/hooks-server-context.js";
+import { MockedResponse } from "next/dist/server/lib/mock-request.js";
+import { RequestMeta } from "next/dist/server/request-meta.js";
+export { MockedResponse, type RequestMeta, fromNodeOutgoingHttpHeaders, isDynamicServerError, toNodeOutgoingHttpHeaders };

package/dist/compat/ssr/node-server.js

@@ -0,0 +1,4 @@
+import { fromNodeOutgoingHttpHeaders, toNodeOutgoingHttpHeaders } from "next/dist/server/web/utils.js";
+import { isDynamicServerError } from "next/dist/client/components/hooks-server-context.js";
+import { MockedResponse } from "next/dist/server/lib/mock-request.js";
+export { MockedResponse, fromNodeOutgoingHttpHeaders, isDynamicServerError, toNodeOutgoingHttpHeaders };

package/dist/compat/ssr/render-errors.d.ts

@@ -0,0 +1,4 @@
+import { getAccessFallbackHTTPStatus, isHTTPAccessFallbackError } from "next/dist/client/components/http-access-fallback/http-access-fallback.js";
+import { getRedirectStatusCodeFromError, getURLFromRedirectError } from "next/dist/client/components/redirect.js";
+import { isRedirectError } from "next/dist/client/components/redirect-error.js";
+export { getAccessFallbackHTTPStatus, getRedirectStatusCodeFromError, getURLFromRedirectError, isHTTPAccessFallbackError, isRedirectError };

package/dist/compat/ssr/render-errors.js

@@ -0,0 +1,4 @@
+import { getAccessFallbackHTTPStatus, isHTTPAccessFallbackError } from "next/dist/client/components/http-access-fallback/http-access-fallback.js";
+import { getRedirectStatusCodeFromError, getURLFromRedirectError } from "next/dist/client/components/redirect.js";
+import { isRedirectError } from "next/dist/client/components/redirect-error.js";
+export { getAccessFallbackHTTPStatus, getRedirectStatusCodeFromError, getURLFromRedirectError, isHTTPAccessFallbackError, isRedirectError };

package/dist/compat/ssr/senders.d.ts

@@ -0,0 +1,6 @@
+import { NodeNextResponse } from "next/dist/server/base-http/node.js";
+import { generateETag } from "next/dist/server/lib/etag.js";
+import RenderResult from "next/dist/server/render-result.js";
+import { sendRenderResult } from "next/dist/server/send-payload.js";
+import { sendResponse } from "next/dist/server/send-response.js";
+export { NodeNextResponse, RenderResult, generateETag, sendRenderResult, sendResponse };

package/dist/compat/ssr/senders.js

@@ -0,0 +1,6 @@
+import { NodeNextResponse } from "next/dist/server/base-http/node.js";
+import { generateETag } from "next/dist/server/lib/etag.js";
+import RenderResult from "next/dist/server/render-result.js";
+import { sendRenderResult } from "next/dist/server/send-payload.js";
+import { sendResponse } from "next/dist/server/send-response.js";
+export { NodeNextResponse, RenderResult, generateETag, sendRenderResult, sendResponse };

package/dist/compat/types.d.ts

@@ -0,0 +1,8 @@
+import { RoutesManifest } from "next/dist/build/index.js";
+import { AdapterOutputs } from "next/dist/build/adapter/build-complete.js";
+import { ProxyMatcher } from "next/dist/build/analysis/get-page-static-info.js";
+import { AppLoaderOptions } from "next/dist/build/webpack/loaders/next-app-loader/index.js";
+import { EdgeFunctionDefinition, MiddlewareManifest } from "next/dist/build/webpack/plugins/middleware-plugin.js";
+import { Header } from "next/dist/lib/load-custom-routes.js";
+import { NextConfigComplete } from "next/dist/server/config-shared.js";
+export { type AdapterOutputs, type AppLoaderOptions, type EdgeFunctionDefinition, type Header, type MiddlewareManifest, type NextConfigComplete, type ProxyMatcher, type RoutesManifest };

package/dist/compat/types.js

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

package/dist/compile.d.ts

@@ -0,0 +1,31 @@
+import { NextLayer, NextProject } from "./project.js";
+import { Plugin } from "vite";
+
+//#region src/compile.d.ts
+/**
+ * The call of a `next/font` function whose CSS a module is, by the module's
+ * id: the import the SWC transform turns the call into. Nothing for any other
+ * module.
+ */
+declare function fontRequestOf(id: string): string | undefined;
+declare function createDependencyCompilePlugin(getProject: () => NextProject, layer: NextLayer, isAppCode: (file: string, layer: NextLayer) => boolean): {
+  name: string;
+  resolveId(source: string): {
+    id: string;
+    external: boolean;
+  } | undefined;
+  transform(code: string, id: string): Promise<{
+    code: string;
+    map: string | null;
+  } | undefined>;
+};
+declare function createScanCompilePlugin(getProject: () => NextProject, layer: NextLayer, isAppCode: (file: string, layer: NextLayer) => boolean): {
+  name: string;
+  transform(code: string, id: string): Promise<{
+    code: string;
+    map: string | null;
+  } | undefined>;
+};
+declare function createCompilePlugin(getProject: () => NextProject, layerOf: (environment: string) => NextLayer | undefined, isAppCode: (file: string, layer: NextLayer) => boolean): Plugin;
+//#endregion
+export { createCompilePlugin, createDependencyCompilePlugin, createScanCompilePlugin, fontRequestOf };

package/dist/compile.js

@@ -0,0 +1,140 @@
+import { linked } from "./styles.js";
+import { normalizePath } from "vite";
+import path from "node:path";
+import fs from "node:fs";
+import { withBuiltFiles } from "@kasperpeulen/vitest-plugin-rsc/internal/static-build";
+//#region src/compile.ts
+const fontPrefix = "\0vitest-plugin-rsc/next-font/";
+const fontRequest = /^next\/font\/(?:google|local)\/target\.css\?/;
+/**
+* The call of a `next/font` function whose CSS a module is, by the module's
+* id: the import the SWC transform turns the call into. Nothing for any other
+* module.
+*/
+function fontRequestOf(id) {
+	if (!id.startsWith(fontPrefix)) return void 0;
+	const name = id.slice(29).split("?")[0];
+	if (!name.endsWith(".css")) return void 0;
+	return Buffer.from(name.slice(0, -4), "base64url").toString();
+}
+const sourceFile = /\.(?:tsx|ts|jsx|js|mjs)$/;
+function createDependencyCompilePlugin(getProject, layer, isAppCode) {
+	return {
+		name: "vitest-plugin-rsc:next-compile-dependency",
+		resolveId(source) {
+			if (fontRequest.test(source)) return {
+				id: source,
+				external: true
+			};
+		},
+		async transform(code, id) {
+			if (!/\.[cm]?js$/.test(id) || !/\bnext\/font\b/.test(code) || isAppCode(id, layer)) return;
+			if (!path.relative(getProject().nextDir, id).startsWith("..")) return;
+			const compiled = await getProject().compile(code, id, layer);
+			return compiled && {
+				code: compiled.code,
+				map: compiled.map ?? null
+			};
+		}
+	};
+}
+function createScanCompilePlugin(getProject, layer, isAppCode) {
+	return {
+		name: `vitest-plugin-rsc:next-compile-scan:${layer}`,
+		async transform(code, id) {
+			if (id.includes("?") || !sourceFile.test(id) || !isAppCode(id, layer)) return;
+			const compiled = await getProject().compile(code, id, layer).catch(() => void 0);
+			if (!compiled || compiled.refused) return;
+			return {
+				code: compiled.code,
+				map: compiled.map ?? null
+			};
+		}
+	};
+}
+function createCompilePlugin(getProject, layerOf, isAppCode) {
+	return {
+		name: "vitest-plugin-rsc:next-compile",
+		enforce: "pre",
+		configureServer(server) {
+			const serveFile = async (request, response) => {
+				server.middlewares.handle(request, response, (error) => {
+					response.statusCode = error ? 500 : 404;
+					response.end();
+				});
+			};
+			const serve = async (request, response) => {
+				const project = getProject();
+				if (await project.optimizeImage(request, response, serveFile)) return true;
+				const file = project.readEmittedFile(new URL(request.url, "http://n").pathname);
+				if (!file) return false;
+				response.setHeader("content-type", file.contentType);
+				response.end(file.body);
+				return true;
+			};
+			server.middlewares.use(async (request, response, next) => {
+				let served;
+				try {
+					served = await serve(request, response);
+				} catch (error) {
+					server.config.logger.error(`vitest-plugin-rsc: ${request.url} failed. ${String(error)}`);
+					response.statusCode = 500;
+					response.end("Internal Server Error");
+					return;
+				}
+				if (!served) next();
+			});
+		},
+		async resolveId(source, importer, options) {
+			if (source.startsWith(fontPrefix)) return source;
+			if (fontRequest.test(source)) return `${fontPrefix}${Buffer.from(source).toString("base64url")}.js`;
+			const layer = layerOf(this.environment.name);
+			const candidates = layer && getProject().webpackAliasOf(source, layer);
+			for (const candidate of candidates ?? []) {
+				const resolved = await this.resolve(candidate, importer, {
+					...options,
+					skipSelf: true
+				});
+				if (resolved) return resolved;
+			}
+		},
+		async load(id) {
+			const built = (code, language) => {
+				if (this.environment.mode !== "build") return code;
+				const pathnames = getProject().emittedFiles().map((file) => file.pathname);
+				return withBuiltFiles(code, pathnames, language);
+			};
+			if (id.startsWith(fontPrefix)) {
+				const name = id.slice(29).split("?")[0];
+				const key = name.replace(/\.(?:js|css)$/, "");
+				const request = Buffer.from(key, "base64url").toString();
+				const { css, exports } = await getProject().loadFont(request);
+				if (name.endsWith(".css")) return built(css, "css");
+				const stylesheet = linked(`${fontPrefix}${key}.css`, this.environment.mode === "build");
+				return `import ${JSON.stringify(stylesheet)};\nexport default ${JSON.stringify(exports)};\n`;
+			}
+			const layer = layerOf(this.environment.name);
+			if (!layer || id.includes("?")) return;
+			if (getProject().webpackRuleOf(id, layer) && fs.existsSync(id)) return {
+				code: await getProject().loadWithWebpackRule(id, layer),
+				moduleType: "js"
+			};
+			if (!getProject().isImage(id) || !fs.existsSync(id)) return;
+			return built(await getProject().loadImage(id), "js");
+		},
+		async transform(code, id) {
+			const layer = layerOf(this.environment.name);
+			if (!layer || id.includes("?")) return;
+			if (!sourceFile.test(id) && !getProject().webpackRuleOf(id, layer)?.compile) return;
+			if (!isAppCode(id, layer) || !fs.existsSync(id)) return;
+			if (id.startsWith(`${normalizePath(this.environment.config.cacheDir)}/`)) return;
+			const compiled = await getProject().compile(code, id, layer);
+			return compiled && {
+				code: compiled.code,
+				map: compiled.map ?? null
+			};
+		}
+	};
+}
+//#endregion
+export { createCompilePlugin, createDependencyCompilePlugin, createScanCompilePlugin, fontRequestOf };

package/dist/disk.d.ts

@@ -0,0 +1,16 @@
+//#region src/disk.d.ts
+/** The global the disk is on. */
+declare const diskGlobal = "__vitest_plugin_rsc_disk__";
+/** The disk: the `fs` of memfs, and what empties it. */
+type Disk = {
+  fs: Record<string, any>;
+  reset(): void;
+};
+/**
+ * Empties the disk, as it is before any test: nothing but `/tmp`, which
+ * `os.tmpdir()` names. Closes what watches a file of it, which would see the
+ * next test's files otherwise. Nothing to do while no module imports `fs`.
+ */
+declare function resetDisk(): void;
+//#endregion
+export { Disk, diskGlobal, resetDisk };

package/dist/disk.js

@@ -0,0 +1,13 @@
+//#region src/disk.ts
+/** The global the disk is on. */
+const diskGlobal = "__vitest_plugin_rsc_disk__";
+/**
+* Empties the disk, as it is before any test: nothing but `/tmp`, which
+* `os.tmpdir()` names. Closes what watches a file of it, which would see the
+* next test's files otherwise. Nothing to do while no module imports `fs`.
+*/
+function resetDisk() {
+	globalThis[diskGlobal]?.reset();
+}
+//#endregion
+export { diskGlobal, resetDisk };

package/dist/document-loads.d.ts

@@ -0,0 +1,15 @@
+import { PageStore } from "./page-store.js";
+
+//#region src/document-loads.d.ts
+/**
+ * What a navigation does in a browser context of the app, whose store is
+ * `from`. The app can leave its page without its router:
+ * `location.assign()`, a `<form>` or an `<a>` that React does not handle,
+ * Next's own fallback when a client-side navigation is not possible. For a
+ * browser that is a page load. Here it would replace the test with the app,
+ * so `navigate()` loads the page the way `renderServer()` does instead, or
+ * downloads what a browser would.
+ */
+declare function followNavigation(event: Event, from: PageStore): void;
+//#endregion
+export { followNavigation };

package/dist/document-loads.js

@@ -0,0 +1,53 @@
+import { openedAt } from "./registry.js";
+import { leftTheApp } from "./app-requests.js";
+import { documentUrl } from "./document.js";
+import { enctypeOf, formBody } from "./form-submission.js";
+import { fromPage } from "./from-page.js";
+import { currentPage, leavePage, navigate, noRouter } from "./page.js";
+//#region src/document-loads.ts
+import.meta.hot?.on("vite:beforeFullReload", ({ path }) => {
+	if (reloadsDocument(path)) return leavePage("a reload of the page");
+});
+import.meta.hot?.on("vite:ws:disconnect", () => leavePage("a lost connection to the dev server"));
+function reloadsDocument(path) {
+	if (!path?.endsWith(".html") || path === "/index.html") return true;
+	const pagePath = decodeURI(new URL(documentUrl()).pathname);
+	const payloadPath = (import.meta.env?.BASE_URL ?? "/") + path.slice(1);
+	return pagePath === payloadPath || pagePath.endsWith("/") && `${pagePath}index.html` === payloadPath;
+}
+/**
+* What a navigation does in a browser context of the app, whose store is
+* `from`. The app can leave its page without its router:
+* `location.assign()`, a `<form>` or an `<a>` that React does not handle,
+* Next's own fallback when a client-side navigation is not possible. For a
+* browser that is a page load. Here it would replace the test with the app,
+* so `navigate()` loads the page the way `renderServer()` does instead, or
+* downloads what a browser would.
+*/
+function followNavigation(event, from) {
+	const { destination, hashChange, formData, downloadRequest, navigationType, sourceElement } = event;
+	if (destination.sameDocument) currentPage()?.nodeOnPage?.at(new URL(destination.url).pathname);
+	if (destination.sameDocument || hashChange || !event.cancelable) return;
+	const url = new URL(destination.url);
+	if (downloadRequest !== null && (url.protocol === "blob:" || url.protocol === "data:")) return;
+	if (destination.url === documentUrl()) return;
+	if (url.origin === window.location.origin && openedAt(url)?.node) {
+		event.preventDefault();
+		leavePage("a navigation to the host's document").catch(() => {}).then(() => window.location.reload());
+		return;
+	}
+	event.preventDefault();
+	if (url.origin !== window.location.origin) {
+		reportError(currentPage() ? leftTheApp(url) : noRouter(url));
+		return;
+	}
+	navigate(url, fromPage(url, {
+		method: formData ? "POST" : "GET",
+		headers: { accept: "text/html" },
+		body: formData && formBody(formData, enctypeOf(sourceElement))
+	})[1], downloadRequest, from, navigationType === "push").catch((error) => {
+		if (!(error instanceof DOMException && error.name === "AbortError")) reportError(error);
+	});
+}
+//#endregion
+export { followNavigation };

package/dist/document.d.ts

@@ -0,0 +1,79 @@
+//#region src/document.d.ts
+/** An entry of the history: its URL and its state. */
+type HistoryEntry = {
+  url: string;
+  state: unknown;
+};
+/**
+ * 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.
+ */
+declare function keepProperties(target: object, keys?: Iterable<PropertyKey>): void;
+/**
+ * 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.
+ */
+declare function documentUrl(): string;
+/**
+ * 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.
+ */
+declare function preloadPage({
+  stylesheets,
+  crossOrigin,
+  modules
+}: {
+  stylesheets: string[];
+  crossOrigin: string | undefined;
+  modules: string[];
+}): void;
+/**
+ * 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.
+ */
+declare function loadDocument(html: string, url: string, container?: Element, after?: HistoryEntry, inKeptApp?: boolean): Promise<() => void>;
+/** `self.$RC` of a page. */
+declare const streamedContentQueue: PropertyDescriptor;
+/**
+ * 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.
+ */
+declare function unloadKeptApp(withGlobals?: boolean): void;
+/**
+ * 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()`).
+ */
+declare function unloadDocument(): void;
+//#endregion
+export { HistoryEntry, documentUrl, keepProperties, loadDocument, preloadPage, streamedContentQueue, unloadDocument, unloadKeptApp };