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

package/dist/paths.js

@@ -0,0 +1,47 @@
+import path from "node:path";
+//#region src/paths.ts
+/**
+* The part of `request` that the `*` of `pattern` stands for, or nothing. A
+* pattern has one `*` at most: Next leaves out one with more.
+*/
+function matchOf(pattern, request) {
+	const star = pattern.indexOf("*");
+	if (star === -1) return pattern === request ? "" : void 0;
+	if (pattern.includes("*", star + 1)) return void 0;
+	const [before, after] = [pattern.slice(0, star), pattern.slice(star + 1)];
+	return request.length >= before.length + after.length && request.startsWith(before) && request.endsWith(after) ? request.slice(before.length, request.length - after.length) : void 0;
+}
+/**
+* The files that the `paths` have for a request, in order: TypeScript takes
+* the pattern with the longest prefix. Not a declaration file, which is for
+* the types only.
+*/
+function candidatesOf(paths, request) {
+	const prefix = (pattern) => pattern.split("*")[0].length;
+	const pattern = Object.keys(paths.patterns).filter((candidate) => matchOf(candidate, request) !== void 0).sort((a, b) => prefix(b) - prefix(a))[0];
+	if (!pattern) return [];
+	return paths.patterns[pattern].filter((target) => !target.endsWith(".d.ts")).map((target) => path.resolve(paths.baseUrl, target.replace("*", matchOf(pattern, request))));
+}
+function createPathsPlugin(getProject) {
+	return {
+		name: "vitest-plugin-rsc:next-paths",
+		enforce: "pre",
+		async resolveId(source, importer, options) {
+			const { paths } = getProject();
+			if (!paths || !importer || importer.includes("/node_modules/")) return;
+			if (!(!source.startsWith(".") && !source.startsWith("\0")) || path.isAbsolute(source)) return;
+			const resolve = (id) => this.resolve(id, importer, {
+				...options,
+				skipSelf: true
+			});
+			for (const candidate of candidatesOf(paths, source)) {
+				const resolved = await resolve(candidate);
+				if (resolved) return resolved;
+			}
+			if (!paths.explicitBaseUrl) return;
+			return await resolve(source) ?? resolve(path.resolve(paths.baseUrl, source));
+		}
+	};
+}
+//#endregion
+export { candidatesOf, createPathsPlugin };

package/dist/plugin.d.ts

@@ -0,0 +1,23 @@
+import { Mode, ModeOptions, SpeedOptions } from "./mode.js";
+import { NextBuild } from "./build.js";
+import { returnToHostScript, topLevelHost } from "./not-found-page.js";
+import { ServerCodeOptions } from "./server-code.js";
+import { Plugin } from "vite";
+//#region src/plugin.d.ts
+type VitestPluginNextOptions = ServerCodeOptions & ModeOptions & {
+  /**
+   * Experimental. The code that Next's runtime and React run, in all three
+   * layers: `"development"` as `next dev` runs it, `"production"` as
+   * `next start` runs it after `next build`. Production renders faster,
+   * without what the development code checks and reports. In a test run
+   * the app's `process.env.NODE_ENV` stays as it is, in a static build it is
+   * the build. See docs/internals/next-routes.md, "Development Or Production".
+   *
+   * @default `"development"` for a test run and a dev server, `"production"`
+   * for `vite build`, a static build of the app
+   */
+  build?: NextBuild;
+};
+declare function vitestPluginNext(options?: VitestPluginNextOptions): Plugin[];
+//#endregion
+export { type Mode, type NextBuild, type SpeedOptions, VitestPluginNextOptions, returnToHostScript, topLevelHost, vitestPluginNext };