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

package/dist/node-builtins.d.ts

@@ -0,0 +1,40 @@
+import { esmExternalRequirePlugin } from "vite";
+
+//#region src/node-builtins.d.ts
+/**
+ * What the server layers import for a module of Node.js: the package's
+ * `stand-ins`, for a page in a browser, or Node's own, `native`, for a page in
+ * a worker of Node.js. A native module is no file: the layer leaves it to
+ * the runner to import, and so does a pre-bundle that imports it.
+ */
+type NodeModules = "stand-ins" | "native";
+/**
+ * What a server layer imports for `source`, a module of Node.js with or
+ * without `node:`, if it imports another module for it: the file of the
+ * package's module, `.../node/fs.js` for `node:fs`, or, `native`, the module
+ * of Node.js by its `node:` name.
+ */
+declare function nodeModuleOf(source: string, modules: NodeModules): string | undefined;
+/** Whether `id` is a file of the package's modules of Node.js. */
+declare const isNodeModule: (id: string) => boolean;
+/** Whether `id` is a module of Node.js itself, which `nodeModuleOf()` gives for `native`. */
+declare const isNativeNodeModule: (id: string) => boolean;
+/**
+ * The plugin of a server layer's optimizer for `native` modules: in a
+ * pre-bundle, a `require()` of a module of Node.js is an import of it, which
+ * the runner imports, and `module.exports` its default export, as Node.js
+ * gives it. Rolldown's runtime for a browser has no `require` to call. Also
+ * `async_hooks`, which the layer imports as the package's: the import is the
+ * layer's to resolve, to Node's own here (../async-hooks-node.ts), like the
+ * one of `@sentry/nextjs` for Node.js.
+ */
+declare function nativeRequirePlugin(): ReturnType<typeof esmExternalRequirePlugin>;
+/**
+ * What the package of `importer`, a dependency, says it uses for `source` in
+ * a browser, by its `browser` field: `false` for nothing, a file of its own
+ * as a string, or `undefined` where it says nothing. By the specifier as
+ * written: Vite maps `fs` and `node:fs` apart too.
+ */
+declare function browserMapping(source: string, importer: string | undefined): false | string | undefined;
+//#endregion
+export { NodeModules, browserMapping, isNativeNodeModule, isNodeModule, nativeRequirePlugin, nodeModuleOf };

package/dist/node-builtins.js

