next
Version:
The React Framework
1,063 lines • 59.8 kB
JavaScript
import "../server/require-hook";
import "../server/node-polyfill-fetch";
import "../server/node-polyfill-crypto";
import "../server/node-environment";
import chalk from "next/dist/compiled/chalk";
import getGzipSize from "next/dist/compiled/gzip-size";
import textTable from "next/dist/compiled/text-table";
import path from "path";
import { promises as fs } from "fs";
import { isValidElementType } from "next/dist/compiled/react-is";
import stripAnsi from "next/dist/compiled/strip-ansi";
import browserslist from "next/dist/compiled/browserslist";
import { SSG_GET_INITIAL_PROPS_CONFLICT, SERVER_PROPS_GET_INIT_PROPS_CONFLICT, SERVER_PROPS_SSG_CONFLICT, MIDDLEWARE_FILENAME, INSTRUMENTATION_HOOK_FILENAME } from "../lib/constants";
import { MODERN_BROWSERSLIST_TARGET } from "../shared/lib/constants";
import prettyBytes from "../lib/pretty-bytes";
import { getRouteRegex } from "../shared/lib/router/utils/route-regex";
import { getRouteMatcher } from "../shared/lib/router/utils/route-matcher";
import { isDynamicRoute } from "../shared/lib/router/utils/is-dynamic";
import escapePathDelimiters from "../shared/lib/router/utils/escape-path-delimiters";
import { findPageFile } from "../server/lib/find-page-file";
import { removeTrailingSlash } from "../shared/lib/router/utils/remove-trailing-slash";
import { isEdgeRuntime } from "../lib/is-edge-runtime";
import { normalizeLocalePath } from "../shared/lib/i18n/normalize-locale-path";
import * as Log from "./output/log";
import { loadComponents } from "../server/load-components";
import { trace } from "../trace";
import { setHttpClientAndAgentOptions } from "../server/setup-http-agent-env";
import { recursiveDelete } from "../lib/recursive-delete";
import { Sema } from "next/dist/compiled/async-sema";
import { denormalizePagePath } from "../shared/lib/page-path/denormalize-page-path";
import { normalizePagePath } from "../shared/lib/page-path/normalize-page-path";
import { getRuntimeContext } from "../server/web/sandbox";
import { isClientReference } from "../lib/client-reference";
import { StaticGenerationAsyncStorageWrapper } from "../server/async-storage/static-generation-async-storage-wrapper";
import { IncrementalCache } from "../server/lib/incremental-cache";
import { patchFetch } from "../server/lib/patch-fetch";
import { nodeFs } from "../server/lib/node-fs-methods";
import * as ciEnvironment from "../telemetry/ci-info";
import { normalizeAppPath } from "../shared/lib/router/utils/app-paths";
import { denormalizeAppPagePath } from "../shared/lib/page-path/denormalize-app-path";
import { AppRouteRouteModule } from "../server/future/route-modules/app-route/module";
const RESERVED_PAGE = /^\/(_app|_error|_document|api(\/|$))/;
const fileGzipStats = {};
const fsStatGzip = (file)=>{
const cached = fileGzipStats[file];
if (cached) return cached;
return fileGzipStats[file] = getGzipSize.file(file);
};
const fileSize = async (file)=>(await fs.stat(file)).size;
const fileStats = {};
const fsStat = (file)=>{
const cached = fileStats[file];
if (cached) return cached;
return fileStats[file] = fileSize(file);
};
export function unique(main, sub) {
return [
...new Set([
...main,
...sub
])
];
}
export function difference(main, sub) {
const a = new Set(main);
const b = new Set(sub);
return [
...a
].filter((x)=>!b.has(x));
}
/**
* Return an array of the items shared by both arrays.
*/ function intersect(main, sub) {
const a = new Set(main);
const b = new Set(sub);
return [
...new Set([
...a
].filter((x)=>b.has(x)))
];
}
function sum(a) {
return a.reduce((size, stat)=>size + stat, 0);
}
let cachedBuildManifest;
let cachedAppBuildManifest;
let lastCompute;
let lastComputePageInfo;
export async function computeFromManifest(manifests, distPath, gzipSize = true, pageInfos) {
var _manifests_app, _files_app;
if (Object.is(cachedBuildManifest, manifests.build) && lastComputePageInfo === !!pageInfos && Object.is(cachedAppBuildManifest, manifests.app)) {
return lastCompute;
}
// Determine the files that are in pages and app and count them, this will
// tell us if they are unique or common.
const countBuildFiles = (map, key, manifest)=>{
for (const file of manifest[key]){
if (key === "/_app") {
map.set(file, Infinity);
} else if (map.has(file)) {
map.set(file, map.get(file) + 1);
} else {
map.set(file, 1);
}
}
};
const files = {
pages: {
each: new Map(),
expected: 0
}
};
for(const key in manifests.build.pages){
if (pageInfos) {
const pageInfo = pageInfos.get(key);
// don't include AMP pages since they don't rely on shared bundles
// AMP First pages are not under the pageInfos key
if (pageInfo == null ? void 0 : pageInfo.isHybridAmp) {
continue;
}
}
files.pages.expected++;
countBuildFiles(files.pages.each, key, manifests.build.pages);
}
// Collect the build files form the app manifest.
if ((_manifests_app = manifests.app) == null ? void 0 : _manifests_app.pages) {
files.app = {
each: new Map(),
expected: 0
};
for(const key in manifests.app.pages){
files.app.expected++;
countBuildFiles(files.app.each, key, manifests.app.pages);
}
}
const getSize = gzipSize ? fsStatGzip : fsStat;
const stats = new Map();
// For all of the files in the pages and app manifests, compute the file size
// at once.
await Promise.all([
...new Set([
...files.pages.each.keys(),
...((_files_app = files.app) == null ? void 0 : _files_app.each.keys()) ?? []
])
].map(async (f)=>{
try {
// Add the file size to the stats.
stats.set(f, await getSize(path.join(distPath, f)));
} catch {}
}));
const groupFiles = async (listing)=>{
const entries = [
...listing.each.entries()
];
const shapeGroup = (group)=>group.reduce((acc, [f])=>{
acc.files.push(f);
const size = stats.get(f);
if (typeof size === "number") {
acc.size.total += size;
}
return acc;
}, {
files: [],
size: {
total: 0
}
});
return {
unique: shapeGroup(entries.filter(([, len])=>len === 1)),
common: shapeGroup(entries.filter(([, len])=>len === listing.expected || len === Infinity))
};
};
lastCompute = {
router: {
pages: await groupFiles(files.pages),
app: files.app ? await groupFiles(files.app) : undefined
},
sizes: stats
};
cachedBuildManifest = manifests.build;
cachedAppBuildManifest = manifests.app;
lastComputePageInfo = !!pageInfos;
return lastCompute;
}
export function isMiddlewareFilename(file) {
return file === MIDDLEWARE_FILENAME || file === `src/${MIDDLEWARE_FILENAME}`;
}
export function isInstrumentationHookFilename(file) {
return file === INSTRUMENTATION_HOOK_FILENAME || file === `src/${INSTRUMENTATION_HOOK_FILENAME}`;
}
export async function printTreeView(lists, pageInfos, { distPath , buildId , pagesDir , pageExtensions , buildManifest , appBuildManifest , middlewareManifest , useStatic404 , gzipSize =true }) {
var _middlewareManifest_middleware;
const getPrettySize = (_size)=>{
const size = prettyBytes(_size);
// green for 0-130kb
if (_size < 130 * 1000) return chalk.green(size);
// yellow for 130-170kb
if (_size < 170 * 1000) return chalk.yellow(size);
// red for >= 170kb
return chalk.red.bold(size);
};
const MIN_DURATION = 300;
const getPrettyDuration = (_duration)=>{
const duration = `${_duration} ms`;
// green for 300-1000ms
if (_duration < 1000) return chalk.green(duration);
// yellow for 1000-2000ms
if (_duration < 2000) return chalk.yellow(duration);
// red for >= 2000ms
return chalk.red.bold(duration);
};
const getCleanName = (fileName)=>fileName// Trim off `static/`
.replace(/^static\//, "")// Re-add `static/` for root files
.replace(/^<buildId>/, "static")// Remove file hash
.replace(/(?:^|[.-])([0-9a-z]{6})[0-9a-z]{14}(?=\.)/, ".$1");
// Check if we have a custom app.
const hasCustomApp = pagesDir && await findPageFile(pagesDir, "/_app", pageExtensions, false);
const filterAndSortList = (list)=>list.slice().filter((e)=>!(e === "/_document" || e === "/_error" || !hasCustomApp && e === "/_app")).sort((a, b)=>a.localeCompare(b));
// Collect all the symbols we use so we can print the icons out.
const usedSymbols = new Set();
const messages = [];
const stats = await computeFromManifest({
build: buildManifest,
app: appBuildManifest
}, distPath, gzipSize, pageInfos);
const printFileTree = async ({ list , routerType })=>{
var _stats_router_routerType, _stats_router_routerType1;
messages.push([
routerType === "app" ? "Route (app)" : "Route (pages)",
"Size",
"First Load JS"
].map((entry)=>chalk.underline(entry)));
filterAndSortList(list).forEach((item, i, arr)=>{
var _pageInfo_ssgPageDurations, _buildManifest_pages_item, _pageInfo_ssgPageRoutes;
const border = i === 0 ? arr.length === 1 ? "─" : "┌" : i === arr.length - 1 ? "└" : "├";
const pageInfo = pageInfos.get(item);
const ampFirst = buildManifest.ampFirstPages.includes(item);
const totalDuration = ((pageInfo == null ? void 0 : pageInfo.pageDuration) || 0) + ((pageInfo == null ? void 0 : (_pageInfo_ssgPageDurations = pageInfo.ssgPageDurations) == null ? void 0 : _pageInfo_ssgPageDurations.reduce((a, b)=>a + (b || 0), 0)) || 0);
const symbol = item === "/_app" || item === "/_app.server" ? " " : (pageInfo == null ? void 0 : pageInfo.static) ? "○" : (pageInfo == null ? void 0 : pageInfo.isSsg) ? "●" : isEdgeRuntime(pageInfo == null ? void 0 : pageInfo.runtime) ? "ℇ" : "λ";
usedSymbols.add(symbol);
if (pageInfo == null ? void 0 : pageInfo.initialRevalidateSeconds) usedSymbols.add("ISR");
messages.push([
`${border} ${symbol} ${(pageInfo == null ? void 0 : pageInfo.initialRevalidateSeconds) ? `${item} (ISR: ${pageInfo == null ? void 0 : pageInfo.initialRevalidateSeconds} Seconds)` : item}${totalDuration > MIN_DURATION ? ` (${getPrettyDuration(totalDuration)})` : ""}`,
pageInfo ? ampFirst ? chalk.cyan("AMP") : pageInfo.size >= 0 ? prettyBytes(pageInfo.size) : "" : "",
pageInfo ? ampFirst ? chalk.cyan("AMP") : pageInfo.size >= 0 ? getPrettySize(pageInfo.totalSize) : "" : ""
]);
const uniqueCssFiles = ((_buildManifest_pages_item = buildManifest.pages[item]) == null ? void 0 : _buildManifest_pages_item.filter((file)=>{
var _stats_router_routerType;
return file.endsWith(".css") && ((_stats_router_routerType = stats.router[routerType]) == null ? void 0 : _stats_router_routerType.unique.files.includes(file));
})) || [];
if (uniqueCssFiles.length > 0) {
const contSymbol = i === arr.length - 1 ? " " : "├";
uniqueCssFiles.forEach((file, index, { length })=>{
const innerSymbol = index === length - 1 ? "└" : "├";
const size = stats.sizes.get(file);
messages.push([
`${contSymbol} ${innerSymbol} ${getCleanName(file)}`,
typeof size === "number" ? prettyBytes(size) : "",
""
]);
});
}
if (pageInfo == null ? void 0 : (_pageInfo_ssgPageRoutes = pageInfo.ssgPageRoutes) == null ? void 0 : _pageInfo_ssgPageRoutes.length) {
const totalRoutes = pageInfo.ssgPageRoutes.length;
const contSymbol = i === arr.length - 1 ? " " : "├";
let routes;
if (pageInfo.ssgPageDurations && pageInfo.ssgPageDurations.some((d)=>d > MIN_DURATION)) {
const previewPages = totalRoutes === 8 ? 8 : Math.min(totalRoutes, 7);
const routesWithDuration = pageInfo.ssgPageRoutes.map((route, idx)=>({
route,
duration: pageInfo.ssgPageDurations[idx] || 0
})).sort(({ duration: a }, { duration: b })=>// Sort by duration
// keep too small durations in original order at the end
a <= MIN_DURATION && b <= MIN_DURATION ? 0 : b - a);
routes = routesWithDuration.slice(0, previewPages);
const remainingRoutes = routesWithDuration.slice(previewPages);
if (remainingRoutes.length) {
const remaining = remainingRoutes.length;
const avgDuration = Math.round(remainingRoutes.reduce((total, { duration })=>total + duration, 0) / remainingRoutes.length);
routes.push({
route: `[+${remaining} more paths]`,
duration: 0,
avgDuration
});
}
} else {
const previewPages = totalRoutes === 4 ? 4 : Math.min(totalRoutes, 3);
routes = pageInfo.ssgPageRoutes.slice(0, previewPages).map((route)=>({
route,
duration: 0
}));
if (totalRoutes > previewPages) {
const remaining = totalRoutes - previewPages;
routes.push({
route: `[+${remaining} more paths]`,
duration: 0
});
}
}
routes.forEach(({ route , duration , avgDuration }, index, { length })=>{
const innerSymbol = index === length - 1 ? "└" : "├";
messages.push([
`${contSymbol} ${innerSymbol} ${route}${duration > MIN_DURATION ? ` (${getPrettyDuration(duration)})` : ""}${avgDuration && avgDuration > MIN_DURATION ? ` (avg ${getPrettyDuration(avgDuration)})` : ""}`,
"",
""
]);
});
}
});
const sharedFilesSize = (_stats_router_routerType = stats.router[routerType]) == null ? void 0 : _stats_router_routerType.common.size.total;
const sharedFiles = ((_stats_router_routerType1 = stats.router[routerType]) == null ? void 0 : _stats_router_routerType1.common.files) ?? [];
messages.push([
"+ First Load JS shared by all",
typeof sharedFilesSize === "number" ? getPrettySize(sharedFilesSize) : "",
""
]);
const sharedCssFiles = [];
[
...sharedFiles.filter((file)=>{
if (file.endsWith(".css")) {
sharedCssFiles.push(file);
return false;
}
return true;
}).map((e)=>e.replace(buildId, "<buildId>")).sort(),
...sharedCssFiles.map((e)=>e.replace(buildId, "<buildId>")).sort()
].forEach((fileName, index, { length })=>{
const innerSymbol = index === length - 1 ? "└" : "├";
const originalName = fileName.replace("<buildId>", buildId);
const cleanName = getCleanName(fileName);
const size = stats.sizes.get(originalName);
messages.push([
` ${innerSymbol} ${cleanName}`,
typeof size === "number" ? prettyBytes(size) : "",
""
]);
});
};
// If enabled, then print the tree for the app directory.
if (lists.app && stats.router.app) {
await printFileTree({
routerType: "app",
list: lists.app
});
messages.push([
"",
"",
""
]);
}
pageInfos.set("/404", {
...pageInfos.get("/404") || pageInfos.get("/_error"),
static: useStatic404
});
if (!lists.pages.includes("/404")) {
lists.pages = [
...lists.pages,
"/404"
];
}
// Print the tree view for the pages directory.
await printFileTree({
routerType: "pages",
list: lists.pages
});
const middlewareInfo = (_middlewareManifest_middleware = middlewareManifest.middleware) == null ? void 0 : _middlewareManifest_middleware["/"];
if ((middlewareInfo == null ? void 0 : middlewareInfo.files.length) > 0) {
const middlewareSizes = await Promise.all(middlewareInfo.files.map((dep)=>`${distPath}/${dep}`).map(gzipSize ? fsStatGzip : fsStat));
messages.push([
"",
"",
""
]);
messages.push([
"ƒ Middleware",
getPrettySize(sum(middlewareSizes)),
""
]);
}
console.log(textTable(messages, {
align: [
"l",
"l",
"r"
],
stringLength: (str)=>stripAnsi(str).length
}));
console.log();
console.log(textTable([
usedSymbols.has("ℇ") && [
"ℇ",
"(Streaming)",
`server-side renders with streaming (uses React 18 SSR streaming or Server Components)`
],
usedSymbols.has("λ") && [
"λ",
"(Server)",
`server-side renders at runtime (uses ${chalk.cyan("getInitialProps")} or ${chalk.cyan("getServerSideProps")})`
],
usedSymbols.has("○") && [
"○",
"(Static)",
"automatically rendered as static HTML (uses no initial props)"
],
usedSymbols.has("●") && [
"●",
"(SSG)",
`automatically generated as static HTML + JSON (uses ${chalk.cyan("getStaticProps")})`
],
usedSymbols.has("ISR") && [
"",
"(ISR)",
`incremental static regeneration (uses revalidate in ${chalk.cyan("getStaticProps")})`
]
].filter((x)=>x), {
align: [
"l",
"l",
"l"
],
stringLength: (str)=>stripAnsi(str).length
}));
console.log();
}
export function printCustomRoutes({ redirects , rewrites , headers }) {
const printRoutes = (routes, type)=>{
const isRedirects = type === "Redirects";
const isHeaders = type === "Headers";
console.log(chalk.underline(type));
console.log();
/*
┌ source
├ permanent/statusCode
└ destination
*/ const routesStr = routes.map((route)=>{
let routeStr = `┌ source: ${route.source}\n`;
if (!isHeaders) {
const r = route;
routeStr += `${isRedirects ? "├" : "└"} destination: ${r.destination}\n`;
}
if (isRedirects) {
const r = route;
routeStr += `└ ${r.statusCode ? `status: ${r.statusCode}` : `permanent: ${r.permanent}`}\n`;
}
if (isHeaders) {
const r = route;
routeStr += `└ headers:\n`;
for(let i = 0; i < r.headers.length; i++){
const header = r.headers[i];
const last = i === headers.length - 1;
routeStr += ` ${last ? "└" : "├"} ${header.key}: ${header.value}\n`;
}
}
return routeStr;
}).join("\n");
console.log(routesStr, "\n");
};
if (redirects.length) {
printRoutes(redirects, "Redirects");
}
if (headers.length) {
printRoutes(headers, "Headers");
}
const combinedRewrites = [
...rewrites.beforeFiles,
...rewrites.afterFiles,
...rewrites.fallback
];
if (combinedRewrites.length) {
printRoutes(combinedRewrites, "Rewrites");
}
}
export async function getJsPageSizeInKb(routerType, page, distPath, buildManifest, appBuildManifest, gzipSize = true, cachedStats) {
const pageManifest = routerType === "pages" ? buildManifest : appBuildManifest;
if (!pageManifest) {
throw new Error('expected appBuildManifest with an "app" pageType');
}
// Normalize appBuildManifest keys
if (routerType === "app") {
pageManifest.pages = Object.entries(pageManifest.pages).reduce((acc, [key, value])=>{
const newKey = normalizeAppPath(key);
acc[newKey] = value;
return acc;
}, {});
}
// If stats was not provided, then compute it again.
const stats = cachedStats ?? await computeFromManifest({
build: buildManifest,
app: appBuildManifest
}, distPath, gzipSize);
const pageData = stats.router[routerType];
if (!pageData) {
// This error shouldn't happen and represents an error in Next.js.
throw new Error('expected "app" manifest data with an "app" pageType');
}
const pagePath = routerType === "pages" ? denormalizePagePath(page) : denormalizeAppPagePath(page);
const fnFilterJs = (entry)=>entry.endsWith(".js");
const pageFiles = (pageManifest.pages[pagePath] ?? []).filter(fnFilterJs);
const appFiles = (pageManifest.pages["/_app"] ?? []).filter(fnFilterJs);
const fnMapRealPath = (dep)=>`${distPath}/${dep}`;
const allFilesReal = unique(pageFiles, appFiles).map(fnMapRealPath);
const selfFilesReal = difference(// Find the files shared by the pages files and the unique files...
intersect(pageFiles, pageData.unique.files), // but without the common files.
pageData.common.files).map(fnMapRealPath);
const getSize = gzipSize ? fsStatGzip : fsStat;
// Try to get the file size from the page data if available, otherwise do a
// raw compute.
const getCachedSize = async (file)=>{
const key = file.slice(distPath.length + 1);
const size = stats.sizes.get(key);
// If the size wasn't in the stats bundle, then get it from the file
// directly.
if (typeof size !== "number") {
return getSize(file);
}
return size;
};
try {
// Doesn't use `Promise.all`, as we'd double compute duplicate files. This
// function is memoized, so the second one will instantly resolve.
const allFilesSize = sum(await Promise.all(allFilesReal.map(getCachedSize)));
const selfFilesSize = sum(await Promise.all(selfFilesReal.map(getCachedSize)));
return [
selfFilesSize,
allFilesSize
];
} catch {}
return [
-1,
-1
];
}
export async function buildStaticPaths({ page , getStaticPaths , staticPathsResult , configFileName , locales , defaultLocale , appDir }) {
const prerenderPaths = new Set();
const encodedPrerenderPaths = new Set();
const _routeRegex = getRouteRegex(page);
const _routeMatcher = getRouteMatcher(_routeRegex);
// Get the default list of allowed params.
const _validParamKeys = Object.keys(_routeMatcher(page));
if (!staticPathsResult) {
if (getStaticPaths) {
staticPathsResult = await getStaticPaths({
locales,
defaultLocale
});
} else {
throw new Error(`invariant: attempted to buildStaticPaths without "staticPathsResult" or "getStaticPaths" ${page}`);
}
}
const expectedReturnVal = `Expected: { paths: [], fallback: boolean }\n` + `See here for more info: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`;
if (!staticPathsResult || typeof staticPathsResult !== "object" || Array.isArray(staticPathsResult)) {
throw new Error(`Invalid value returned from getStaticPaths in ${page}. Received ${typeof staticPathsResult} ${expectedReturnVal}`);
}
const invalidStaticPathKeys = Object.keys(staticPathsResult).filter((key)=>!(key === "paths" || key === "fallback"));
if (invalidStaticPathKeys.length > 0) {
throw new Error(`Extra keys returned from getStaticPaths in ${page} (${invalidStaticPathKeys.join(", ")}) ${expectedReturnVal}`);
}
if (!(typeof staticPathsResult.fallback === "boolean" || staticPathsResult.fallback === "blocking")) {
throw new Error(`The \`fallback\` key must be returned from getStaticPaths in ${page}.\n` + expectedReturnVal);
}
const toPrerender = staticPathsResult.paths;
if (!Array.isArray(toPrerender)) {
throw new Error(`Invalid \`paths\` value returned from getStaticPaths in ${page}.\n` + `\`paths\` must be an array of strings or objects of shape { params: [key: string]: string }`);
}
toPrerender.forEach((entry)=>{
// For a string-provided path, we must make sure it matches the dynamic
// route.
if (typeof entry === "string") {
entry = removeTrailingSlash(entry);
const localePathResult = normalizeLocalePath(entry, locales);
let cleanedEntry = entry;
if (localePathResult.detectedLocale) {
cleanedEntry = entry.slice(localePathResult.detectedLocale.length + 1);
} else if (defaultLocale) {
entry = `/${defaultLocale}${entry}`;
}
const result = _routeMatcher(cleanedEntry);
if (!result) {
throw new Error(`The provided path \`${cleanedEntry}\` does not match the page: \`${page}\`.`);
}
// If leveraging the string paths variant the entry should already be
// encoded so we decode the segments ensuring we only escape path
// delimiters
prerenderPaths.add(entry.split("/").map((segment)=>escapePathDelimiters(decodeURIComponent(segment), true)).join("/"));
encodedPrerenderPaths.add(entry);
} else {
const invalidKeys = Object.keys(entry).filter((key)=>key !== "params" && key !== "locale");
if (invalidKeys.length) {
throw new Error(`Additional keys were returned from \`getStaticPaths\` in page "${page}". ` + `URL Parameters intended for this dynamic route must be nested under the \`params\` key, i.e.:` + `\n\n\treturn { params: { ${_validParamKeys.map((k)=>`${k}: ...`).join(", ")} } }` + `\n\nKeys that need to be moved: ${invalidKeys.join(", ")}.\n`);
}
const { params ={} } = entry;
let builtPage = page;
let encodedBuiltPage = page;
_validParamKeys.forEach((validParamKey)=>{
const { repeat , optional } = _routeRegex.groups[validParamKey];
let paramValue = params[validParamKey];
if (optional && params.hasOwnProperty(validParamKey) && (paramValue === null || paramValue === undefined || paramValue === false)) {
paramValue = [];
}
if (repeat && !Array.isArray(paramValue) || !repeat && typeof paramValue !== "string") {
// If from appDir and not all params were provided from
// generateStaticParams we can just filter this entry out
// as it's meant to be generated at runtime
if (appDir && typeof paramValue === "undefined") {
builtPage = "";
encodedBuiltPage = "";
return;
}
throw new Error(`A required parameter (${validParamKey}) was not provided as ${repeat ? "an array" : "a string"} received ${typeof paramValue} in ${appDir ? "generateStaticParams" : "getStaticPaths"} for ${page}`);
}
let replaced = `[${repeat ? "..." : ""}${validParamKey}]`;
if (optional) {
replaced = `[${replaced}]`;
}
builtPage = builtPage.replace(replaced, repeat ? paramValue.map((segment)=>escapePathDelimiters(segment, true)).join("/") : escapePathDelimiters(paramValue, true)).replace(/(?!^)\/$/, "");
encodedBuiltPage = encodedBuiltPage.replace(replaced, repeat ? paramValue.map(encodeURIComponent).join("/") : encodeURIComponent(paramValue)).replace(/(?!^)\/$/, "");
});
if (!builtPage && !encodedBuiltPage) {
return;
}
if (entry.locale && !(locales == null ? void 0 : locales.includes(entry.locale))) {
throw new Error(`Invalid locale returned from getStaticPaths for ${page}, the locale ${entry.locale} is not specified in ${configFileName}`);
}
const curLocale = entry.locale || defaultLocale || "";
prerenderPaths.add(`${curLocale ? `/${curLocale}` : ""}${curLocale && builtPage === "/" ? "" : builtPage}`);
encodedPrerenderPaths.add(`${curLocale ? `/${curLocale}` : ""}${curLocale && encodedBuiltPage === "/" ? "" : encodedBuiltPage}`);
}
});
return {
paths: [
...prerenderPaths
],
fallback: staticPathsResult.fallback,
encodedPaths: [
...encodedPrerenderPaths
]
};
}
export const collectAppConfig = (mod)=>{
let hasConfig = false;
const config = {};
if (typeof (mod == null ? void 0 : mod.revalidate) !== "undefined") {
config.revalidate = mod.revalidate;
hasConfig = true;
}
if (typeof (mod == null ? void 0 : mod.dynamicParams) !== "undefined") {
config.dynamicParams = mod.dynamicParams;
hasConfig = true;
}
if (typeof (mod == null ? void 0 : mod.dynamic) !== "undefined") {
config.dynamic = mod.dynamic;
hasConfig = true;
}
if (typeof (mod == null ? void 0 : mod.fetchCache) !== "undefined") {
config.fetchCache = mod.fetchCache;
hasConfig = true;
}
if (typeof (mod == null ? void 0 : mod.preferredRegion) !== "undefined") {
config.preferredRegion = mod.preferredRegion;
hasConfig = true;
}
return hasConfig ? config : undefined;
};
export const collectGenerateParams = async (segment, parentSegments = [], generateParams = [])=>{
var _segment_, _segment_1, _segment__layout, _segment__layout_, _segment_2, _segment__page, _segment__page_, _segment_3;
if (!Array.isArray(segment)) return generateParams;
const isLayout = !!((_segment_ = segment[2]) == null ? void 0 : _segment_.layout);
const mod = await (isLayout ? (_segment_1 = segment[2]) == null ? void 0 : (_segment__layout = _segment_1.layout) == null ? void 0 : (_segment__layout_ = _segment__layout[0]) == null ? void 0 : _segment__layout_.call(_segment__layout) : (_segment_2 = segment[2]) == null ? void 0 : (_segment__page = _segment_2.page) == null ? void 0 : (_segment__page_ = _segment__page[0]) == null ? void 0 : _segment__page_.call(_segment__page));
const config = collectAppConfig(mod);
const isClientComponent = isClientReference(mod);
const isDynamicSegment = segment[0] && /^\[.+\]$/.test(segment[0]);
const result = {
isLayout,
isDynamicSegment,
segmentPath: `/${parentSegments.join("/")}${segment[0] && parentSegments.length > 0 ? "/" : ""}${segment[0]}`,
config,
getStaticPaths: isClientComponent ? undefined : mod == null ? void 0 : mod.getStaticPaths,
generateStaticParams: isClientComponent ? undefined : mod == null ? void 0 : mod.generateStaticParams
};
if (segment[0]) {
parentSegments.push(segment[0]);
}
if (result.config || result.generateStaticParams || result.getStaticPaths) {
generateParams.push(result);
} else if (isDynamicSegment) {
// It is a dynamic route, but no config was provided
generateParams.push(result);
}
return collectGenerateParams((_segment_3 = segment[1]) == null ? void 0 : _segment_3.children, parentSegments, generateParams);
};
export async function buildAppStaticPaths({ page , distDir , configFileName , generateParams , isrFlushToDisk , incrementalCacheHandlerPath , requestHeaders , maxMemoryCacheSize , fetchCacheKeyPrefix , staticGenerationAsyncStorage , serverHooks }) {
patchFetch({
staticGenerationAsyncStorage,
serverHooks
});
let CacheHandler;
if (incrementalCacheHandlerPath) {
CacheHandler = require(incrementalCacheHandlerPath);
CacheHandler = CacheHandler.default || CacheHandler;
}
const incrementalCache = new IncrementalCache({
fs: nodeFs,
dev: true,
appDir: true,
flushToDisk: isrFlushToDisk,
serverDistDir: path.join(distDir, "server"),
fetchCacheKeyPrefix,
maxMemoryCacheSize,
getPrerenderManifest: ()=>({
version: -1,
routes: {},
dynamicRoutes: {},
notFoundRoutes: [],
preview: null
}),
CurCacheHandler: CacheHandler,
requestHeaders,
minimalMode: ciEnvironment.hasNextSupport
});
return StaticGenerationAsyncStorageWrapper.wrap(staticGenerationAsyncStorage, {
pathname: page,
renderOpts: {
originalPathname: page,
incrementalCache,
supportsDynamicHTML: true,
isRevalidate: false,
isBot: false
}
}, async ()=>{
const pageEntry = generateParams[generateParams.length - 1];
// if the page has legacy getStaticPaths we call it like normal
if (typeof (pageEntry == null ? void 0 : pageEntry.getStaticPaths) === "function") {
return buildStaticPaths({
page,
configFileName,
getStaticPaths: pageEntry.getStaticPaths
});
} else {
let hadAllParamsGenerated = false;
const buildParams = async (paramsItems = [
{}
], idx = 0)=>{
const curGenerate = generateParams[idx];
if (idx === generateParams.length) {
return paramsItems;
}
if (typeof curGenerate.generateStaticParams !== "function" && idx < generateParams.length) {
if (curGenerate.isDynamicSegment) {
// This dynamic level has no generateStaticParams so we change
// this flag to false, but it could be covered by a later
// generateStaticParams so it could be set back to true.
hadAllParamsGenerated = false;
}
return buildParams(paramsItems, idx + 1);
}
hadAllParamsGenerated = true;
const newParams = [];
for (const params of paramsItems){
const result = await curGenerate.generateStaticParams({
params
});
// TODO: validate the result is valid here or wait for
// buildStaticPaths to validate?
for (const item of result){
newParams.push({
...params,
...item
});
}
}
if (idx < generateParams.length) {
return buildParams(newParams, idx + 1);
}
return newParams;
};
const builtParams = await buildParams();
const fallback = !generateParams.some(// TODO: dynamic params should be allowed
// to be granular per segment but we need
// additional information stored/leveraged in
// the prerender-manifest to allow this behavior
(generate)=>{
var _generate_config;
return ((_generate_config = generate.config) == null ? void 0 : _generate_config.dynamicParams) === false;
});
if (!hadAllParamsGenerated) {
return {
paths: undefined,
fallback: process.env.NODE_ENV === "production" && isDynamicRoute(page) ? true : undefined,
encodedPaths: undefined
};
}
return buildStaticPaths({
staticPathsResult: {
fallback,
paths: builtParams.map((params)=>({
params
}))
},
page,
configFileName,
appDir: true
});
}
});
}
export async function isPageStatic({ page , distDir , configFileName , runtimeEnvConfig , httpAgentOptions , locales , defaultLocale , parentId , pageRuntime , edgeInfo , pageType , originalAppPath , isrFlushToDisk , maxMemoryCacheSize , incrementalCacheHandlerPath }) {
const isPageStaticSpan = trace("is-page-static-utils", parentId);
return isPageStaticSpan.traceAsyncFn(async ()=>{
require("../shared/lib/runtime-config").setConfig(runtimeEnvConfig);
setHttpClientAndAgentOptions({
httpAgentOptions
});
let componentsResult;
let prerenderRoutes;
let encodedPrerenderRoutes;
let prerenderFallback;
let appConfig = {};
let isClientComponent = false;
const pathIsEdgeRuntime = isEdgeRuntime(pageRuntime);
if (pathIsEdgeRuntime) {
const runtime = await getRuntimeContext({
paths: edgeInfo.files.map((file)=>path.join(distDir, file)),
edgeFunctionEntry: {
...edgeInfo,
wasm: (edgeInfo.wasm ?? []).map((binding)=>({
...binding,
filePath: path.join(distDir, binding.filePath)
}))
},
name: edgeInfo.name,
useCache: true,
distDir
});
const mod = runtime.context._ENTRIES[`middleware_${edgeInfo.name}`].ComponentMod;
isClientComponent = isClientReference(mod);
componentsResult = {
Component: mod.default,
ComponentMod: mod,
pageConfig: mod.config || {},
// @ts-expect-error this is not needed during require
buildManifest: {},
reactLoadableManifest: {},
getServerSideProps: mod.getServerSideProps,
getStaticPaths: mod.getStaticPaths,
getStaticProps: mod.getStaticProps
};
} else {
componentsResult = await loadComponents({
distDir,
pathname: originalAppPath || page,
isAppPath: pageType === "app"
});
}
const Comp = componentsResult.Component || {};
let staticPathsResult;
if (pageType === "app") {
isClientComponent = isClientReference(componentsResult.ComponentMod);
const tree = componentsResult.ComponentMod.tree;
const staticGenerationAsyncStorage = componentsResult.ComponentMod.staticGenerationAsyncStorage;
if (!staticGenerationAsyncStorage) {
throw new Error("Invariant: staticGenerationAsyncStorage should be defined on the module");
}
const serverHooks = componentsResult.ComponentMod.serverHooks;
if (!serverHooks) {
throw new Error("Invariant: serverHooks should be defined on the module");
}
const { routeModule } = componentsResult;
const generateParams = routeModule && AppRouteRouteModule.is(routeModule) ? [
{
config: {
revalidate: routeModule.userland.revalidate,
dynamic: routeModule.userland.dynamic,
dynamicParams: routeModule.userland.dynamicParams
},
generateStaticParams: routeModule.userland.generateStaticParams,
segmentPath: page
}
] : await collectGenerateParams(tree);
appConfig = generateParams.reduce((builtConfig, curGenParams)=>{
const { dynamic , fetchCache , preferredRegion , revalidate: curRevalidate } = (curGenParams == null ? void 0 : curGenParams.config) || {};
// TODO: should conflicting configs here throw an error
// e.g. if layout defines one region but page defines another
if (typeof builtConfig.preferredRegion === "undefined") {
builtConfig.preferredRegion = preferredRegion;
}
if (typeof builtConfig.dynamic === "undefined") {
builtConfig.dynamic = dynamic;
}
if (typeof builtConfig.fetchCache === "undefined") {
builtConfig.fetchCache = fetchCache;
}
// any revalidate number overrides false
// shorter revalidate overrides longer (initially)
if (typeof builtConfig.revalidate === "undefined") {
builtConfig.revalidate = curRevalidate;
}
if (typeof curRevalidate === "number" && (typeof builtConfig.revalidate !== "number" || curRevalidate < builtConfig.revalidate)) {
builtConfig.revalidate = curRevalidate;
}
return builtConfig;
}, {});
if (appConfig.dynamic === "force-static" && pathIsEdgeRuntime) {
Log.warn(`Page "${page}" is using runtime = 'edge' which is currently incompatible with dynamic = 'force-static'. Please remove either "runtime" or "force-static" for correct behavior`);
}
if (appConfig.dynamic === "force-dynamic") {
appConfig.revalidate = 0;
}
if (isDynamicRoute(page)) {
({ paths: prerenderRoutes , fallback: prerenderFallback , encodedPaths: encodedPrerenderRoutes } = await buildAppStaticPaths({
page,
serverHooks,
staticGenerationAsyncStorage,
configFileName,
generateParams,
distDir,
requestHeaders: {},
isrFlushToDisk,
maxMemoryCacheSize,
incrementalCacheHandlerPath
}));
}
} else {
if (!Comp || !isValidElementType(Comp) || typeof Comp === "string") {
throw new Error("INVALID_DEFAULT_EXPORT");
}
}
const hasGetInitialProps = !!Comp.getInitialProps;
const hasStaticProps = !!componentsResult.getStaticProps;
const hasStaticPaths = !!componentsResult.getStaticPaths;
const hasServerProps = !!componentsResult.getServerSideProps;
const hasLegacyServerProps = !!await componentsResult.ComponentMod.unstable_getServerProps;
const hasLegacyStaticProps = !!await componentsResult.ComponentMod.unstable_getStaticProps;
const hasLegacyStaticPaths = !!await componentsResult.ComponentMod.unstable_getStaticPaths;
const hasLegacyStaticParams = !!await componentsResult.ComponentMod.unstable_getStaticParams;
if (hasLegacyStaticParams) {
throw new Error(`unstable_getStaticParams was replaced with getStaticPaths. Please update your code.`);
}
if (hasLegacyStaticPaths) {
throw new Error(`unstable_getStaticPaths was replaced with getStaticPaths. Please update your code.`);
}
if (hasLegacyStaticProps) {
throw new Error(`unstable_getStaticProps was replaced with getStaticProps. Please update your code.`);
}
if (hasLegacyServerProps) {
throw new Error(`unstable_getServerProps was replaced with getServerSideProps. Please update your code.`);
}
// A page cannot be prerendered _and_ define a data requirement. That's
// contradictory!
if (hasGetInitialProps && hasStaticProps) {
throw new Error(SSG_GET_INITIAL_PROPS_CONFLICT);
}
if (hasGetInitialProps && hasServerProps) {
throw new Error(SERVER_PROPS_GET_INIT_PROPS_CONFLICT);
}
if (hasStaticProps && hasServerProps) {
throw new Error(SERVER_PROPS_SSG_CONFLICT);
}
const pageIsDynamic = isDynamicRoute(page);
// A page cannot have static parameters if it is not a dynamic page.
if (hasStaticProps && hasStaticPaths && !pageIsDynamic) {
throw new Error(`getStaticPaths can only be used with dynamic pages, not '${page}'.` + `\nLearn more: https://nextjs.org/docs/routing/dynamic-routes`);
}
if (hasStaticProps && pageIsDynamic && !hasStaticPaths) {
throw new Error(`getStaticPaths is required for dynamic SSG pages and is missing for '${page}'.` + `\nRead more: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`);
}
if (hasStaticProps && hasStaticPaths || staticPathsResult) {
({ paths: prerenderRoutes , fallback: prerenderFallback , encodedPaths: encodedPrerenderRoutes } = await buildStaticPaths({
page,
locales,
defaultLocale,
configFileName,
staticPathsResult,
getStaticPaths: componentsResult.getStaticPaths
}));
}
const isNextImageImported = globalThis.__NEXT_IMAGE_IMPORTED;
const config = isClientComponent ? {} : componentsResult.pageConfig;
if (config.unstable_includeFiles || config.unstable_excludeFiles) {
Log.warn(`unstable_includeFiles/unstable_excludeFiles has been removed in favor of the option in next.config.js.\nSee more info here: https://nextjs.org/docs/advanced-features/output-file-tracing#caveats`);
}
return {
isStatic: !hasStaticProps && !hasGetInitialProps && !hasServerProps,
isHybridAmp: config.amp === "hybrid",
isAmpOnly: config.amp === true,
prerenderRoutes,
prerenderFallback,
encodedPrerenderRoutes,
hasStaticProps,
hasServerProps,
isNextImageImported,
appConfig
};
}).catch((err)=>{
if (err.message === "INVALID_DEFAULT_EXPORT") {
throw err;
}
console.error(err);
throw new Error(`Failed to collect page data for ${page}`);
});
}
export async function hasCustomGetInitialProps(page, distDir, runtimeEnvConfig, checkingApp) {
require("../shared/lib/runtime-config").setConfig(runtimeEnvConfig);
const components = await loadComponents({
distDir,
pathname: page,
isAppPath: false
});
let mod = components.ComponentMod;
if (checkingApp) {
mod = await mod._app || mod.default || mod;
} else {
mod = mod.default || mod;
}
mod = await mod;
return mod.getInitialProps !== mod.origGetInitialProps;
}
export async function getDefinedNamedExports(page, distDir, runtimeEnvConfig) {
require("../shared/lib/runtime-config").setConfig(runtimeEnvConfig);
const components = await loadComponents({
distDir,
pathname: page,
isAppPath: false
});
return Object.keys(components.ComponentMod).filter((key)=>{
return typeof components.ComponentMod[key] !== "undefined";
});
}
export function detectConflictingPaths(combinedPages, ssgPages, additionalSsgPaths) {
const conflictingPaths = new Map();
const dynamicSsgPages = [
...ssgPages
].filter((page)=>isDynamicRoute(page));
const additionalSsgPathsByPath = {};
additionalSsgPaths.forEach((paths, pathsPage)=>{
additionalSsgPathsByPath[pathsPage] ||= {};
paths.forEach((curPath)=>{
const currentPath = curPath.toLowerCase();
additionalSsgPathsByPath[pathsPage][currentPath] = curPath;
});
});
additionalSsgPaths.forEach((paths, pathsPage)=>{
paths.forEach((curPath)=>{
const lowerPath = curPath.toLowerCase();
let conflictingPage = combinedPages.find((page)=>page.toLowerCase() === lowerPath);
if (conflictingPage) {
conflictingPaths.set(lowerPath, [
{
path: curPath,
page: pathsPage
},
{
path: conflictingPage,
page: conflictingPage
}
]);
} else {
let conflictingPath;
conflictingPage = dynamicSsgPages.find((page)=>{
if (page === pathsPage) return false;
conflictingPath = additionalSsgPaths.get(page) == null ? undefined : additionalSsgPathsByPath[page][lowerPath];
return conflictingPath;
});
if (confli