next
Version:
The React Framework
978 lines • 87.5 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/dist/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 = _interopRequireWildcard(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 _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 _flightClientEntryPlugin = require("./webpack/plugins/flight-client-entry-plugin");
var _utils1 = require("./utils");
var _browserslist = _interopRequireDefault(require("next/dist/compiled/browserslist"));
var _loadJsconfig = _interopRequireDefault(require("./load-jsconfig"));
var _swc = require("./swc");
var _utils2 = require("./webpack/loaders/utils");
var _appBuildManifestPlugin = require("./webpack/plugins/app-build-manifest-plugin");
async function getBaseWebpackConfig(dir, { buildId , config , compilerType , dev =false , entrypoints , hasReactRoot , isDevFallback =false , pagesDir , reactProductionProfiling =false , rewrites , runWebpackSpan , target ="server" , appDir , middlewareRegex }) {
var ref47, ref1, ref2, ref3, ref4, ref5, ref6, ref7, ref8, ref9, ref10, ref11, ref12, ref13, ref14, ref15, ref16, ref17, ref18, ref19, ref20, ref21, ref22, ref23, ref24;
const isClient = compilerType === "client";
const isEdgeServer = compilerType === "edge-server";
const isNodeServer = compilerType === "server";
const { useTypeScript , jsConfig , resolvedBaseUrl } = await (0, _loadJsconfig).default(dir, config);
const supportedBrowsers = await getSupportedBrowsers(dir, dev, config);
const hasRewrites = rewrites.beforeFiles.length > 0 || rewrites.afterFiles.length > 0 || rewrites.fallback.length > 0;
if (isClient && !hasReactRoot) {
if (config.experimental.runtime) {
throw new Error("`experimental.runtime` requires React 18 to be installed.");
}
if (config.experimental.serverComponents) {
throw new Error("`experimental.serverComponents` requires React 18 to be installed.");
}
}
const hasConcurrentFeatures = hasReactRoot;
const hasServerComponents = hasConcurrentFeatures && !!config.experimental.serverComponents;
const disableOptimizedLoading = hasConcurrentFeatures ? true : config.experimental.disableOptimizedLoading;
if (isClient) {
if (config.experimental.runtime === _constants.SERVER_RUNTIME.edge) {
Log.warn("You are using the experimental Edge Runtime with `experimental.runtime`.");
}
if (config.experimental.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 || config.experimental.forceSwcTransforms;
let SWCBinaryTarget = undefined;
if (useSWCLoader) {
var ref25, ref26;
// TODO: we do not collect wasm target yet
const binaryTarget = (ref25 = require("./swc")) == null ? void 0 : ref25.getBinaryMetadata == null ? void 0 : (ref26 = ref25.getBinaryMetadata()) == null ? void 0 : ref26.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;
}
// eagerly load swc bindings instead of waiting for transform calls
if (!babelConfigFile && isClient) {
await (0, _swc).loadBindings();
}
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 = ()=>{
var ref;
if (useSWCLoader && (config == null ? void 0 : (ref = config.experimental) == null ? void 0 : ref.swcTraceProfiling)) {
var // This will init subscribers once only in a single process lifecycle,
// even though it can be called multiple times.
// Subscriber need to be initialized _before_ any actual swc's call (transform, etcs)
// to collect correct trace spans when they are called.
ref45;
(ref45 = require("./swc")) == null ? void 0 : ref45.initCustomTraceSubscriber == null ? void 0 : ref45.initCustomTraceSubscriber(_path.default.join(distDir, `swc-trace-profile-${Date.now()}.json`));
}
var ref46;
return useSWCLoader ? {
loader: "next-swc-loader",
options: {
isServer: isNodeServer || isEdgeServer,
pagesDir,
hasReactRefresh: dev && isClient,
fileReading: config.experimental.swcFileReading,
nextConfig: config,
jsConfig,
supportedBrowsers: config.experimental.browsersListForSwc ? supportedBrowsers : undefined,
swcCacheDir: _path.default.join(dir, (ref46 = config == null ? void 0 : config.distDir) != null ? ref46 : ".next", "cache", "swc")
}
} : {
loader: require.resolve("./babel/loader/index"),
options: {
configFile: babelConfigFile,
isServer: isNodeServer || isEdgeServer,
distDir,
pagesDir,
cwd: dir,
development: dev,
hasReactRefresh: dev && isClient,
hasJsxRuntime: true
}
};
};
const defaultLoaders = {
babel: getBabelOrSwcLoader()
};
const rawPageExtensions = hasServerComponents ? (0, _utils1).withoutRSCExtensions(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);
// Intentionally not using isTargetLikeServerless helper
const isLikeServerless = target === "serverless" || target === "experimental-serverless-trace";
const outputPath = isNodeServer || isEdgeServer ? _path.default.join(distDir, isLikeServerless ? _constants1.SERVERLESS_DIRECTORY : _constants1.SERVER_DIRECTORY) : distDir;
const clientEntries = isClient ? {
// Backwards compatibility
"main.js": [],
...dev ? {
[_constants1.CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH]: require.resolve(`next/dist/compiled/@next/react-refresh-utils/dist/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, "/"),
...config.experimental.appDir ? {
[_constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN_APP]: dev ? [
require.resolve(`next/dist/compiled/@next/react-refresh-utils/dist/runtime`),
`./` + _path.default.relative(dir, _path.default.join(_constants.NEXT_PROJECT_ROOT_DIST_CLIENT, "app-next-dev.js")).replace(/\\/g, "/"),
] : `./` + _path.default.relative(dir, _path.default.join(_constants.NEXT_PROJECT_ROOT_DIST_CLIENT, "app-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 = {};
const customRootAliases = {};
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}/_error`] = [
...rawPageExtensions.reduce((prev, ext)=>{
prev.push(_path.default.join(pagesDir, `_error.${ext}`));
return prev;
}, []),
"next/dist/pages/_error.js",
];
customDocumentAliases[`${_constants.PAGES_DIR_ALIAS}/_document`] = [
...rawPageExtensions.reduce((prev, ext)=>{
prev.push(_path.default.join(pagesDir, `_document.${ext}`));
return prev;
}, []),
`next/dist/pages/_document.js`,
];
}
const reactDir = (0, _path).dirname(require.resolve("react/package.json"));
const reactDomDir = (0, _path).dirname(require.resolve("react-dom/package.json"));
const mainFieldsPerCompiler = {
server: [
"main",
"module"
],
client: [
"browser",
"module",
"main"
],
"edge-server": [
"browser",
"module",
"main"
]
};
const resolveConfig = {
// Disable .mjs for node_modules bundling
extensions: isNodeServer ? [
".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,
react: `${reactDir}`,
"react-dom$": `${reactDomDir}`,
"react-dom/server$": `${reactDomDir}/server`,
"react-dom/server.browser$": `${reactDomDir}/server.browser`,
"react-dom/client$": `${reactDomDir}/client`,
"styled-jsx/style$": require.resolve(`next/dist/styled-jsx/style`),
"styled-jsx$": require.resolve(`next/dist/styled-jsx`),
...customAppAliases,
...customErrorAlias,
...customDocumentAliases,
...customRootAliases,
[_constants.PAGES_DIR_ALIAS]: pagesDir,
...appDir ? {
[_constants.APP_DIR_ALIAS]: appDir
} : {},
[_constants.ROOT_DIR_ALIAS]: dir,
[_constants.DOT_NEXT_ALIAS]: distDir,
...isClient || isEdgeServer ? getOptimizedAliases() : {},
...getReactProfilingInProduction(),
...isClient || isEdgeServer ? {
[clientResolveRewrites]: hasRewrites ? clientResolveRewrites : false
} : {},
"@swc/helpers": _path.default.dirname(require.resolve("@swc/helpers/package.json")),
setimmediate: "next/dist/compiled/setimmediate"
},
...isClient || isEdgeServer ? {
fallback: {
process: require.resolve("./polyfills/process")
}
} : undefined,
mainFields: mainFieldsPerCompiler[compilerType],
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);
}
const crossOrigin = config.crossOrigin;
const looseEsmExternals = ((ref47 = config.experimental) == null ? void 0 : ref47.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|future\/image|constants|dynamic|script)$)|string-hash$)/;
if (notExternalModules.test(request)) {
return;
}
}
// @swc/helpers should not be external as it would
// require hoisting the package which we can't rely on
if (request.includes("@swc/helpers")) {
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/styled-jsx, 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[/\\](styled-jsx|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 serverComponentCodeCondition = {
test: serverComponentsRegex,
include: [
dir,
/next[\\/]dist[\\/]pages/
]
};
const rscSharedRegex = /(node_modules\/react\/|\/shared\/lib\/(head-manager-context|router-context|flush-effects)\.js|node_modules\/styled-jsx\/)/;
let webpackConfig = {
parallelism: Number(process.env.NEXT_WEBPACK_PARALLELISM) || undefined,
// @ts-ignore
externals: isClient || isEdgeServer ? // bundles in case a user imported types and it wasn't removed
// TODO: should we warn/error for this instead?
[
"next",
...isEdgeServer ? [
{
"@builder.io/partytown": "{}",
"next/dist/compiled/etag": "{}",
"next/dist/compiled/chalk": "{}",
"react-dom": "{}"
},
_middlewarePlugin.handleWebpackExtenalForEdgeRuntime,
] : [],
] : target !== "serverless" ? [
({ 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 ? void 0 : (ref = resolveData.descriptionFileData) == null ? 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 compilers.
moduleIds: isClient ? "deterministic" : "named"
} : {},
splitChunks: (()=>{
// For the edge runtime, we have to bundle all dependencies inside without dynamic `require`s.
// To make some dependencies like `react` to be shared between entrypoints, we use a special
// cache group here even under dev mode.
const edgeRSCCacheGroups = hasServerComponents ? {
rscDeps: {
enforce: true,
name: "rsc-runtime-deps",
filename: "rsc-runtime-deps.js",
test: rscSharedRegex
}
} : undefined;
if (isEdgeServer && edgeRSCCacheGroups) {
return {
cacheGroups: edgeRSCCacheGroups
};
}
if (dev) {
return false;
}
if (isNodeServer) {
return {
// @ts-ignore
filename: "[name].js",
chunks: "all",
minSize: 1000
};
}
if (isEdgeServer) {
return {
// @ts-ignore
filename: "edge-chunks/[name].js",
chunks: "all",
minChunks: 2,
cacheGroups: edgeRSCCacheGroups
};
}
return {
// 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),
cacheGroups: {
framework: {
chunks: "all",
name: "framework",
test (module) {
const resource = module.nameForCondition == null ? void 0 : module.nameForCondition();
return resource ? topLevelFrameworkPaths.some((pkgPath)=>resource.startsWith(pkgPath)) : false;
},
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
}
},
maxInitialRequests: 25,
minSize: 20000
};
})(),
runtimeChunk: isClient ? {
name: _constants1.CLIENT_STATIC_FILES_RUNTIME_WEBPACK
} : undefined,
minimize: !dev && isClient,
minimizer: [
// Minify JavaScript
(compiler)=>{
var ref, ref48;
// @ts-ignore No typings yet
const { TerserPlugin , } = require("./webpack/plugins/terser-webpack-plugin/src/index.js");
var ref49, ref50;
new TerserPlugin({
cacheDir: _path.default.join(distDir, "cache", "next-minifier"),
parallel: config.experimental.cpus,
swcMinify: config.swcMinify,
terserOptions: {
...terserOptions,
compress: {
...terserOptions.compress,
...(ref49 = (ref = config.experimental.swcMinifyDebugOptions) == null ? void 0 : ref.compress) != null ? ref49 : {}
},
mangle: {
...terserOptions.mangle,
...(ref50 = (ref48 = config.experimental.swcMinifyDebugOptions) == null ? void 0 : ref48.mangle) != null ? ref50 : {}
}
}
}).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: !dev && isNodeServer ? _path.default.join(outputPath, "chunks") : outputPath,
// On the server we don't use hashes
filename: isNodeServer || isEdgeServer ? dev || isEdgeServer ? `[name].js` : `../[name].js` : `static/chunks/${isDevFallback ? "fallback/" : ""}[name]${dev ? "" : appDir ? "-[chunkhash]" : "-[contenthash]"}.js`,
library: isClient || isEdgeServer ? "_N_E" : undefined,
libraryTarget: isClient || isEdgeServer ? "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: isNodeServer || isEdgeServer ? "[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",
"next-flight-client-entry-loader",
"noop-loader",
"next-middleware-loader",
"next-edge-function-loader",
"next-edge-ssr-loader",
"next-middleware-asset-loader",
"next-middleware-wasm-loader",
"next-app-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 ? isNodeServer || isEdgeServer ? [
// RSC server compilation loaders
{
...serverComponentCodeCondition,
issuerLayer: "sc_server",
use: {
loader: "next-flight-server-loader"
}
},
{
test: _utils2.clientComponentRegex,
issuerLayer: "sc_server",
use: {
loader: "next-flight-client-loader"
}
},
// _app should be treated as a client component as well as all its dependencies.
{
test: new RegExp(`_app\\.(${rawPageExtensions.join("|")})$`),
layer: "sc_client"
},
] : [] : [],
...hasServerComponents && isEdgeServer ? [
// Move shared dependencies from sc_server and sc_client into the
// same layer.
{
test: rscSharedRegex,
layer: "rsc_shared_deps"
},
] : [],
{
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()
},
{
...codeCondition,
use: dev && isClient ? [
require.resolve("next/dist/compiled/@next/react-refresh-utils/dist/loader"),
defaultLoaders.babel,
] : defaultLoaders.babel
},
]
},
...!config.images.disableStaticImages ? [
{
test: nextImageLoaderRegex,
loader: "next-image-loader",
issuer: {
not: _css.regexLikeCss
},
dependency: {
not: [
"url"
]
},
options: {
isServer: isNodeServer || isEdgeServer,
isDev: dev,
basePath: config.basePath,
assetPrefix: config.assetPrefix
}
},
] : [],
...isEdgeServer || isClient ? [
{
oneOf: [
{
issuerLayer: "middleware",
resolve: {
fallback: {
process: require.resolve("./polyfills/process")
}
}
},
{
resolve: {
// 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")
}
}
},
]
},
] : [],
].filter(Boolean)
},
plugins: [
dev && isClient && new _reactRefreshWebpackPlugin.default(_webpack.webpack),
// Makes sure `Buffer` and `process` are polyfilled in client and flight bundles (same behavior as webpack 4)
(isClient || isEdgeServer) && new _webpack.webpack.ProvidePlugin({
// Buffer is used by getInlineScriptSource
Buffer: [
require.resolve("buffer"),
"Buffer"
],
// Avoid process being overridden when in web run time
...isClient && {
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)=>{
errorIfEnvConflicted(config, key);
return {
...acc,
[`process.env.${key}`]: JSON.stringify(config.env[key])
};
}, {}),
...compilerType !== "edge-server" ? {} : {
EdgeRuntime: JSON.stringify(/**
* Cloud providers can set this environment variable to allow users
* and library authors to have different implementations based on
* the runtime they are running with, if it's not using `edge-runtime`
*/ process.env.NEXT_EDGE_RUNTIME_PROVIDER || "edge-runtime")
},
// TODO: enforce `NODE_ENV` on `process.env`, and add a test:
"process.env.NODE_ENV": JSON.stringify(dev ? "development" : "production"),
...(isNodeServer || isEdgeServer) && {
"process.env.NEXT_RUNTIME": JSON.stringify(isEdgeServer ? "edge" : "nodejs")
},
"process.env.__NEXT_MIDDLEWARE_REGEX": JSON.stringify(middlewareRegex || ""),
"process.env.__NEXT_MANUAL_CLIENT_BASE_PATH": JSON.stringify(config.experimental.manualClientBasePath),
"process.env.__NEXT_NEW_LINK_BEHAVIOR": JSON.stringify(config.experimental.newNextLinkBehavior),
"process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE": JSON.stringify(config.experimental.skipMiddlewareUrlNormalize),
"process.env.__NEXT_OPTIMISTIC_CLIENT_CACHE": JSON.stringify(config.experimental.optimisticClientCache),
"process.env.__NEXT_CROSS_ORIGIN": JSON.stringify(crossOrigin),
"process.browser": JSON.stringify(isClient),
"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 && (isClient || isEdgeServer) ? {
"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_STRICT_MODE": JSON.stringify(config.reactStrictMode),
"process.env.__NEXT_REACT_ROOT": JSON.stringify(hasReactRoot),
"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,
dangerouslyAllowSVG: config.images.dangerouslyAllowSVG,
experimentalUnoptimized: config == null ? void 0 : (ref1 = config.experimental) == null ? void 0 : (ref2 = ref1.images) == null ? void 0 : ref2.unoptimized,
experimentalFuture: (ref3 = config.experimental) == null ? void 0 : (ref4 = ref3.images) == null ? void 0 : ref4.allowFutureImage,
...dev ? {
// pass domains in development to allow validating on the client
domains: config.images.domains,
experimentalRemotePatterns: (ref5 = config.experimental) == null ? void 0 : (ref6 = ref5.images) == null ? void 0 : ref6.remotePatterns
} : {}
}),
"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((ref7 = config.i18n) == null ? void 0 : ref7.domains),
"process.env.__NEXT_ANALYTICS_ID": JSON.stringify(config.analyticsId),
...isNodeServer || isEdgeServer ? {
// 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(${isNodeServer ? "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]
}
})
`
} : {}
}),
isClient && new _reactLoadablePlugin.ReactLoadablePlugin({
filename: _constants1.REACT_LOADABLE_MANIFEST,
pagesDir,
runtimeAsset: hasConcurrentFeatures ? `server/${_constants1.MIDDLEWARE_REACT_LOADABLE_MANIFEST}.js` : undefined,
dev
}),
(isClient || isEdgeServer) && new _nextDropClientPagePlugin.DropClientPage(),
config.outputFileTracing && !isLikeServerless && (isNodeServer ||