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

package/dist/project/routing.js

@@ -0,0 +1,280 @@
+import { receivers } from "../adapter.js";
+import { inDirectory } from "./context.js";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+//#region src/project/routing.ts
+function urlPathname(pathname) {
+	const url = new URL("http://localhost");
+	url.pathname = pathname;
+	return url.pathname;
+}
+function outputPagesOf(outputs, trailingSlash) {
+	const pages = {};
+	for (const { pathname, sourcePage } of [...outputs.appPages, ...outputs.appRoutes]) for (const requested of /* @__PURE__ */ new Set([pathname, urlPathname(pathname)])) {
+		pages[requested] = sourcePage;
+		if (trailingSlash && !requested.endsWith("/")) pages[`${requested}/`] = sourcePage;
+	}
+	return pages;
+}
+/**
+* A rule of `headers()` in `next.config` with its `Set-Cookie` headers as
+* one, joined with a comma. Next's build hands an adapter the headers of a
+* rule as an object, one value per name, and `@next/routing` sets each on
+* the response: the second cookie would be lost. `next start` sends every
+* one. Joined, they are the way Next's build writes the `set-cookie` of a
+* prerendered route, and `resolve()` in server-in-front.ts splits them
+* again, with the split Next's `toNodeOutgoingHttpHeaders()` has for them.
+*/
+function joinSetCookies(rule) {
+	const isCookie = ({ key }) => key.toLowerCase() === "set-cookie";
+	const cookies = rule.headers.filter(isCookie);
+	if (cookies.length < 2) return rule;
+	const joined = {
+		key: "Set-Cookie",
+		value: cookies.map(({ value }) => value).join(", ")
+	};
+	return {
+		...rule,
+		headers: [...rule.headers.filter((header) => !isCookie(header)), joined]
+	};
+}
+async function findMiddleware(context) {
+	const { root, fail, config, appDir, pageExtensions, next } = context;
+	const { MIDDLEWARE_FILENAME, PROXY_FILENAME, createPagesMapping, getFilesInDir, getStaticInfoIncludingLayouts, rootPageType } = next;
+	const rootDir = path.dirname(appDir);
+	const rootFiles = await getFilesInDir(rootDir);
+	const middlewareFiles = [PROXY_FILENAME, MIDDLEWARE_FILENAME].flatMap((name) => {
+		const file = pageExtensions.map((extension) => `${name}.${extension}`).find((candidate) => rootFiles.has(candidate));
+		return file ? [path.join(rootDir, file)] : [];
+	});
+	if (middlewareFiles.length > 1) {
+		const files = middlewareFiles.map((file) => path.relative(root, file));
+		throw new Error(`vitest-plugin-rsc: the app has both ${files.join(" and ")}. Next.js takes one of them.`);
+	}
+	const [middlewareFile] = middlewareFiles;
+	return {
+		middlewareFile,
+		middleware: middlewareFile ? await (async () => {
+			const mapped = await createPagesMapping({
+				isDev: false,
+				pageExtensions,
+				pagePaths: [middlewareFile.replace(root, "")],
+				pagesType: rootPageType,
+				pagesDir: void 0,
+				appDir,
+				appDirOnly: true
+			});
+			const [entry] = Object.entries(mapped);
+			const [page, pagePath] = entry ?? fail(`\`createPagesMapping()\` has no page for ${middlewareFile}`);
+			return {
+				page,
+				pagePath,
+				staticInfo: await getStaticInfoIncludingLayouts({
+					isInsideAppDir: false,
+					pageExtensions,
+					pageFilePath: middlewareFile,
+					appDir,
+					config,
+					isDev: false,
+					page
+				})
+			};
+		})() : void 0
+	};
+}
+/** `adapterPath` is the file of the adapter that Next's build hands the routes to: adapter.ts. */
+async function buildRouting(context, { routes, appPathsPerRoute }, { middleware }, adapterPath) {
+	const { root, projectRequire, version, fail, config, buildId, buildEnvironment, previewProps, next } = context;
+	const { Bundler, NEXT_URL, generateInterceptionRoutesRewrites, generateRoutesManifest, getNamedMiddlewareRegex, handleBuildComplete, loadCustomRoutes } = next;
+	let routingVersion;
+	try {
+		({version: routingVersion} = projectRequire("@next/routing/package.json"));
+	} catch (error) {
+		throw new Error(`@kasperpeulen/vitest-plugin-nextjs needs @next/routing, the package of Next.js that resolves the route of a request. Install it at the version of next: @next/routing@${version}.`, { cause: error });
+	}
+	if (routingVersion !== version) throw new Error(`@kasperpeulen/vitest-plugin-nextjs needs @next/routing at the version of next, and found @next/routing@${routingVersion} next to next@${version}. Install @next/routing@${version}.`);
+	const edgeFunction = (name, page, matchers = []) => ({
+		name,
+		page,
+		matchers,
+		env: buildEnvironment,
+		entrypoint: "",
+		files: [],
+		wasm: [],
+		assets: []
+	});
+	const middlewareManifest = {
+		version: 3,
+		sortedMiddleware: middleware ? ["/"] : [],
+		middleware: middleware ? { "/": edgeFunction(middleware.page.slice(1), "/", middleware.staticInfo.middleware?.matchers ?? [{
+			regexp: getNamedMiddlewareRegex("/", { catchAll: true }).namedRegex,
+			originalSource: "/:path*"
+		}]) } : {},
+		functions: Object.fromEntries(routes.map((route) => [route.page, edgeFunction(`app${route.page}`, route.page)]))
+	};
+	const routedConfig = {
+		...config,
+		output: void 0
+	};
+	const { built, routesManifest } = await inDirectory(root, async () => {
+		const custom = await loadCustomRoutes(routedConfig);
+		const { redirects, rewrites } = custom;
+		const headers = custom.headers.map(joinSetCookies);
+		const onMatchHeaders = custom.onMatchHeaders.map(joinSetCookies);
+		const appPaths = Object.keys(appPathsPerRoute);
+		rewrites.beforeFiles.push(...generateInterceptionRoutesRewrites(appPaths, config.basePath));
+		const { routesManifest } = generateRoutesManifest({
+			appType: "app",
+			pageKeys: {
+				pages: [],
+				app: appPaths
+			},
+			config: routedConfig,
+			redirects,
+			headers,
+			onMatchHeaders,
+			rewrites,
+			restrictedRedirectPaths: [`${config.basePath}/_next`],
+			isAppPPREnabled: Boolean(config.cacheComponents),
+			deploymentId: config.deploymentId
+		});
+		const buildDir = fs.mkdtempSync(path.join(os.tmpdir(), "vitest-plugin-rsc-"));
+		fs.mkdirSync(path.join(buildDir, "static"));
+		const { log } = console;
+		console.log = (...message) => {
+			if (!String(message[0]).includes("onBuildComplete")) log(...message);
+		};
+		try {
+			return {
+				built: await new Promise((resolve, reject) => {
+					receivers.set(buildDir, resolve);
+					handleBuildComplete({
+						adapterPath,
+						dir: root,
+						distDir: buildDir,
+						configOutDir: path.join(root, "out"),
+						repoRoot: config.repoRoot,
+						outputFileTracingRoot: config.outputFileTracingRoot || root,
+						config: routedConfig,
+						appType: "app",
+						buildId,
+						nextVersion: version,
+						bundler: Bundler.Turbopack,
+						routesManifest,
+						middlewareManifest,
+						prerenderManifest: {
+							version: 4,
+							routes: {},
+							dynamicRoutes: {},
+							notFoundRoutes: [],
+							preview: previewProps
+						},
+						functionsConfigManifest: {
+							version: 1,
+							functions: {}
+						},
+						previewProps,
+						pageKeys: [],
+						appPageKeys: routes.map((route) => route.page),
+						staticPages: /* @__PURE__ */ new Set(),
+						serverPropsPages: /* @__PURE__ */ new Set(),
+						requiredServerFiles: [],
+						hasNodeMiddleware: false,
+						hasInstrumentationHook: false,
+						hasStatic404: false,
+						hasStatic500: false
+					}).then(() => reject(/* @__PURE__ */ new Error("it does not call `onBuildComplete` of the adapter")), reject);
+				}),
+				routesManifest
+			};
+		} catch (error) {
+			return fail(`\`handleBuildComplete()\` does not hand an adapter the routes of an app without a build on disk (${error.message})`, error);
+		} finally {
+			console.log = log;
+			receivers.delete(buildDir);
+			fs.rmSync(buildDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	});
+	for (const phase of [
+		"beforeMiddleware",
+		"beforeFiles",
+		"afterFiles",
+		"dynamicRoutes",
+		"onMatch",
+		"fallback"
+	]) if (!Array.isArray(built.routing?.[phase])) fail(`\`handleBuildComplete()\` hands an adapter no \`routing.${phase}\``);
+	const routing = {
+		appRoutes: {
+			...built.routing,
+			beforeMiddleware: [],
+			middlewareMatchers: [],
+			beforeFiles: built.routing.beforeFiles.filter((route) => route.has?.some((has) => has.type === "header" && has.key.toLowerCase() === NEXT_URL)),
+			afterFiles: [],
+			fallback: []
+		},
+		routes: built.routing,
+		basePath: config.basePath,
+		buildId,
+		outputs: outputPagesOf(built.outputs, config.trailingSlash)
+	};
+	const { resolveRoutes } = projectRequire("@next/routing");
+	const outputPages = new Set(Object.values(routing.outputs));
+	const unmatchedRoutes = [];
+	for (const route of routes) {
+		if (!outputPages.has(route.page)) fail(`\`handleBuildComplete()\` has no output for ${route.page}`);
+		const isDynamic = route.pathname.includes("[");
+		const sample = route.pathname.replace(/\[\[?(?:\.\.\.)?[^\]]+\]\]?/g, "-x-");
+		const pathname = config.basePath + (sample === "/" && config.basePath ? "" : sample);
+		const url = new URL("http://localhost");
+		url.pathname = pathname;
+		if (isDynamic && url.pathname !== pathname) {
+			unmatchedRoutes.push(route.pathname);
+			continue;
+		}
+		const resolved = await resolveRoutes({
+			url,
+			headers: new Headers(),
+			requestBody: new ReadableStream(),
+			basePath: routing.basePath,
+			buildId: routing.buildId,
+			pathnames: Object.keys(routing.outputs),
+			routes: routing.appRoutes,
+			invokeMiddleware: async () => ({})
+		});
+		const page = routing.outputs[resolved.resolvedPathname ?? ""];
+		if (isDynamic ? page === void 0 : page !== route.page) fail(`\`resolveRoutes()\` of @next/routing@${routingVersion} does not find ${route.pathname} in the routes that \`handleBuildComplete()\` hands an adapter`);
+	}
+	const pageOf = async (url, { proxy }) => {
+		for (let redirects = 0; redirects <= maxRedirects; redirects++) {
+			const resolved = await resolveRoutes({
+				url,
+				headers: new Headers(),
+				requestBody: new ReadableStream(),
+				basePath: routing.basePath,
+				buildId: routing.buildId,
+				pathnames: Object.keys(routing.outputs),
+				routes: proxy ? routing.routes : routing.appRoutes,
+				invokeMiddleware: async () => ({})
+			});
+			const status = resolved.redirect?.status ?? resolved.status ?? 0;
+			const header = resolved.resolvedHeaders?.get("location");
+			const location = resolved.redirect?.url ?? (status >= 300 && status < 400 && header ? new URL(header, url) : void 0);
+			if (!location) return routing.outputs[resolved.resolvedPathname ?? ""];
+			if (location.origin !== url.origin) return;
+			url = location;
+		}
+	};
+	return {
+		routing,
+		routesManifest,
+		unmatchedRoutes,
+		pageOf
+	};
+}
+const maxRedirects = 20;
+//#endregion
+export { buildRouting, findMiddleware, joinSetCookies };

package/dist/project/transform.d.ts

@@ -0,0 +1,8 @@
+import { NextContext } from "./context.js";
+import { NextProject } from "../project.js";
+
+//#region src/project/transform.d.ts
+/** Next's SWC transform of a module of the app, and the `paths` of its tsconfig. */
+declare function createCompiler(context: NextContext): Promise<Pick<NextProject, "compile" | "paths" | "dependencyCompileOptions">>;
+//#endregion
+export { createCompiler };

package/dist/project/transform.js

@@ -0,0 +1,110 @@
+import { exportStubs } from "./module-exports.js";
+import { normalizePath } from "vite";
+import path from "node:path";
+import { stripVTControlCharacters } from "node:util";
+//#region src/project/transform.ts
+const compiledByVite = /\.(?:m?ts|[jt]sx)$/;
+/** Next's SWC transform of a module of the app, and the `paths` of its tsconfig. */
+async function createCompiler(context) {
+	const { root, fail, config, appDir, pageExtensions, distDir, next } = context;
+	const { WEBPACK_LAYERS, getLoaderSWCOptions, getRSCModuleInformation, loadJsConfig, swc } = next;
+	const { jsConfig, resolvedBaseUrl } = await loadJsConfig(root, config);
+	const paths = resolvedBaseUrl && {
+		baseUrl: resolvedBaseUrl.baseUrl,
+		explicitBaseUrl: !resolvedBaseUrl.isImplicit,
+		patterns: jsConfig?.compilerOptions?.paths ?? {}
+	};
+	const bundleLayers = {
+		rsc: WEBPACK_LAYERS.reactServerComponents,
+		ssr: WEBPACK_LAYERS.serverSideRendering,
+		browser: WEBPACK_LAYERS.appPagesBrowser
+	};
+	const swcOptions = (file, layer) => {
+		const { serverActions: _serverActions, cjsRequireOptimizer: _cjsRequireOptimizer, env: _env, ...options } = getLoaderSWCOptions({
+			filename: file,
+			development: false,
+			isServer: layer !== "browser",
+			pagesDir: void 0,
+			appDir,
+			isPageFile: false,
+			isCacheComponents: config.cacheComponents,
+			hasReactRefresh: false,
+			configDir: root,
+			modularizeImports: void 0,
+			optimizePackageImports: void 0,
+			swcPlugins: config.experimental.swcPlugins,
+			compilerOptions: config.compiler,
+			jsConfig,
+			supportedBrowsers: void 0,
+			swcCacheDir: path.join(distDir, "cache", "swc"),
+			relativeFilePathFromRoot: path.relative(root, file),
+			serverComponents: true,
+			serverReferenceHashSalt: "",
+			bundleLayer: bundleLayers[layer],
+			esm: true,
+			cacheHandlers: config.cacheHandlers,
+			useCacheEnabled: config.experimental.useCache,
+			taintEnabled: config.experimental.taint,
+			pageExtensions
+		});
+		const { optimizer: _optimizer, regenerator: _regenerator, react, ...transform } = options.jsc.transform;
+		return {
+			...options,
+			jsc: {
+				...options.jsc,
+				target: "esnext",
+				externalHelpers: false,
+				experimental: {
+					...options.jsc.experimental,
+					emitAssertForImportAttributes: false
+				},
+				transform: {
+					...transform,
+					react: compiledByVite.test(file) ? {
+						...react,
+						runtime: "preserve"
+					} : react
+				}
+			},
+			filename: file,
+			sourceFileName: file,
+			sourceMaps: true
+		};
+	};
+	const compile = async (code, file, layer) => {
+		const options = swcOptions(file, layer);
+		let output;
+		try {
+			output = await swc.transform(code, options);
+		} catch (error) {
+			const exports = await exportStubs(code, file).catch(() => Promise.reject(error));
+			const message = stripVTControlCharacters(error.message ?? String(error)).trim().replace(/(,-\[)(.+?)(:\d+:\d+\])/g, (frame, start, file, end) => path.isAbsolute(file) ? `${start}${normalizePath(path.relative(root, file))}${end}` : frame).replaceAll(root + path.sep, "");
+			return {
+				code: `throw new Error(${JSON.stringify(message)});\n${exports}`,
+				refused: true
+			};
+		}
+		if (layer === "rsc" && getRSCModuleInformation(output.code, true).type === "client") {
+			if (compiledByVite.test(file)) return;
+			return swc.transform(code, {
+				...options,
+				serverComponents: void 0
+			});
+		}
+		return output;
+	};
+	if (!(await compile(`import { Inter } from "next/font/google";\nexport const inter = Inter({});\n`, path.join(appDir, "layout.js"), "rsc"))?.code.includes("next/font/google/target.css?")) fail("the SWC transform no longer turns a call of a `next/font` function into an import");
+	if (await compile(`"use client";\nexport const a = 1;\n`, path.join(appDir, "a.ts"), "rsc")) fail("the SWC transform no longer marks a `\"use client\"` module of the rsc layer");
+	const dependency = path.join(root, "node_modules", "dependency.js");
+	return {
+		compile,
+		paths,
+		dependencyCompileOptions: {
+			rsc: swcOptions(dependency, "rsc"),
+			ssr: swcOptions(dependency, "ssr"),
+			browser: swcOptions(dependency, "browser")
+		}
+	};
+}
+//#endregion
+export { createCompiler };

package/dist/project/webpack.d.ts

@@ -0,0 +1,65 @@
+import { RunLoader } from "./loaders.js";
+import { NextContext } from "./context.js";
+import { NextProject } from "../project.js";
+
+//#region src/project/webpack.d.ts
+/**
+ * What a rule matches, as webpack takes it: a string is the start of the path,
+ * a function decides, and a list matches where one of it does.
+ */
+type WebpackCondition = RegExp | string | ((value: string) => boolean) | WebpackCondition[];
+/** A rule of the `webpack` function: the files it is for, and their loaders. */
+type WebpackRule = {
+  /** Of the path of the file, as `include` and `exclude`. */test: WebpackCondition;
+  include?: WebpackCondition;
+  exclude?: WebpackCondition; /** Of the query of the file, `?collection=docs`, with its `?`. */
+  resourceQuery?: WebpackCondition;
+  enforce?: "pre" | "post"; /** As webpack calls them: the last first. */
+  loaders: {
+    loader: string;
+    options: unknown;
+  }[]; /** Whether Next's compiler, `defaultLoaders.babel`, runs after them. */
+  compile: boolean;
+};
+/** The loaders of the rules that match a file, as webpack runs them. */
+type WebpackLoaders = Pick<WebpackRule, "loaders" | "compile">;
+type WebpackFunction = {
+  rules: WebpackRule[]; /** The candidates of each alias it sets, in order: the first that resolves is the one. */
+  aliases: Record<string, string[]>; /** What of it does not apply, to say when a run starts. */
+  differences: string[];
+};
+/**
+ * Calls the `webpack` function of a `next.config` with a config of webpack
+ * that has what the plugin reads of it, as Next calls it for the compiler of
+ * a layer, and reads the rules and the aliases it adds.
+ */
+declare function readWebpackFunction(webpack: unknown, options: {
+  root: string;
+  isServer: boolean;
+  buildId: string;
+  config: unknown;
+}): WebpackFunction;
+/**
+ * The loaders of the rules for a file, as webpack matches them: `test`,
+ * `include` and `exclude` its path, `resourceQuery` its query. Each rule that
+ * matches adds its loaders, as webpack runs them: those of `enforce: "pre"`
+ * first, then the others, then those of `enforce: "post"`. Fumadocs matches an
+ * `.mdx` file with `?collection=docs`, and a `meta.json` with it by its query.
+ */
+declare function loadersOf(rules: WebpackRule[], id: string): WebpackLoaders | undefined;
+/**
+ * The candidates of an alias for an import, as webpack takes them: a name
+ * matches the import and what is under it, and one that ends with `$` only
+ * the import itself.
+ */
+declare function aliasOf(aliases: Record<string, string[]>, source: string): string[] | undefined;
+/**
+ * A file of a package by the import that names it, `@next/mdx/mdx-components.js`:
+ * what Vite pre-bundles. The candidate of an alias is often the file, as
+ * `require.resolve()` finds it.
+ */
+declare function importOfFile(file: string): string;
+/** The rules and aliases of the `webpack` function in `next.config`, for each layer. */
+declare function createWebpackRules(context: NextContext, runLoader: RunLoader): Pick<NextProject, "webpackRuleOf" | "loadWithWebpackRule" | "webpackAliasOf" | "webpackPackages" | "webpackDifferences">;
+//#endregion
+export { WebpackCondition, WebpackFunction, WebpackLoaders, WebpackRule, aliasOf, createWebpackRules, importOfFile, loadersOf, readWebpackFunction };

package/dist/project/webpack.js

@@ -0,0 +1,191 @@
+import path from "node:path";
+import fs from "node:fs";
+//#region src/project/webpack.ts
+/**
+* Calls the `webpack` function of a `next.config` with a config of webpack
+* that has what the plugin reads of it, as Next calls it for the compiler of
+* a layer, and reads the rules and the aliases it adds.
+*/
+function readWebpackFunction(webpack, options) {
+	const read = {
+		rules: [],
+		aliases: {},
+		differences: []
+	};
+	if (typeof webpack !== "function") return read;
+	const babel = {
+		loader: "next-swc-loader",
+		options: {}
+	};
+	const before = {
+		resolve: { alias: {} },
+		module: { rules: [] },
+		plugins: []
+	};
+	let after;
+	try {
+		after = webpack(before, {
+			dir: options.root,
+			dev: false,
+			isServer: options.isServer,
+			buildId: options.buildId,
+			config: options.config,
+			defaultLoaders: { babel },
+			totalPages: 0,
+			...options.isServer && { nextRuntime: "nodejs" }
+		});
+	} catch (error) {
+		read.differences.push(`the \`webpack\` function of next.config failed, so none of it applies: ${error.message}`);
+		return read;
+	}
+	for (const rule of after?.module?.rules ?? []) {
+		const { test, include, exclude, resourceQuery, enforce, use, ...rest } = rule ?? {};
+		const uses = Array.isArray(use) ? use : [use];
+		const loaders = uses.flatMap((entry) => {
+			if (entry === babel) return [];
+			if (typeof entry === "string") return [{
+				loader: entry,
+				options: void 0
+			}];
+			const { loader, options } = entry ?? {};
+			return typeof loader === "string" ? [{
+				loader,
+				options
+			}] : [];
+		});
+		if (!isCondition(test) || [
+			include,
+			exclude,
+			resourceQuery
+		].some((condition) => condition !== void 0 && !isCondition(condition)) || enforce !== void 0 && enforce !== "pre" && enforce !== "post" || Object.keys(rest).length > 0 || loaders.length + (uses.includes(babel) ? 1 : 0) !== uses.length) {
+			read.differences.push(`a rule of the \`webpack\` function of next.config does not apply: only one with a \`test\` and the loaders in \`use\` does, with \`include\`, \`exclude\`, \`resourceQuery\` and \`enforce\` or not, not ${String(test ?? "this one")}`);
+			continue;
+		}
+		read.rules.push({
+			test,
+			...include !== void 0 && { include },
+			...exclude !== void 0 && { exclude },
+			...resourceQuery !== void 0 && { resourceQuery },
+			...enforce !== void 0 && { enforce },
+			loaders,
+			compile: uses.includes(babel)
+		});
+	}
+	for (const [name, target] of Object.entries(after?.resolve?.alias ?? {})) {
+		const candidates = (Array.isArray(target) ? target : [target]).filter((candidate) => typeof candidate === "string");
+		read.aliases[name] = candidates.map((candidate) => candidate.replace(/^private-next-root-dir(?=\/|$)/, options.root));
+	}
+	if ((after?.plugins?.length ?? 0) > 0) read.differences.push("the plugins of webpack that the `webpack` function of next.config adds do not run");
+	return read;
+}
+const isCondition = (condition) => condition instanceof RegExp || typeof condition === "string" || typeof condition === "function" || Array.isArray(condition) && condition.every(isCondition);
+const matches = (condition, value) => condition instanceof RegExp ? condition.test(value) : typeof condition === "string" ? value.startsWith(condition) : typeof condition === "function" ? condition(value) : condition.some((entry) => matches(entry, value));
+const viteQuery = /[?&](?:raw|url|inline|no-inline|worker|worker_file|sharedworker)(?=[=&]|$)/;
+/**
+* The loaders of the rules for a file, as webpack matches them: `test`,
+* `include` and `exclude` its path, `resourceQuery` its query. Each rule that
+* matches adds its loaders, as webpack runs them: those of `enforce: "pre"`
+* first, then the others, then those of `enforce: "post"`. Fumadocs matches an
+* `.mdx` file with `?collection=docs`, and a `meta.json` with it by its query.
+*/
+function loadersOf(rules, id) {
+	if (viteQuery.test(id)) return;
+	const queryAt = id.indexOf("?");
+	const file = queryAt < 0 ? id : id.slice(0, queryAt);
+	const query = queryAt < 0 ? "" : id.slice(queryAt);
+	const matched = rules.filter((rule) => matches(rule.test, file) && (rule.include === void 0 || matches(rule.include, file)) && (rule.exclude === void 0 || !matches(rule.exclude, file)) && (rule.resourceQuery === void 0 || matches(rule.resourceQuery, query)));
+	if (matched.length === 0) return;
+	const phase = ({ enforce }) => enforce === "post" ? 0 : enforce === "pre" ? 2 : 1;
+	return {
+		loaders: matched.toSorted((a, b) => phase(a) - phase(b)).flatMap((rule) => rule.loaders),
+		compile: matched.some((rule) => rule.compile)
+	};
+}
+/**
+* The candidates of an alias for an import, as webpack takes them: a name
+* matches the import and what is under it, and one that ends with `$` only
+* the import itself.
+*/
+function aliasOf(aliases, source) {
+	for (const [name, candidates] of Object.entries(aliases)) if (name.endsWith("$")) {
+		if (source === name.slice(0, -1)) return candidates;
+	} else if (source === name) return candidates;
+	else if (source.startsWith(`${name}/`)) return candidates.map((candidate) => candidate + source.slice(name.length));
+}
+/**
+* A file of a package by the import that names it, `@next/mdx/mdx-components.js`:
+* what Vite pre-bundles. The candidate of an alias is often the file, as
+* `require.resolve()` finds it.
+*/
+function importOfFile(file) {
+	if (!path.isAbsolute(file) || !file.split(path.sep).includes("node_modules")) return file;
+	for (let dir = path.dirname(file); path.basename(dir) !== "node_modules";) {
+		const manifest = path.join(dir, "package.json");
+		const name = fs.existsSync(manifest) ? JSON.parse(fs.readFileSync(manifest, "utf8")).name : void 0;
+		if (name) return `${name}/${path.relative(dir, file).split(path.sep).join("/")}`;
+		const parent = path.dirname(dir);
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return file;
+}
+/** The rules and aliases of the `webpack` function in `next.config`, for each layer. */
+function createWebpackRules(context, runLoader) {
+	const { root, projectRequire, config, buildId } = context;
+	const read = (isServer) => readWebpackFunction(config.webpack, {
+		root,
+		isServer,
+		buildId,
+		config
+	});
+	const client = read(false);
+	const server = read(true);
+	const of = {
+		rsc: server,
+		ssr: server,
+		browser: client
+	};
+	const ruleOf = (id, layer) => loadersOf(of[layer].rules, id);
+	const loaders = /* @__PURE__ */ new Map();
+	const loaderAt = (request) => {
+		let loader = loaders.get(request);
+		if (!loader) {
+			const loaded = projectRequire(request);
+			loader = typeof loaded === "function" ? loaded : loaded.default;
+			loaders.set(request, loader);
+		}
+		return loader;
+	};
+	const packagesOf = ({ aliases }) => Object.values(aliases).flat().map(importOfFile).filter((candidate) => {
+		if (candidate.startsWith(".") || path.isAbsolute(candidate)) return false;
+		try {
+			projectRequire.resolve(candidate);
+			return true;
+		} catch {
+			return false;
+		}
+	});
+	return {
+		webpackRuleOf: ruleOf,
+		webpackPackages: {
+			rsc: packagesOf(server),
+			ssr: packagesOf(server),
+			browser: packagesOf(client)
+		},
+		async loadWithWebpackRule(id, layer, source) {
+			const rule = ruleOf(id, layer);
+			if (!rule) return;
+			let code = source ?? await fs.promises.readFile(id.split("?")[0]);
+			for (const { loader, options } of rule.loaders.toReversed()) {
+				const run = loaderAt(loader);
+				const input = run.raw ? Buffer.from(code) : String(code);
+				[code] = await runLoader(run, options, id, input);
+			}
+			return String(code);
+		},
+		webpackAliasOf: (source, layer) => aliasOf(of[layer].aliases, source)?.map(importOfFile),
+		webpackDifferences: Array.from(/* @__PURE__ */ new Set([...client.differences, ...server.differences]))
+	};
+}
+//#endregion
+export { aliasOf, createWebpackRules, importOfFile, loadersOf, readWebpackFunction };