next
Version:
The React Framework
1,584 lines • 92.6 kB
JavaScript
import { existsSync } from 'fs';
import { createRequire } from 'module';
import { basename, extname, join, relative, isAbsolute, resolve } from 'path';
import { pathToFileURL } from 'url';
import findUp from 'next/dist/compiled/find-up';
import semver from 'next/dist/compiled/semver';
import * as Log from '../build/output/log';
import * as ciEnvironment from '../server/ci-info';
import { CONFIG_FILES, PHASE_DEVELOPMENT_SERVER, PHASE_EXPORT, PHASE_PRODUCTION_BUILD, PHASE_PRODUCTION_SERVER, PHASE_INFO, PHASE_TEST } from '../shared/lib/constants';
import { defaultConfig, normalizeConfig, resolveCssChunkingMode } from './config-shared';
import { loadWebpackHook } from './config-utils';
import { imageConfigDefault } from '../shared/lib/image-config';
import { loadEnvConfig, updateInitialEnv } from '@next/env';
import { flushTelemetry } from '../telemetry/flush-telemetry';
import { findRootDirAndLockFiles, warnDuplicatedLockFiles, warnRootBoundary } from '../lib/find-root';
import { setHttpClientAndAgentOptions } from './setup-http-agent-env';
import { pathHasPrefix } from '../shared/lib/router/utils/path-has-prefix';
import { matchRemotePattern } from '../shared/lib/match-remote-pattern';
import { hasNextSupport } from '../server/ci-info';
import { transpileConfig } from '../build/next-config-ts/transpile-config';
import { dset } from '../shared/lib/dset';
import { normalizeZodErrors } from '../shared/lib/zod';
import { HTML_LIMITED_BOT_UA_RE_STRING } from '../shared/lib/router/utils/is-bot';
import { findDir } from '../lib/find-pages-dir';
import { INFINITE_CACHE } from '../lib/constants';
import { validateAndNormalizeCacheLifeProfile } from './use-cache/cache-life-profile';
import { resolveCacheHandlerPathToFilesystem } from '../lib/format-dynamic-import-path';
import { interopDefault } from '../lib/interop-default';
import { djb2Hash } from '../shared/lib/hash';
import { HardDeprecatedConfigError } from '../shared/lib/errors/hard-deprecated-config-error';
import { NextInstanceErrorState } from './mcp/tools/next-instance-error-state';
import { Bundler } from '../lib/bundler';
import { hrtimeBigIntDurationToString } from '../build/duration-to-string';
export { normalizeConfig } from './config-shared';
import { verifyDistDir } from '../lib/dist-dir';
const REACT_18_DEPRECATION_WARNING = 'React 18 support is deprecated in Next.js 16 and will be removed in Next.js 17. Please upgrade to React 19. Learn more: https://nextjs.org/docs/messages/react-version';
function getInstalledPackageVersion(dir, name) {
try {
const projectRequire = createRequire(join(dir, 'package.json'));
return projectRequire(name).version;
} catch {
return undefined;
}
}
function warnIfReact18IsInstalled(phase, dir, silent) {
if (silent !== false || phase !== PHASE_DEVELOPMENT_SERVER && phase !== PHASE_PRODUCTION_BUILD) {
return;
}
const reactVersion = getInstalledPackageVersion(dir, 'react');
const reactDomVersion = getInstalledPackageVersion(dir, 'react-dom');
if ((reactVersion == null ? void 0 : reactVersion.startsWith('18.')) || (reactDomVersion == null ? void 0 : reactDomVersion.startsWith('18.'))) {
Log.warnOnce(REACT_18_DEPRECATION_WARNING);
}
}
function normalizeNextConfigZodErrors(error) {
const warnings = [];
const fatalErrors = [];
const issues = normalizeZodErrors(error);
for (const { issue, message: originalMessage } of issues){
let message = originalMessage;
let shouldExit = false;
if (issue.path[0] === 'images') {
// We exit the build when encountering an error in the images config
shouldExit = true;
}
if (issue.code === 'unrecognized_keys' && issue.path[0] === 'experimental') {
if (message.includes('turbopackPersistentCachingForBuild')) {
// We exit the build when encountering an error in the turbopackPersistentCaching config
shouldExit = true;
message += "\nUse 'experimental.turbopackFileSystemCacheForBuild' instead.";
message += '\nLearn more: https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopackFileSystemCache';
} else if (message.includes('turbopackPersistentCaching')) {
// We exit the build when encountering an error in the turbopackPersistentCaching config
shouldExit = true;
message += "\nUse 'experimental.turbopackFileSystemCacheForDev' instead.";
message += '\nLearn more: https://nextjs.org/docs/app/api-reference/config/next-config-js/turbopackFileSystemCache';
} else if (message.includes('dynamicIO')) {
shouldExit = true;
message += '\n`experimental.dynamicIO` has been replaced by `cacheComponents`. Please update your next.config file accordingly.';
message += '\nLearn more: https://nextjs.org/docs/app/api-reference/config/next-config-js/cacheComponents';
}
}
if (shouldExit) {
fatalErrors.push(message);
} else {
warnings.push(message);
}
}
return [
warnings,
fatalErrors
];
}
// Infinity means "never", but turns into null when serialized as JSON (e.g.
// for build workers or the prerender manifest), unlike INFINITE_CACHE.
function normalizeInfiniteDuration(value, name) {
if (value === undefined || Number.isFinite(value)) {
return value;
}
if (value === Infinity) {
return INFINITE_CACHE;
}
throw new Error(`Invalid "${name}" provided, expected a finite number of seconds or Infinity, received ${value}`);
}
export function warnOptionHasBeenDeprecated(config, nestedPropertyKey, reason, silent) {
let hasWarned = false;
if (!silent) {
let current = config;
let found = true;
const nestedPropertyKeys = nestedPropertyKey.split('.');
for (const key of nestedPropertyKeys){
if (current[key] !== undefined) {
current = current[key];
} else {
found = false;
break;
}
}
if (found) {
Log.warnOnce(reason);
hasWarned = true;
}
}
return hasWarned;
}
function checkDeprecations(userConfig, configFileName, silent, dir) {
var _userConfig_images_domains, _userConfig_images, _userConfig_experimental;
warnOptionHasBeenDeprecated(userConfig, 'experimental.middlewarePrefetch', `\`experimental.middlewarePrefetch\` is deprecated. Please use \`experimental.proxyPrefetch\` instead in ${configFileName}.`, silent);
warnOptionHasBeenDeprecated(userConfig, 'experimental.middlewareClientMaxBodySize', `\`experimental.middlewareClientMaxBodySize\` is deprecated. Please use \`experimental.proxyClientMaxBodySize\` instead in ${configFileName}.`, silent);
warnOptionHasBeenDeprecated(userConfig, 'experimental.externalMiddlewareRewritesResolve', `\`experimental.externalMiddlewareRewritesResolve\` is deprecated. Please use \`experimental.externalProxyRewritesResolve\` instead in ${configFileName}.`, silent);
warnOptionHasBeenDeprecated(userConfig, 'skipMiddlewareUrlNormalize', `\`skipMiddlewareUrlNormalize\` is deprecated. Please use \`skipProxyUrlNormalize\` instead in ${configFileName}.`, silent);
warnOptionHasBeenDeprecated(userConfig, 'experimental.instrumentationHook', `\`experimental.instrumentationHook\` is no longer needed, because \`instrumentation.js\` is available by default. You can remove it from ${configFileName}.`, silent);
warnOptionHasBeenDeprecated(userConfig, 'experimental.after', `\`experimental.after\` is no longer needed, because \`after\` is available by default. You can remove it from ${configFileName}.`, silent);
warnOptionHasBeenDeprecated(userConfig, 'experimental.rootParams', `\`experimental.rootParams\` is no longer needed, because \`next/root-params\` is available by default. You can remove it from ${configFileName}.`, silent);
warnOptionHasBeenDeprecated(userConfig, 'eslint', `\`eslint\` configuration in ${configFileName} is no longer supported. See more info here: https://nextjs.org/docs/app/api-reference/cli/next#next-lint-options`, silent);
if ((_userConfig_images = userConfig.images) == null ? void 0 : (_userConfig_images_domains = _userConfig_images.domains) == null ? void 0 : _userConfig_images_domains.length) {
warnOptionHasBeenDeprecated(userConfig, 'images.domains', `\`images.domains\` is deprecated in favor of \`images.remotePatterns\`. Please update ${configFileName} to protect your application from malicious users.`, silent);
}
// i18n deprecation for App Router
if (userConfig.i18n) {
const hasAppDir = Boolean(findDir(dir, 'app'));
if (hasAppDir) {
warnOptionHasBeenDeprecated(userConfig, 'i18n', `i18n configuration in ${configFileName} is unsupported in App Router.\nLearn more about internationalization in App Router: https://nextjs.org/docs/app/building-your-application/routing/internationalization`, silent);
}
}
// browserDebugInfoInTerminal has moved to logging.browserToTerminal
if (((_userConfig_experimental = userConfig.experimental) == null ? void 0 : _userConfig_experimental.browserDebugInfoInTerminal) !== undefined) {
warnOptionHasBeenDeprecated(userConfig, 'experimental.browserDebugInfoInTerminal', `\`experimental.browserDebugInfoInTerminal\` has been moved to \`logging.browserToTerminal\`. Please update your ${configFileName} file accordingly.`, silent);
}
}
export function warnOptionHasBeenMovedOutOfExperimental(config, oldExperimentalKey, newKey, configFileName, silent) {
if (config.experimental && oldExperimentalKey in config.experimental) {
if (!silent) {
Log.warn(`\`experimental.${oldExperimentalKey}\` has been moved to \`${newKey}\`. ` + `Please update your ${configFileName} file accordingly.`);
}
let current = config;
const newKeys = newKey.split('.');
while(newKeys.length > 1){
const key = newKeys.shift();
current[key] = current[key] || {};
current = current[key];
}
;
current[newKeys.shift()] = config.experimental[oldExperimentalKey];
}
return config;
}
function warnCustomizedOption(config, key, defaultValue, customMessage, configFileName, silent) {
const segs = key.split('.');
let current = config;
while(segs.length >= 1){
const seg = segs.shift();
if (!(seg in current)) {
return;
}
current = current[seg];
}
if (!silent && current !== defaultValue) {
Log.warn(`The "${key}" option has been modified. ${customMessage ? customMessage + '. ' : ''}It should be removed from your ${configFileName}.`);
}
}
/**
* Assigns defaults to the user config and validates the config.
*
* @param dir - The directory of the project.
* @param userConfig - The user config.
* @param silent - Whether to suppress warnings.
* @returns The complete config.
*/ function assignDefaultsAndValidate(dir, userConfig, silent, phase) {
var _result_experimental, _result_experimental1, _result_experimental_serverActions, _result_experimental2, _userConfig_experimental, _userConfig_experimental1, _userConfig_experimental2, _userConfig_experimental3, _userConfig_experimental4, _userConfig_experimental5, _userConfig_experimental6, _userConfig_experimental7, _userConfig_experimental8, _userConfig_experimental9, _userConfig_experimental10, _userConfig_experimental11, _userConfig_experimental12, _userConfig_experimental13, _userConfig_experimental14, _userConfig_experimental15, _result_experimental3, _result_turbopack, _result_turbopack1, _result_turbopack2, _result_devIndicators, _result_experimental4;
const configFileName = userConfig.configFileName;
if (typeof userConfig.exportTrailingSlash !== 'undefined') {
if (!silent) {
Log.warn(`The "exportTrailingSlash" option has been renamed to "trailingSlash". Please update your ${configFileName}.`);
}
if (typeof userConfig.trailingSlash === 'undefined') {
userConfig.trailingSlash = userConfig.exportTrailingSlash;
}
delete userConfig.exportTrailingSlash;
}
const config = Object.keys(userConfig).reduce((currentConfig, key)=>{
const value = userConfig[key];
if (value === undefined || value === null) {
return currentConfig;
}
if (key === 'distDir') {
if (typeof value !== 'string') {
throw new Error(`Specified distDir is not a string, found type "${typeof value}"`);
}
const userDistDir = value.trim();
// don't allow public as the distDir as this is a reserved folder for
// public files
if (userDistDir === 'public') {
throw new Error(`The 'public' directory is reserved in Next.js and can not be set as the 'distDir'. https://nextjs.org/docs/messages/can-not-output-to-public`);
}
// make sure distDir isn't an empty string as it can result in the provided
// directory being deleted in development mode
if (userDistDir.length === 0) {
throw new Error(`Invalid distDir provided, distDir can not be an empty string. Please remove this config or set it to undefined`);
}
}
if (key === 'pageExtensions') {
if (!Array.isArray(value)) {
throw new Error(`Specified pageExtensions is not an array of strings, found "${value}". Please update this config or remove it.`);
}
if (!value.length) {
throw new Error(`Specified pageExtensions is an empty array. Please update it with the relevant extensions or remove it.`);
}
value.forEach((ext)=>{
if (typeof ext !== 'string') {
throw new Error(`Specified pageExtensions is not an array of strings, found "${ext}" of type "${typeof ext}". Please update this config or remove it.`);
}
});
}
const defaultValue = defaultConfig[key];
if (!!value && value.constructor === Object && typeof defaultValue === 'object') {
currentConfig[key] = {
...defaultValue,
...Object.keys(value).reduce((c, k)=>{
const v = value[k];
if (v !== undefined && v !== null) {
c[k] = v;
}
return c;
}, {})
};
} else {
currentConfig[key] = value;
}
return currentConfig;
}, {});
const result = {
...defaultConfig,
...config,
experimental: {
...defaultConfig.experimental,
...config.experimental
}
};
result.experimental.strictRouteMatching = !result.deprecated.looseRouteMatching;
// Pruning assumes that children only exists when it is backed by an
// ordinary route branch. Restoring the legacy implicit children slot must
// therefore also restore the legacy matcher behavior.
if (!result.experimental.explicitParallelRouteChildren) {
result.experimental.strictRouteMatching = false;
}
// Normalize prefetchInlining: true | { maxSize?, maxBundleSize? } into a
// resolved object with concrete defaults, so consumers don't have to
// resolve the values themselves.
if (result.experimental.prefetchInlining) {
const raw = result.experimental.prefetchInlining;
const maxSize = typeof raw === 'object' ? raw.maxSize ?? 2048 : 2048;
const maxBundleSize = typeof raw === 'object' ? raw.maxBundleSize ?? 10240 : 10240;
result.experimental.prefetchInlining = {
// Clamp Infinity to a finite value so the config survives
// JSON.stringify (used by output: standalone).
maxSize: Number.isFinite(maxSize) ? maxSize : Number.MAX_SAFE_INTEGER,
maxBundleSize: Number.isFinite(maxBundleSize) ? maxBundleSize : Number.MAX_SAFE_INTEGER
};
}
// ensure correct default is set for api-resolver revalidate handling
if (!result.experimental.trustHostHeader && ciEnvironment.hasNextSupport) {
result.experimental.trustHostHeader = true;
}
// Normalize the user-facing `turbopackMemoryEviction` (`false | 'full' |
// 'auto' | undefined`) into the `turbopackMemoryEvictionMode` enum expected by
// napi (`'off' | 'full' | 'auto'`).
let turbopackMemoryEvictionMode;
switch(result.experimental.turbopackMemoryEviction){
case false:
turbopackMemoryEvictionMode = 'off';
break;
case 'full':
case 'auto':
turbopackMemoryEvictionMode = result.experimental.turbopackMemoryEviction;
break;
case undefined:
default:
// Not set by the user, or an invalid value, use the default.
turbopackMemoryEvictionMode = 'auto';
}
;
result.experimental.turbopackMemoryEvictionMode = turbopackMemoryEvictionMode;
// Normalize the user-facing `turbopackGc` (`boolean | { minProgressMs?,
// rootTtlMs? } | undefined`) into the object napi expects
const turbopackGc = result.experimental.turbopackGc;
let turbopackGcOptions;
if (turbopackGc === true) {
turbopackGcOptions = {};
} else if (typeof turbopackGc === 'object' && turbopackGc !== null) {
turbopackGcOptions = {
minProgressMs: turbopackGc.minProgressMs,
rootTtlMs: turbopackGc.rootTtlMs
};
} else {
turbopackGcOptions = undefined;
}
;
result.experimental.turbopackGcOptions = turbopackGcOptions;
// Normalize experimental.browserDebugInfoInTerminal to logging.browserToTerminal
if (result.logging !== false && ((_result_experimental = result.experimental) == null ? void 0 : _result_experimental.browserDebugInfoInTerminal) !== undefined) {
const loggingConfig = result.logging || {};
if (!('browserToTerminal' in loggingConfig)) {
const expConfig = result.experimental.browserDebugInfoInTerminal;
// Convert object config to simple format (level or true)
const level = typeof expConfig === 'object' && expConfig !== null ? expConfig.level ?? true : expConfig;
// Map 'verbose' to true since browserToTerminal doesn't support 'verbose'
const normalizedValue = level === 'verbose' ? true : level;
result.logging = {
...loggingConfig,
browserToTerminal: normalizedValue
};
}
}
if (((_result_experimental1 = result.experimental) == null ? void 0 : _result_experimental1.allowDevelopmentBuild) && process.env.NODE_ENV !== 'development') {
throw new Error(`The experimental.allowDevelopmentBuild option requires NODE_ENV to be explicitly set to 'development'.`);
}
// Validate sassOptions.functions is not used with Turbopack
if (process.env.TURBOPACK && result.sassOptions && 'functions' in result.sassOptions) {
throw new Error(`The "sassOptions.functions" option is not supported when using Turbopack. ` + `Custom Sass functions are only available with webpack. ` + `Please remove the "functions" property from your sassOptions in ${configFileName}.`);
}
// Build and development phases validate bundler-specific options. Server,
// info, and test phases do not select a bundler. They must accept
// configuration from either bundler.
if (phase !== PHASE_PRODUCTION_SERVER && phase !== PHASE_INFO && phase !== PHASE_TEST) {
if (result.experimental.durableUseCacheEntries && !process.env.TURBOPACK) {
throw new Error(`\`experimental.durableUseCacheEntries: true\` is only supported with Turbopack. ` + `Please remove the option or run Next.js with Turbopack in ${configFileName}.`);
}
if (result.experimental.useCacheStaticRootParamTracking && !process.env.TURBOPACK) {
throw new Error(`\`experimental.useCacheStaticRootParamTracking: true\` is only supported with Turbopack. ` + `Please remove the option or run Next.js with Turbopack in ${configFileName}.`);
}
const cssChunkingValue = result.experimental.cssChunking;
const cssChunkingMode = resolveCssChunkingMode(cssChunkingValue);
if (cssChunkingMode === 'graph' && !process.env.TURBOPACK) {
throw new Error(`\`experimental.cssChunking: "graph"\` is only supported with Turbopack. ` + `Please remove the option or run Next.js with Turbopack in ${configFileName}.`);
}
if (cssChunkingMode === 'strict' && process.env.TURBOPACK) {
throw new Error(`\`experimental.cssChunking: "strict"\` is only supported with webpack. ` + `Please remove the option or run Next.js with webpack in ${configFileName}.`);
}
// Only error when `false` was set explicitly. `undefined` (the default) also resolves to
// `'off'` but that's the implicit default and must not error on Turbopack.
if (cssChunkingValue === false && process.env.TURBOPACK) {
throw new Error(`\`experimental.cssChunking: false\` is only supported with webpack. ` + `Please remove the option or run Next.js with webpack in ${configFileName}.`);
}
if (result.experimental.turbopackRustReactCompiler && !process.env.TURBOPACK) {
throw new Error(`\`experimental.turbopackRustReactCompiler\` is only supported with Turbopack. ` + `Please remove the option or run Next.js with Turbopack in ${configFileName}.`);
}
if (result.experimental.turbopackRustReactCompiler && !result.reactCompiler) {
throw new Error(`\`experimental.turbopackRustReactCompiler\` requires \`reactCompiler\` to be enabled. ` + `Please add \`reactCompiler: true\` in ${configFileName}.`);
}
}
if (result.experimental.cachedNavigations && !result.cacheComponents) {
throw new Error(`\`experimental.cachedNavigations\` requires \`cacheComponents\` to be enabled. Please update your ${configFileName} accordingly.`);
}
if (result.partialPrefetching && !result.cacheComponents) {
throw new Error(`\`partialPrefetching\` requires \`cacheComponents\` to be enabled. Please update your ${configFileName} accordingly.`);
}
// TODO: Before Next.js 17, also warn when `partialPrefetching` is `false`
// so apps can migrate before both features are enabled together by default.
if (result.cacheComponents && result.partialPrefetching === undefined && !silent) {
Log.warnOnce([
'`cacheComponents` is enabled without a corresponding `partialPrefetching` option. Set `partialPrefetching` to either `true` or `false`.',
"The only reason to set `partialPrefetching` to `false` is if you're migrating an older Cache Components app. The initial release of Cache Components did not include Partial Prefetching. New projects should enable both Cache Components and Partial Prefetching.",
'Both Cache Components and Partial Prefetching will be enabled everywhere in the next major release, and the old configurations will be removed.',
'Learn more: https://nextjs.org/docs/app/guides/adopting-partial-prefetching'
].join('\n\n'));
}
if (result.experimental.ppr) {
throw new HardDeprecatedConfigError(`\`experimental.ppr\` has been merged into \`cacheComponents\`. The Partial Prerendering feature is still available, but is now enabled via \`cacheComponents\`. Please update your ${configFileName} accordingly.`);
}
if (result.output === 'export') {
if (result.i18n) {
throw new Error('Specified "i18n" cannot be used with "output: export". See more info here: https://nextjs.org/docs/messages/export-no-i18n');
}
if (!hasNextSupport) {
if (result.rewrites) {
Log.warn('Specified "rewrites" will not automatically work with "output: export". See more info here: https://nextjs.org/docs/messages/export-no-custom-routes');
}
if (result.redirects) {
Log.warn('Specified "redirects" will not automatically work with "output: export". See more info here: https://nextjs.org/docs/messages/export-no-custom-routes');
}
if (result.headers) {
Log.warn('Specified "headers" will not automatically work with "output: export". See more info here: https://nextjs.org/docs/messages/export-no-custom-routes');
}
}
}
if (typeof result.assetPrefix !== 'string') {
throw new Error(`Specified assetPrefix is not a string, found type "${typeof result.assetPrefix}" https://nextjs.org/docs/messages/invalid-assetprefix`);
}
if (typeof result.basePath !== 'string') {
throw new Error(`Specified basePath is not a string, found type "${typeof result.basePath}"`);
}
if (result.basePath !== '') {
if (result.basePath === '/') {
throw new Error(`Specified basePath /. basePath has to be either an empty string or a path prefix"`);
}
if (!result.basePath.startsWith('/')) {
throw new Error(`Specified basePath has to start with a /, found "${result.basePath}"`);
}
if (result.basePath !== '/') {
if (result.basePath.endsWith('/')) {
throw new Error(`Specified basePath should not end with /, found "${result.basePath}"`);
}
if (result.assetPrefix === '') {
result.assetPrefix = result.basePath;
}
}
}
if (result == null ? void 0 : result.images) {
const images = result.images;
if (typeof images !== 'object') {
throw new Error(`Specified images should be an object received ${typeof images}.\nSee more info here: https://nextjs.org/docs/messages/invalid-images-config`);
}
if (images.localPatterns) {
if (!Array.isArray(images.localPatterns)) {
throw new Error(`Specified images.localPatterns should be an Array received ${typeof images.localPatterns}.\nSee more info here: https://nextjs.org/docs/messages/invalid-images-config`);
}
// avoid double-pushing the same pattern if it already exists
if (!images.localPatterns.some((pattern)=>pattern.pathname === '/_next/static/media/**' && pattern.search === '')) {
// static import images are automatically allowed
images.localPatterns.push({
pathname: '/_next/static/media/**',
search: ''
});
}
if (!images.localPatterns.some((pattern)=>pattern.pathname === '/_next/static/immutable/media/**' && pattern.search === '')) {
// static import images are automatically allowed
images.localPatterns.push({
pathname: '/_next/static/immutable/media/**',
search: ''
});
}
} else {
// All paths are not allowed for a search query by default.
images.localPatterns = [
{
pathname: '**',
search: ''
}
];
}
if (images.remotePatterns) {
var _config_assetPrefix;
if (!Array.isArray(images.remotePatterns)) {
throw new Error(`Specified images.remotePatterns should be an Array received ${typeof images.remotePatterns}.\nSee more info here: https://nextjs.org/docs/messages/invalid-images-config`);
}
// We must convert URL to RemotePattern since URL has a colon in the protocol
// and also has additional properties we want to filter out. Also, new URL()
// accepts any protocol so we need manual validation here.
images.remotePatterns = images.remotePatterns.map(({ protocol, hostname, port, pathname, search })=>{
const proto = protocol == null ? void 0 : protocol.replace(/:$/, '');
if (![
'http',
'https',
undefined
].includes(proto)) {
throw new Error(`Specified images.remotePatterns must have protocol "http" or "https" received "${proto}".`);
}
return {
protocol: proto,
hostname,
port,
pathname,
search
};
});
// static images are automatically prefixed with assetPrefix
// so we need to ensure _next/image allows downloading from
// this resource
if ((_config_assetPrefix = config.assetPrefix) == null ? void 0 : _config_assetPrefix.startsWith('http')) {
try {
const url = new URL(config.assetPrefix);
const hasMatchForAssetPrefix = images.remotePatterns.some((pattern)=>matchRemotePattern(pattern, url));
// avoid double-pushing the same pattern if it already can be matched
if (!hasMatchForAssetPrefix) {
images.remotePatterns.push({
hostname: url.hostname,
protocol: url.protocol.replace(/:$/, ''),
port: url.port
});
}
} catch (error) {
throw new Error(`Invalid assetPrefix provided. Original error: ${error}`);
}
}
}
if (images.domains) {
if (!Array.isArray(images.domains)) {
throw new Error(`Specified images.domains should be an Array received ${typeof images.domains}.\nSee more info here: https://nextjs.org/docs/messages/invalid-images-config`);
}
}
if (!images.loader) {
images.loader = 'default';
}
if (images.loader !== 'default' && images.loader !== 'custom' && images.path === imageConfigDefault.path) {
throw new Error(`Specified images.loader property (${images.loader}) also requires images.path property to be assigned to a URL prefix.\nSee more info here: https://nextjs.org/docs/api-reference/next/legacy/image#loader-configuration`);
}
if (images.path === imageConfigDefault.path && result.basePath && !pathHasPrefix(images.path, result.basePath)) {
images.path = `${result.basePath}${images.path}`;
}
// Append trailing slash for non-default loaders and when trailingSlash is set
if (images.path && !images.path.endsWith('/') && (images.loader !== 'default' || result.trailingSlash)) {
images.path += '/';
}
if (images.loaderFile) {
if (images.loader !== 'default' && images.loader !== 'custom') {
throw new Error(`Specified images.loader property (${images.loader}) cannot be used with images.loaderFile property. Please set images.loader to "custom".`);
}
const absolutePath = join(dir, images.loaderFile);
if (!existsSync(absolutePath)) {
throw new Error(`Specified images.loaderFile does not exist at "${absolutePath}".`);
}
images.loaderFile = absolutePath;
}
}
warnCustomizedOption(result, 'experimental.esmExternals', true, 'experimental.esmExternals is not recommended to be modified as it may disrupt module resolution', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'bundlePagesExternals', 'bundlePagesRouterDependencies', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'serverComponentsExternalPackages', 'serverExternalPackages', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'relay', 'compiler.relay', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'styledComponents', 'compiler.styledComponents', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'emotion', 'compiler.emotion', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'reactRemoveProperties', 'compiler.reactRemoveProperties', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'removeConsole', 'compiler.removeConsole', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'swrDelta', 'expireTime', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'typedRoutes', 'typedRoutes', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'outputFileTracingRoot', 'outputFileTracingRoot', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'outputFileTracingIncludes', 'outputFileTracingIncludes', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'outputFileTracingExcludes', 'outputFileTracingExcludes', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'reactCompiler', 'reactCompiler', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'enablePrerenderSourceMaps', 'enablePrerenderSourceMaps', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'cacheComponents', 'cacheComponents', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'cacheLife', 'cacheLife', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'cacheHandlers', 'cacheHandlers', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'adapterPath', 'adapterPath', configFileName, silent);
if (result.experimental.outputStandalone) {
if (!silent) {
Log.warn(`experimental.outputStandalone has been renamed to "output: 'standalone'", please move the config.`);
}
result.output = 'standalone';
}
if (typeof ((_result_experimental2 = result.experimental) == null ? void 0 : (_result_experimental_serverActions = _result_experimental2.serverActions) == null ? void 0 : _result_experimental_serverActions.bodySizeLimit) !== 'undefined') {
const bytes = require('next/dist/compiled/bytes');
const bodySizeLimit = result.experimental.serverActions.bodySizeLimit;
let value;
if (typeof bodySizeLimit === 'number') {
value = bodySizeLimit;
} else {
value = bytes.parse(bodySizeLimit);
}
if (value === null || isNaN(value) || value < 1) {
throw new Error('Server Actions Size Limit must be a valid number or filesize format larger than 1MB: https://nextjs.org/docs/app/api-reference/next-config-js/serverActions#bodysizelimit');
}
}
// Throw if both Middleware and Proxy config are set.
if (((_userConfig_experimental = userConfig.experimental) == null ? void 0 : _userConfig_experimental.proxyClientMaxBodySize) !== undefined && ((_userConfig_experimental1 = userConfig.experimental) == null ? void 0 : _userConfig_experimental1.middlewareClientMaxBodySize) !== undefined) {
throw new Error('Config options `experimental.proxyClientMaxBodySize` and `experimental.middlewareClientMaxBodySize` cannot be set at the same time. Please use `experimental.proxyClientMaxBodySize` instead.');
}
if (((_userConfig_experimental2 = userConfig.experimental) == null ? void 0 : _userConfig_experimental2.proxyPrefetch) !== undefined && ((_userConfig_experimental3 = userConfig.experimental) == null ? void 0 : _userConfig_experimental3.middlewarePrefetch) !== undefined) {
throw new Error('Config options `experimental.proxyPrefetch` and `experimental.middlewarePrefetch` cannot be set at the same time. Please use `experimental.proxyPrefetch` instead.');
}
if (((_userConfig_experimental4 = userConfig.experimental) == null ? void 0 : _userConfig_experimental4.externalProxyRewritesResolve) !== undefined && ((_userConfig_experimental5 = userConfig.experimental) == null ? void 0 : _userConfig_experimental5.externalMiddlewareRewritesResolve) !== undefined) {
throw new Error('Config options `experimental.externalProxyRewritesResolve` and `experimental.externalMiddlewareRewritesResolve` cannot be set at the same time. Please use `experimental.externalProxyRewritesResolve` instead.');
}
if (userConfig.skipProxyUrlNormalize !== undefined && userConfig.skipMiddlewareUrlNormalize !== undefined) {
throw new Error('Config options `skipProxyUrlNormalize` and `skipMiddlewareUrlNormalize` cannot be set at the same time. Please use `skipProxyUrlNormalize` instead.');
}
// Map Proxy config to Middleware config as it is currently an alias.
if (((_userConfig_experimental6 = userConfig.experimental) == null ? void 0 : _userConfig_experimental6.proxyClientMaxBodySize) === undefined && ((_userConfig_experimental7 = userConfig.experimental) == null ? void 0 : _userConfig_experimental7.middlewareClientMaxBodySize) !== undefined) {
result.experimental.proxyClientMaxBodySize = userConfig.experimental.middlewareClientMaxBodySize;
}
if (((_userConfig_experimental8 = userConfig.experimental) == null ? void 0 : _userConfig_experimental8.proxyPrefetch) === undefined && ((_userConfig_experimental9 = userConfig.experimental) == null ? void 0 : _userConfig_experimental9.middlewarePrefetch) !== undefined) {
result.experimental.proxyPrefetch = userConfig.experimental.middlewarePrefetch;
}
if (((_userConfig_experimental10 = userConfig.experimental) == null ? void 0 : _userConfig_experimental10.externalProxyRewritesResolve) === undefined && ((_userConfig_experimental11 = userConfig.experimental) == null ? void 0 : _userConfig_experimental11.externalMiddlewareRewritesResolve) !== undefined) {
result.experimental.externalProxyRewritesResolve = userConfig.experimental.externalMiddlewareRewritesResolve;
}
if (userConfig.skipProxyUrlNormalize === undefined && userConfig.skipMiddlewareUrlNormalize !== undefined) {
result.skipProxyUrlNormalize = userConfig.skipMiddlewareUrlNormalize;
}
// Inverse case: when new name is set but not the old name, copy the value to the old name
// to avoid breaking change on resolved config object written to `.next/`
if (((_userConfig_experimental12 = userConfig.experimental) == null ? void 0 : _userConfig_experimental12.proxyPrefetch) !== undefined && ((_userConfig_experimental13 = userConfig.experimental) == null ? void 0 : _userConfig_experimental13.middlewarePrefetch) === undefined) {
result.experimental.middlewarePrefetch = userConfig.experimental.proxyPrefetch;
}
if (((_userConfig_experimental14 = userConfig.experimental) == null ? void 0 : _userConfig_experimental14.externalProxyRewritesResolve) !== undefined && ((_userConfig_experimental15 = userConfig.experimental) == null ? void 0 : _userConfig_experimental15.externalMiddlewareRewritesResolve) === undefined) {
result.experimental.externalMiddlewareRewritesResolve = userConfig.experimental.externalProxyRewritesResolve;
}
if (userConfig.skipProxyUrlNormalize !== undefined && userConfig.skipMiddlewareUrlNormalize === undefined) {
result.skipMiddlewareUrlNormalize = userConfig.skipProxyUrlNormalize;
}
// Normalize & validate experimental.proxyClientMaxBodySize
if (typeof ((_result_experimental3 = result.experimental) == null ? void 0 : _result_experimental3.proxyClientMaxBodySize) !== 'undefined') {
const proxyClientMaxBodySize = result.experimental.proxyClientMaxBodySize;
let normalizedValue;
if (typeof proxyClientMaxBodySize === 'string') {
const bytes = require('next/dist/compiled/bytes');
normalizedValue = bytes.parse(proxyClientMaxBodySize);
} else if (typeof proxyClientMaxBodySize === 'number') {
normalizedValue = proxyClientMaxBodySize;
} else {
throw new Error('Client Max Body Size must be a valid number (bytes) or filesize format string (e.g., "5mb")');
}
if (isNaN(normalizedValue) || normalizedValue < 1) {
throw new Error('Client Max Body Size must be larger than 0 bytes');
}
// Store the normalized value as a number
result.experimental.proxyClientMaxBodySize = normalizedValue;
}
warnOptionHasBeenMovedOutOfExperimental(result, 'transpilePackages', 'transpilePackages', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'skipMiddlewareUrlNormalize', 'skipMiddlewareUrlNormalize', configFileName, silent);
warnOptionHasBeenMovedOutOfExperimental(result, 'skipTrailingSlashRedirect', 'skipTrailingSlashRedirect', configFileName, silent);
if ((result == null ? void 0 : result.outputFileTracingRoot) && !isAbsolute(result.outputFileTracingRoot)) {
result.outputFileTracingRoot = resolve(result.outputFileTracingRoot);
if (!silent) {
Log.warn(`outputFileTracingRoot should be absolute, using: ${result.outputFileTracingRoot}`);
}
}
if ((result == null ? void 0 : (_result_turbopack = result.turbopack) == null ? void 0 : _result_turbopack.root) && !isAbsolute(result.turbopack.root)) {
result.turbopack.root = resolve(result.turbopack.root);
if (!silent) {
Log.warn(`turbopack.root should be absolute, using: ${result.turbopack.root}`);
}
}
if (result == null ? void 0 : (_result_turbopack1 = result.turbopack) == null ? void 0 : _result_turbopack1.chunkLoadingGlobal) {
const g = result.turbopack.chunkLoadingGlobal;
if (!g.startsWith('TURBOPACK_')) {
result.turbopack.chunkLoadingGlobal = `TURBOPACK_${g}`;
}
}
if (result.experimental.runtimeServerDeploymentId == null && phase === PHASE_PRODUCTION_BUILD && ciEnvironment.hasNextSupport && process.env.NEXT_DEPLOYMENT_ID) {
if (result.deploymentId != null && result.deploymentId !== process.env.NEXT_DEPLOYMENT_ID) {
throw new Error(`The NEXT_DEPLOYMENT_ID environment variable value "${process.env.NEXT_DEPLOYMENT_ID}" does not match the provided deploymentId "${result.deploymentId}" in the config.`);
}
result.experimental.runtimeServerDeploymentId = true;
}
// only leverage deploymentId
if (process.env.NEXT_DEPLOYMENT_ID) {
result.deploymentId = process.env.NEXT_DEPLOYMENT_ID;
}
if (process.env.NEXT_HASH_SALT) {
result.outputHashSalt = (result.outputHashSalt ?? '') + (process.env.NEXT_HASH_SALT ?? '');
}
const tracingRoot = result == null ? void 0 : result.outputFileTracingRoot;
const turbopackRoot = result == null ? void 0 : (_result_turbopack2 = result.turbopack) == null ? void 0 : _result_turbopack2.root;
let repoRoot = process.env.NEXT_PRIVATE_OUTPUT_TRACE_ROOT;
let rootDirResult;
if (!repoRoot) {
rootDirResult = findRootDirAndLockFiles(dir);
repoRoot = rootDirResult.rootDir;
}
;
result.repoRoot = repoRoot;
// If both provided, validate they match. If not, use outputFileTracingRoot.
if (tracingRoot && turbopackRoot && tracingRoot !== turbopackRoot) {
Log.warn(`Both \`outputFileTracingRoot\` and \`turbopack.root\` are set, but they must have the same value.\n` + `Using \`outputFileTracingRoot\` value: ${tracingRoot}.`);
}
let rootDir = tracingRoot || turbopackRoot;
if (!rootDir) {
rootDir = repoRoot;
if (rootDirResult && !silent) {
if (rootDirResult.boundary) {
warnRootBoundary(rootDirResult.boundary);
}
warnDuplicatedLockFiles(rootDirResult.lockFiles);
}
}
if (!rootDir) {
throw new Error('Failed to find the root directory of the project. This is a bug in Next.js.');
}
// Ensure both properties are set to the same value
result.outputFileTracingRoot = rootDir;
dset(result, [
'turbopack',
'root'
], rootDir);
verifyDistDir(resolve(dir, result.distDir), dir, repoRoot);
setHttpClientAndAgentOptions(result || defaultConfig);
if (result.i18n) {
const { i18n } = result;
const i18nType = typeof i18n;
if (i18nType !== 'object') {
throw new Error(`Specified i18n should be an object received ${i18nType}.\nSee more info here: https://nextjs.org/docs/messages/invalid-i18n-config`);
}
if (!Array.isArray(i18n.locales)) {
throw new Error(`Specified i18n.locales should be an Array received ${typeof i18n.locales}.\nSee more info here: https://nextjs.org/docs/messages/invalid-i18n-config`);
}
if (i18n.locales.length > 100 && !silent) {
Log.warn(`Received ${i18n.locales.length} i18n.locales items which exceeds the recommended max of 100.\nSee more info here: https://nextjs.org/docs/advanced-features/i18n-routing#how-does-this-work-with-static-generation`);
}
const defaultLocaleType = typeof i18n.defaultLocale;
if (!i18n.defaultLocale || defaultLocaleType !== 'string') {
throw new Error(`Specified i18n.defaultLocale should be a string.\nSee more info here: https://nextjs.org/docs/messages/invalid-i18n-config`);
}
if (typeof i18n.domains !== 'undefined' && !Array.isArray(i18n.domains)) {
throw new Error(`Specified i18n.domains must be an array of domain objects e.g. [ { domain: 'example.fr', defaultLocale: 'fr', locales: ['fr'] } ] received ${typeof i18n.domains}.\nSee more info here: https://nextjs.org/docs/messages/invalid-i18n-config`);
}
if (i18n.domains) {
const invalidDomainItems = i18n.domains.filter((item)=>{
var _i18n_domains;
if (!item || typeof item !== 'object') return true;
if (!item.defaultLocale) return true;
if (!item.domain || typeof item.domain !== 'string') return true;
if (item.domain.includes(':')) {
console.warn(`i18n domain: "${item.domain}" is invalid it should be a valid domain without protocol (https://) or port (:3000) e.g. example.vercel.sh`);
return true;
}
const defaultLocaleDuplicate = (_i18n_domains = i18n.domains) == null ? void 0 : _i18n_domains.find((altItem)=>altItem.defaultLocale === item.defaultLocale && altItem.domain !== item.domain);
if (!silent && defaultLocaleDuplicate) {
console.warn(`Both ${item.domain} and ${defaultLocaleDuplicate.domain} configured the defaultLocale ${item.defaultLocale} but only one can. Change one item's default locale to continue`);
return true;
}
let hasInvalidLocale = false;
if (Array.isArray(item.locales)) {
for (const locale of item.locales){
if (typeof locale !== 'string') hasInvalidLocale = true;
for (const domainItem of i18n.domains || []){
if (domainItem === item) continue;
if (domainItem.locales && domainItem.locales.includes(locale)) {
console.warn(`Both ${item.domain} and ${domainItem.domain} configured the locale (${locale}) but only one can. Remove it from one i18n.domains config to continue`);
hasInvalidLocale = true;
break;
}
}
}
}
return hasInvalidLocale;
});
if (invalidDomainItems.length > 0) {
throw new Error(`Invalid i18n.domains values:\n${invalidDomainItems.map((item)=>JSON.stringify(item)).join('\n')}\n\ndomains value must follow format { domain: 'example.fr', defaultLocale: 'fr', locales: ['fr'] }.\nSee more info here: https://nextjs.org/docs/messages/invalid-i18n-config`);
}
}
if (!Array.isArray(i18n.locales)) {
throw new Error(`Specified i18n.locales must be an array of locale strings e.g. ["en-US", "nl-NL"] received ${typeof i18n.locales}.\nSee more info here: https://nextjs.org/docs/messages/invalid-i18n-config`);
}
const invalidLocales = i18n.locales.filter((locale)=>typeof locale !== 'string');
if (invalidLocales.length > 0) {
throw new Error(`Specified i18n.locales contains invalid values (${invalidLocales.map(String).join(', ')}), locales must be valid locale tags provided as strings e.g. "en-US".\n` + `See here for list of valid language sub-tags: http://www.iana.org/assignments/language-subtag-registry/language-subtag-registry`);
}
if (!i18n.locales.includes(i18n.defaultLocale)) {
throw new Error(`Specified i18n.defaultLocale should be included in i18n.locales.\nSee more info here: https://nextjs.org/docs/messages/invalid-i18n-config`);
}
const normalizedLocales = new Set();
const duplicateLocales = new Set();
i18n.locales.forEach((locale)=>{
const localeLower = locale.toLowerCase();
if (normalizedLocales.has(localeLower)) {
duplicateLocales.add(locale);
}
normalizedLocales.add(localeLower);
});
if (duplicateLocales.size > 0) {
throw new Error(`Specified i18n.locales contains the following duplicate locales:\n` + `${[
...duplicateLocales
].join(', ')}\n` + `Each locale should be listed only once.\n` + `See more info here: https://nextjs.org/docs/messages/invalid-i18n-config`);
}
// make sure default Locale is at the front
i18n.locales = [
i18n.defaultLocale,
...i18n.locales.filter((locale)=>locale !== i18n.defaultLocale)
];
const localeDetectionType = typeof i18n.localeDetection;
if (localeDetectionType !== 'boolean' && localeDetectionType !== 'undefined') {
throw new Error(`Specified i18n.localeDetection should be undefined or a boolean received ${localeDetectionType}.\nSee more info here: https://nextjs.org/docs/messages/invalid-i18n-config`);
}
}
if (result.devIndicators !== false && ((_result_devIndicators = result.devIndicators) == null ? void 0 : _result_devIndicators.position)) {
const { position } = result.devIndicators;
const allowedValues = [
'top-left',
'top-right',
'bottom-left',
'bottom-right'
];
if (!allowedValues.includes(position)) {
throw new Error(`Invalid "devIndicator.position" provided, expected one of ${allowedValues.join(', ')}, received ${position}`);
}
}
result.expireTime = normalizeInfiniteDuration(result.expireTime, 'expireTime');
const staleTimes = result.experimental.staleTimes;
if (staleTimes) {
staleTimes.dynamic = normalizeInfiniteDuration(staleTimes.dynamic, 'experimental.staleTimes.dynamic');
staleTimes.static = normalizeInfiniteDuration(staleTimes.static, 'experimental.staleTimes.static');
}
if (result.cacheLife) {
var _defaultConfig_cacheLife, _defaultConfig_experimental_staleTimes, _defaultConfig_experimental;
const userCacheLifeProfiles = result.cacheLife;
// The default profiles are cloned because the backfill below mutates the
// default profile, and multiple next() instances in the same process must
// not observe each other's config through the shared objects.
const cacheLifeProfiles = {
...structuredClone(defaultConfig.cacheLife),
...userCacheLifeProfiles
};
result.cacheLife = cacheLifeProfiles;
// Only validate values the user wrote themselves. Backfilling the
// default profile below can produce a revalidate that's larger than a
// user-provided expire (e.g. for `default: { expire: 0 }`), which is
// fine — the expire wins — but would fail validation.
for (const [profileName, profile] of Object.entries(userCacheLifeProfiles)){
cacheLifeProfiles[profileName] = validateAndNormalizeCacheLifeProfile(profile, {
kind: 'config',
profileName
});
}
const defaultDefault = (_defaultConfig_cacheLife = defaultConfig.cacheLife) == null ? void 0 : _defaultConfig_cacheLife['default'];
if (!defaultDefault || defaultDefault.revalidate === undefined || defaultDefault.expire === undefined || !((_defaultConfig_experimental = defaultConfig.experimental) == null ? void 0 : (_defaultConfig_experimental_staleTimes = _defaultConfig_experimental.staleTimes) == null ? void 0 : _defaultConfig_experimental_staleTimes.static)) {
throw new Error('No default cacheLife profile.');
}
const defaultCacheLifeProfile = result.cacheLife['default'];
if (!defaultCacheLifeProfile) {
result.cacheLife['default'] = defaultDefault;
} else {
if (defaultCacheLifeProfile.stale === undefined) {
var _result_experimental_staleTimes, _defaultConfig_experimental_staleTimes1, _defaultConfig_experimental1;
const staticStaleTime = (_result_experimental_staleTimes = result.experimental.staleTimes) == null ? void 0 : _result_experimental_staleTimes.static;
defaultCacheLifeProfile.stale = staticStaleTime ?? ((_defaultConfig_experimental1 = defaultConfig.experimental) == null ? void 0 : (_defaultConfig_experimental_staleTimes1 = _defaultConfig_experimental1.staleTimes) == null ? void 0 : _defaultConfig_experimental_staleTimes1.static);
}
if (defaultCacheLifeProfile.revalidate === undefined) {
defaultCacheLifeProfile.revalidate = defaultDefault.revalidate;
}
if (defaultCacheLifeProfile.expire === undefined) {
defaultCacheLifeProfile.expire = result.expireTime ?? defaultDefault.expire;
}
}
}
if (result.cacheHandlers) {
const allowedHandlerNameRegex = /^[a-z-]+$/;
if (typeof result.cacheHandlers !== 'object') {
throw new Error(`Invalid "cacheHandlers" provided, expected an object e.g. { default: '/my-handler.js' }, received ${JSON.stringify(result.cacheHandlers)}`);
}
const handlerKeys = Object.keys(result.cacheHandlers);
const invalidHandlerItems = [];
for (const key of handlerKeys){
if (key === 'private') {
invalidHandlerItems.push({
key,
reason: 'The cache handler for "use cache: private" cannot be customized.'
});
} else if (!allowedHandlerNameRegex.test(key)) {
invalidHandlerItems.push({
key,
reason: 'key must only use characters a-z and -'
});
} else {
const handlerPath = result.cacheHandlers[key];
const resolvedHandlerPath = handlerPath && resolveCacheHandlerPathToFilesystem(handlerPath);
if (resolvedHandlerPath && !existsSync(resolvedHandlerPath)) {
invalidHandlerItems.push({
key,
reason: `cache handler path provided does not exist, received ${handlerPath}`
});
}
}
if (invalidHandlerItems.length) {
throw new Error(`Invalid handler fields configured for "cacheHandlers":\n${invalidHandlerItems.map((item)=>`${key}: ${item.reason}`).join('\n')}`);
}
}
}
const userProvidedModularizeImports = result.modularizeImports;
// Unfortunately these packages end up re-exporting 10600 modules, for example: https://unpkg.com/browse/@mui/icons-material@5.11.16/esm/index.js.
// Leveraging modularizeImports tremendously reduces compile times for these.
result.modularizeImports = {
...userProvidedModularizeImports || {},
// This is intentionally added after the user-provided modularizeImports config.
'@mui/icons-material': {
transform: '@mui/icons-material/{{member}}'
},
lodash: {
transform: 'lodash/{{member}}'
}
};
const userProvidedOptimizePackageImports = ((_result_experimental4 = result.experimental) == null ? void 0 : _result_experimental4.optimizePackageImports) || [];
result.experimental.optimizePackageImports = [
...new Set([
...userProvidedOptimizePackageImports,
'lucide-react',
'date-fns',
'lodash-es',
'ramda',
'antd',
'react-bootstrap',
'ahooks',
'@ant-design/icons',
'@headlessui/react',
'@headlessui-float/react',
'@heroicons/react/20/solid',
'@heroicons/react/24/solid',
'@heroicons/react/24/outline',
'@visx/visx',
'@tremor/react',
'rxjs',
'@mui/material',
'@mui/icons-material',
'recharts',
'react-use',
'effect',
'@effect/schema',
'@effect/platform',
'@effect/platform-node',
'@effect/platform-browser',
'@effect/platform-bun',
'@effect/sql',
'@effect/sql-mssql',
'@effect/sql-mysql2',
'@effect/sql-pg',
'@effect/sql-sqlite-node',
'@effect/sql-sqlite-bun',
'@effect/sql-sqlite-wasm',
'@effect/sql-sqlite-react-native',
'@effect/rpc',
'@effect/rpc-http',
'@effect/typeclass',
'@effect/experimental',
'@effect/opentelemetry',
'@material-ui/core',
'@material-ui/icons',
'@tabler/icons-react',
'mui-core',
// We don't support wildcard imports for these configs, e.g. `react-icons/*`
// so we need to add them manually.
// In the future, we should consider automatically detecting packages that
// need to be optimized.
'react-icons/ai',
'react-icons/bi',
'react-icons/bs',
'react-icons/cg',
'react-icons/ci',
'react-icons/di',
'react-icons/fa',
'react-icons/fa6',
'react-icons/fc',
'react-icons/fi',
'react-icons/gi',
'react-icons/go',
'react-icons/gr',
'react-icons/hi',
'react-icons/hi2',
'react-icons/im',
'react-icons/io',
'react-icons/io5',
'react-icons/lia',
'react-icons/lib',
'react-icons/lu',
'react-icons/md',
'react-icons/pi',
'react-icons/ri',
'react-icons/rx',
'react-icons/si',
'react-icons/sl',
'react-icons/tb',
'react-icons/tfi',
'react-icons/ti',
'react-icons/vsc',
'react-icons/wi'
])
];
if (!result.htmlLimitedBots) {
// @ts-expect-error: override the htmlLimitedBots with default string, type covert: RegExp -> string
result.htmlLimitedBots = HTML_LIMITED_BOT_UA_RE_STRING;
}
if (typeof result.experimental.mcpServer === 'undefined' && process.env.__NEXT_EXPERIMENTAL_MCP_SERVER === 'true') {
result.experimental.mcpServer = true;
}
if (result.cacheComponents) {
// TODO: Kept for backwards compatibility with legacy builders.
result.experimental.cacheComponents = true;
}
// `experimental.useCache` is deprecated in favor of the top-level
// `cacheComponents` option. A defined value means the user set the option
// explicitly, because it's only backfilled from `cacheComponents` below.
if (result.experimental.useCache !== undefined) {
// Disabling the directive that Cache Components is built around leaves the
// app in a state where every `"use cache"` fails to compile with an error
// that asks for the already-enabled `cacheComponents` option.
if (!result.experimental.useCache && result.cacheComponents) {
throw new Error(`\`experimental.useCache\` cannot be disabled when \`cacheComponents\` is enabled, because Cache Components relies on the \`"use cache"\` directive. Please remove it from ${configFileName}.`);
}
if (!silent) {
if (result.cacheComponents) {
Log.warnOnce(`\`experimental.useCache\` is no longer needed, because \`cacheComponents\` already enables the \`"use cache"\` directive. You can remove it from ${configFileName}.`);
} else {
Log.warnOnce(`\`experimental.useCache\` is deprecated. Please use the top-level \`cacheComponents\` option instead in ${configFileName}.`);
}
}
}
// "use cache" was originally implicitly enabled with the cacheComponents flag, so
// we transfer the value for cacheComponents to the explicit useCache flag to ensure
// backwards compatibility.
if (result.experimental.useCache === undefined) {
result.experimental.useCache = result.cacheComponents;
}
const pluginRuntimeStrategy = result.experimental.turbopackPluginRuntimeStrategy;
if (pluginRuntimeStrategy === 'workerThreads' || pluginRuntimeStrategy === 'forceWorkerThreads') {
result.experimental.turbopackPluginRuntimeStrategy = 'workerThreads';
if (!process.versions.bun && !process.versions.deno) {
const nodeVersion = process.versions.node;
const affectedNodeRange = '>=24.13.1';
if (semver.satisfies(nodeVersion, affectedNodeRange, {
includePrerelease: true
})) {
if (pluginRuntimeStrategy === 'forceWorkerThreads') {
Log.warn(`\`experimental.turbopackPluginRuntimeStrategy = ` + `'forceWorkerThreads'\` is enabled, bypassing protection ` + `against a known potential crash in Node.js ${affectedNodeRange}.\n` + `A Node.js worker-thread teardown bug can abort the process ` + `when a native addon, such as fsevents, has a live Node-API ` + `threadsafe function as a worker exits.\n` + `See https://github.com/nodejs/node/issues/65100.`);
} else {
Log.warn(`\`experimental.turbopackPluginRuntimeStrategy = ` + `'workerThreads'\` is disabled on Node.js ${nodeVersion}.\n` + `A Node.js worker-thread teardown bug can abort the process ` + `when a native addon, such as fsevents, has a live Node-API ` + `threadsafe function as a worker exits.\n` + `See https://github.com/nodejs/node/issues/65100.\n` + `Falling back to 'childProcesses'. To override at your own ` + `risk, use 'forceWorkerThreads'.`);
result.experimental.turbopackPluginRuntimeStrategy = 'childProcesses';
}
}
}
}
// Store the distDirRoot in the config before it is modified for development mode
;
result.distDirRoot = result.distDir;
if (phase === PHASE_DEVELOPMENT_SERVER) {
result.distDir = join(result.distDir, 'dev');
}
// Derive the `'use cache'` fill timeout from `staticPageGenerationTimeout`
// if the user didn't set one explicitly. 90% leaves headroom for the
// cache-fill error to surface before the build worker kills the page.
if (result.experimental.useCacheTimeout === undefined) {
result.experimental.useCacheTimeout = result.staticPageGenerationTimeout * 0.9;
}
return result;
}
/**
* Post-processing applied by `loadConfig` after `applyModifyConfig`, so that
* any mutations the user made through `modifyConfig` still flow through the
* same defaulting rules. Keep framework-default resolution in one place so
* consumers don't each need to know the current framework default (which may
* evolve over time).
*/ function finalizeConfig(config, bundler) {
var _config_experimental_instantInsights, _config_experimental;
config.experimental.instantInsights = {
validationLevel: ((_config_experimental_instantInsights = config.experimental.instantInsights) == null ? void 0 : _config_experimental_instantInsights.validationLevel) ?? 'warning'
};
// Only read process.env.__NEXT_IMMUTABLE_ASSET_TOKEN to make our testing setup easier. In the
// real world, this is done by the adapter's modifyConfig
if (process.env.__NEXT_TEST_MODE && process.env.IS_TURBOPACK_TEST && config.deploymentId && process.env.__NEXT_SUPPORTS_IMMUTABLE_ASSETS) {
config.supportsImmutableAssets = true;
}
// Normalize again for Adapters that only set config.experimental.supportsImmutableAssets for now.
if (config.supportsImmutableAssets !== ((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.supportsImmutableAssets)) {
var _config_experimental1;
config.supportsImmutableAssets = config.supportsImmutableAssets ?? ((_config_experimental1 = config.experimental) == null ? void 0 : _config_experimental1.supportsImmutableAssets);
}
if (bundler !== undefined && bundler !== Bundler.Turbopack) {
// Silently ignore that flag for Webpack/Rspack since the server code assumes that all files
// in `static/chunks` are always immutable without checking the manifest.
config.supportsImmutableAssets = false;
}
if (config.supportsImmutableAssets && config.output === 'standalone') {
// supportsImmutableAssets is designed to work with adapters. Disable it for output=standalone,
// which is currently using a non-adapter codepath.
// TODO remove again once output=standalone is using adapters.
config.supportsImmutableAssets = false;
}
if (config.experimental.outputHashSalt !== undefined) {
config.outputHashSalt = (config.outputHashSalt ?? '') + config.experimental.outputHashSalt;
}
return config;
}
async function applyModifyConfig(config, phase, silent, dir) {
// we always call modify config and phase can be used to only
// modify for specific times
if (config.adapterPath) {
const adapterMod = interopDefault(await import(pathToFileURL(require.resolve(config.adapterPath)).href));
if (typeof adapterMod.modifyConfig === 'function') {
if (!silent) {
Log.info(`Applying modifyConfig from ${adapterMod.name}`);
}
config = await adapterMod.modifyConfig(config, {
phase,
nextVersion: "16.4.0",
projectDir: dir
});
}
}
return config;
}
// Cache config with keys to handle multiple configurations (e.g., multi-zone)
const configCache = new Map();
// Generate cache key based on parameters that affect config output
// We need a unique key for cache because there can be multiple values
function getCacheKey(phase, dir, customConfig, reactProductionProfiling, debugPrerender, pid) {
// The next.config.js is unique per project, so we can use the dir as the major key
// to generate the unique config key. Include PID to invalidate on server restart.
const keyData = JSON.stringify({
dir,
phase,
hasCustomConfig: Boolean(customConfig),
reactProductionProfiling: Boolean(reactProductionProfiling),
debugPrerender: Boolean(debugPrerender),
pid: pid || 0
});
return djb2Hash(keyData).toString(36);
}
export default async function loadConfig(phase, dir, opts = {}) {
// Test for an explicit `silent == false` since the default in loadConfig is true
const logTiming = opts.silent === false;
const startTimeNanos = logTiming ? process.hrtime.bigint() : undefined;
const [config, meta] = await loadConfigImpl(phase, dir, opts);
warnIfReact18IsInstalled(phase, dir, opts.silent);
if (!meta.cacheHit && logTiming) {
const durationNanos = process.hrtime.bigint() - startTimeNanos;
Log.event(`Running ${meta.configFileName ?? 'next.config'} took ${hrtimeBigIntDurationToString(durationNanos)}`);
}
return config;
}
async function loadConfigImpl(phase, dir, { customConfig, rawConfig, silent = true, reportExperimentalFeatures, reactProductionProfiling, debugPrerender, bundler }) {
const meta = {};
// Generate cache key based on parameters that affect config output
// Include process.pid to invalidate cache on server restart
const cacheKey = getCacheKey(phase, dir, customConfig, reactProductionProfiling, debugPrerender, process.pid);
// Check if we have a cached result
const cachedResult = configCache.get(cacheKey);
if (cachedResult) {
meta.cacheHit = true;
// Call the experimental features callback if provided
if (reportExperimentalFeatures) {
reportExperimentalFeatures(cachedResult.configuredExperimentalFeatures);
}
// Return raw config if requested and available
if (rawConfig && cachedResult.rawConfig) {
return [
cachedResult.rawConfig,
meta
];
}
return [
cachedResult.config,
meta
];
} else {
// Reset next.config errors before loading config
// This happens on every config load to ensure fresh validation
NextInstanceErrorState.nextConfig = [];
}
// Original implementation continues below...
if (!process.env.__NEXT_PRIVATE_RENDER_WORKER) {
try {
loadWebpackHook();
} catch (err) {
// this can fail in standalone mode as the files
// aren't traced/included
if (!process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
throw err;
}
}
}
if (process.env.__NEXT_PRIVATE_STANDALONE_CONFIG) {
// we don't apply assignDefaults or modifyConfig here as it
// has already been applied
const standaloneConfig = JSON.parse(process.env.__NEXT_PRIVATE_STANDALONE_CONFIG);
// Cache the standalone config
configCache.set(cacheKey, {
config: standaloneConfig,
rawConfig: standaloneConfig,
configuredExperimentalFeatures: []
});
return [
standaloneConfig,
meta
];
}
const curLog = silent ? {
warn: ()=>{},
info: ()=>{},
error: ()=>{}
} : Log;
loadEnvConfig(dir, phase === PHASE_DEVELOPMENT_SERVER, curLog);
let configFileName = 'next.config.js';
const configuredExperimentalFeatures = [];
if (customConfig) {
// Check deprecation warnings on the custom config before merging with defaults
checkDeprecations(customConfig, configFileName, silent, dir);
const config = finalizeConfig(await applyModifyConfig(assignDefaultsAndValidate(dir, {
configOrigin: 'server',
configFileName,
...customConfig
}, silent, phase), phase, silent, dir), bundler);
// Cache the custom config result
configCache.set(cacheKey, {
config,
rawConfig: customConfig,
configuredExperimentalFeatures
});
reportExperimentalFeatures == null ? void 0 : reportExperimentalFeatures(configuredExperimentalFeatures);
return [
config,
meta
];
}
const path = await findUp(CONFIG_FILES, {
cwd: dir
});
// If config file was found
if (path == null ? void 0 : path.length) {
var _userConfig_experimental, _userConfig_experimental1, _userConfig_experimental2, _userConfig_experimental3, _userConfig_experimental4, _userConfig_experimental5, _userConfig_experimental6;
configFileName = basename(path);
meta.configFileName = configFileName;
let userConfigModule;
let loadedConfig;
try {
const envBefore = Object.assign({}, process.env);
// `import()` expects url-encoded strings, so the path must be properly
// escaped and (especially on Windows) absolute paths must pe prefixed
// with the `file://` protocol
if (process.env.__NEXT_TEST_MODE === 'jest') {
// dynamic import does not currently work inside of vm which
// jest relies on so we fall back to require for this case
// https://github.com/nodejs/node/issues/35889
userConfigModule = require(path);
} else if (configFileName === 'next.config.ts') {
userConfigModule = await transpileConfig({
nextConfigPath: path,
dir
});
} else {
userConfigModule = await import(pathToFileURL(path).href);
}
const newEnv = {};
for (const key of Object.keys(process.env)){
if (envBefore[key] !== process.env[key]) {
newEnv[key] = process.env[key];
}
}
updateInitialEnv(newEnv);
if (rawConfig) {
// Cache the raw config
configCache.set(cacheKey, {
config: userConfigModule,
rawConfig: userConfigModule,
configuredExperimentalFeatures
});
reportExperimentalFeatures == null ? void 0 : reportExperimentalFeatures(configuredExperimentalFeatures);
return [
userConfigModule,
meta
];
}
// `normalizeConfig` invokes the user's exported config function (or
// awaits its returned promise) if it is one. Errors thrown from that
// call belong to the same "failed to load config" category as parse
// errors from `import()` above, so we keep them inside this try/catch
// to attach the same framing message.
loadedConfig = Object.freeze(await normalizeConfig(phase, interopDefault(userConfigModule)));
} catch (err) {
// Capture the error for MCP tool reporting
NextInstanceErrorState.nextConfig.push(err);
// TODO: Modify docs to add cases of failing next.config.ts transformation
curLog.error(`Failed to load ${configFileName}, see more info here https://nextjs.org/docs/messages/next-config-error`);
throw err;
}
if (loadedConfig.experimental) {
for (const name of Object.keys(loadedConfig.experimental)){
const value = loadedConfig.experimental[name];
if (name.startsWith('turbopack') && !process.env.TURBOPACK) {
continue;
}
addConfiguredExperimentalFeature(configuredExperimentalFeatures, name, value);
}
}
// Clone a new userConfig each time to avoid mutating the original
const userConfig = cloneObject(loadedConfig);
// Check deprecation warnings on the actual user config before merging with defaults
checkDeprecations(userConfig, configFileName, silent, dir);
if (userConfig.supportsImmutableAssets === undefined && ((_userConfig_experimental = userConfig.experimental) == null ? void 0 : _userConfig_experimental.supportsImmutableAssets) !== undefined) {
userConfig.supportsImmutableAssets = userConfig.experimental.supportsImmutableAssets;
}
// `experimental.turbopackGenerateComponentChunks` has moved into
// `experimental.turbopackChunking.generateComponentChunks`.
if (((_userConfig_experimental1 = userConfig.experimental) == null ? void 0 : _userConfig_experimental1.turbopackGenerateComponentChunks) !== undefined) {
throw new Error(`\`experimental.turbopackGenerateComponentChunks\` has been moved to \`experimental.turbopackChunking.generateComponentChunks\`. Please update your ${configFileName} file accordingly.`);
}
// `experimental.turbopackChunkingHeuristics` has been renamed to
// `experimental.turbopackChunking`.
if (((_userConfig_experimental2 = userConfig.experimental) == null ? void 0 : _userConfig_experimental2.turbopackChunkingHeuristics) !== undefined) {
throw new Error(`\`experimental.turbopackChunkingHeuristics\` has been renamed to \`experimental.turbopackChunking\`. Please update your ${configFileName} file accordingly.`);
}
// Always validate the config against schema in non minimal mode
if (!process.env.NEXT_MINIMAL && !silent) {
await validateConfigSchema(userConfig, configFileName, curLog.warn, (messages)=>{
// Capture validation messages for MCP error reporting
if (messages.length > 0) {
const fullMessage = messages.join('\n');
NextInstanceErrorState.nextConfig.push(new Error(fullMessage));
}
});
}
if (userConfig.target && userConfig.target !== 'server') {
throw new Error(`The "target" property is no longer supported in ${configFileName}.\n` + 'See more info here https://nextjs.org/docs/messages/deprecated-target-config');
}
if (reactProductionProfiling) {
userConfig.reactProductionProfiling = reactProductionProfiling;
}
if (((_userConfig_experimental3 = userConfig.experimental) == null ? void 0 : _userConfig_experimental3.lightningCssFeatures) && !((_userConfig_experimental4 = userConfig.experimental) == null ? void 0 : _userConfig_experimental4.useLightningcss) && bundler !== Bundler.Turbopack) {
curLog.warn(`experimental.lightningCssFeatures is set but experimental.useLightningcss is not enabled. ` + `The lightningCssFeatures option has no effect without useLightningcss.`);
}
if (phase !== PHASE_PRODUCTION_SERVER && ((_userConfig_experimental5 = userConfig.experimental) == null ? void 0 : _userConfig_experimental5.useLightningcss)) {
var _css, _this, _userConfig_experimental7;
const { loadBindings } = require('../build/swc');
const isLightningSupported = (_this = await loadBindings((_userConfig_experimental7 = userConfig.experimental) == null ? void 0 : _userConfig_experimental7.useWasmBinary)) == null ? void 0 : (_css = _this.css) == null ? void 0 : _css.lightning;
if (!isLightningSupported) {
curLog.warn(`experimental.useLightningcss is set, but the setting is disabled because next-swc/wasm does not support it yet.`);
userConfig.experimental.useLightningcss = false;
}
}
// serialize the regex config into string
if ((userConfig == null ? void 0 : userConfig.htmlLimitedBots) instanceof RegExp) {
// @ts-expect-error: override the htmlLimitedBots with default string, type covert: RegExp -> string
userConfig.htmlLimitedBots = userConfig.htmlLimitedBots.source;
}
enforceExperimentalFeatures(userConfig, {
isDefaultConfig: false,
configuredExperimentalFeatures,
debugPrerender,
phase
});
const completeConfig = assignDefaultsAndValidate(dir, {
configOrigin: relative(dir, path),
configFile: path,
configFileName,
...userConfig
}, silent, phase);
const finalConfig = finalizeConfig(await applyModifyConfig(completeConfig, phase, silent, dir), bundler);
// Normalize so that also Adapters can still see userConfig.experimental.supportsImmutableAssets for now
if (userConfig.supportsImmutableAssets === undefined || ((_userConfig_experimental6 = userConfig.experimental) == null ? void 0 : _userConfig_experimental6.supportsImmutableAssets) === undefined) {
var _userConfig_experimental8;
const value = userConfig.supportsImmutableAssets ?? ((_userConfig_experimental8 = userConfig.experimental) == null ? void 0 : _userConfig_experimental8.supportsImmutableAssets);
userConfig.supportsImmutableAssets = value;
userConfig.experimental ??= {};
userConfig.experimental.supportsImmutableAssets = value;
}
// Cache the final result
configCache.set(cacheKey, {
config: finalConfig,
rawConfig: userConfigModule,
configuredExperimentalFeatures
});
if (reportExperimentalFeatures) {
reportExperimentalFeatures(configuredExperimentalFeatures);
}
return [
finalConfig,
meta
];
} else {
const configBaseName = basename(CONFIG_FILES[0], extname(CONFIG_FILES[0]));
const unsupportedConfig = findUp.sync([
`${configBaseName}.cjs`,
`${configBaseName}.cts`,
// TODO: Remove `as any` once we bump @types/node to v22.10.0+
...process.features.typescript ? [] : [
'next.config.mts'
],
`${configBaseName}.json`,
`${configBaseName}.jsx`,
`${configBaseName}.tsx`
], {
cwd: dir
});
if (unsupportedConfig == null ? void 0 : unsupportedConfig.length) {
throw new Error(`Configuring Next.js via '${basename(unsupportedConfig)}' is not supported. Please replace the file with 'next.config.js', 'next.config.mjs', or 'next.config.ts'.`);
}
}
const clonedDefaultConfig = cloneObject(defaultConfig);
enforceExperimentalFeatures(clonedDefaultConfig, {
isDefaultConfig: true,
configuredExperimentalFeatures,
debugPrerender,
phase
});
// always call assignDefaults to ensure settings like
// reactRoot can be updated correctly even with no next.config.js
const completeConfig = assignDefaultsAndValidate(dir, {
...clonedDefaultConfig,
configFileName
}, silent, phase);
setHttpClientAndAgentOptions(completeConfig);
const finalConfig = finalizeConfig(await applyModifyConfig(completeConfig, phase, silent, dir), bundler);
// Cache the default config result
configCache.set(cacheKey, {
config: finalConfig,
rawConfig: clonedDefaultConfig,
configuredExperimentalFeatures
});
if (reportExperimentalFeatures) {
reportExperimentalFeatures(configuredExperimentalFeatures);
}
return [
finalConfig,
meta
];
}
function enforceExperimentalFeatures(config, options) {
const { configuredExperimentalFeatures, debugPrerender, isDefaultConfig, phase } = options;
config.experimental ??= {};
if (debugPrerender && (phase === PHASE_PRODUCTION_BUILD || phase === PHASE_EXPORT)) {
setExperimentalFeatureForDebugPrerender(config.experimental, 'serverSourceMaps', true, configuredExperimentalFeatures);
setExperimentalFeatureForDebugPrerender(config.experimental, process.env.TURBOPACK ? 'turbopackMinify' : 'serverMinification', false, configuredExperimentalFeatures);
setExperimentalFeatureForDebugPrerender(config.experimental, 'prerenderEarlyExit', false, configuredExperimentalFeatures);
setExperimentalFeatureForDebugPrerender(config.experimental, 'allowDevelopmentBuild', true, configuredExperimentalFeatures);
}
// TODO: Remove this once we've made Cache Components the default.
if (process.env.__NEXT_CACHE_COMPONENTS === 'true' && // We do respect an explicit value in the user config.
(config.cacheComponents === undefined || isDefaultConfig && !config.cacheComponents)) {
config.cacheComponents = true;
}
if (process.env.__NEXT_PARTIAL_PREFETCHING === 'true') {
config.partialPrefetching = true;
}
// TODO: Remove this once cachedNavigations is the default.
if (process.env.__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS === 'true' && // We do respect an explicit value in the user config.
(config.experimental.cachedNavigations === undefined || isDefaultConfig && !config.experimental.cachedNavigations)) {
config.experimental.cachedNavigations = true;
if (configuredExperimentalFeatures) {
addConfiguredExperimentalFeature(configuredExperimentalFeatures, 'cachedNavigations', true, 'enabled by `__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS`');
}
}
// TODO: Remove this once serverComponentsHmrCancellation is the default.
if (process.env.__NEXT_EXPERIMENTAL_SERVER_COMPONENTS_HMR_CANCELLATION === 'true' && // We do respect an explicit value in the user config.
(config.experimental.serverComponentsHmrCancellation === undefined || isDefaultConfig && !config.experimental.serverComponentsHmrCancellation)) {
config.experimental.serverComponentsHmrCancellation = true;
if (configuredExperimentalFeatures) {
addConfiguredExperimentalFeature(configuredExperimentalFeatures, 'serverComponentsHmrCancellation', true, 'enabled by `__NEXT_EXPERIMENTAL_SERVER_COMPONENTS_HMR_CANCELLATION`');
}
}
// Enable cachedNavigations by default when cacheComponents is enabled.
// cachedNavigations relies on Cache Components rendering to do anything
// useful, so the two features are tied together: we only flip the default
// for projects that are already using Cache Components. Done silently —
// we don't report this through `configuredExperimentalFeatures` because
// (a) the existing `cacheComponents` env-var auto-enable above is also
// silent, and (b) reporting it would force every snapshot test that has
// `cacheComponents: true` to take on a new line.
// TODO: Remove this once cachedNavigations is unconditionally the default.
if (config.cacheComponents && (config.experimental.cachedNavigations === undefined || isDefaultConfig && !config.experimental.cachedNavigations)) {
config.experimental.cachedNavigations = true;
}
// TODO: Remove this once strictRouteTypes is the default.
if (process.env.__NEXT_EXPERIMENTAL_STRICT_ROUTE_TYPES === 'true' && // We do respect an explicit value in the user config.
(config.experimental.strictRouteTypes === undefined || isDefaultConfig && !config.experimental.strictRouteTypes)) {
config.experimental.strictRouteTypes = true;
if (configuredExperimentalFeatures) {
addConfiguredExperimentalFeature(configuredExperimentalFeatures, 'strictRouteTypes', true, 'enabled by `__NEXT_EXPERIMENTAL_STRICT_ROUTE_TYPES`');
}
}
if (process.env.__NEXT_EXPERIMENTAL_TRANSITION_INDICATOR === 'true' && // We do respect an explicit value in the user config.
(config.experimental.transitionIndicator === undefined || isDefaultConfig && !config.experimental.transitionIndicator)) {
config.experimental.transitionIndicator = true;
if (configuredExperimentalFeatures) {
addConfiguredExperimentalFeature(configuredExperimentalFeatures, 'transitionIndicator', true, 'enabled by `__NEXT_EXPERIMENTAL_TRANSITION_INDICATOR`');
}
}
if (process.env.__NEXT_ENABLE_REACT_COMPILER === 'true' && // We do respect an explicit value in the user config.
(config.reactCompiler === undefined || isDefaultConfig && !config.reactCompiler)) {
config.reactCompiler = true;
// TODO: Report if we enable non-experimental features via env
}
}
function addConfiguredExperimentalFeature(configuredExperimentalFeatures, key, value, reason) {
if (value !== defaultConfig.experimental[key]) {
configuredExperimentalFeatures.push({
key,
value,
reason
});
}
}
function setExperimentalFeatureForDebugPrerender(experimentalConfig, key, value, configuredExperimentalFeatures) {
if (experimentalConfig[key] !== value) {
experimentalConfig[key] = value;
if (configuredExperimentalFeatures) {
const action = value === true ? 'enabled' : value === false ? 'disabled' : 'set';
const reason = `${action} by \`--debug-prerender\``;
addConfiguredExperimentalFeature(configuredExperimentalFeatures, key, value, reason);
}
}
}
function cloneObject(obj) {
// Primitives & null
if (obj === null || typeof obj !== 'object') {
return obj;
}
// RegExp → clone via constructor
if (obj instanceof RegExp) {
return new RegExp(obj.source, obj.flags);
}
// Function → just reuse the function reference
if (typeof obj === 'function') {
return obj;
}
// Arrays → map each element
if (Array.isArray(obj)) {
return obj.map(cloneObject);
}
// Detect non‑plain objects (class instances)
const proto = Object.getPrototypeOf(obj);
const isPlainObject = proto === Object.prototype || proto === null;
// If it's not a plain object, just return the original
if (!isPlainObject) {
return obj;
}
// Plain object → create a new object with the same prototype
// and copy all properties, cloning data properties and keeping
// accessor properties (getters/setters) as‑is.
const result = Object.create(proto);
for (const key of Reflect.ownKeys(obj)){
const descriptor = Object.getOwnPropertyDescriptor(obj, key);
if (descriptor && (descriptor.get || descriptor.set)) {
// Accessor property → copy descriptor as‑is (get/set functions)
Object.defineProperty(result, key, descriptor);
} else {
// Data property → clone the value
result[key] = cloneObject(obj[key]);
}
}
return result;
}
async function validateConfigSchema(userConfig, configFileName, warn, onValidationMessages) {
// We only validate the config against schema in non minimal mode
const { configSchema } = require('./config-schema');
const state = configSchema.safeParse(userConfig);
if (!state.success) {
const [warnings, fatalErrors] = normalizeNextConfigZodErrors(state.error);
const hasFatalErrors = fatalErrors.length > 0;
// Group warnings first
if (warnings.length > 0) {
const warningMessages = [
`Invalid ${configFileName} options detected: `
];
for (const error of warnings){
warningMessages.push(` ${error.split('\n').join('\n ')}`);
}
warningMessages.push('See more info here: https://nextjs.org/docs/messages/invalid-next-config');
// Call the callback with validation messages if provided
if (onValidationMessages) {
onValidationMessages(warningMessages);
}
for (const message of warningMessages){
warn(message);
}
}
// Then throw hard errors
if (hasFatalErrors) {
await flushTelemetry();
const errorMessages = [
`Fatal next config errors found in ${configFileName} that must be fixed:`
];
for (const error of fatalErrors){
errorMessages.push(` ${error.split('\n').join('\n ')}`);
}
errorMessages.push('These configuration options are required or have been migrated. Please update your configuration.');
errorMessages.push('See more info here: https://nextjs.org/docs/messages/invalid-next-config');
// Call the callback with validation messages if provided
if (onValidationMessages) {
onValidationMessages(errorMessages);
}
const fullErrorMessage = errorMessages.join('\n');
throw new Error(fullErrorMessage);
}
}
}
//# sourceMappingURL=config.js.map