@@ -0,0 +1,74 @@
+import { builtinModules, isBuiltin } from "node:module";
+import { esmExternalRequirePlugin, normalizePath } from "vite";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/node-builtins.ts
+const ownFile = fileURLToPath(import.meta.url);
+const nodeDir = normalizePath(path.join(path.dirname(ownFile), path.extname(ownFile) === ".ts" ? "../dist/node" : "./node")) + "/";
+const extension = ".js";
+const notHere = /* @__PURE__ */ new Set(["async_hooks"]);
+const files = /* @__PURE__ */ new Map();
+/**
+* What a server layer imports for `source`, a module of Node.js with or
+* without `node:`, if it imports another module for it: the file of the
+* package's module, `.../node/fs.js` for `node:fs`, or, `native`, the module
+* of Node.js by its `node:` name.
+*/
+function nodeModuleOf(source, modules) {
+	if (!isBuiltin(source)) return;
+	const name = source.replace(/^node:/, "");
+	if (notHere.has(name)) return;
+	if (modules === "native") return `node:${name}`;
+	if (!files.has(name)) {
+		if (!fs.existsSync(nodeDir)) throw new Error(`vitest-plugin-rsc: no ${nodeDir}, the package is not built: run \`pnpm build\``);
+		const file = `${nodeDir}${name}${extension}`;
+		files.set(name, fs.existsSync(file) ? file : void 0);
+	}
+	return files.get(name);
+}
+/** Whether `id` is a file of the package's modules of Node.js. */
+const isNodeModule = (id) => id.startsWith(nodeDir);
+/** Whether `id` is a module of Node.js itself, which `nodeModuleOf()` gives for `native`. */
+const isNativeNodeModule = (id) => id.startsWith("node:");
+/**
+* The plugin of a server layer's optimizer for `native` modules: in a
+* pre-bundle, a `require()` of a module of Node.js is an import of it, which
+* the runner imports, and `module.exports` its default export, as Node.js
+* gives it. Rolldown's runtime for a browser has no `require` to call. Also
+* `async_hooks`, which the layer imports as the package's: the import is the
+* layer's to resolve, to Node's own here (../async-hooks-node.ts), like the
+* one of `@sentry/nextjs` for Node.js.
+*/
+function nativeRequirePlugin() {
+	const names = builtinModules.filter((name) => !name.startsWith("_") && (notHere.has(name) || nodeModuleOf(name, "native")));
+	const external = [.../* @__PURE__ */ new Set([...names, ...names.map((name) => name.replace(/^(?!node:)/, "node:"))])];
+	return esmExternalRequirePlugin({ external });
+}
+const browserFields = /* @__PURE__ */ new Map();
+function browserFieldOf(dir) {
+	if (browserFields.has(dir)) return browserFields.get(dir);
+	let field;
+	const file = path.join(dir, "package.json");
+	const parent = path.dirname(dir);
+	if (fs.existsSync(file)) {
+		const { browser } = JSON.parse(fs.readFileSync(file, "utf8"));
+		field = typeof browser === "object" && browser ? browser : {};
+	} else if (parent !== dir) field = browserFieldOf(parent);
+	browserFields.set(dir, field);
+	return field;
+}
+/**
+* What the package of `importer`, a dependency, says it uses for `source` in
+* a browser, by its `browser` field: `false` for nothing, a file of its own
+* as a string, or `undefined` where it says nothing. By the specifier as
+* written: Vite maps `fs` and `node:fs` apart too.
+*/
+function browserMapping(source, importer) {
+	const file = importer?.split("?")[0];
+	if (!file || !path.isAbsolute(file) || !/[\\/]node_modules[\\/]/.test(file)) return;
+	const mapping = browserFieldOf(path.dirname(file))?.[source];
+	return mapping === false || typeof mapping === "string" ? mapping : void 0;
+}
+//#endregion
+export { browserMapping, isNativeNodeModule, isNodeModule, nativeRequirePlugin, nodeModuleOf };

package/dist/node-on-page.d.ts

@@ -0,0 +1,46 @@
+//#region src/node-on-page.d.ts
+/**
+ * What `NodeRendered` tells the node of its page. A shape, not the class:
+ * node-rendered.tsx is an entry of its own in the package, whose types have
+ * a copy of the class, and a class with private fields is only itself.
+ */
+type NodeReports = Pick<NodeOnPage, "mounted" | "shown" | "hidden">;
+declare class NodeOnPage {
+  #private;
+  constructor(pathname: string);
+  /**
+   * Renders the node again: `swap` puts the node with the next version where
+   * the server reads it, and then Next's router asks the server for the page
+   * again, one request for every call. Resolves once the page has committed
+   * that version or a later one, and run its effects. Rejects at once, and
+   * later, when the page no longer has the node.
+   */
+  rerender(swap: (version: number) => void): Promise<void>;
+  /** The page is at `pathname` now. At another than the node's, the node is not there. */
+  at(pathname: string): void;
+  /** From the page, in the commit that mounts the node: its router. */
+  mounted(refresh: () => void): void;
+  /**
+   * From the page, from a passive effect, after the effects of the node: it
+   * shows the node at `version`.
+   */
+  shown(version: number): void;
+  /** From the page: the node is no longer shown. Something else may be in its place. */
+  hidden(): void;
+  /**
+   * From the root of the page: React reported an error. For a node that is
+   * mounted, a boundary in it shows the error, or one around it does and the
+   * node is no longer shown. One that is not mounted by the end of the commit
+   * never will be: an error took its place before it hydrated.
+   */
+  errored(error: unknown): void;
+  /** Something else is in the node's place: a page it redirected to, an error page. */
+  replaced(): void;
+  /**
+   * The page was left: by `cleanup()`, `unmount()`, another `renderServer()`,
+   * the app or the dev server.
+   */
+  left(by: string): void;
+}
+//#endregion
+export { NodeOnPage, NodeReports };

