next
Version:
The React Framework
884 lines • 77.9 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = build;
var _env = require("@next/env");
var _chalk = _interopRequireDefault(require("next/dist/compiled/chalk"));
var _crypto = _interopRequireDefault(require("crypto"));
var _micromatch = require("next/dist/compiled/micromatch");
var _fs = require("fs");
var _worker = require("../lib/worker");
var _devalue = _interopRequireDefault(require("next/dist/compiled/devalue"));
var _escapeRegexp = require("../shared/lib/escape-regexp");
var _findUp = _interopRequireDefault(require("next/dist/compiled/find-up"));
var _indexCjs = require("next/dist/compiled/nanoid/index.cjs");
var _pathToRegexp = require("next/dist/compiled/path-to-regexp");
var _path = _interopRequireWildcard(require("path"));
var _formatWebpackMessages = _interopRequireDefault(require("../client/dev/error-overlay/format-webpack-messages"));
var _constants = require("../lib/constants");
var _fileExists = require("../lib/file-exists");
var _findPagesDir = require("../lib/find-pages-dir");
var _loadCustomRoutes = _interopRequireWildcard(require("../lib/load-custom-routes"));
var _nonNullable = require("../lib/non-nullable");
var _recursiveDelete = require("../lib/recursive-delete");
var _verifyAndLint = require("../lib/verifyAndLint");
var _verifyPartytownSetup = require("../lib/verify-partytown-setup");
var _verifyTypeScriptSetup = require("../lib/verifyTypeScriptSetup");
var _constants1 = require("../shared/lib/constants");
var _utils = require("../shared/lib/router/utils");
var _config = _interopRequireWildcard(require("../server/config"));
var _utils1 = require("../server/utils");
var _normalizePagePath = require("../server/normalize-page-path");
var _require = require("../server/require");
var ciEnvironment = _interopRequireWildcard(require("../telemetry/ci-info"));
var _events = require("../telemetry/events");
var _storage = require("../telemetry/storage");
var _compiler = require("./compiler");
var _entries = require("./entries");
var _generateBuildId = require("./generate-build-id");
var _isWriteable = require("./is-writeable");
var Log = _interopRequireWildcard(require("./output/log"));
var _spinner = _interopRequireDefault(require("./spinner"));
var _trace = require("../trace");
var _utils2 = require("./utils");
var _webpackConfig = _interopRequireDefault(require("./webpack-config"));
var _writeBuildId = require("./write-build-id");
var _normalizeLocalePath = require("../shared/lib/i18n/normalize-locale-path");
var _isError = _interopRequireDefault(require("../lib/is-error"));
var _telemetryPlugin = require("./webpack/plugins/telemetry-plugin");
var _recursiveCopy = require("../lib/recursive-copy");
async function build(dir, conf = null, reactProductionProfiling = false, debugOutput = false, runLint = true) {
const nextBuildSpan = (0, _trace).trace('next-build', undefined, {
version: "12.1.6-canary.0"
});
const buildResult = await nextBuildSpan.traceAsyncFn(async ()=>{
// attempt to load global env values so they are available in next.config.js
const { loadedEnvFiles } = nextBuildSpan.traceChild('load-dotenv').traceFn(()=>(0, _env).loadEnvConfig(dir, false, Log)
);
const config = await nextBuildSpan.traceChild('load-next-config').traceAsyncFn(()=>(0, _config).default(_constants1.PHASE_PRODUCTION_BUILD, dir, conf)
);
const distDir = _path.default.join(dir, config.distDir);
(0, _trace).setGlobal('phase', _constants1.PHASE_PRODUCTION_BUILD);
(0, _trace).setGlobal('distDir', distDir);
// We enable concurrent features (Fizz-related rendering architecture) when
// using React 18 or experimental.
const hasReactRoot = (0, _config).shouldUseReactRoot();
const hasConcurrentFeatures = hasReactRoot;
const hasServerComponents = hasReactRoot && !!config.experimental.serverComponents;
const { target } = config;
const buildId = await nextBuildSpan.traceChild('generate-buildid').traceAsyncFn(()=>(0, _generateBuildId).generateBuildId(config.generateBuildId, _indexCjs.nanoid)
);
const customRoutes = await nextBuildSpan.traceChild('load-custom-routes').traceAsyncFn(()=>(0, _loadCustomRoutes).default(config)
);
const { headers , rewrites , redirects } = customRoutes;
const cacheDir = _path.default.join(distDir, 'cache');
if (ciEnvironment.isCI && !ciEnvironment.hasNextSupport) {
const hasCache = await (0, _fileExists).fileExists(cacheDir);
if (!hasCache) {
// Intentionally not piping to stderr in case people fail in CI when
// stderr is detected.
console.log(`${Log.prefixes.warn} No build cache found. Please configure build caching for faster rebuilds. Read more: https://nextjs.org/docs/messages/no-cache`);
}
}
const telemetry = new _storage.Telemetry({
distDir
});
(0, _trace).setGlobal('telemetry', telemetry);
const publicDir = _path.default.join(dir, 'public');
const pagesDir = (0, _findPagesDir).findPagesDir(dir);
const hasPublicDir = await (0, _fileExists).fileExists(publicDir);
telemetry.record((0, _events).eventCliSession(dir, config, {
webpackVersion: 5,
cliCommand: 'build',
isSrcDir: _path.default.relative(dir, pagesDir).startsWith('src'),
hasNowJson: !!await (0, _findUp).default('now.json', {
cwd: dir
}),
isCustomServer: null
}));
(0, _events).eventNextPlugins(_path.default.resolve(dir)).then((events)=>telemetry.record(events)
);
const ignoreTypeScriptErrors = Boolean(config.typescript.ignoreBuildErrors);
const typeCheckStart = process.hrtime();
const typeCheckingSpinner = (0, _spinner).default({
prefixText: `${Log.prefixes.info} ${ignoreTypeScriptErrors ? 'Skipping validation of types' : 'Checking validity of types'}`
});
const verifyResult = await nextBuildSpan.traceChild('verify-typescript-setup').traceAsyncFn(()=>(0, _verifyTypeScriptSetup).verifyTypeScriptSetup(dir, pagesDir, !ignoreTypeScriptErrors, config, cacheDir)
);
const typeCheckEnd = process.hrtime(typeCheckStart);
if (!ignoreTypeScriptErrors) {
var ref, ref1, ref2;
telemetry.record((0, _events).eventTypeCheckCompleted({
durationInSeconds: typeCheckEnd[0],
typescriptVersion: verifyResult.version,
inputFilesCount: (ref = verifyResult.result) === null || ref === void 0 ? void 0 : ref.inputFilesCount,
totalFilesCount: (ref1 = verifyResult.result) === null || ref1 === void 0 ? void 0 : ref1.totalFilesCount,
incremental: (ref2 = verifyResult.result) === null || ref2 === void 0 ? void 0 : ref2.incremental
}));
}
if (typeCheckingSpinner) {
typeCheckingSpinner.stopAndPersist();
}
const ignoreESLint = Boolean(config.eslint.ignoreDuringBuilds);
const eslintCacheDir = _path.default.join(cacheDir, 'eslint/');
const shouldLint = !ignoreESLint && runLint;
if (shouldLint) {
await nextBuildSpan.traceChild('verify-and-lint').traceAsyncFn(async ()=>{
var ref;
await (0, _verifyAndLint).verifyAndLint(dir, eslintCacheDir, (ref = config.eslint) === null || ref === void 0 ? void 0 : ref.dirs, config.experimental.cpus, config.experimental.workerThreads, telemetry);
});
}
const buildLintEvent = {
featureName: 'build-lint',
invocationCount: shouldLint ? 1 : 0
};
telemetry.record({
eventName: _events.EVENT_BUILD_FEATURE_USAGE,
payload: buildLintEvent
});
const buildSpinner = (0, _spinner).default({
prefixText: `${Log.prefixes.info} Creating an optimized production build`
});
const isLikeServerless = (0, _utils1).isTargetLikeServerless(target);
const pagePaths = await nextBuildSpan.traceChild('collect-pages').traceAsyncFn(()=>(0, _utils2).collectPages(pagesDir, config.pageExtensions)
);
// needed for static exporting since we want to replace with HTML
// files
const allStaticPages = new Set();
let allPageInfos = new Map();
const previewProps = {
previewModeId: _crypto.default.randomBytes(16).toString('hex'),
previewModeSigningKey: _crypto.default.randomBytes(32).toString('hex'),
previewModeEncryptionKey: _crypto.default.randomBytes(32).toString('hex')
};
const mappedPages = nextBuildSpan.traceChild('create-pages-mapping').traceFn(()=>(0, _entries).createPagesMapping(pagePaths, config.pageExtensions, {
isDev: false,
hasServerComponents
})
);
const entrypoints = await nextBuildSpan.traceChild('create-entrypoints').traceAsyncFn(()=>(0, _entries).createEntrypoints(mappedPages, target, buildId, previewProps, config, loadedEnvFiles, pagesDir, false)
);
const pageKeys = Object.keys(mappedPages);
const hasMiddleware = pageKeys.some((page)=>_constants.MIDDLEWARE_ROUTE.test(page)
);
const conflictingPublicFiles = [];
const hasCustomErrorPage = mappedPages['/_error'].startsWith('private-next-pages');
const hasPages404 = Boolean(mappedPages['/404'] && mappedPages['/404'].startsWith('private-next-pages'));
if (hasMiddleware) {
Log.warn(`using beta Middleware (not covered by semver) - https://nextjs.org/docs/messages/beta-middleware`);
}
if (hasPublicDir) {
const hasPublicUnderScoreNextDir = await (0, _fileExists).fileExists(_path.default.join(publicDir, '_next'));
if (hasPublicUnderScoreNextDir) {
throw new Error(_constants.PUBLIC_DIR_MIDDLEWARE_CONFLICT);
}
}
await nextBuildSpan.traceChild('public-dir-conflict-check').traceAsyncFn(async ()=>{
// Check if pages conflict with files in `public`
// Only a page of public file can be served, not both.
for(const page in mappedPages){
const hasPublicPageFile = await (0, _fileExists).fileExists(_path.default.join(publicDir, page === '/' ? '/index' : page), 'file');
if (hasPublicPageFile) {
conflictingPublicFiles.push(page);
}
}
const numConflicting = conflictingPublicFiles.length;
if (numConflicting) {
throw new Error(`Conflicting public and page file${numConflicting === 1 ? ' was' : 's were'} found. https://nextjs.org/docs/messages/conflicting-public-file-page\n${conflictingPublicFiles.join('\n')}`);
}
});
const nestedReservedPages = pageKeys.filter((page)=>{
return page.match(/\/(_app|_document|_error)$/) && _path.default.dirname(page) !== '/';
});
if (nestedReservedPages.length) {
Log.warn(`The following reserved Next.js pages were detected not directly under the pages directory:\n` + nestedReservedPages.join('\n') + `\nSee more info here: https://nextjs.org/docs/messages/nested-reserved-page\n`);
}
const restrictedRedirectPaths = [
'/_next'
].map((p)=>config.basePath ? `${config.basePath}${p}` : p
);
const buildCustomRoute = (r, type)=>{
const keys = [];
const routeRegex = (0, _pathToRegexp).pathToRegexp(r.source, keys, {
strict: true,
sensitive: false,
delimiter: '/'
});
let regexSource = routeRegex.source;
if (!r.internal) {
regexSource = (0, _loadCustomRoutes).modifyRouteRegex(routeRegex.source, type === 'redirect' ? restrictedRedirectPaths : undefined);
}
return {
...r,
...type === 'redirect' ? {
statusCode: (0, _loadCustomRoutes).getRedirectStatus(r),
permanent: undefined
} : {},
regex: (0, _loadCustomRoutes).normalizeRouteRegex(regexSource)
};
};
const routesManifestPath = _path.default.join(distDir, _constants1.ROUTES_MANIFEST);
const routesManifest = nextBuildSpan.traceChild('generate-routes-manifest').traceFn(()=>({
version: 3,
pages404: true,
basePath: config.basePath,
redirects: redirects.map((r)=>buildCustomRoute(r, 'redirect')
),
headers: headers.map((r)=>buildCustomRoute(r, 'header')
),
dynamicRoutes: (0, _utils).getSortedRoutes(pageKeys).filter((page)=>(0, _utils).isDynamicRoute(page) && !page.match(_constants.MIDDLEWARE_ROUTE)
).map(pageToRoute),
staticRoutes: (0, _utils).getSortedRoutes(pageKeys).filter((page)=>!(0, _utils).isDynamicRoute(page) && !page.match(_constants.MIDDLEWARE_ROUTE) && !(0, _utils2).isReservedPage(page)
).map(pageToRoute),
dataRoutes: [],
i18n: config.i18n || undefined
})
);
if (rewrites.beforeFiles.length === 0 && rewrites.fallback.length === 0) {
routesManifest.rewrites = rewrites.afterFiles.map((r)=>buildCustomRoute(r, 'rewrite')
);
} else {
routesManifest.rewrites = {
beforeFiles: rewrites.beforeFiles.map((r)=>buildCustomRoute(r, 'rewrite')
),
afterFiles: rewrites.afterFiles.map((r)=>buildCustomRoute(r, 'rewrite')
),
fallback: rewrites.fallback.map((r)=>buildCustomRoute(r, 'rewrite')
)
};
}
const combinedRewrites = [
...rewrites.beforeFiles,
...rewrites.afterFiles,
...rewrites.fallback,
];
const distDirCreated = await nextBuildSpan.traceChild('create-dist-dir').traceAsyncFn(async ()=>{
try {
await _fs.promises.mkdir(distDir, {
recursive: true
});
return true;
} catch (err) {
if ((0, _isError).default(err) && err.code === 'EPERM') {
return false;
}
throw err;
}
});
if (!distDirCreated || !await (0, _isWriteable).isWriteable(distDir)) {
throw new Error('> Build directory is not writeable. https://nextjs.org/docs/messages/build-dir-not-writeable');
}
if (config.cleanDistDir) {
await (0, _recursiveDelete).recursiveDelete(distDir, /^cache/);
}
// Ensure commonjs handling is used for files in the distDir (generally .next)
// Files outside of the distDir can be "type": "module"
await _fs.promises.writeFile(_path.default.join(distDir, 'package.json'), '{"type": "commonjs"}');
// We need to write the manifest with rewrites before build
// so serverless can import the manifest
await nextBuildSpan.traceChild('write-routes-manifest').traceAsyncFn(()=>_fs.promises.writeFile(routesManifestPath, JSON.stringify(routesManifest), 'utf8')
);
const manifestPath = _path.default.join(distDir, isLikeServerless ? _constants1.SERVERLESS_DIRECTORY : _constants1.SERVER_DIRECTORY, _constants1.PAGES_MANIFEST);
const requiredServerFiles = nextBuildSpan.traceChild('generate-required-server-files').traceFn(()=>({
version: 1,
config: {
...config,
configFile: undefined,
experimental: {
...config.experimental,
trustHostHeader: ciEnvironment.hasNextSupport
}
},
appDir: dir,
files: [
_constants1.ROUTES_MANIFEST,
_path.default.relative(distDir, manifestPath),
_constants1.BUILD_MANIFEST,
_constants1.PRERENDER_MANIFEST,
_path.default.join(_constants1.SERVER_DIRECTORY, _constants1.MIDDLEWARE_MANIFEST),
...hasServerComponents ? [
_path.default.join(_constants1.SERVER_DIRECTORY, _constants1.MIDDLEWARE_FLIGHT_MANIFEST + '.js'),
_path.default.join(_constants1.SERVER_DIRECTORY, _constants1.MIDDLEWARE_FLIGHT_MANIFEST + '.json'),
] : [],
_constants1.REACT_LOADABLE_MANIFEST,
config.optimizeFonts ? _path.default.join(isLikeServerless ? _constants1.SERVERLESS_DIRECTORY : _constants1.SERVER_DIRECTORY, _constants1.FONT_MANIFEST) : null,
_constants1.BUILD_ID_FILE,
].filter(_nonNullable.nonNullable).map((file)=>_path.default.join(config.distDir, file)
),
ignore: []
})
);
let result = {
warnings: [],
errors: []
};
let webpackBuildStart;
let telemetryPlugin;
await (async ()=>{
var ref;
// IIFE to isolate locals and avoid retaining memory too long
const runWebpackSpan = nextBuildSpan.traceChild('run-webpack-compiler');
const configs = await runWebpackSpan.traceChild('generate-webpack-config').traceAsyncFn(()=>Promise.all([
(0, _webpackConfig).default(dir, {
buildId,
reactProductionProfiling,
isServer: false,
config,
target,
pagesDir,
entrypoints: entrypoints.client,
rewrites,
runWebpackSpan,
hasReactRoot
}),
(0, _webpackConfig).default(dir, {
buildId,
reactProductionProfiling,
isServer: true,
config,
target,
pagesDir,
entrypoints: entrypoints.server,
rewrites,
runWebpackSpan,
hasReactRoot
}),
hasReactRoot ? (0, _webpackConfig).default(dir, {
buildId,
reactProductionProfiling,
isServer: true,
isEdgeRuntime: true,
config,
target,
pagesDir,
entrypoints: entrypoints.edgeServer,
rewrites,
runWebpackSpan,
hasReactRoot
}) : null,
])
);
const clientConfig = configs[0];
if (clientConfig.optimization && (clientConfig.optimization.minimize !== true || clientConfig.optimization.minimizer && clientConfig.optimization.minimizer.length === 0)) {
Log.warn(`Production code optimization has been disabled in your project. Read more: https://nextjs.org/docs/messages/minification-disabled`);
}
webpackBuildStart = process.hrtime();
// We run client and server compilation separately to optimize for memory usage
await runWebpackSpan.traceAsyncFn(async ()=>{
const clientResult = await (0, _compiler).runCompiler(clientConfig, {
runWebpackSpan
});
// Fail build if clientResult contains errors
if (clientResult.errors.length > 0) {
result = {
warnings: [
...clientResult.warnings
],
errors: [
...clientResult.errors
]
};
} else {
const serverResult = await (0, _compiler).runCompiler(configs[1], {
runWebpackSpan
});
const edgeServerResult = configs[2] ? await (0, _compiler).runCompiler(configs[2], {
runWebpackSpan
}) : null;
result = {
warnings: [
...clientResult.warnings,
...serverResult.warnings,
...(edgeServerResult === null || edgeServerResult === void 0 ? void 0 : edgeServerResult.warnings) || [],
],
errors: [
...clientResult.errors,
...serverResult.errors,
...(edgeServerResult === null || edgeServerResult === void 0 ? void 0 : edgeServerResult.errors) || [],
]
};
}
});
result = nextBuildSpan.traceChild('format-webpack-messages').traceFn(()=>(0, _formatWebpackMessages).default(result, true)
);
telemetryPlugin = (ref = clientConfig.plugins) === null || ref === void 0 ? void 0 : ref.find(isTelemetryPlugin);
})();
const webpackBuildEnd = process.hrtime(webpackBuildStart);
if (buildSpinner) {
buildSpinner.stopAndPersist();
}
if (result.errors.length > 0) {
// Only keep the first few errors. Others are often indicative
// of the same problem, but confuse the reader with noise.
if (result.errors.length > 5) {
result.errors.length = 5;
}
const error = result.errors.join('\n\n');
console.error(_chalk.default.red('Failed to compile.\n'));
if (error.indexOf('private-next-pages') > -1 && error.indexOf('does not contain a default export') > -1) {
const page_name_regex = /'private-next-pages\/(?<page_name>[^']*)'/;
const parsed = page_name_regex.exec(error);
const page_name = parsed && parsed.groups && parsed.groups.page_name;
throw new Error(`webpack build failed: found page without a React Component as default export in pages/${page_name}\n\nSee https://nextjs.org/docs/messages/page-without-valid-component for more info.`);
}
console.error(error);
console.error();
// When using the web runtime, common Node.js native APIs are not available.
const moduleName = (0, _utils2).getUnresolvedModuleFromError(error);
if (hasConcurrentFeatures && moduleName) {
const err = new Error(`Native Node.js APIs are not supported in the Edge Runtime. Found \`${moduleName}\` imported.\n\n`);
err.code = 'EDGE_RUNTIME_UNSUPPORTED_API';
throw err;
}
if (error.indexOf('private-next-pages') > -1 || error.indexOf('__next_polyfill__') > -1) {
const err = new Error('webpack config.resolve.alias was incorrectly overridden. https://nextjs.org/docs/messages/invalid-resolve-alias');
err.code = 'INVALID_RESOLVE_ALIAS';
throw err;
}
const err = new Error('Build failed because of webpack errors');
err.code = 'WEBPACK_ERRORS';
throw err;
} else {
telemetry.record((0, _events).eventBuildCompleted(pagePaths, {
durationInSeconds: webpackBuildEnd[0]
}));
if (result.warnings.length > 0) {
Log.warn('Compiled with warnings\n');
console.warn(result.warnings.join('\n\n'));
console.warn();
} else {
Log.info('Compiled successfully');
}
}
const postCompileSpinner = (0, _spinner).default({
prefixText: `${Log.prefixes.info} Collecting page data`
});
const buildManifestPath = _path.default.join(distDir, _constants1.BUILD_MANIFEST);
const ssgPages = new Set();
const ssgStaticFallbackPages = new Set();
const ssgBlockingFallbackPages = new Set();
const staticPages = new Set();
const invalidPages = new Set();
const hybridAmpPages = new Set();
const serverPropsPages = new Set();
const additionalSsgPaths = new Map();
const additionalSsgPathsEncoded = new Map();
const pageTraceIncludes = new Map();
const pageTraceExcludes = new Map();
const pageInfos = new Map();
const pagesManifest = JSON.parse(await _fs.promises.readFile(manifestPath, 'utf8'));
const buildManifest = JSON.parse(await _fs.promises.readFile(buildManifestPath, 'utf8'));
const timeout = config.staticPageGenerationTimeout || 0;
const sharedPool = config.experimental.sharedPool || false;
const staticWorker = sharedPool ? require.resolve('./worker') : require.resolve('./utils');
let infoPrinted = false;
process.env.NEXT_PHASE = _constants1.PHASE_PRODUCTION_BUILD;
const staticWorkers = new _worker.Worker(staticWorker, {
timeout: timeout * 1000,
onRestart: (method, [arg], attempts)=>{
if (method === 'exportPage') {
const { path: pagePath } = arg;
if (attempts >= 3) {
throw new Error(`Static page generation for ${pagePath} is still timing out after 3 attempts. See more info here https://nextjs.org/docs/messages/static-page-generation-timeout`);
}
Log.warn(`Restarted static page generation for ${pagePath} because it took more than ${timeout} seconds`);
} else {
const pagePath = arg;
if (attempts >= 2) {
throw new Error(`Collecting page data for ${pagePath} is still timing out after 2 attempts. See more info here https://nextjs.org/docs/messages/page-data-collection-timeout`);
}
Log.warn(`Restarted collecting page data for ${pagePath} because it took more than ${timeout} seconds`);
}
if (!infoPrinted) {
Log.warn('See more info here https://nextjs.org/docs/messages/static-page-generation-timeout');
infoPrinted = true;
}
},
numWorkers: config.experimental.cpus,
enableWorkerThreads: config.experimental.workerThreads,
exposedMethods: sharedPool ? [
'hasCustomGetInitialProps',
'isPageStatic',
'getNamedExports',
'exportPage',
] : [
'hasCustomGetInitialProps',
'isPageStatic',
'getNamedExports'
]
});
const analysisBegin = process.hrtime();
const staticCheckSpan = nextBuildSpan.traceChild('static-check');
const { customAppGetInitialProps , namedExports , isNextImageImported: isNextImageImported1 , hasSsrAmpPages: hasSsrAmpPages1 , hasNonStaticErrorPage , } = await staticCheckSpan.traceAsyncFn(async ()=>{
const { configFileName , publicRuntimeConfig , serverRuntimeConfig } = config;
const runtimeEnvConfig = {
publicRuntimeConfig,
serverRuntimeConfig
};
const nonStaticErrorPageSpan = staticCheckSpan.traceChild('check-static-error-page');
const errorPageHasCustomGetInitialProps = nonStaticErrorPageSpan.traceAsyncFn(async ()=>hasCustomErrorPage && await staticWorkers.hasCustomGetInitialProps('/_error', distDir, isLikeServerless, runtimeEnvConfig, false)
);
const errorPageStaticResult = nonStaticErrorPageSpan.traceAsyncFn(async ()=>{
var ref, ref5;
return hasCustomErrorPage && staticWorkers.isPageStatic('/_error', distDir, isLikeServerless, configFileName, runtimeEnvConfig, config.httpAgentOptions, (ref = config.i18n) === null || ref === void 0 ? void 0 : ref.locales, (ref5 = config.i18n) === null || ref5 === void 0 ? void 0 : ref5.defaultLocale);
});
// we don't output _app in serverless mode so use _app export
// from _error instead
const appPageToCheck = isLikeServerless ? '/_error' : '/_app';
const customAppGetInitialPropsPromise = staticWorkers.hasCustomGetInitialProps(appPageToCheck, distDir, isLikeServerless, runtimeEnvConfig, true);
const namedExportsPromise = staticWorkers.getNamedExports(appPageToCheck, distDir, isLikeServerless, runtimeEnvConfig);
// eslint-disable-next-line no-shadow
let isNextImageImported;
// eslint-disable-next-line no-shadow
let hasSsrAmpPages = false;
const computedManifestData = await (0, _utils2).computeFromManifest(buildManifest, distDir, config.experimental.gzipSize);
await Promise.all(pageKeys.map(async (page)=>{
const checkPageSpan = staticCheckSpan.traceChild('check-page', {
page
});
return checkPageSpan.traceAsyncFn(async ()=>{
const actualPage = (0, _normalizePagePath).normalizePagePath(page);
const [selfSize, allSize] = await (0, _utils2).getJsPageSizeInKb(actualPage, distDir, buildManifest, config.experimental.gzipSize, computedManifestData);
let isSsg = false;
let isStatic = false;
let isServerComponent = false;
let isHybridAmp = false;
let ssgPageRoutes = null;
let isMiddlewareRoute = !!page.match(_constants.MIDDLEWARE_ROUTE);
const pagePath = pagePaths.find((p)=>p.startsWith(actualPage + '.') || p.startsWith(actualPage + '/index.')
);
const pageRuntime = pagePath ? await (0, _entries).getPageRuntime((0, _path).join(pagesDir, pagePath), config) : undefined;
if (hasServerComponents && pagePath) {
if ((0, _utils2).isFlightPage(config, pagePath)) {
isServerComponent = true;
}
}
if (!isMiddlewareRoute && !(0, _utils2).isReservedPage(page) && // We currently don't support static optimization in the Edge runtime.
pageRuntime !== 'edge') {
try {
let isPageStaticSpan = checkPageSpan.traceChild('is-page-static');
let workerResult = await isPageStaticSpan.traceAsyncFn(()=>{
var ref, ref6;
return staticWorkers.isPageStatic(page, distDir, isLikeServerless, configFileName, runtimeEnvConfig, config.httpAgentOptions, (ref = config.i18n) === null || ref === void 0 ? void 0 : ref.locales, (ref6 = config.i18n) === null || ref6 === void 0 ? void 0 : ref6.defaultLocale, isPageStaticSpan.id);
});
if (config.outputFileTracing) {
pageTraceIncludes.set(page, workerResult.traceIncludes || []);
pageTraceExcludes.set(page, workerResult.traceExcludes || []);
}
if (workerResult.isStatic === false && (workerResult.isHybridAmp || workerResult.isAmpOnly)) {
hasSsrAmpPages = true;
}
if (workerResult.isHybridAmp) {
isHybridAmp = true;
hybridAmpPages.add(page);
}
if (workerResult.isNextImageImported) {
isNextImageImported = true;
}
if (workerResult.hasStaticProps) {
ssgPages.add(page);
isSsg = true;
if (workerResult.prerenderRoutes && workerResult.encodedPrerenderRoutes) {
additionalSsgPaths.set(page, workerResult.prerenderRoutes);
additionalSsgPathsEncoded.set(page, workerResult.encodedPrerenderRoutes);
ssgPageRoutes = workerResult.prerenderRoutes;
}
if (workerResult.prerenderFallback === 'blocking') {
ssgBlockingFallbackPages.add(page);
} else if (workerResult.prerenderFallback === true) {
ssgStaticFallbackPages.add(page);
}
} else if (workerResult.hasServerProps) {
serverPropsPages.add(page);
} else if (workerResult.isStatic && !isServerComponent && await customAppGetInitialPropsPromise === false) {
staticPages.add(page);
isStatic = true;
} else if (isServerComponent) {
// This is a static server component page that doesn't have
// gSP or gSSP. We still treat it as a SSG page.
ssgPages.add(page);
isSsg = true;
}
if (hasPages404 && page === '/404') {
if (!workerResult.isStatic && !workerResult.hasStaticProps) {
throw new Error(`\`pages/404\` ${_constants.STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR}`);
}
// we need to ensure the 404 lambda is present since we use
// it when _app has getInitialProps
if (await customAppGetInitialPropsPromise && !workerResult.hasStaticProps) {
staticPages.delete(page);
}
}
if (_constants1.STATIC_STATUS_PAGES.includes(page) && !workerResult.isStatic && !workerResult.hasStaticProps) {
throw new Error(`\`pages${page}\` ${_constants.STATIC_STATUS_PAGE_GET_INITIAL_PROPS_ERROR}`);
}
} catch (err) {
if (!(0, _isError).default(err) || err.message !== 'INVALID_DEFAULT_EXPORT') throw err;
invalidPages.add(page);
}
}
pageInfos.set(page, {
size: selfSize,
totalSize: allSize,
static: isStatic,
isSsg,
isHybridAmp,
ssgPageRoutes,
initialRevalidateSeconds: false,
runtime: !(0, _utils2).isReservedPage(page) && !(0, _utils2).isCustomErrorPage(page) ? pageRuntime : undefined,
pageDuration: undefined,
ssgPageDurations: undefined
});
});
}));
const errorPageResult = await errorPageStaticResult;
const nonStaticErrorPage = await errorPageHasCustomGetInitialProps || errorPageResult && errorPageResult.hasServerProps;
const returnValue = {
customAppGetInitialProps: await customAppGetInitialPropsPromise,
namedExports: await namedExportsPromise,
isNextImageImported,
hasSsrAmpPages,
hasNonStaticErrorPage: nonStaticErrorPage
};
if (!sharedPool) staticWorkers.end();
return returnValue;
});
if (customAppGetInitialProps) {
console.warn(_chalk.default.bold.yellow(`Warning: `) + _chalk.default.yellow(`You have opted-out of Automatic Static Optimization due to \`getInitialProps\` in \`pages/_app\`. This does not opt-out pages with \`getStaticProps\``));
console.warn('Read more: https://nextjs.org/docs/messages/opt-out-auto-static-optimization\n');
}
if (!hasSsrAmpPages1) {
requiredServerFiles.ignore.push(_path.default.relative(dir, _path.default.join(_path.default.dirname(require.resolve('next/dist/compiled/@ampproject/toolbox-optimizer')), '**/*')));
}
if (config.outputFileTracing) {
const { nodeFileTrace } = require('next/dist/compiled/@vercel/nft');
const includeExcludeSpan = nextBuildSpan.traceChild('apply-include-excludes');
await includeExcludeSpan.traceAsyncFn(async ()=>{
const globOrig = require('next/dist/compiled/glob');
const glob = (pattern)=>{
return new Promise((resolve, reject)=>{
globOrig(pattern, {
cwd: dir
}, (err, files)=>{
if (err) {
return reject(err);
}
resolve(files);
});
});
};
for (let page of pageKeys){
await includeExcludeSpan.traceChild('include-exclude', {
page
}).traceAsyncFn(async ()=>{
const includeGlobs = pageTraceIncludes.get(page);
const excludeGlobs = pageTraceExcludes.get(page);
page = (0, _normalizePagePath).normalizePagePath(page);
if (!(includeGlobs === null || includeGlobs === void 0 ? void 0 : includeGlobs.length) && !(excludeGlobs === null || excludeGlobs === void 0 ? void 0 : excludeGlobs.length)) {
return;
}
const traceFile = _path.default.join(distDir, 'server/pages', `${page}.js.nft.json`);
const pageDir = _path.default.dirname(traceFile);
const traceContent = JSON.parse(await _fs.promises.readFile(traceFile, 'utf8'));
let includes = [];
if (includeGlobs === null || includeGlobs === void 0 ? void 0 : includeGlobs.length) {
for (const includeGlob of includeGlobs){
const results = await glob(includeGlob);
includes.push(...results.map((file)=>{
return _path.default.relative(pageDir, _path.default.join(dir, file));
}));
}
}
const combined = new Set([
...traceContent.files,
...includes
]);
if (excludeGlobs === null || excludeGlobs === void 0 ? void 0 : excludeGlobs.length) {
const resolvedGlobs = excludeGlobs.map((exclude)=>_path.default.join(dir, exclude)
);
combined.forEach((file)=>{
if ((0, _micromatch).isMatch(_path.default.join(pageDir, file), resolvedGlobs)) {
combined.delete(file);
}
});
}
await _fs.promises.writeFile(traceFile, JSON.stringify({
version: traceContent.version,
files: [
...combined
]
}));
});
}
});
// TODO: move this inside of webpack so it can be cached
// between builds. Should only need to be re-run on lockfile change
await nextBuildSpan.traceChild('trace-next-server').traceAsyncFn(async ()=>{
let cacheKey;
// consider all lockFiles in tree in case user accidentally
// has both package-lock.json and yarn.lock
const lockFiles = (await Promise.all([
'package-lock.json',
'yarn.lock',
'pnpm-lock.yaml'
].map((file)=>(0, _findUp).default(file, {
cwd: dir
})
))).filter(Boolean)// TypeScript doesn't like this filter
;
const nextServerTraceOutput = _path.default.join(distDir, 'next-server.js.nft.json');
const cachedTracePath = _path.default.join(distDir, 'cache/next-server.js.nft.json');
if (lockFiles.length > 0) {
const cacheHash = require('crypto').createHash('sha256');
cacheHash.update(require('next/package').version);
cacheHash.update(hasSsrAmpPages1 + '');
cacheHash.update(ciEnvironment.hasNextSupport + '');
await Promise.all(lockFiles.map(async (lockFile)=>{
cacheHash.update(await _fs.promises.readFile(lockFile));
}));
cacheKey = cacheHash.digest('hex');
try {
const existingTrace = JSON.parse(await _fs.promises.readFile(cachedTracePath, 'utf8'));
if (existingTrace.cacheKey === cacheKey) {
await _fs.promises.copyFile(cachedTracePath, nextServerTraceOutput);
return;
}
} catch (_) {}
}
const root = _path.default.parse(dir).root;
const serverResult = await nodeFileTrace([
require.resolve('next/dist/server/next-server')
], {
base: root,
processCwd: dir,
ignore: [
'**/next/dist/pages/**/*',
'**/next/dist/compiled/webpack/(bundle4|bundle5).js',
'**/node_modules/webpack5/**/*',
'**/next/dist/server/lib/squoosh/**/*.wasm',
...ciEnvironment.hasNextSupport ? [
// only ignore image-optimizer code when
// this is being handled outside of next-server
'**/next/dist/server/image-optimizer.js',
'**/node_modules/sharp/**/*',
] : [],
...!hasSsrAmpPages1 ? [
'**/next/dist/compiled/@ampproject/toolbox-optimizer/**/*'
] : [],
]
});
const tracedFiles = new Set();
serverResult.fileList.forEach((file)=>{
tracedFiles.add(_path.default.relative(distDir, _path.default.join(root, file)).replace(/\\/g, '/'));
});
await _fs.promises.writeFile(nextServerTraceOutput, JSON.stringify({
version: 1,
cacheKey,
files: [
...tracedFiles
]
}));
await _fs.promises.unlink(cachedTracePath).catch(()=>{});
await _fs.promises.copyFile(nextServerTraceOutput, cachedTracePath).catch(()=>{});
});
}
if (serverPropsPages.size > 0 || ssgPages.size > 0) {
// We update the routes manifest after the build with the
// data routes since we can't determine these until after build
routesManifest.dataRoutes = (0, _utils).getSortedRoutes([
...serverPropsPages,
...ssgPages,
]).map((page)=>{
const pagePath = (0, _normalizePagePath).normalizePagePath(page);
const dataRoute = _path.default.posix.join('/_next/data', buildId, `${pagePath}.json`);
let dataRouteRegex;
let namedDataRouteRegex;
let routeKeys;
if ((0, _utils).isDynamicRoute(page)) {
const routeRegex = (0, _utils).getRouteRegex(dataRoute.replace(/\.json$/, ''));
dataRouteRegex = (0, _loadCustomRoutes).normalizeRouteRegex(routeRegex.re.source.replace(/\(\?:\\\/\)\?\$$/, `\\.json$`));
namedDataRouteRegex = routeRegex.namedRegex.replace(/\(\?:\/\)\?\$$/, `\\.json$`);
routeKeys = routeRegex.routeKeys;
} else {
dataRouteRegex = (0, _loadCustomRoutes).normalizeRouteRegex(new RegExp(`^${_path.default.posix.join('/_next/data', (0, _escapeRegexp).escapeStringRegexp(buildId), `${pagePath}.json`)}$`).source);
}
return {
page,
routeKeys,
dataRouteRegex,
namedDataRouteRegex
};
});
await _fs.promises.writeFile(routesManifestPath, JSON.stringify(routesManifest), 'utf8');
}
// Since custom _app.js can wrap the 404 page we have to opt-out of static optimization if it has getInitialProps
// Only export the static 404 when there is no /_error present
const useStatic404 = !customAppGetInitialProps && (!hasNonStaticErrorPage || hasPages404);
if (invalidPages.size > 0) {
const err = new Error(`Build optimization failed: found page${invalidPages.size === 1 ? '' : 's'} without a React Component as default export in \n${[
...invalidPages
].map((pg)=>`pages${pg}`
).join('\n')}\n\nSee https://nextjs.org/docs/messages/page-without-valid-component for more info.\n`);
err.code = 'BUILD_OPTIMIZATION_FAILED';
throw err;
}
await (0, _writeBuildId).writeBuildId(distDir, buildId);
if (config.experimental.optimizeCss) {
const globOrig = require('next/dist/compiled/glob');
const cssFilePaths = await new Promise((resolve, reject)=>{
globOrig('**/*.css', {
cwd: (0, _path).join(distDir, 'static')
}, (err, files)=>{
if (err) {
return reject(err);
}
resolve(files);
});
});
requiredServerFiles.files.push(...cssFilePaths.map((filePath)=>_path.default.join(config.distDir, 'static', filePath)
));
}
const features = [
{
featureName: 'experimental/optimizeCss',
invocationCount: config.experimental.optimizeCss ? 1 : 0
},
{
featureName: 'optimizeFonts',
invocationCount: config.optimizeFonts ? 1 : 0
},
];
telemetry.record(features.map((feature)=>{
return {
eventName: _events.EVENT_BUILD_FEATURE_USAGE,
payload: feature
};
}));
await _fs.promises.writeFile(_path.default.join(distDir, _constants1.SERVER_FILES_MANIFEST), JSON.stringify(requiredServerFiles), 'utf8');
const middlewareManifest = JSON.parse(await _fs.promises.readFile(_path.default.join(distDir, _constants1.SERVER_DIRECTORY, _constants1.MIDDLEWARE_MANIFEST), 'utf8'));
const outputFileTracingRoot = config.experimental.outputFileTracingRoot || dir;
if (config.experimental.outputStandalone) {
await nextBuildSpan.traceChild('copy-traced-files').traceAsyncFn(async ()=>{
await (0, _utils2).copyTracedFiles(dir, distDir, pageKeys, outputFileTracingRoot, requiredServerFiles.config, middlewareManifest);
});
}
const finalPrerenderRoutes = {};
const tbdPrerenderRoutes = [];
let ssgNotFoundPaths = [];
if (postCompileSpinner) postCompileSpinner.stopAndPersist();
const { i18n } = config;
const usedStaticStatusPages = _constants1.STATIC_STATUS_PAGES.filter((page)=>mappedPages[page] && mappedPages[page].startsWith('private-next-pages')
);
usedStaticStatusPages.forEach((page)=>{
if (!ssgPages.has(page) && !customAppGetInitialProps) {
staticPages.add(page);
}
});
const hasPages500 = usedStaticStatusPages.includes('/500');
const useDefaultStatic500 = !hasPages500 && !hasNonStaticErrorPage && !customAppGetInitialProps;
const combinedPages = [
...staticPages,
...ssgPages
];
if (combinedPages.length > 0 || useStatic404 || use