next
Version:
The React Framework
1,015 lines • 78.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = getBaseWebpackConfig;
exports.attachReactRefresh = attachReactRefresh;
exports.resolveExternal = resolveExternal;
exports.nextImageLoaderRegex = exports.NODE_BASE_ESM_RESOLVE_OPTIONS = exports.NODE_ESM_RESOLVE_OPTIONS = exports.NODE_BASE_RESOLVE_OPTIONS = exports.NODE_RESOLVE_OPTIONS = void 0;
var _reactRefreshWebpackPlugin = _interopRequireDefault(require("next/dist/compiled/@next/react-refresh-utils/ReactRefreshWebpackPlugin"));
var _chalk = _interopRequireDefault(require("next/dist/compiled/chalk"));
var _crypto = _interopRequireDefault(require("crypto"));
var _webpack = require("next/dist/compiled/webpack/webpack");
var _path = _interopRequireWildcard(require("path"));
var _escapeRegexp = require("../shared/lib/escape-regexp");
var _constants = require("../lib/constants");
var _fileExists = require("../lib/file-exists");
var _constants1 = require("../shared/lib/constants");
var _utils = require("../shared/lib/utils");
var _entries = require("./entries");
var Log = _interopRequireWildcard(require("./output/log"));
var _config = require("./webpack/config");
var _middlewarePlugin = _interopRequireDefault(require("./webpack/plugins/middleware-plugin"));
var _buildManifestPlugin = _interopRequireDefault(require("./webpack/plugins/build-manifest-plugin"));
var _jsconfigPathsPlugin = require("./webpack/plugins/jsconfig-paths-plugin");
var _nextDropClientPagePlugin = require("./webpack/plugins/next-drop-client-page-plugin");
var _nextTraceEntrypointsPlugin = require("./webpack/plugins/next-trace-entrypoints-plugin");
var _pagesManifestPlugin = _interopRequireDefault(require("./webpack/plugins/pages-manifest-plugin"));
var _profilingPlugin = require("./webpack/plugins/profiling-plugin");
var _reactLoadablePlugin = require("./webpack/plugins/react-loadable-plugin");
var _serverlessPlugin = require("./webpack/plugins/serverless-plugin");
var _wellknownErrorsPlugin = require("./webpack/plugins/wellknown-errors-plugin");
var _css = require("./webpack/config/blocks/css");
var _copyFilePlugin = require("./webpack/plugins/copy-file-plugin");
var _flightManifestPlugin = require("./webpack/plugins/flight-manifest-plugin");
var _telemetryPlugin = require("./webpack/plugins/telemetry-plugin");
var _utils1 = require("./utils");
var _browserslist = _interopRequireDefault(require("next/dist/compiled/browserslist"));
var _loadJsconfig = _interopRequireDefault(require("./load-jsconfig"));
var _middlewareSourceMapsPlugin = require("./webpack/plugins/middleware-source-maps-plugin");
async function getBaseWebpackConfig(dir, { buildId , config , dev =false , isServer =false , isEdgeRuntime =false , pagesDir , target ='server' , reactProductionProfiling =false , entrypoints , rewrites , isDevFallback =false , runWebpackSpan , hasReactRoot }) {
var ref36, ref1, ref2, ref3, ref4, ref5, ref6, ref7, ref8, ref9, ref10, ref11, ref12, ref13, ref14, ref15, ref16, ref17, ref18, ref19, ref20;
const { useTypeScript , jsConfig , resolvedBaseUrl } = await (0, _loadJsconfig).default(dir, config);
const supportedBrowsers = await getSupportedBrowsers(dir, dev);
const hasRewrites = rewrites.beforeFiles.length > 0 || rewrites.afterFiles.length > 0 || rewrites.fallback.length > 0;
const hasReactRefresh = dev && !isServer;
const runtime = config.experimental.runtime;
// Make sure `reactRoot` is enabled when React 18 or experimental is detected.
if (hasReactRoot) {
config.experimental.reactRoot = true;
}
// Only inform during one of the builds
if (!isServer && config.experimental.reactRoot && !hasReactRoot) {
// It's fine to only mention React 18 here as we don't recommend people to try experimental.
Log.warn('You have to use React 18 to use `experimental.reactRoot`.');
}
if (!isServer && runtime && !hasReactRoot) {
throw new Error('`experimental.runtime` requires `experimental.reactRoot` to be enabled along with React 18.');
}
if (config.experimental.serverComponents && !hasReactRoot) {
throw new Error('`experimental.serverComponents` requires React 18 to be installed.');
}
const targetWeb = isEdgeRuntime || !isServer;
const hasConcurrentFeatures = hasReactRoot;
const hasServerComponents = hasConcurrentFeatures && !!config.experimental.serverComponents;
const disableOptimizedLoading = hasConcurrentFeatures ? true : config.experimental.disableOptimizedLoading;
if (!isServer) {
if (runtime === 'edge') {
Log.warn('You are using the experimental Edge Runtime with `experimental.runtime`.');
}
if (runtime === 'nodejs') {
Log.warn('You are using the experimental Node.js Runtime with `experimental.runtime`.');
}
if (hasServerComponents) {
Log.warn('You have experimental React Server Components enabled. Continue at your own risk.');
}
}
const babelConfigFile = await [
'.babelrc',
'.babelrc.json',
'.babelrc.js',
'.babelrc.mjs',
'.babelrc.cjs',
'babel.config.js',
'babel.config.json',
'babel.config.mjs',
'babel.config.cjs',
].reduce(async (memo, filename)=>{
const configFilePath = _path.default.join(dir, filename);
return await memo || (await (0, _fileExists).fileExists(configFilePath) ? configFilePath : undefined);
}, Promise.resolve(undefined));
const distDir = _path.default.join(dir, config.distDir);
let useSWCLoader = !babelConfigFile;
let SWCBinaryTarget = undefined;
if (useSWCLoader) {
var ref21, ref22, ref23;
// TODO: we do not collect wasm target yet
const binaryTarget = (ref21 = require('./swc')) === null || ref21 === void 0 ? void 0 : (ref22 = ref21.getBinaryMetadata) === null || ref22 === void 0 ? void 0 : (ref23 = ref22.call(ref21)) === null || ref23 === void 0 ? void 0 : ref23.target;
SWCBinaryTarget = binaryTarget ? [
`swc/target/${binaryTarget}`,
true
] : undefined;
}
if (!loggedSwcDisabled && !useSWCLoader && babelConfigFile) {
Log.info(`Disabled SWC as replacement for Babel because of custom Babel configuration "${_path.default.relative(dir, babelConfigFile)}" https://nextjs.org/docs/messages/swc-disabled`);
loggedSwcDisabled = true;
}
if (!loggedIgnoredCompilerOptions && !useSWCLoader && config.compiler) {
Log.info('`compiler` options in `next.config.js` will be ignored while using Babel https://nextjs.org/docs/messages/ignored-compiler-options');
loggedIgnoredCompilerOptions = true;
}
const getBabelOrSwcLoader = (isMiddleware)=>{
return useSWCLoader ? {
loader: 'next-swc-loader',
options: {
isServer: isMiddleware || isServer,
pagesDir,
hasReactRefresh: !isMiddleware && hasReactRefresh,
fileReading: config.experimental.swcFileReading,
nextConfig: config,
jsConfig
}
} : {
loader: require.resolve('./babel/loader/index'),
options: {
configFile: babelConfigFile,
isServer: isMiddleware ? true : isServer,
distDir,
pagesDir,
cwd: dir,
development: dev,
hasReactRefresh: isMiddleware ? false : hasReactRefresh,
hasJsxRuntime: true
}
};
};
const defaultLoaders = {
babel: getBabelOrSwcLoader(false)
};
const rawPageExtensions = hasServerComponents ? (0, _utils1).getRawPageExtensions(config.pageExtensions) : config.pageExtensions;
const serverComponentsRegex = new RegExp(`\\.server\\.(${rawPageExtensions.join('|')})$`);
const babelIncludeRegexes = [
/next[\\/]dist[\\/]shared[\\/]lib/,
/next[\\/]dist[\\/]client/,
/next[\\/]dist[\\/]pages/,
/[\\/](strip-ansi|ansi-regex)[\\/]/,
];
// Support for NODE_PATH
const nodePathList = (process.env.NODE_PATH || '').split(process.platform === 'win32' ? ';' : ':').filter((p)=>!!p
);
const isServerless = target === 'serverless';
const isServerlessTrace = target === 'experimental-serverless-trace';
// Intentionally not using isTargetLikeServerless helper
const isLikeServerless = isServerless || isServerlessTrace;
const outputDir = isLikeServerless ? _constants1.SERVERLESS_DIRECTORY : _constants1.SERVER_DIRECTORY;
const outputPath = _path.default.join(distDir, isServer ? outputDir : '');
const totalPages = Object.keys(entrypoints).length;
const clientEntries = !isServer ? {
// Backwards compatibility
'main.js': [],
...dev ? {
[_constants1.CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH]: require.resolve(`next/dist/compiled/@next/react-refresh-utils/runtime`),
[_constants1.CLIENT_STATIC_FILES_RUNTIME_AMP]: `./` + (0, _path).relative(dir, (0, _path).join(_constants.NEXT_PROJECT_ROOT_DIST_CLIENT, 'dev', 'amp-dev')).replace(/\\/g, '/')
} : {},
[_constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN]: `./` + _path.default.relative(dir, _path.default.join(_constants.NEXT_PROJECT_ROOT_DIST_CLIENT, dev ? `next-dev.js` : 'next.js')).replace(/\\/g, '/')
} : undefined;
function getReactProfilingInProduction() {
if (reactProductionProfiling) {
return {
'react-dom$': 'react-dom/profiling',
'scheduler/tracing': 'scheduler/tracing-profiling'
};
}
}
// tell webpack where to look for _app and _document
// using aliases to allow falling back to the default
// version when removed or not present
const clientResolveRewrites = require.resolve('../shared/lib/router/utils/resolve-rewrites');
const customAppAliases = {};
const customErrorAlias = {};
const customDocumentAliases = {};
if (dev) {
customAppAliases[`${_constants.PAGES_DIR_ALIAS}/_app`] = [
...rawPageExtensions.reduce((prev, ext)=>{
prev.push(_path.default.join(pagesDir, `_app.${ext}`));
return prev;
}, []),
'next/dist/pages/_app.js',
];
customAppAliases[`${_constants.PAGES_DIR_ALIAS}/_app.server`] = [
...rawPageExtensions.reduce((prev, ext)=>{
prev.push(_path.default.join(pagesDir, `_app.server.${ext}`));
return prev;
}, []),
'next/dist/pages/_app.server.js',
];
customAppAliases[`${_constants.PAGES_DIR_ALIAS}/_error`] = [
...config.pageExtensions.reduce((prev, ext)=>{
prev.push(_path.default.join(pagesDir, `_error.${ext}`));
return prev;
}, []),
'next/dist/pages/_error.js',
];
customDocumentAliases[`${_constants.PAGES_DIR_ALIAS}/_document`] = [
...config.pageExtensions.reduce((prev, ext)=>{
prev.push(_path.default.join(pagesDir, `_document.${ext}`));
return prev;
}, []),
`next/dist/pages/_document.js`,
];
}
const resolveConfig = {
// Disable .mjs for node_modules bundling
extensions: !targetWeb ? [
'.js',
'.mjs',
...useTypeScript ? [
'.tsx',
'.ts'
] : [],
'.jsx',
'.json',
'.wasm',
] : [
'.mjs',
'.js',
...useTypeScript ? [
'.tsx',
'.ts'
] : [],
'.jsx',
'.json',
'.wasm',
],
modules: [
'node_modules',
...nodePathList
],
alias: {
next: _constants.NEXT_PROJECT_ROOT,
...customAppAliases,
...customErrorAlias,
...customDocumentAliases,
[_constants.PAGES_DIR_ALIAS]: pagesDir,
[_constants.DOT_NEXT_ALIAS]: distDir,
...targetWeb ? getOptimizedAliases() : {},
...getReactProfilingInProduction(),
...targetWeb ? {
[clientResolveRewrites]: hasRewrites ? clientResolveRewrites : false
} : {},
setimmediate: 'next/dist/compiled/setimmediate'
},
...targetWeb ? {
// Full list of old polyfills is accessible here:
// https://github.com/webpack/webpack/blob/2a0536cf510768111a3a6dceeb14cb79b9f59273/lib/ModuleNotFoundError.js#L13-L42
fallback: {
assert: require.resolve('next/dist/compiled/assert'),
buffer: require.resolve('next/dist/compiled/buffer/'),
constants: require.resolve('next/dist/compiled/constants-browserify'),
crypto: require.resolve('next/dist/compiled/crypto-browserify'),
domain: require.resolve('next/dist/compiled/domain-browser'),
http: require.resolve('next/dist/compiled/stream-http'),
https: require.resolve('next/dist/compiled/https-browserify'),
os: require.resolve('next/dist/compiled/os-browserify'),
path: require.resolve('next/dist/compiled/path-browserify'),
punycode: require.resolve('next/dist/compiled/punycode'),
process: require.resolve('./polyfills/process'),
// Handled in separate alias
querystring: require.resolve('next/dist/compiled/querystring-es3'),
stream: require.resolve('next/dist/compiled/stream-browserify'),
string_decoder: require.resolve('next/dist/compiled/string_decoder'),
sys: require.resolve('next/dist/compiled/util/'),
timers: require.resolve('next/dist/compiled/timers-browserify'),
tty: require.resolve('next/dist/compiled/tty-browserify'),
// Handled in separate alias
// url: require.resolve('url/'),
util: require.resolve('next/dist/compiled/util/'),
vm: require.resolve('next/dist/compiled/vm-browserify'),
zlib: require.resolve('next/dist/compiled/browserify-zlib'),
events: require.resolve('next/dist/compiled/events/'),
setImmediate: require.resolve('next/dist/compiled/setimmediate')
}
} : undefined,
mainFields: targetWeb ? (isEdgeRuntime ? [] : [
'browser'
]).concat([
'module',
'main'
]) : [
'main',
'module'
],
plugins: []
};
const terserOptions = {
parse: {
ecma: 8
},
compress: {
ecma: 5,
warnings: false,
// The following two options are known to break valid JavaScript code
comparisons: false,
inline: 2
},
mangle: {
safari10: true
},
output: {
ecma: 5,
safari10: true,
comments: false,
// Fixes usage of Emoji and certain Regex
ascii_only: true
}
};
const isModuleCSS = (module)=>{
return(// mini-css-extract-plugin
module.type === `css/mini-extract` || // extract-css-chunks-webpack-plugin (old)
module.type === `css/extract-chunks` || // extract-css-chunks-webpack-plugin (new)
module.type === `css/extract-css-chunks`);
};
// Packages which will be split into the 'framework' chunk.
// Only top-level packages are included, e.g. nested copies like
// 'node_modules/meow/node_modules/object-assign' are not included.
const topLevelFrameworkPaths = [];
const visitedFrameworkPackages = new Set();
// Adds package-paths of dependencies recursively
const addPackagePath = (packageName, relativeToPath)=>{
try {
if (visitedFrameworkPackages.has(packageName)) {
return;
}
visitedFrameworkPackages.add(packageName);
const packageJsonPath = require.resolve(`${packageName}/package.json`, {
paths: [
relativeToPath
]
});
// Include a trailing slash so that a `.startsWith(packagePath)` check avoids false positives
// when one package name starts with the full name of a different package.
// For example:
// "node_modules/react-slider".startsWith("node_modules/react") // true
// "node_modules/react-slider".startsWith("node_modules/react/") // false
const directory = _path.default.join(packageJsonPath, '../');
// Returning from the function in case the directory has already been added and traversed
if (topLevelFrameworkPaths.includes(directory)) return;
topLevelFrameworkPaths.push(directory);
const dependencies = require(packageJsonPath).dependencies || {};
for (const name of Object.keys(dependencies)){
addPackagePath(name, directory);
}
} catch (_) {
// don't error on failing to resolve framework packages
}
};
for (const packageName1 of [
'react',
'react-dom'
]){
addPackagePath(packageName1, dir);
}
// Select appropriate SplitChunksPlugin config for this build
const splitChunksConfig = dev ? false : {
// Keep main and _app chunks unsplitted in webpack 5
// as we don't need a separate vendor chunk from that
// and all other chunk depend on them so there is no
// duplication that need to be pulled out.
chunks: (chunk)=>!/^(polyfills|main|pages\/_app)$/.test(chunk.name) && !_constants.MIDDLEWARE_ROUTE.test(chunk.name)
,
cacheGroups: {
framework: {
chunks: (chunk)=>{
var ref;
return !((ref = chunk.name) === null || ref === void 0 ? void 0 : ref.match(_constants.MIDDLEWARE_ROUTE));
},
name: 'framework',
test (module) {
const resource = module.nameForCondition && module.nameForCondition();
if (!resource) {
return false;
}
return topLevelFrameworkPaths.some((packagePath)=>resource.startsWith(packagePath)
);
},
priority: 40,
// Don't let webpack eliminate this chunk (prevents this chunk from
// becoming a part of the commons chunk)
enforce: true
},
lib: {
test (module) {
return module.size() > 160000 && /node_modules[/\\]/.test(module.nameForCondition() || '');
},
name (module) {
const hash = _crypto.default.createHash('sha1');
if (isModuleCSS(module)) {
module.updateHash(hash);
} else {
if (!module.libIdent) {
throw new Error(`Encountered unknown module type: ${module.type}. Please open an issue.`);
}
hash.update(module.libIdent({
context: dir
}));
}
return hash.digest('hex').substring(0, 8);
},
priority: 30,
minChunks: 1,
reuseExistingChunk: true
},
middleware: {
chunks: (chunk)=>{
var ref;
return (ref = chunk.name) === null || ref === void 0 ? void 0 : ref.match(_constants.MIDDLEWARE_ROUTE);
},
filename: 'server/middleware-chunks/[name].js',
minChunks: 2,
enforce: true
}
},
maxInitialRequests: 25,
minSize: 20000
};
const crossOrigin = config.crossOrigin;
const looseEsmExternals = ((ref36 = config.experimental) === null || ref36 === void 0 ? void 0 : ref36.esmExternals) === 'loose';
async function handleExternals(context, request, dependencyType, getResolve) {
// We need to externalize internal requests for files intended to
// not be bundled.
const isLocal = request.startsWith('.') || // Always check for unix-style path, as webpack sometimes
// normalizes as posix.
_path.default.posix.isAbsolute(request) || // When on Windows, we also want to check for Windows-specific
// absolute paths.
(process.platform === 'win32' && _path.default.win32.isAbsolute(request));
// make sure import "next" shows a warning when imported
// in pages/components
if (request === 'next') {
return `commonjs next/dist/lib/import-next-warning`;
}
// Relative requires don't need custom resolution, because they
// are relative to requests we've already resolved here.
// Absolute requires (require('/foo')) are extremely uncommon, but
// also have no need for customization as they're already resolved.
if (!isLocal) {
if (/^(?:next$|react(?:$|\/))/.test(request)) {
return `commonjs ${request}`;
}
const notExternalModules = /^(?:private-next-pages\/|next\/(?:dist\/pages\/|(?:app|document|link|image|constants|dynamic)$)|string-hash$)/;
if (notExternalModules.test(request)) {
return;
}
}
// When in esm externals mode, and using import, we resolve with
// ESM resolving options.
const isEsmRequested = dependencyType === 'esm';
const isLocalCallback = (localRes)=>{
// Makes sure dist/shared and dist/server are not bundled
// we need to process shared `router/router` and `dynamic`,
// so that the DefinePlugin can inject process.env values
const isNextExternal = /next[/\\]dist[/\\](shared|server)[/\\](?!lib[/\\](router[/\\]router|dynamic))/.test(localRes);
if (isNextExternal) {
// Generate Next.js external import
const externalRequest = _path.default.posix.join('next', 'dist', _path.default.relative(// Root of Next.js package:
_path.default.join(__dirname, '..'), localRes)// Windows path normalization
.replace(/\\/g, '/'));
return `commonjs ${externalRequest}`;
} else {
// We don't want to retry local requests
// with other preferEsm options
return;
}
};
const resolveResult = await resolveExternal(dir, config.experimental.esmExternals, context, request, isEsmRequested, getResolve, isLocal ? isLocalCallback : undefined);
if ('localRes' in resolveResult) {
return resolveResult.localRes;
}
const { res , isEsm } = resolveResult;
// If the request cannot be resolved we need to have
// webpack "bundle" it so it surfaces the not found error.
if (!res) {
return;
}
// ESM externals can only be imported (and not required).
// Make an exception in loose mode.
if (!isEsmRequested && isEsm && !looseEsmExternals) {
throw new Error(`ESM packages (${request}) need to be imported. Use 'import' to reference the package instead. https://nextjs.org/docs/messages/import-esm-externals`);
}
const externalType = isEsm ? 'module' : 'commonjs';
if (res.match(/next[/\\]dist[/\\]shared[/\\](?!lib[/\\]router[/\\]router)/) || res.match(/next[/\\]dist[/\\]compiled[/\\].*\.[mc]?js$/)) {
return `${externalType} ${request}`;
}
// Default pages have to be transpiled
if (res.match(/[/\\]next[/\\]dist[/\\]/) || // This is the @babel/plugin-transform-runtime "helpers: true" option
res.match(/node_modules[/\\]@babel[/\\]runtime[/\\]/)) {
return;
}
// Webpack itself has to be compiled because it doesn't always use module relative paths
if (res.match(/node_modules[/\\]webpack/) || res.match(/node_modules[/\\]css-loader/)) {
return;
}
// Anything else that is standard JavaScript within `node_modules`
// can be externalized.
if (/node_modules[/\\].*\.[mc]?js$/.test(res)) {
return `${externalType} ${request}`;
}
// Default behavior: bundle the code!
}
const codeCondition = {
test: /\.(tsx|ts|js|cjs|mjs|jsx)$/,
...config.experimental.externalDir ? {} : {
include: [
dir,
...babelIncludeRegexes
]
},
exclude: (excludePath)=>{
if (babelIncludeRegexes.some((r)=>r.test(excludePath)
)) {
return false;
}
return /node_modules/.test(excludePath);
}
};
const rscCodeCondition = {
test: serverComponentsRegex,
// only apply to the pages as the begin process of rsc loaders
include: [
dir,
/next[\\/]dist[\\/]pages/
]
};
let webpackConfig = {
parallelism: Number(process.env.NEXT_WEBPACK_PARALLELISM) || undefined,
externals: targetWeb ? // bundles in case a user imported types and it wasn't removed
// TODO: should we warn/error for this instead?
[
'next',
...isEdgeRuntime ? [
{
'@builder.io/partytown': '{}',
'next/dist/compiled/etag': '{}',
'next/dist/compiled/chalk': '{}',
'react-dom': '{}'
},
] : [],
] : !isServerless ? [
({ context , request , dependencyType , getResolve })=>{
return handleExternals(context, request, dependencyType, (options)=>{
const resolveFunction = getResolve(options);
return (resolveContext, requestToResolve)=>{
return new Promise((resolve, reject)=>{
resolveFunction(resolveContext, requestToResolve, (err, result, resolveData)=>{
var ref;
if (err) return reject(err);
if (!result) return resolve([
null,
false
]);
const isEsm = /\.js$/i.test(result) ? (resolveData === null || resolveData === void 0 ? void 0 : (ref = resolveData.descriptionFileData) === null || ref === void 0 ? void 0 : ref.type) === 'module' : /\.mjs$/i.test(result);
resolve([
result,
isEsm
]);
});
});
};
});
},
] : [
// When the 'serverless' target is used all node_modules will be compiled into the output bundles
// So that the 'serverless' bundles have 0 runtime dependencies
'next/dist/compiled/@ampproject/toolbox-optimizer',
// Mark this as external if not enabled so it doesn't cause a
// webpack error from being missing
...config.experimental.optimizeCss ? [] : [
'critters'
],
],
optimization: {
// @ts-ignore: TODO remove ts-ignore when webpack 4 is removed
emitOnErrors: !dev,
checkWasmTypes: false,
nodeEnv: false,
...hasServerComponents ? {
// We have to use the names here instead of hashes to ensure the consistency between builds.
moduleIds: 'named'
} : {},
splitChunks: isServer ? dev ? false : {
filename: isEdgeRuntime ? 'chunks/[name].js' : '[name].js',
// allow to split entrypoints
chunks: ({ name })=>{
return !(name === null || name === void 0 ? void 0 : name.match(_constants.MIDDLEWARE_ROUTE));
},
// size of files is not so relevant for server build
// we want to prefer deduplication to load less code
minSize: 1000
} : splitChunksConfig,
runtimeChunk: isServer ? undefined : {
name: _constants1.CLIENT_STATIC_FILES_RUNTIME_WEBPACK
},
minimize: !dev && targetWeb,
minimizer: [
// Minify JavaScript
(compiler)=>{
// @ts-ignore No typings yet
const { TerserPlugin , } = require('./webpack/plugins/terser-webpack-plugin/src/index.js');
new TerserPlugin({
cacheDir: _path.default.join(distDir, 'cache', 'next-minifier'),
parallel: config.experimental.cpus,
swcMinify: config.swcMinify,
terserOptions
}).apply(compiler);
},
// Minify CSS
(compiler)=>{
const { CssMinimizerPlugin , } = require('./webpack/plugins/css-minimizer-plugin');
new CssMinimizerPlugin({
postcssOptions: {
map: {
// `inline: false` generates the source map in a separate file.
// Otherwise, the CSS file is needlessly large.
inline: false,
// `annotation: false` skips appending the `sourceMappingURL`
// to the end of the CSS file. Webpack already handles this.
annotation: false
}
}
}).apply(compiler);
},
]
},
context: dir,
// Kept as function to be backwards compatible
// @ts-ignore TODO webpack 5 typings needed
entry: async ()=>{
return {
...clientEntries ? clientEntries : {},
...entrypoints
};
},
watchOptions,
output: {
// we must set publicPath to an empty value to override the default of
// auto which doesn't work in IE11
publicPath: `${config.assetPrefix || ''}/_next/`,
path: isServer && !dev && !isEdgeRuntime ? _path.default.join(outputPath, 'chunks') : outputPath,
// On the server we don't use hashes
filename: isServer ? !dev && !isEdgeRuntime ? `../[name].js` : `[name].js` : `static/chunks/${isDevFallback ? 'fallback/' : ''}[name]${dev ? '' : '-[contenthash]'}.js`,
library: targetWeb ? '_N_E' : undefined,
libraryTarget: targetWeb ? 'assign' : 'commonjs2',
hotUpdateChunkFilename: 'static/webpack/[id].[fullhash].hot-update.js',
hotUpdateMainFilename: 'static/webpack/[fullhash].[runtime].hot-update.json',
// This saves chunks with the name given via `import()`
chunkFilename: isServer ? '[name].js' : `static/chunks/${isDevFallback ? 'fallback/' : ''}${dev ? '[name]' : '[name].[contenthash]'}.js`,
strictModuleExceptionHandling: true,
crossOriginLoading: crossOrigin,
webassemblyModuleFilename: 'static/wasm/[modulehash].wasm',
hashFunction: 'xxhash64',
hashDigestLength: 16
},
performance: false,
resolve: resolveConfig,
resolveLoader: {
// The loaders Next.js provides
alias: [
'error-loader',
'next-swc-loader',
'next-client-pages-loader',
'next-image-loader',
'next-serverless-loader',
'next-style-loader',
'next-flight-client-loader',
'next-flight-server-loader',
'noop-loader',
'next-middleware-loader',
'next-middleware-ssr-loader',
'next-middleware-wasm-loader',
].reduce((alias, loader)=>{
// using multiple aliases to replace `resolveLoader.modules`
alias[loader] = _path.default.join(__dirname, 'webpack', 'loaders', loader);
return alias;
}, {}),
modules: [
'node_modules',
...nodePathList
],
plugins: []
},
module: {
rules: [
// TODO: FIXME: do NOT webpack 5 support with this
// x-ref: https://github.com/webpack/webpack/issues/11467
...!config.experimental.fullySpecified ? [
{
test: /\.m?js/,
resolve: {
fullySpecified: false
}
},
] : [],
...hasServerComponents ? isServer ? [
// RSC server compilation loaders
{
...rscCodeCondition,
use: {
loader: 'next-flight-server-loader',
options: {
extensions: rawPageExtensions
}
}
},
] : [
// RSC client compilation loaders
{
...rscCodeCondition,
use: {
loader: 'next-flight-server-loader',
options: {
client: 1,
extensions: rawPageExtensions
}
}
},
] : [],
{
test: /\.(js|cjs|mjs)$/,
issuerLayer: 'api',
parser: {
// Switch back to normal URL handling
url: true
}
},
{
oneOf: [
{
...codeCondition,
issuerLayer: 'api',
parser: {
// Switch back to normal URL handling
url: true
},
use: defaultLoaders.babel
},
{
...codeCondition,
issuerLayer: 'middleware',
use: getBabelOrSwcLoader(true)
},
{
...codeCondition,
use: hasReactRefresh ? [
require.resolve('next/dist/compiled/@next/react-refresh-utils/loader'),
defaultLoaders.babel,
] : defaultLoaders.babel
},
]
},
...!config.images.disableStaticImages ? [
{
test: nextImageLoaderRegex,
loader: 'next-image-loader',
issuer: {
not: _css.regexLikeCss
},
dependency: {
not: [
'url'
]
},
options: {
isServer,
isDev: dev,
basePath: config.basePath,
assetPrefix: config.assetPrefix
}
},
] : [],
].filter(Boolean)
},
plugins: [
...!dev && !isServer && !!config.experimental.middlewareSourceMaps && !config.productionBrowserSourceMaps ? (0, _middlewareSourceMapsPlugin).getMiddlewareSourceMapPlugins() : [],
hasReactRefresh && new _reactRefreshWebpackPlugin.default(_webpack.webpack),
// Makes sure `Buffer` and `process` are polyfilled in client and flight bundles (same behavior as webpack 4)
targetWeb && new _webpack.webpack.ProvidePlugin({
// Buffer is used by getInlineScriptSource
Buffer: [
require.resolve('buffer'),
'Buffer'
],
// Avoid process being overridden when in web run time
...!isServer && {
process: [
require.resolve('process')
]
}
}),
new _webpack.webpack.DefinePlugin({
...Object.keys(process.env).reduce((prev, key)=>{
if (key.startsWith('NEXT_PUBLIC_')) {
prev[`process.env.${key}`] = JSON.stringify(process.env[key]);
}
return prev;
}, {}),
...Object.keys(config.env).reduce((acc, key)=>{
if (/^(?:NODE_.+)|^(?:__.+)$/i.test(key)) {
throw new Error(`The key "${key}" under "env" in ${config.configFileName} is not allowed. https://nextjs.org/docs/messages/env-key-not-allowed`);
}
return {
...acc,
[`process.env.${key}`]: JSON.stringify(config.env[key])
};
}, {}),
// TODO: enforce `NODE_ENV` on `process.env`, and add a test:
'process.env.NODE_ENV': JSON.stringify(dev ? 'development' : 'production'),
'process.env.__NEXT_CROSS_ORIGIN': JSON.stringify(crossOrigin),
'process.browser': JSON.stringify(targetWeb),
'process.env.__NEXT_TEST_MODE': JSON.stringify(process.env.__NEXT_TEST_MODE),
// This is used in client/dev-error-overlay/hot-dev-client.js to replace the dist directory
...dev && !isServer ? {
'process.env.__NEXT_DIST_DIR': JSON.stringify(distDir)
} : {},
'process.env.__NEXT_TRAILING_SLASH': JSON.stringify(config.trailingSlash),
'process.env.__NEXT_BUILD_INDICATOR': JSON.stringify(config.devIndicators.buildActivity),
'process.env.__NEXT_BUILD_INDICATOR_POSITION': JSON.stringify(config.devIndicators.buildActivityPosition),
'process.env.__NEXT_PLUGINS': JSON.stringify(config.experimental.plugins),
'process.env.__NEXT_STRICT_MODE': JSON.stringify(config.reactStrictMode),
'process.env.__NEXT_REACT_ROOT': JSON.stringify(hasReactRoot),
'process.env.__NEXT_CONCURRENT_FEATURES': JSON.stringify(hasConcurrentFeatures),
'process.env.__NEXT_RSC': JSON.stringify(hasServerComponents),
'process.env.__NEXT_OPTIMIZE_FONTS': JSON.stringify(config.optimizeFonts && !dev),
'process.env.__NEXT_OPTIMIZE_CSS': JSON.stringify(config.experimental.optimizeCss && !dev),
'process.env.__NEXT_SCRIPT_WORKERS': JSON.stringify(config.experimental.nextScriptWorkers && !dev),
'process.env.__NEXT_SCROLL_RESTORATION': JSON.stringify(config.experimental.scrollRestoration),
'process.env.__NEXT_IMAGE_OPTS': JSON.stringify({
deviceSizes: config.images.deviceSizes,
imageSizes: config.images.imageSizes,
path: config.images.path,
loader: config.images.loader,
experimentalLayoutRaw: (ref1 = config.experimental) === null || ref1 === void 0 ? void 0 : (ref2 = ref1.images) === null || ref2 === void 0 ? void 0 : ref2.layoutRaw,
...dev ? {
// pass domains in development to allow validating on the client
domains: config.images.domains
} : {}
}),
'process.env.__NEXT_ROUTER_BASEPATH': JSON.stringify(config.basePath),
'process.env.__NEXT_HAS_REWRITES': JSON.stringify(hasRewrites),
'process.env.__NEXT_I18N_SUPPORT': JSON.stringify(!!config.i18n),
'process.env.__NEXT_I18N_DOMAINS': JSON.stringify((ref3 = config.i18n) === null || ref3 === void 0 ? void 0 : ref3.domains),
'process.env.__NEXT_ANALYTICS_ID': JSON.stringify(config.analyticsId),
...isServer ? {
// Fix bad-actors in the npm ecosystem (e.g. `node-formidable`)
// This is typically found in unmaintained modules from the
// pre-webpack era (common in server-side code)
'global.GENTLY': JSON.stringify(false)
} : undefined,
// stub process.env with proxy to warn a missing value is
// being accessed in development mode
...config.experimental.pageEnv && dev ? {
'process.env': `
new Proxy(${!targetWeb ? 'process.env' : '{}'}, {
get(target, prop) {
if (typeof target[prop] === 'undefined') {
console.warn(\`An environment variable (\${prop}) that was not provided in the environment was accessed.\nSee more info here: https://nextjs.org/docs/messages/missing-env-value\`)
}
return target[prop]
}
})
`
} : {}
}),
!isServer && new _reactLoadablePlugin.ReactLoadablePlugin({
filename: _constants1.REACT_LOADABLE_MANIFEST,
pagesDir,
runtimeAsset: hasConcurrentFeatures ? `server/${_constants1.MIDDLEWARE_REACT_LOADABLE_MANIFEST}.js` : undefined,
dev
}),
targetWeb && new _nextDropClientPagePlugin.DropClientPage(),
config.outputFileTracing && !isLikeServerless && isServer && !dev && new _nextTraceEntrypointsPlugin.TraceEntryPointsPlugin({
appDir: dir,
esmExternals: config.experimental.esmExternals,
staticImageImports: !config.images.disableStaticImages,
outputFileTracingRoot: config.experimental.outputFileTracingRoot
}),
// Moment.js is an extremely popular library that bundles large locale files
// by default due to how Webpack interprets its code. This is a practical
// solution that requires the user to opt into importing specific locales.
// https://github.com/jmblog/how-to-optimize-momentjs-with-webpack
config.excludeDefaultMomentLocales && new _webpack.webpack.IgnorePlugin({
resourceRegExp: /^\.\/locale$/,
contextRegExp: /moment$/
}),
...dev ? (()=>{
// Even though require.cache is server only we have to clear assets from both compilations
// This is because the client compilation generates the build manifest that's used on the server side
const { NextJsRequireCacheHotReloader , } = require('./webpack/plugins/nextjs-require-cache-hot-reloader');
const devPlugins = [
new NextJsRequireCacheHotReloader()
];
if (targetWeb) {
devPlugins.push(new _webpack.webpack.HotModuleReplacementPlugin());
}
return devPlugins;
})() : [],
!dev && new _webpack.webpack.IgnorePlugin({
resourceRegExp: /react-is/,
contextRegExp: /next[\\/]dist[\\/]/
}),
(isServerless && isServer || isEdgeRuntime) && new _serverlessPlugin.ServerlessPlugin(),
isServer && new _pagesManifestPlugin.default({
serverless: isLikeServerless,
dev,
isEdgeRuntime
}),
// MiddlewarePlugin should be after DefinePlugin so NEXT_PUBLIC_*
// replacement is done before its process.env.* handling
(!isServer || isEdgeRuntime) && new _middlewarePlugin.default({
dev,
isEdgeRuntime
}),
!isServer && new _buildManifestPlugin.default({
buildId,
rewrites,
isDevFallback,
exportRuntime: hasConcurrentFeatures
}),
new _profilingPlugin.ProfilingPlugin({
runWebpackSpan
}),
config.optimizeFonts && !dev && isServer && !isEdgeRuntime && function() {
const { FontStylesheetGatheringPlugin } = require('./webpack/plugins/font-stylesheet-gathering-plugin');
return new FontStylesheetGatheringPlugin({
isLikeServerless
});
}(),
new _wellknownErrorsPlugin.WellKnownErrorsPlugin(),
!isServer && new _copyFilePlugin.CopyFilePlugin({
filePath: require.resolve('./polyfills/polyfill-nomodule'),
cacheKey: "12.1.6-canary.0",
name: `static/chunks/polyfills${dev ? '' : '-[hash]'}.js`,
minimize: false,
info: {
[_constants1.CLIENT_STATIC_FILES_RUNTIME_POLYFILLS_SYMBOL]: 1,
// This file is already minified
minimized: true
}
}),
hasServerComponents && !isServer && new _flightManifestPlugin.FlightManifestPlugin({
dev,
pageExtensions: rawPageExtensions
}),
!dev && !isServer && new _telemetryPlugin.TelemetryPlugin(new Map([
[
'swcLoader',
useSWCLoader
],
[
'swcMinify',
config.swcMinify
],
[
'swcRelay',
!!((ref4 = config.compiler) === null || ref4 === void 0 ? void 0 : ref4.relay)
],
[
'swcStyledComponents',
!!((ref5 = config.compiler) === null || ref5 === void 0 ? void 0 : ref5.styledComponents)
],
[
'swcReactRemoveProperties',
!!((ref6 = config.compiler) === null || ref6 === void 0 ? void 0 : ref6.reactRemoveProperties),
],
[
'swcExperimentalDecorators',
!!(jsConfig === null || jsConfig === void 0 ? void 0 : (ref7 = jsConfig.compilerOptions) === null || ref7 === void 0 ? void 0 : ref7.experimentalDecorators),
],
[
'swcRemoveConsole',
!!((ref8 = config.compiler) === null || ref8 === void 0 ? void 0 : ref8.removeConsole)
],
[
'swcImportSource',
!!(jsConfig === null || jsConfig === void 0 ? void 0 : (ref9 = jsConfig.compilerOptions) === null || ref9 === void 0 ? void 0 : ref9.jsxImportSource)
],
[
'swcEmotion',
!!config.experimental.emotion
],
SWCBinaryTarget,
].filter(Boolean))),
].filter(Boolean)
};
// Support tsconfig and jsconfig baseUrl
if (resolvedBaseUrl) {
var ref24, ref25;
(ref24 = webpackConfig.resolve) === null || ref24 === void 0 ? void 0 : (ref25 = ref24.modules) === null || ref25 === void 0 ? void 0 : ref25.push(resolvedBaseUrl);
}
if ((jsConfig === null || jsConfig === void 0 ? void 0 : (ref10 = jsConfig.compilerOptions) === null || ref10 === void 0 ? void 0 : ref10.paths) && resolvedBaseUrl) {
var ref26, ref27;
(ref26 = webpackConfig.resolve) === null || ref26 === void 0 ? void 0 : (ref27 = ref26.plugins) === null || ref27 === void 0 ? void 0 : ref27.unshift(new _jsconfigPathsPlugin.JsConfigPathsPlugin(jsConfig.compilerOptions.paths, resolvedBaseUrl));
}
const webpack5Config = webpackConfig;
(ref11 = webpack5Config.module) === null || ref11 === void 0 ? void 0 : (ref12 = ref11.rules) === null || ref12 === void 0 ? void 0 : ref12.unshift({
test: /\.wasm$/,
issuerLayer: 'middleware',
loader: 'next-middleware-wasm-loader',
type: 'javascript/auto',
resourceQuery: /module/i
});
webpack5Config.experiments = {
layers: true,
cacheUnaffected: true,
buildHttp: Array.isArray(config.experimental.urlImports) ? {
allowedUris: config.experimental.urlImports,
cacheLocation: _path.default.join(dir, 'next.lock/data'),
lockfileLocation: _path.default.