package/dist/node-on-page.js

@@ -0,0 +1,101 @@
+//#region src/node-on-page.ts
+var NodeOnPage = class {
+	#pathname;
+	#version = 0;
+	#waiting = /* @__PURE__ */ new Set();
+	#shown = 0;
+	#refresh;
+	#error;
+	#gone;
+	constructor(pathname) {
+		this.#pathname = pathname;
+	}
+	/**
+	* Renders the node again: `swap` puts the node with the next version where
+	* the server reads it, and then Next's router asks the server for the page
+	* again, one request for every call. Resolves once the page has committed
+	* that version or a later one, and run its effects. Rejects at once, and
+	* later, when the page no longer has the node.
+	*/
+	rerender(swap) {
+		if (this.#gone) return Promise.reject(this.#gone());
+		this.#error = void 0;
+		const version = ++this.#version;
+		swap(version);
+		const committed = new Promise((resolve, reject) => {
+			this.#waiting.add({
+				version,
+				resolve,
+				reject
+			});
+		});
+		this.#refresh?.();
+		return committed;
+	}
+	/** The page is at `pathname` now. At another than the node's, the node is not there. */
+	at(pathname) {
+		if (pathname !== this.#pathname) this.replaced();
+	}
+	/** From the page, in the commit that mounts the node: its router. */
+	mounted(refresh) {
+		if (this.#gone) return;
+		const first = !this.#refresh;
+		this.#refresh = refresh;
+		if (first && this.#waiting.size > 0) refresh();
+	}
+	/**
+	* From the page, from a passive effect, after the effects of the node: it
+	* shows the node at `version`.
+	*/
+	shown(version) {
+		this.#shown++;
+		if (this.#gone) return;
+		this.#error = void 0;
+		for (const waiting of this.#waiting) {
+			if (waiting.version > version) continue;
+			this.#waiting.delete(waiting);
+			waiting.resolve();
+		}
+	}
+	/** From the page: the node is no longer shown. Something else may be in its place. */
+	hidden() {
+		this.#shown--;
+		Promise.resolve().then(() => {
+			if (this.#shown === 0) this.replaced();
+		});
+	}
+	/**
+	* From the root of the page: React reported an error. For a node that is
+	* mounted, a boundary in it shows the error, or one around it does and the
+	* node is no longer shown. One that is not mounted by the end of the commit
+	* never will be: an error took its place before it hydrated.
+	*/
+	errored(error) {
+		this.#error = error;
+		Promise.resolve().then(() => {
+			if (!this.#refresh) this.replaced();
+		});
+	}
+	/** Something else is in the node's place: a page it redirected to, an error page. */
+	replaced() {
+		if (this.#gone) return;
+		const cause = this.#error;
+		const error = () => Object.assign(new Error("vitest-plugin-rsc: rerender() renders the node again in its place, and the page has something else there: an error or a not-found page, a page the node redirected to, or a route the app navigated to. Render the node with renderServer() instead.", cause === void 0 ? void 0 : { cause }), { name: "NodeReplacedError" });
+		this.#leave(error, error());
+	}
+	/**
+	* The page was left: by `cleanup()`, `unmount()`, another `renderServer()`,
+	* the app or the dev server.
+	*/
+	left(by) {
+		if (this.#gone) return;
+		this.#leave(() => /* @__PURE__ */ new Error(`vitest-plugin-rsc: rerender() renders the node again on its page, which ${by} has left. Render the node with renderServer() instead.`), new DOMException(`The page was left before the node had rendered again: by ${by}.`, "AbortError"));
+	}
+	#leave(gone, reason) {
+		this.#gone = gone;
+		for (const waiting of this.#waiting) waiting.reject(reason);
+		this.#waiting.clear();
+	}
+};
+//#endregion
+export { NodeOnPage };

package/dist/node-platform.d.ts

@@ -0,0 +1,36 @@
+import { Plugin } from "vite";
+import MagicString from "magic-string";
+
+//#region src/node-platform.d.ts
+/** An export of a module of Next that its stand-in does not have. */
+type NewExport = {
+  name: string;
+  module: string;
+};
+/**
+ * The stand-ins, for a `registry` in the browser that some of them call and a
+ * `prefix` that their module ids start with.
+ */
+declare function createNodePlatform(registry: string, prefix: string): {
+  /** The id of the stand-in for a specifier of a server layer, if it has one. */moduleOf(source: string): string | undefined;
+  /**
+   * The code of a stand-in, by its id without the prefix, with a stub for
+   * each export of Next's module that it has not, of the installed `version`.
+   */
+  load(name: string, newExports?: NewExport[], version?: string): string | undefined;
+};
+/**
+ * The code of the module of Next that loads `instrumentation.ts`, with a
+ * `require` that finds no file. Or why it cannot have one: its one use of
+ * `require` has to be a call that loads the file, or this is a Next that
+ * loads it otherwise.
+ */
+declare function instrumentationRequire(code: string): MagicString | string;
+/**
+ * Next's module that loads `instrumentation.ts`, with a `require` that finds
+ * no file: for the dependency optimizer of a server layer, and for a static
+ * build, which has no optimizer.
+ */
+declare function instrumentationPlugin(): Plugin;
+//#endregion
+export { NewExport, createNodePlatform, instrumentationPlugin, instrumentationRequire };

package/dist/node-platform.js

@@ -0,0 +1,152 @@
+import { missingHelper, walk } from "./commonjs.js";
+import { instrumentationModule, nodePlatformModuleOf, nodePlatformModules } from "./compat/paths.js";
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/node-platform.ts
+const newExportHelper = `const $$newExport = (message) => {
+  const fail = () => { throw new Error(message); };
+  return new Proxy(function () {}, {
+    apply: fail,
+    construct: fail,
+    get: (_, key) =>
+      typeof key === "symbol" || key === "__esModule" || key === "then" ? undefined : fail(),
+  });
+};
+`;
+function newExportStubs(newExports, version) {
+	if (newExports.length === 0) return "";
+	return newExportHelper + newExports.map(({ name, module }, index) => {
+		const message = `vitest-plugin-rsc: next@${version} has \`${name}\` in ${module}, which the plugin's stand-in for that module does not have. Use a version of @kasperpeulen/vitest-plugin-nextjs that supports next@${version}.`;
+		return `const $$new${index} = /* @__PURE__ */ $$newExport(${JSON.stringify(message)});\nexport { $$new${index} as ${JSON.stringify(name)} };\n`;
+	}).join("");
+}
+/**
+* The stand-ins, for a `registry` in the browser that some of them call and a
+* `prefix` that their module ids start with.
+*/
+function createNodePlatform(registry, prefix) {
+	const forward = (owner, names) => names.map((name) => `export const ${name} = (...args) => ${registry}.${owner}.${name}(...args);`).join("\n");
+	const stagedRendering = `throw new Error(${JSON.stringify("vitest-plugin-rsc: Next's staged rendering, for Cache Components, is not supported.")});`;
+	const modules = {
+		"react-server-node": forward("flightServer", [
+			"createTemporaryReferenceSet",
+			"decodeReply",
+			"decodeReplyFromBusboy",
+			"decodeAction",
+			"decodeFormState"
+		]),
+		"load-manifest": forward("node", [
+			"loadManifest",
+			"evalManifest",
+			"loadManifestFromRelativePath",
+			"evalManifestFromRelativePath"
+		]) + `\nexport const clearManifestCache = () => false;`,
+		"node-environment": `
+  export const installProcessErrorHandlers = () => {};
+  export const isUnhandledRejectionListenerRegistered = () => false;
+  export const registerUnhandledRejectionListener = () => {};
+  export const setAbortedLogsStyle = () => {};
+  `,
+		"vendored-react": `
+  export const React = undefined;
+  export const ReactDOM = undefined;
+  export const ReactDOMServer = undefined;
+  export const ReactJsxDevRuntime = undefined;
+  export const ReactJsxRuntime = undefined;
+  export const ReactCompilerRuntime = undefined;
+  export const ReactServerDOMTurbopackClient = undefined;
+  export const ReactServerDOMTurbopackServer = undefined;
+  export const ReactServerDOMTurbopackStatic = undefined;
+  export const ReactServerDOMWebpackClient = undefined;
+  export const ReactServerDOMWebpackServer = undefined;
+  export const ReactServerDOMWebpackStatic = undefined;
+  `,
+		"gzip-size": `
+  export const sync = () => 0;
+  export default { sync };
+  `,
+		"fast-set-immediate": `
+  export const unpatchedSetImmediate = (...args) => ${registry}.setImmediate(...args);
+  export function DANGEROUSLY_runPendingImmediatesAfterCurrentTask() {
+    ${stagedRendering}
+  }
+  export function expectNoPendingImmediates() {}
+  export class ImmediateTracker {
+    constructor() {
+      ${stagedRendering}
+    }
+  }
+  export function runWithNativeImmediateTracking() {
+    ${stagedRendering}
+  }
+  `,
+		"ssr-app-page-module": `
+  export const AppPageRouteModule = new Proxy(class {}, {
+    construct: (_, args) => new ${registry}.ssr.AppPageRouteModule(...args),
+  });
+  export default AppPageRouteModule;
+  export const vendored = new Proxy({}, {
+    get: (_, key) => ${registry}.ssr.vendored[key],
+  });
+  ${forward("ssr", ["renderToHTMLOrFlight", "prerenderToHTMLOrFlight"])}
+  `
+	};
+	const names = new Map(Object.entries(nodePlatformModules).flatMap(([name, nextModules]) => nextModules.map((nextModule) => [nextModule, name])));
+	return {
+		/** The id of the stand-in for a specifier of a server layer, if it has one. */
+		moduleOf(source) {
+			const name = names.get(nodePlatformModuleOf(source) ?? "");
+			return name && prefix + name;
+		},
+		/**
+		* The code of a stand-in, by its id without the prefix, with a stub for
+		* each export of Next's module that it has not, of the installed `version`.
+		*/
+		load(name, newExports = [], version = "") {
+			const code = modules[name];
+			return code === void 0 ? void 0 : code + newExportStubs(newExports, version);
+		}
+	};
+}
+const missingRequire = "$$cjsMissing";
+const hookFilename = "INSTRUMENTATION_HOOK_FILENAME";
+/** The files of the module of Next that loads `instrumentation.ts`, of either build. */
+const instrumentationFile = new RegExp(`/next/dist/(?:esm/)?${instrumentationModule.replaceAll(".", "\\.")}\\.js$`);
+/**
+* The code of the module of Next that loads `instrumentation.ts`, with a
+* `require` that finds no file. Or why it cannot have one: its one use of
+* `require` has to be a call that loads the file, or this is a Next that
+* loads it otherwise.
+*/
+function instrumentationRequire(code) {
+	const uses = [];
+	for (const [node, parent] of walk(parseAst(code))) if (node.type === "Identifier" && node.name === "require") uses.push([node, parent]);
+	const [use, call] = uses[0] ?? [];
+	if (!(uses.length === 1 && call?.type === "CallExpression" && call.callee === use && [...walk(call)].some(([node]) => node.type === "Identifier" && node.name === hookFilename))) return `\`require\` ${uses.length === 1 ? "once" : `${uses.length} times`}, and not as the one call that loads \`${hookFilename}\``;
+	const replaced = new MagicString(code);
+	replaced.overwrite(use.start, use.end, missingRequire);
+	return replaced.prepend(missingHelper);
+}
+/**
+* Next's module that loads `instrumentation.ts`, with a `require` that finds
+* no file: for the dependency optimizer of a server layer, and for a static
+* build, which has no optimizer.
+*/
+function instrumentationPlugin() {
+	return {
+		name: "vitest-plugin-rsc:next-instrumentation",
+		transform: {
+			filter: { id: instrumentationFile },
+			handler(code, id) {
+				const replaced = instrumentationRequire(code);
+				if (typeof replaced === "string") throw new Error(`vitest-plugin-rsc: ${id} has ${replaced}.`);
+				return {
+					code: replaced.toString(),
+					map: replaced.generateMap({ hires: "boundary" })
+				};
+			}
+		}
+	};
+}
+//#endregion
+export { createNodePlatform, instrumentationPlugin, instrumentationRequire };

package/dist/node-rendered.d.ts

@@ -0,0 +1,21 @@
+import { NodeReports } from "./node-on-page.js";
+import { ReactNode } from "react";
+
+//#region src/node-rendered.d.ts
+/** @internal For client.tsx, as it starts the page. */
+declare function setNodeOnPage(node: NodeReports | undefined): void;
+/**
+ * @internal What the server renders around the node of `renderServer()`, from
+ * its first render: it tells `rerender()` the page's router once the node is
+ * mounted, which render of the node the page shows, and when the node has
+ * left the page. It renders the node and nothing else.
+ */
+declare function NodeRendered({
+  version,
+  children
+}: {
+  version: number;
+  children?: ReactNode;
+}): ReactNode;
+//#endregion
+export { NodeRendered, setNodeOnPage };

package/dist/node-rendered.js

@@ -0,0 +1,26 @@
+"use client";
+import { useRouter } from "next/navigation.js";
+import { useEffect, useLayoutEffect } from "react";
+//#region src/node-rendered.tsx
+let nodeOnPage;
+/** @internal For client.tsx, as it starts the page. */
+function setNodeOnPage(node) {
+	nodeOnPage = node;
+}
+/**
+* @internal What the server renders around the node of `renderServer()`, from
+* its first render: it tells `rerender()` the page's router once the node is
+* mounted, which render of the node the page shows, and when the node has
+* left the page. It renders the node and nothing else.
+*/
+function NodeRendered({ version, children }) {
+	const { refresh } = useRouter();
+	useLayoutEffect(() => nodeOnPage?.mounted(refresh), [refresh]);
+	useEffect(() => {
+		nodeOnPage?.shown(version);
+		return () => nodeOnPage?.hidden();
+	}, [version]);
+	return children;
+}
+//#endregion
+export { NodeRendered, setNodeOnPage };

package/dist/node-server.d.ts

@@ -0,0 +1,46 @@
+import { RequestHandler, ServerRequest } from "./registry.js";
+import { RequestMeta } from "./compat/ssr/node-server.js";
+
+//#region src/node-server.d.ts
+/**
+ * How the body of a response of `handleRequest()` is written: `written`
+ * resolves once it ends, whole or not, and `stop` ends it as a page that is
+ * left does. The server writes on whether it is read or not: nothing waits
+ * for a reader.
+ */
+type Writing = {
+  written: Promise<void>;
+  stop: () => void;
+};
+/** The `Writing` of a response of `handleRequest()` with a body. */
+declare const writingOf: (response: Response) => Writing | undefined;
+declare const isPrerenderBailout: (error: unknown) => boolean;
+/**
+ * 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.
+ */
+declare function countBailouts(): () => number;
+/**
+ * What the server in front of a route knows of a request that it routed: see
+ * `handle()` in ssr.ts.
+ */
+type RoutedRequestMeta = Pick<RequestMeta, "params" | "query">;
+/**
+ * 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.
+ */
+declare function handleRequest(request: ServerRequest, context: {
+  waitUntil?: (promise: Promise<unknown>) => void;
+}, handler: RequestHandler, routed?: RoutedRequestMeta, {
+  statusCode,
+  headers
+}?: {
+  statusCode?: number;
+  headers?: Headers;
+}): Promise<Response>;
+//#endregion
+export { RoutedRequestMeta, Writing, countBailouts, handleRequest, isPrerenderBailout, writingOf };