vinext 0.0.53 → 0.0.55

package/dist/config/next-config.js

@@ -3,7 +3,8 @@ import { applyLocaleToRoutes, isExternalUrl } from "./config-matchers.js";
 import { isUnknownRecord } from "../utils/record.js";
 import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import { getHtmlLimitedBotRegex } from "../utils/html-limited-bots.js";
-import { loadTsconfigPathAliasesForRoot } from "./tsconfig-paths.js";
+import { loadTsconfigResolutionForRoot } from "./tsconfig-paths.js";
+import { getViteMajorVersion } from "../utils/vite-version.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
@@ -291,7 +292,9 @@ async function loadNextConfig(root, phase = DEFAULT_PHASE) {
 	const configPath = findNextConfigPath(root);
 	if (!configPath) return null;
 	const filename = path.basename(configPath);
-	const tsconfigAliases = loadTsconfigPathAliasesForRoot(root);
+	const isTypeScriptConfig = /\.[cm]?ts$/.test(configPath);
+	const tsconfigResolution = loadTsconfigResolutionForRoot(root);
+	const useNativeTsconfigPaths = !!(isTypeScriptConfig ? tsconfigResolution.baseUrl : null) && getViteMajorVersion() >= 8;
 	const normalizedConfigPath = safeRealpath(path.resolve(configPath));
 	try {
 		const { runnerImport } = await import("vite");
@@ -300,7 +303,8 @@ async function loadNextConfig(root, phase = DEFAULT_PHASE) {
 			logLevel: "error",
 			clearScreen: false,
 			resolve: {
-				alias: tsconfigAliases,
+				alias: tsconfigResolution.aliases,
+				...useNativeTsconfigPaths ? { tsconfigPaths: true } : {},
 				extensions: [
 					".mjs",
 					".js",
@@ -313,7 +317,7 @@ async function loadNextConfig(root, phase = DEFAULT_PHASE) {
 					".json"
 				]
 			},
-			plugins: [.../\.[cm]?ts$/.test(configPath) ? [cjsGlobalsInjectorPlugin(configPath)] : [], commonjs({ filter: (id) => {
+			plugins: [...isTypeScriptConfig ? [cjsGlobalsInjectorPlugin(configPath)] : [], commonjs({ filter: (id) => {
 				const idPath = id.startsWith("file://") ? fileURLToPath(id) : id.split("?")[0];
 				if (safeRealpath(path.resolve(idPath)) === normalizedConfigPath) return false;
 				return id.includes("node_modules") ? true : void 0;
@@ -423,6 +427,49 @@ function readStringArray(value) {
 	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 /**
+* Serialize a `compiler.define` / `compiler.defineServer` map into the
+* Vite-friendly `Record<string, string>` shape where each value is already
+* a JSON-encoded literal of source code. Entries whose values are not a
+* string/number/boolean are silently dropped, matching how Next.js types
+* the API (other shapes are not part of the contract).
+*
+* Mirrors Next.js: packages/next/src/build/define-env.ts (serializeDefineEnv).
+*/
+function serializeCompilerDefine(value) {
+	if (!isUnknownRecord(value)) return {};
+	const out = {};
+	for (const [key, raw] of Object.entries(value)) if (typeof raw === "string" || typeof raw === "number" || typeof raw === "boolean") out[key] = JSON.stringify(raw);
+	return out;
+}
+/**
+* Defaults for `experimental.staleTimes` (in seconds), matching Next.js'
+* `config-shared.ts` defaults.
+*/
+const DEFAULT_STALE_TIMES = {
+	dynamic: 0,
+	static: 300
+};
+/**
+* Parse `experimental.staleTimes` from a raw next.config object.
+*
+* Mirrors Next.js' `build/define-env.ts` parsing logic:
+*   - missing / NaN / negative values fall back to the documented defaults
+*     (`dynamic: 0`, `static: 300`) — matching Next.js parity and the
+*     non-negative guard in `resolvePrefetchCacheTtl`
+*   - all values are in seconds
+*
+* @see https://nextjs.org/docs/app/api-reference/config/next-config-js/staleTimes
+*/
+function resolveStaleTimes(experimental) {
+	const staleTimes = readOptionalRecord(experimental?.staleTimes);
+	const dynamicRaw = Number(staleTimes?.dynamic);
+	const staticRaw = Number(staleTimes?.static);
+	return {
+		dynamic: Number.isFinite(dynamicRaw) && dynamicRaw >= 0 ? dynamicRaw : DEFAULT_STALE_TIMES.dynamic,
+		static: Number.isFinite(staticRaw) && staticRaw >= 0 ? staticRaw : DEFAULT_STALE_TIMES.static
+	};
+}
+/**
 * Resolve a NextConfig into a fully-resolved ResolvedNextConfig.
 * Awaits async functions for redirects/rewrites/headers.
 */
@@ -438,6 +485,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 			output: "",
 			pageExtensions: normalizePageExtensions(),
 			cacheComponents: false,
+			prefetchInlining: false,
 			redirects: [],
 			rewrites: {
 				beforeFiles: [],
@@ -452,6 +500,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 			allowedDevOrigins: [],
 			serverActionsAllowedOrigins: [],
 			optimizePackageImports: [],
+			inlineCss: false,
 			serverActionsBodySizeLimit: 1 * 1024 * 1024,
 			expireTime: DEFAULT_EXPIRE_TIME,
 			htmlLimitedBots: void 0,
@@ -459,11 +508,18 @@ async function resolveNextConfig(config, root = process.cwd()) {
 			cacheHandler: void 0,
 			cacheMaxMemorySize: void 0,
 			enablePrerenderSourceMaps: true,
+			appShells: false,
 			hashSalt: process.env.NEXT_HASH_SALT ?? "",
 			buildId,
 			deploymentId,
 			sassOptions: null,
-			instrumentationClientInject: []
+			removeConsole: false,
+			disableOptimizedLoading: false,
+			compilerDefine: {},
+			compilerDefineServer: {},
+			instrumentationClientInject: [],
+			clientTraceMetadata: void 0,
+			staleTimes: { ...DEFAULT_STALE_TIMES }
 		};
 		detectNextIntlConfig(root, resolved);
 		return resolved;
@@ -516,11 +572,24 @@ async function resolveNextConfig(config, root = process.cwd()) {
 	const htmlLimitedBots = resolveHtmlLimitedBots(config.htmlLimitedBots);
 	const rawOptimize = experimental?.optimizePackageImports;
 	const optimizePackageImports = Array.isArray(rawOptimize) ? rawOptimize.filter((x) => typeof x === "string") : [];
+	const inlineCss = experimental?.inlineCss === true;
+	const prefetchInlining = experimental?.prefetchInlining === true || isUnknownRecord(experimental?.prefetchInlining);
+	const appShells = experimental?.appShells === true;
+	if (appShells) {
+		const missingCoFlags = [];
+		if (!config.cacheComponents) missingCoFlags.push("cacheComponents");
+		if (experimental?.prefetchInlining !== true) missingCoFlags.push("experimental.prefetchInlining");
+		if (experimental?.varyParams !== true) missingCoFlags.push("experimental.varyParams");
+		if (experimental?.optimisticRouting !== true) missingCoFlags.push("experimental.optimisticRouting");
+		if (experimental?.cachedNavigations !== true) missingCoFlags.push("experimental.cachedNavigations");
+		if (missingCoFlags.length > 0) console.warn(`[vinext] experimental.appShells is enabled but requires the following co-flags which are not yet supported or not enabled: ${missingCoFlags.join(", ")}. App Shell prefetching behavior is not implemented in vinext (see issue #1614). The flag will be accepted for config compatibility but has no functional effect.`);
+	}
 	const topLevelServerExternalPackages = Array.isArray(config.serverExternalPackages) ? readStringArray(config.serverExternalPackages) : void 0;
 	const legacyServerComponentsExternal = readStringArray(experimental?.serverComponentsExternalPackages);
 	const serverExternalPackages = topLevelServerExternalPackages ?? legacyServerComponentsExternal;
 	if (experimental?.swcEnvOptions !== void 0) console.warn("[vinext] next.config option \"experimental.swcEnvOptions\" is not applicable and will be ignored (vinext uses Vite, not SWC). A Vite-compatible polyfill solution may be explored in the future.");
 	if (experimental?.rootParams !== void 0) console.warn("[vinext] `experimental.rootParams` is no longer needed, because `next/root-params` is available by default. You can remove it from next.config.(js|mjs|ts).");
+	if (experimental?.cachedNavigations === true && !config.cacheComponents) console.warn("[vinext] `experimental.cachedNavigations` requires `cacheComponents: true` to have any effect. Set `cacheComponents: true` in your next.config, or remove `experimental.cachedNavigations`.");
 	if (config.webpack !== void 0) if (mdx || Object.keys(webpackProbe.aliases).length > 0) console.warn("[vinext] next.config option \"webpack\" is only partially supported. vinext preserves resolve.alias entries and MDX loader settings, but other webpack customization is ignored");
 	else console.warn("[vinext] next.config option \"webpack\" is not yet supported and will be ignored");
 	const output = readOptionalString(config.output) ?? "";
@@ -555,6 +624,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		pageExtensions,
 		instrumentationClientInject: Array.isArray(config.instrumentationClientInject) ? config.instrumentationClientInject.filter((x) => typeof x === "string") : [],
 		cacheComponents: config.cacheComponents ?? false,
+		prefetchInlining,
 		redirects,
 		rewrites,
 		headers,
@@ -565,6 +635,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		allowedDevOrigins,
 		serverActionsAllowedOrigins,
 		optimizePackageImports,
+		inlineCss,
 		serverActionsBodySizeLimit,
 		expireTime: typeof config.expireTime === "number" ? config.expireTime : DEFAULT_EXPIRE_TIME,
 		htmlLimitedBots,
@@ -572,10 +643,17 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		cacheHandler,
 		cacheMaxMemorySize,
 		enablePrerenderSourceMaps: config.enablePrerenderSourceMaps ?? true,
+		appShells,
 		hashSalt,
 		buildId,
 		deploymentId,
-		sassOptions: readOptionalRecord(config.sassOptions) ?? null
+		sassOptions: readOptionalRecord(config.sassOptions) ?? null,
+		removeConsole: config.compiler?.removeConsole === true ? true : isUnknownRecord(config.compiler?.removeConsole) ? { exclude: readStringArray(config.compiler.removeConsole.exclude) } : false,
+		disableOptimizedLoading: experimental?.disableOptimizedLoading === true,
+		compilerDefine: serializeCompilerDefine(config.compiler?.define),
+		compilerDefineServer: serializeCompilerDefine(config.compiler?.defineServer),
+		clientTraceMetadata: Array.isArray(experimental?.clientTraceMetadata) ? experimental.clientTraceMetadata.filter((value) => typeof value === "string") : void 0,
+		staleTimes: resolveStaleTimes(experimental)
 	};
 	detectNextIntlConfig(root, resolved);
 	if (resolved.basePath !== "" && resolved.basePath !== "/" && resolved.assetPrefix === "") resolved.assetPrefix = resolved.basePath;
@@ -619,6 +697,7 @@ async function probeWebpackConfig(config, root) {
 	try {
 		const finalConfig = await config.webpack(mockConfig, mockOptions) ?? mockConfig;
 		const rules = finalConfig.module?.rules ?? mockModuleRules;
+		invokeLoaderSideEffects(rules, root);
 		return {
 			aliases: normalizeAliasEntries(finalConfig.resolve?.alias, root),
 			mdx: extractMdxOptionsFromRules(rules)
@@ -631,6 +710,76 @@ async function probeWebpackConfig(config, root) {
 	}
 }
 /**
+* Walk webpack module rules and invoke each referenced loader once with a
+* dummy source string. Loaders that mutate `process.env` at compile time (a
+* pattern supported by Next.js' webpack pipeline — see issue #1500) get a
+* chance to land their mutations before vinext computes its defines.
+* Failures are swallowed: a loader throwing on dummy input must not break
+* the build, since vinext doesn't actually use the loader's transform output.
+*/
+function invokeLoaderSideEffects(rules, root) {
+	const require = createRequire(path.join(root, "package.json"));
+	const seen = /* @__PURE__ */ new Set();
+	const invokeLoaderEntry = (entry, ruleOptions) => {
+		if (!entry) return;
+		let loaderPath;
+		let loaderFn;
+		let options = ruleOptions;
+		if (typeof entry === "string") loaderPath = entry;
+		else if (typeof entry === "function") loaderFn = entry;
+		else if (typeof entry === "object") {
+			const e = entry;
+			if (typeof e.loader === "string") loaderPath = e.loader;
+			else if (typeof e.loader === "function") loaderFn = e.loader;
+			if (e.options !== void 0) options = e.options;
+		}
+		if (loaderPath !== void 0) {
+			if (seen.has(loaderPath)) return;
+			seen.add(loaderPath);
+			if (loaderPath.includes("next-babel-loader") || loaderPath.includes("mdx") || loaderPath.startsWith("next/dist/build/webpack")) return;
+			try {
+				loaderFn = require(loaderPath);
+				if (loaderFn && typeof loaderFn === "object" && typeof loaderFn.default === "function") loaderFn = loaderFn.default;
+			} catch {
+				return;
+			}
+		}
+		if (typeof loaderFn !== "function") return;
+		if (seen.has(loaderFn)) return;
+		seen.add(loaderFn);
+		try {
+			const loaderThis = {
+				async: () => () => {},
+				callback: () => {},
+				emitError: () => {},
+				emitWarning: () => {},
+				cacheable: () => {},
+				getOptions: () => options ?? {},
+				query: options ?? {},
+				resourcePath: "",
+				resource: "",
+				rootContext: root,
+				context: root,
+				mode: "production"
+			};
+			loaderFn.call(loaderThis, "");
+		} catch {}
+	};
+	const visit = (rule) => {
+		if (!rule || typeof rule !== "object") return;
+		if (Array.isArray(rule)) {
+			for (const child of rule) visit(child);
+			return;
+		}
+		if (Array.isArray(rule.oneOf)) for (const child of rule.oneOf) visit(child);
+		if (Array.isArray(rule.rules)) for (const child of rule.rules) visit(child);
+		const uses = Array.isArray(rule.use) ? rule.use : rule.use ? [rule.use] : [];
+		for (const use of uses) invokeLoaderEntry(use);
+		if (rule.loader !== void 0) invokeLoaderEntry(rule.loader, rule.options);
+	};
+	for (const rule of rules) visit(rule);
+}
+/**
 * Extract MDX compilation options (remark/rehype/recma plugins) from
 * a Next.js config that uses @next/mdx.
 *