vinext 0.0.52 → 0.0.54

package/dist/config/next-config.js

@@ -1,6 +1,8 @@
 import { normalizePageExtensions } from "../routing/file-matcher.js";
 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 { createRequire } from "node:module";
 import fs from "node:fs";
@@ -398,6 +400,71 @@ function resolveCacheHandlerPathToFilesystem(filePath) {
 	if (filePath.startsWith("file://")) return fileURLToPath(filePath);
 	return filePath;
 }
+function resolveHtmlLimitedBots(value) {
+	const source = value instanceof RegExp ? value.source : typeof value === "string" ? value : void 0;
+	if (!source) return void 0;
+	try {
+		getHtmlLimitedBotRegex(source);
+	} catch (error) {
+		throw new Error("Invalid next.config option \"htmlLimitedBots\": expected a valid regular expression source", { cause: error });
+	}
+	return source;
+}
+function readOptionalRecord(value) {
+	return isUnknownRecord(value) ? value : void 0;
+}
+function readOptionalString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function readOptionalBodySizeLimit(value) {
+	return typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+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.
@@ -428,8 +495,10 @@ async function resolveNextConfig(config, root = process.cwd()) {
 			allowedDevOrigins: [],
 			serverActionsAllowedOrigins: [],
 			optimizePackageImports: [],
+			inlineCss: false,
 			serverActionsBodySizeLimit: 1 * 1024 * 1024,
 			expireTime: DEFAULT_EXPIRE_TIME,
+			htmlLimitedBots: void 0,
 			serverExternalPackages: [],
 			cacheHandler: void 0,
 			cacheMaxMemorySize: void 0,
@@ -437,7 +506,14 @@ async function resolveNextConfig(config, root = process.cwd()) {
 			hashSalt: process.env.NEXT_HASH_SALT ?? "",
 			buildId,
 			deploymentId,
-			sassOptions: null
+			sassOptions: null,
+			removeConsole: false,
+			disableOptimizedLoading: false,
+			compilerDefine: {},
+			compilerDefineServer: {},
+			instrumentationClientInject: [],
+			clientTraceMetadata: void 0,
+			staleTimes: { ...DEFAULT_STALE_TIMES }
 		};
 		detectNextIntlConfig(root, resolved);
 		return resolved;
@@ -482,20 +558,23 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		...webpackProbe.aliases
 	};
 	const allowedDevOrigins = Array.isArray(config.allowedDevOrigins) ? config.allowedDevOrigins : [];
-	const experimental = config.experimental;
-	const serverActionsConfig = experimental?.serverActions;
-	const serverActionsAllowedOrigins = Array.isArray(serverActionsConfig?.allowedOrigins) ? serverActionsConfig.allowedOrigins : [];
-	const serverActionsBodySizeLimit = parseBodySizeLimit(serverActionsConfig?.bodySizeLimit);
-	const hashSalt = (experimental?.outputHashSalt ?? "") + (process.env.NEXT_HASH_SALT ?? "");
+	const experimental = readOptionalRecord(config.experimental);
+	const serverActionsConfig = readOptionalRecord(experimental?.serverActions);
+	const serverActionsAllowedOrigins = readStringArray(serverActionsConfig?.allowedOrigins);
+	const serverActionsBodySizeLimit = parseBodySizeLimit(readOptionalBodySizeLimit(serverActionsConfig?.bodySizeLimit));
+	const hashSalt = (readOptionalString(experimental?.outputHashSalt) ?? "") + (process.env.NEXT_HASH_SALT ?? "");
+	const htmlLimitedBots = resolveHtmlLimitedBots(config.htmlLimitedBots);
 	const rawOptimize = experimental?.optimizePackageImports;
 	const optimizePackageImports = Array.isArray(rawOptimize) ? rawOptimize.filter((x) => typeof x === "string") : [];
-	const legacyServerComponentsExternal = experimental?.serverComponentsExternalPackages;
-	const serverExternalPackages = Array.isArray(config.serverExternalPackages) ? config.serverExternalPackages : Array.isArray(legacyServerComponentsExternal) ? legacyServerComponentsExternal : [];
+	const inlineCss = experimental?.inlineCss === true;
+	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 (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 = config.output ?? "";
+	const output = readOptionalString(config.output) ?? "";
 	if (output && output !== "export" && output !== "standalone") console.warn(`[vinext] Unknown output mode "${output}", ignoring`);
 	const pageExtensions = normalizePageExtensions(config.pageExtensions);
 	let i18n = null;
@@ -525,6 +604,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		trailingSlash: config.trailingSlash ?? false,
 		output: output === "export" || output === "standalone" ? output : "",
 		pageExtensions,
+		instrumentationClientInject: Array.isArray(config.instrumentationClientInject) ? config.instrumentationClientInject.filter((x) => typeof x === "string") : [],
 		cacheComponents: config.cacheComponents ?? false,
 		redirects,
 		rewrites,
@@ -536,8 +616,10 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		allowedDevOrigins,
 		serverActionsAllowedOrigins,
 		optimizePackageImports,
+		inlineCss,
 		serverActionsBodySizeLimit,
 		expireTime: typeof config.expireTime === "number" ? config.expireTime : DEFAULT_EXPIRE_TIME,
+		htmlLimitedBots,
 		serverExternalPackages,
 		cacheHandler,
 		cacheMaxMemorySize,
@@ -545,7 +627,13 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		hashSalt,
 		buildId,
 		deploymentId,
-		sassOptions: config.sassOptions && typeof config.sassOptions === "object" ? 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;
@@ -561,11 +649,11 @@ function normalizeAliasEntries(aliases, root) {
 	return normalized;
 }
 function extractTurboAliases(config, root) {
-	const experimentalTurbo = config.experimental?.turbo;
-	const topLevelTurbopack = config.turbopack;
+	const experimentalTurbo = readOptionalRecord(readOptionalRecord(config.experimental)?.turbo);
+	const topLevelTurbopack = readOptionalRecord(config.turbopack);
 	return {
-		...normalizeAliasEntries(experimentalTurbo?.resolveAlias, root),
-		...normalizeAliasEntries(topLevelTurbopack?.resolveAlias, root)
+		...normalizeAliasEntries(readOptionalRecord(experimentalTurbo?.resolveAlias), root),
+		...normalizeAliasEntries(readOptionalRecord(topLevelTurbopack?.resolveAlias), root)
 	};
 }
 async function probeWebpackConfig(config, root) {
@@ -589,6 +677,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)
@@ -601,6 +690,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.
 *