Spaces:
Running
Running
| ; | |
| Object.defineProperty(exports, "__esModule", { | |
| value: true | |
| }); | |
| 0 && (module.exports = { | |
| NestedMiddlewareError: null, | |
| RSPACK_DEFAULT_LAYERS_REGEX: null, | |
| collectMeta: null, | |
| collectRoutesUsingEdgeRuntime: null, | |
| copyTracedFiles: null, | |
| detectConflictingPaths: null, | |
| difference: null, | |
| getDefinedNamedExports: null, | |
| getPossibleInstrumentationHookFilenames: null, | |
| getPossibleMiddlewareFilenames: null, | |
| getSupportedBrowsers: null, | |
| hasCustomGetInitialProps: null, | |
| isAppBuiltinPage: null, | |
| isCustomErrorPage: null, | |
| isInstrumentationHookFile: null, | |
| isInstrumentationHookFilename: null, | |
| isMiddlewareFile: null, | |
| isMiddlewareFilename: null, | |
| isPageStatic: null, | |
| isProxyFile: null, | |
| isReservedPage: null, | |
| isWebpackAppPagesLayer: null, | |
| isWebpackBundledLayer: null, | |
| isWebpackClientOnlyLayer: null, | |
| isWebpackDefaultLayer: null, | |
| pageToRoute: null, | |
| printBuildErrors: null, | |
| printCustomRoutes: null, | |
| printTreeView: null, | |
| reduceAppConfig: null, | |
| shouldUseReactServerCondition: null, | |
| unique: null | |
| }); | |
| function _export(target, all) { | |
| for(var name in all)Object.defineProperty(target, name, { | |
| enumerable: true, | |
| get: all[name] | |
| }); | |
| } | |
| _export(exports, { | |
| NestedMiddlewareError: function() { | |
| return NestedMiddlewareError; | |
| }, | |
| RSPACK_DEFAULT_LAYERS_REGEX: function() { | |
| return RSPACK_DEFAULT_LAYERS_REGEX; | |
| }, | |
| collectMeta: function() { | |
| return collectMeta; | |
| }, | |
| collectRoutesUsingEdgeRuntime: function() { | |
| return collectRoutesUsingEdgeRuntime; | |
| }, | |
| copyTracedFiles: function() { | |
| return copyTracedFiles; | |
| }, | |
| detectConflictingPaths: function() { | |
| return detectConflictingPaths; | |
| }, | |
| difference: function() { | |
| return difference; | |
| }, | |
| getDefinedNamedExports: function() { | |
| return getDefinedNamedExports; | |
| }, | |
| getPossibleInstrumentationHookFilenames: function() { | |
| return getPossibleInstrumentationHookFilenames; | |
| }, | |
| getPossibleMiddlewareFilenames: function() { | |
| return getPossibleMiddlewareFilenames; | |
| }, | |
| getSupportedBrowsers: function() { | |
| return getSupportedBrowsers; | |
| }, | |
| hasCustomGetInitialProps: function() { | |
| return hasCustomGetInitialProps; | |
| }, | |
| isAppBuiltinPage: function() { | |
| return isAppBuiltinPage; | |
| }, | |
| isCustomErrorPage: function() { | |
| return isCustomErrorPage; | |
| }, | |
| isInstrumentationHookFile: function() { | |
| return isInstrumentationHookFile; | |
| }, | |
| isInstrumentationHookFilename: function() { | |
| return isInstrumentationHookFilename; | |
| }, | |
| isMiddlewareFile: function() { | |
| return isMiddlewareFile; | |
| }, | |
| isMiddlewareFilename: function() { | |
| return isMiddlewareFilename; | |
| }, | |
| isPageStatic: function() { | |
| return isPageStatic; | |
| }, | |
| isProxyFile: function() { | |
| return isProxyFile; | |
| }, | |
| isReservedPage: function() { | |
| return isReservedPage; | |
| }, | |
| isWebpackAppPagesLayer: function() { | |
| return isWebpackAppPagesLayer; | |
| }, | |
| isWebpackBundledLayer: function() { | |
| return isWebpackBundledLayer; | |
| }, | |
| isWebpackClientOnlyLayer: function() { | |
| return isWebpackClientOnlyLayer; | |
| }, | |
| isWebpackDefaultLayer: function() { | |
| return isWebpackDefaultLayer; | |
| }, | |
| pageToRoute: function() { | |
| return pageToRoute; | |
| }, | |
| printBuildErrors: function() { | |
| return printBuildErrors; | |
| }, | |
| printCustomRoutes: function() { | |
| return printCustomRoutes; | |
| }, | |
| printTreeView: function() { | |
| return printTreeView; | |
| }, | |
| reduceAppConfig: function() { | |
| return reduceAppConfig; | |
| }, | |
| shouldUseReactServerCondition: function() { | |
| return shouldUseReactServerCondition; | |
| }, | |
| unique: function() { | |
| return unique; | |
| } | |
| }); | |
| const _ppr = require("../server/lib/experimental/ppr"); | |
| const _loadcustomroutes = require("../lib/load-custom-routes"); | |
| const _constants = require("../lib/constants"); | |
| require("../server/require-hook"); | |
| require("../server/node-polyfill-crypto"); | |
| require("../server/node-environment"); | |
| const _picocolors = require("../lib/picocolors"); | |
| const _texttable = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/text-table")); | |
| const _path = /*#__PURE__*/ _interop_require_default(require("path")); | |
| const _fs = require("fs"); | |
| const _reactis = require("next/dist/compiled/react-is"); | |
| const _stripansi = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/strip-ansi")); | |
| const _browserslist = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/browserslist")); | |
| const _constants1 = require("../shared/lib/constants"); | |
| const _isdynamic = require("../shared/lib/router/utils/is-dynamic"); | |
| const _findpagefile = require("../server/lib/find-page-file"); | |
| const _isedgeruntime = require("../lib/is-edge-runtime"); | |
| const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log")); | |
| const _loadcomponents = require("../server/load-components"); | |
| const _trace = require("../trace"); | |
| const _setuphttpagentenv = require("../server/setup-http-agent-env"); | |
| const _asyncsema = require("next/dist/compiled/async-sema"); | |
| const _normalizepagepath = require("../shared/lib/page-path/normalize-page-path"); | |
| const _sandbox = require("../server/web/sandbox"); | |
| const _routekind = require("../server/route-kind"); | |
| const _appsegments = require("./segment-config/app/app-segments"); | |
| const _createincrementalcache = require("../export/helpers/create-incremental-cache"); | |
| const _collectrootparamkeys = require("./segment-config/app/collect-root-param-keys"); | |
| const _app = require("./static-paths/app"); | |
| const _pages = require("./static-paths/pages"); | |
| const _format = require("./output/format"); | |
| const _utils = require("../shared/lib/turbopack/utils"); | |
| const _routeregex = require("../shared/lib/router/utils/route-regex"); | |
| const _app1 = require("../shared/lib/router/routes/app"); | |
| function _interop_require_default(obj) { | |
| return obj && obj.__esModule ? obj : { | |
| default: obj | |
| }; | |
| } | |
| function _getRequireWildcardCache(nodeInterop) { | |
| if (typeof WeakMap !== "function") return null; | |
| var cacheBabelInterop = new WeakMap(); | |
| var cacheNodeInterop = new WeakMap(); | |
| return (_getRequireWildcardCache = function(nodeInterop) { | |
| return nodeInterop ? cacheNodeInterop : cacheBabelInterop; | |
| })(nodeInterop); | |
| } | |
| function _interop_require_wildcard(obj, nodeInterop) { | |
| if (!nodeInterop && obj && obj.__esModule) { | |
| return obj; | |
| } | |
| if (obj === null || typeof obj !== "object" && typeof obj !== "function") { | |
| return { | |
| default: obj | |
| }; | |
| } | |
| var cache = _getRequireWildcardCache(nodeInterop); | |
| if (cache && cache.has(obj)) { | |
| return cache.get(obj); | |
| } | |
| var newObj = { | |
| __proto__: null | |
| }; | |
| var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; | |
| for(var key in obj){ | |
| if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { | |
| var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; | |
| if (desc && (desc.get || desc.set)) { | |
| Object.defineProperty(newObj, key, desc); | |
| } else { | |
| newObj[key] = obj[key]; | |
| } | |
| } | |
| } | |
| newObj.default = obj; | |
| if (cache) { | |
| cache.set(obj, newObj); | |
| } | |
| return newObj; | |
| } | |
| // Use `print()` for expected console output | |
| const print = console.log; | |
| const RESERVED_PAGE = /^\/(_app|_error|_document|api(\/|$))/; | |
| function unique(main, sub) { | |
| return [ | |
| ...new Set([ | |
| ...main, | |
| ...sub | |
| ]) | |
| ]; | |
| } | |
| function difference(main, sub) { | |
| const a = new Set(main); | |
| const b = new Set(sub); | |
| return [ | |
| ...a | |
| ].filter((x)=>!b.has(x)); | |
| } | |
| function isMiddlewareFilename(file) { | |
| return file === _constants.MIDDLEWARE_FILENAME || file === `src/${_constants.MIDDLEWARE_FILENAME}` || file === _constants.PROXY_FILENAME || file === `src/${_constants.PROXY_FILENAME}`; | |
| } | |
| function isInstrumentationHookFilename(file) { | |
| return file === _constants.INSTRUMENTATION_HOOK_FILENAME || file === `src/${_constants.INSTRUMENTATION_HOOK_FILENAME}`; | |
| } | |
| const filterAndSortList = (list, routeType, hasCustomApp)=>{ | |
| let pages; | |
| if (routeType === 'app') { | |
| // filter out static app route of /favicon.ico and /_global-error | |
| pages = list.filter((e)=>{ | |
| if (e === '/favicon.ico') return false; | |
| // Hide static /_global-error from build output | |
| if (e === '/_global-error') return false; | |
| return true; | |
| }); | |
| } else { | |
| // filter built-in pages | |
| pages = list.slice().filter((e)=>!(e === '/_document' || e === '/_error' || !hasCustomApp && e === '/_app')); | |
| } | |
| return pages.sort((a, b)=>a.localeCompare(b)); | |
| }; | |
| function collectRoutesUsingEdgeRuntime(input) { | |
| const routesUsingEdgeRuntime = {}; | |
| for (const [route, info] of input.entries()){ | |
| if ((0, _isedgeruntime.isEdgeRuntime)(info.runtime)) { | |
| routesUsingEdgeRuntime[route] = 0; | |
| } | |
| } | |
| return routesUsingEdgeRuntime; | |
| } | |
| function printBuildErrors(entrypoints, isDev) { | |
| // Issues that we want to stop the server from executing | |
| const topLevelFatalIssues = []; | |
| // Issues that are true errors, but we believe we can keep running and allow the user to address the issue | |
| const topLevelErrors = []; | |
| // Issues that are warnings but should not affect the running of the build | |
| const topLevelWarnings = []; | |
| // Track seen formatted error messages to avoid duplicates | |
| const seenFatalIssues = new Set(); | |
| const seenErrors = new Set(); | |
| const seenWarnings = new Set(); | |
| for (const issue of entrypoints.issues){ | |
| // We only want to completely shut down the server | |
| if (issue.severity === 'fatal' || issue.severity === 'bug') { | |
| const formatted = (0, _utils.formatIssue)(issue); | |
| if (!seenFatalIssues.has(formatted)) { | |
| seenFatalIssues.add(formatted); | |
| topLevelFatalIssues.push(formatted); | |
| } | |
| } else if ((0, _utils.isRelevantWarning)(issue)) { | |
| const formatted = (0, _utils.formatIssue)(issue); | |
| if (!seenWarnings.has(formatted)) { | |
| seenWarnings.add(formatted); | |
| topLevelWarnings.push(formatted); | |
| } | |
| } else if (issue.severity === 'error') { | |
| const formatted = (0, _utils.formatIssue)(issue); | |
| if (isDev) { | |
| // We want to treat errors as recoverable in development | |
| // so that we can show the errors in the site and allow users | |
| // to respond to the errors when necessary. In production builds | |
| // though we want to error out and stop the build process. | |
| if (!seenErrors.has(formatted)) { | |
| seenErrors.add(formatted); | |
| topLevelErrors.push(formatted); | |
| } | |
| } else { | |
| if (!seenFatalIssues.has(formatted)) { | |
| seenFatalIssues.add(formatted); | |
| topLevelFatalIssues.push(formatted); | |
| } | |
| } | |
| } | |
| } | |
| // TODO: print in order by source location so issues from the same file are displayed together and then add a summary at the end about the number of warnings/errors | |
| if (topLevelWarnings.length > 0) { | |
| console.warn(`Turbopack build encountered ${topLevelWarnings.length} warnings:\n${topLevelWarnings.join('\n')}`); | |
| } | |
| if (topLevelErrors.length > 0) { | |
| console.error(`Turbopack build encountered ${topLevelErrors.length} errors:\n${topLevelErrors.join('\n')}`); | |
| } | |
| if (topLevelFatalIssues.length > 0) { | |
| throw Object.defineProperty(new Error(`Turbopack build failed with ${topLevelFatalIssues.length} errors:\n${topLevelFatalIssues.join('\n')}`), "__NEXT_ERROR_CODE", { | |
| value: "E425", | |
| enumerable: false, | |
| configurable: true | |
| }); | |
| } | |
| } | |
| async function printTreeView(lists, pageInfos, { pagesDir, pageExtensions, middlewareManifest, functionsConfigManifest, useStaticPages404, hasGSPAndRevalidateZero }) { | |
| var _lists_app, _middlewareManifest_middleware_, _middlewareManifest_middleware, // 'nodejs' runtime middleware or proxy is set to | |
| // functions-config-manifest instead of middleware-manifest. | |
| _functionsConfigManifest_functions; | |
| // Can be overridden for test purposes to omit the build duration output. | |
| const MIN_DURATION = process.env.__NEXT_PRIVATE_DETERMINISTIC_BUILD_OUTPUT ? Infinity // Don't ever log build durations. | |
| : 300; | |
| const getPrettyDuration = (_duration)=>{ | |
| const duration = `${_duration} ms`; | |
| // green for 300-1000ms | |
| if (_duration < 1000) return (0, _picocolors.green)(duration); | |
| // yellow for 1000-2000ms | |
| if (_duration < 2000) return (0, _picocolors.yellow)(duration); | |
| // red for >= 2000ms | |
| return (0, _picocolors.red)((0, _picocolors.bold)(duration)); | |
| }; | |
| // Check if we have a custom app. | |
| const hasCustomApp = !!(pagesDir && await (0, _findpagefile.findPageFile)(pagesDir, '/_app', pageExtensions, false)); | |
| // Collect all the symbols we use so we can print the icons out. | |
| const usedSymbols = new Set(); | |
| const messages = []; | |
| const printFileTree = async ({ list, routerType })=>{ | |
| const filteredPages = filterAndSortList(list, routerType, hasCustomApp); | |
| if (filteredPages.length === 0) { | |
| return; | |
| } | |
| let showRevalidate = false; | |
| let showExpire = false; | |
| for (const page of filteredPages){ | |
| var _pageInfos_get; | |
| const cacheControl = (_pageInfos_get = pageInfos.get(page)) == null ? void 0 : _pageInfos_get.initialCacheControl; | |
| if (cacheControl == null ? void 0 : cacheControl.revalidate) { | |
| showRevalidate = true; | |
| } | |
| if (cacheControl == null ? void 0 : cacheControl.expire) { | |
| showExpire = true; | |
| } | |
| if (showRevalidate && showExpire) { | |
| break; | |
| } | |
| } | |
| messages.push([ | |
| routerType === 'app' ? 'Route (app)' : 'Route (pages)', | |
| showRevalidate ? 'Revalidate' : '', | |
| showExpire ? 'Expire' : '' | |
| ].filter((entry)=>entry !== '').map((entry)=>(0, _picocolors.underline)(entry))); | |
| filteredPages.forEach((item, i, arr)=>{ | |
| var _pageInfo_ssgPageDurations, _pageInfo_ssgPageRoutes; | |
| const border = i === 0 ? arr.length === 1 ? '─' : '┌' : i === arr.length - 1 ? '└' : '├'; | |
| const pageInfo = pageInfos.get(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); | |
| let symbol; | |
| if (item === '/_app' || item === '/_app.server') { | |
| symbol = ' '; | |
| } else if ((0, _isedgeruntime.isEdgeRuntime)(pageInfo == null ? void 0 : pageInfo.runtime)) { | |
| symbol = 'ƒ'; | |
| } else if (pageInfo == null ? void 0 : pageInfo.isRoutePPREnabled) { | |
| if (// If the page has an empty static shell, then it's equivalent to a | |
| // dynamic page | |
| (pageInfo == null ? void 0 : pageInfo.hasEmptyStaticShell) || // ensure we don't mark dynamic paths that postponed as being dynamic | |
| // since in this case we're able to partially prerender it | |
| pageInfo.isDynamicAppRoute && !pageInfo.hasPostponed) { | |
| symbol = 'ƒ'; | |
| } else if (!(pageInfo == null ? void 0 : pageInfo.hasPostponed)) { | |
| symbol = '○'; | |
| } else { | |
| symbol = '◐'; | |
| } | |
| } else if (pageInfo == null ? void 0 : pageInfo.isStatic) { | |
| symbol = '○'; | |
| } else if (pageInfo == null ? void 0 : pageInfo.isSSG) { | |
| symbol = '●'; | |
| } else { | |
| symbol = 'ƒ'; | |
| } | |
| if (hasGSPAndRevalidateZero.has(item)) { | |
| usedSymbols.add('ƒ'); | |
| messages.push([ | |
| `${border} ƒ ${item}${totalDuration > MIN_DURATION ? ` (${getPrettyDuration(totalDuration)})` : ''}`, | |
| showRevalidate && (pageInfo == null ? void 0 : pageInfo.initialCacheControl) ? (0, _format.formatRevalidate)(pageInfo.initialCacheControl) : '', | |
| showExpire && (pageInfo == null ? void 0 : pageInfo.initialCacheControl) ? (0, _format.formatExpire)(pageInfo.initialCacheControl) : '' | |
| ]); | |
| } | |
| usedSymbols.add(symbol); | |
| messages.push([ | |
| `${border} ${symbol} ${item}${totalDuration > MIN_DURATION ? ` (${getPrettyDuration(totalDuration)})` : ''}`, | |
| showRevalidate && (pageInfo == null ? void 0 : pageInfo.initialCacheControl) ? (0, _format.formatRevalidate)(pageInfo.initialCacheControl) : '', | |
| showExpire && (pageInfo == null ? void 0 : pageInfo.initialCacheControl) ? (0, _format.formatExpire)(pageInfo.initialCacheControl) : '' | |
| ]); | |
| if (pageInfo == null ? void 0 : (_pageInfo_ssgPageRoutes = pageInfo.ssgPageRoutes) == null ? void 0 : _pageInfo_ssgPageRoutes.length) { | |
| var _pageInfo_ssgPageDurations1; | |
| const totalRoutes = pageInfo.ssgPageRoutes.length; | |
| const contSymbol = i === arr.length - 1 ? ' ' : '│'; | |
| // HERE | |
| let routes; | |
| if ((_pageInfo_ssgPageDurations1 = pageInfo.ssgPageDurations) == null ? void 0 : _pageInfo_ssgPageDurations1.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 })=>{ | |
| var _pageInfos_get; | |
| const innerSymbol = index === length - 1 ? '└' : '├'; | |
| const initialCacheControl = (_pageInfos_get = pageInfos.get(route)) == null ? void 0 : _pageInfos_get.initialCacheControl; | |
| messages.push([ | |
| `${contSymbol} ${innerSymbol} ${route}${duration > MIN_DURATION ? ` (${getPrettyDuration(duration)})` : ''}${avgDuration && avgDuration > MIN_DURATION ? ` (avg ${getPrettyDuration(avgDuration)})` : ''}`, | |
| showRevalidate && initialCacheControl ? (0, _format.formatRevalidate)(initialCacheControl) : '', | |
| showExpire && initialCacheControl ? (0, _format.formatExpire)(initialCacheControl) : '' | |
| ]); | |
| }); | |
| } | |
| }); | |
| }; | |
| // If enabled, then print the tree for the app directory. | |
| if (lists.app) { | |
| await printFileTree({ | |
| routerType: 'app', | |
| list: lists.app | |
| }); | |
| messages.push([ | |
| '', | |
| '', | |
| '', | |
| '' | |
| ]); | |
| } | |
| pageInfos.set('/404', { | |
| ...pageInfos.get('/404') || pageInfos.get('/_error'), | |
| isStatic: useStaticPages404 | |
| }); | |
| // If there's no app /_notFound page present, then the 404 is still using the pages/404 | |
| if (!lists.pages.includes('/404') && !((_lists_app = lists.app) == null ? void 0 : _lists_app.includes(_constants1.UNDERSCORE_NOT_FOUND_ROUTE))) { | |
| lists.pages = [ | |
| ...lists.pages, | |
| '/404' | |
| ]; | |
| } | |
| // Print the tree view for the pages directory. | |
| await printFileTree({ | |
| routerType: 'pages', | |
| list: lists.pages | |
| }); | |
| if (((_middlewareManifest_middleware = middlewareManifest.middleware) == null ? void 0 : (_middlewareManifest_middleware_ = _middlewareManifest_middleware['/']) == null ? void 0 : _middlewareManifest_middleware_.files.length) > 0 || ((_functionsConfigManifest_functions = functionsConfigManifest.functions) == null ? void 0 : _functionsConfigManifest_functions['/_middleware'])) { | |
| messages.push([]); | |
| messages.push([ | |
| 'ƒ Proxy (Middleware)' | |
| ]); | |
| } | |
| print((0, _texttable.default)(messages, { | |
| align: [ | |
| 'l', | |
| 'r', | |
| 'r', | |
| 'r' | |
| ], | |
| stringLength: (str)=>(0, _stripansi.default)(str).length | |
| })); | |
| const staticFunctionInfo = lists.app ? 'generateStaticParams' : 'getStaticProps'; | |
| print(); | |
| print((0, _texttable.default)([ | |
| usedSymbols.has('○') && [ | |
| '○', | |
| '(Static)', | |
| 'prerendered as static content' | |
| ], | |
| usedSymbols.has('●') && [ | |
| '●', | |
| '(SSG)', | |
| `prerendered as static HTML (uses ${(0, _picocolors.cyan)(staticFunctionInfo)})` | |
| ], | |
| usedSymbols.has('◐') && [ | |
| '◐', | |
| '(Partial Prerender)', | |
| 'prerendered as static HTML with dynamic server-streamed content' | |
| ], | |
| usedSymbols.has('ƒ') && [ | |
| 'ƒ', | |
| '(Dynamic)', | |
| `server-rendered on demand` | |
| ] | |
| ].filter((x)=>x), { | |
| align: [ | |
| 'l', | |
| 'l', | |
| 'l' | |
| ], | |
| stringLength: (str)=>(0, _stripansi.default)(str).length | |
| })); | |
| print(); | |
| } | |
| function printCustomRoutes({ redirects, rewrites, headers }) { | |
| const printRoutes = (routes, type)=>{ | |
| const isRedirects = type === 'Redirects'; | |
| const isHeaders = type === 'Headers'; | |
| print((0, _picocolors.underline)(type)); | |
| /* | |
| ┌ 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'); | |
| print(`${routesStr}\n`); | |
| }; | |
| print(); | |
| 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'); | |
| } | |
| } | |
| async function isPageStatic({ dir, page, distDir, configFileName, httpAgentOptions, locales, defaultLocale, parentId, pageRuntime, edgeInfo, pageType, cacheComponents, authInterrupts, originalAppPath, isrFlushToDisk, cacheMaxMemorySize, nextConfigOutput, cacheHandler, cacheHandlers, cacheLifeProfiles, pprConfig, buildId, sriEnabled }) { | |
| // Skip page data collection for synthetic _global-error routes | |
| if (page === _constants1.UNDERSCORE_GLOBAL_ERROR_ROUTE) { | |
| return { | |
| isStatic: true, | |
| isRoutePPREnabled: false, | |
| prerenderFallbackMode: undefined, | |
| prerenderedRoutes: undefined, | |
| rootParamKeys: undefined, | |
| hasStaticProps: false, | |
| hasServerProps: false, | |
| isNextImageImported: false, | |
| appConfig: {} | |
| }; | |
| } | |
| await (0, _createincrementalcache.createIncrementalCache)({ | |
| cacheHandler, | |
| cacheHandlers, | |
| distDir, | |
| dir, | |
| flushToDisk: isrFlushToDisk, | |
| cacheMaxMemorySize | |
| }); | |
| const isPageStaticSpan = (0, _trace.trace)('is-page-static-utils', parentId); | |
| return isPageStaticSpan.traceAsyncFn(async ()=>{ | |
| (0, _setuphttpagentenv.setHttpClientAndAgentOptions)({ | |
| httpAgentOptions | |
| }); | |
| let componentsResult; | |
| let prerenderedRoutes; | |
| let prerenderFallbackMode; | |
| let appConfig = {}; | |
| let rootParamKeys; | |
| const pathIsEdgeRuntime = (0, _isedgeruntime.isEdgeRuntime)(pageRuntime); | |
| if (pathIsEdgeRuntime) { | |
| const runtime = await (0, _sandbox.getRuntimeContext)({ | |
| paths: edgeInfo.files.map((file)=>_path.default.join(distDir, file)), | |
| edgeFunctionEntry: { | |
| ...edgeInfo, | |
| wasm: (edgeInfo.wasm ?? []).map((binding)=>({ | |
| ...binding, | |
| filePath: _path.default.join(distDir, binding.filePath) | |
| })) | |
| }, | |
| name: edgeInfo.name, | |
| useCache: true, | |
| distDir | |
| }); | |
| const mod = (await runtime.context._ENTRIES[`middleware_${edgeInfo.name}`]).ComponentMod; | |
| // This is not needed during require. | |
| const buildManifest = {}; | |
| componentsResult = { | |
| Component: mod.default, | |
| Document: mod.Document, | |
| App: mod.App, | |
| routeModule: mod.routeModule, | |
| page, | |
| ComponentMod: mod, | |
| pageConfig: mod.config || {}, | |
| buildManifest, | |
| reactLoadableManifest: {}, | |
| getServerSideProps: mod.getServerSideProps, | |
| getStaticPaths: mod.getStaticPaths, | |
| getStaticProps: mod.getStaticProps | |
| }; | |
| } else { | |
| componentsResult = await (0, _loadcomponents.loadComponents)({ | |
| distDir, | |
| page: originalAppPath || page, | |
| isAppPath: pageType === 'app', | |
| isDev: false, | |
| sriEnabled, | |
| needsManifestsForLegacyReasons: true | |
| }); | |
| } | |
| const { Component, routeModule } = componentsResult; | |
| const Comp = Component; | |
| let isRoutePPREnabled = false; | |
| if (pageType === 'app') { | |
| // @ts-expect-error pageType is app, so we can assume AppPageModule | AppRouteModule | |
| const ComponentMod = componentsResult.ComponentMod; | |
| let segments; | |
| try { | |
| segments = await (0, _appsegments.collectSegments)(// We know this is an app page or app route module because we | |
| // checked above that the page type is 'app'. | |
| routeModule); | |
| } catch (err) { | |
| throw Object.defineProperty(new Error(`Failed to collect configuration for ${page}`, { | |
| cause: err | |
| }), "__NEXT_ERROR_CODE", { | |
| value: "E434", | |
| enumerable: false, | |
| configurable: true | |
| }); | |
| } | |
| appConfig = originalAppPath === _constants1.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY ? {} : reduceAppConfig(segments); | |
| 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`); | |
| } | |
| rootParamKeys = (0, _collectrootparamkeys.collectRootParamKeys)(routeModule); | |
| // A page supports partial prerendering if it is an app page and either | |
| // the whole app has PPR enabled or this page has PPR enabled when we're | |
| // in incremental mode. | |
| isRoutePPREnabled = routeModule.definition.kind === _routekind.RouteKind.APP_PAGE && (0, _ppr.checkIsRoutePPREnabled)(pprConfig); | |
| // If force dynamic was set and we don't have PPR enabled, then set the | |
| // revalidate to 0. | |
| // TODO: (PPR) remove this once PPR is enabled by default | |
| if (appConfig.dynamic === 'force-dynamic' && !isRoutePPREnabled) { | |
| appConfig.revalidate = 0; | |
| } | |
| const route = (0, _app1.parseAppRoute)(page, true); | |
| // If the page is dynamic and we're not in edge runtime, then we need to | |
| // build the static paths. The edge runtime doesn't support static | |
| // paths. | |
| if (route.dynamicSegments.length > 0 && !pathIsEdgeRuntime) { | |
| ; | |
| ({ prerenderedRoutes, fallbackMode: prerenderFallbackMode } = await (0, _app.buildAppStaticPaths)({ | |
| dir, | |
| page, | |
| route, | |
| cacheComponents, | |
| authInterrupts, | |
| segments, | |
| distDir, | |
| requestHeaders: {}, | |
| isrFlushToDisk, | |
| cacheMaxMemorySize, | |
| cacheHandler, | |
| cacheLifeProfiles, | |
| ComponentMod, | |
| nextConfigOutput, | |
| isRoutePPREnabled, | |
| buildId, | |
| rootParamKeys | |
| })); | |
| } | |
| } else { | |
| if (!Comp || !(0, _reactis.isValidElementType)(Comp) || typeof Comp === 'string') { | |
| throw Object.defineProperty(new Error('INVALID_DEFAULT_EXPORT'), "__NEXT_ERROR_CODE", { | |
| value: "E457", | |
| enumerable: false, | |
| configurable: true | |
| }); | |
| } | |
| } | |
| const hasGetInitialProps = !!(Comp == null ? void 0 : Comp.getInitialProps); | |
| const hasStaticProps = !!componentsResult.getStaticProps; | |
| const hasStaticPaths = !!componentsResult.getStaticPaths; | |
| const hasServerProps = !!componentsResult.getServerSideProps; | |
| // A page cannot be prerendered _and_ define a data requirement. That's | |
| // contradictory! | |
| if (hasGetInitialProps && hasStaticProps) { | |
| throw Object.defineProperty(new Error(_constants.SSG_GET_INITIAL_PROPS_CONFLICT), "__NEXT_ERROR_CODE", { | |
| value: "E394", | |
| enumerable: false, | |
| configurable: true | |
| }); | |
| } | |
| if (hasGetInitialProps && hasServerProps) { | |
| throw Object.defineProperty(new Error(_constants.SERVER_PROPS_GET_INIT_PROPS_CONFLICT), "__NEXT_ERROR_CODE", { | |
| value: "E394", | |
| enumerable: false, | |
| configurable: true | |
| }); | |
| } | |
| if (hasStaticProps && hasServerProps) { | |
| throw Object.defineProperty(new Error(_constants.SERVER_PROPS_SSG_CONFLICT), "__NEXT_ERROR_CODE", { | |
| value: "E394", | |
| enumerable: false, | |
| configurable: true | |
| }); | |
| } | |
| const pageIsDynamic = (0, _isdynamic.isDynamicRoute)(page); | |
| // A page cannot have static parameters if it is not a dynamic page. | |
| if (hasStaticProps && hasStaticPaths && !pageIsDynamic) { | |
| throw Object.defineProperty(new Error(`getStaticPaths can only be used with dynamic pages, not '${page}'.` + `\nLearn more: https://nextjs.org/docs/routing/dynamic-routes`), "__NEXT_ERROR_CODE", { | |
| value: "E356", | |
| enumerable: false, | |
| configurable: true | |
| }); | |
| } | |
| if (hasStaticProps && pageIsDynamic && !hasStaticPaths) { | |
| throw Object.defineProperty(new Error(`getStaticPaths is required for dynamic SSG pages and is missing for '${page}'.` + `\nRead more: https://nextjs.org/docs/messages/invalid-getstaticpaths-value`), "__NEXT_ERROR_CODE", { | |
| value: "E255", | |
| enumerable: false, | |
| configurable: true | |
| }); | |
| } | |
| if (hasStaticProps && hasStaticPaths) { | |
| ; | |
| ({ prerenderedRoutes, fallbackMode: prerenderFallbackMode } = await (0, _pages.buildPagesStaticPaths)({ | |
| page, | |
| locales, | |
| defaultLocale, | |
| configFileName, | |
| getStaticPaths: componentsResult.getStaticPaths | |
| })); | |
| } | |
| const isNextImageImported = globalThis.__NEXT_IMAGE_IMPORTED; | |
| let isStatic = false; | |
| if (!hasStaticProps && !hasGetInitialProps && !hasServerProps) { | |
| isStatic = true; | |
| } | |
| // When PPR is enabled, any route may be completely static, so | |
| // mark this route as static. | |
| if (isRoutePPREnabled) { | |
| isStatic = true; | |
| } | |
| return { | |
| isStatic, | |
| isRoutePPREnabled, | |
| prerenderFallbackMode, | |
| prerenderedRoutes, | |
| rootParamKeys, | |
| hasStaticProps, | |
| hasServerProps, | |
| isNextImageImported, | |
| appConfig | |
| }; | |
| }).catch((err)=>{ | |
| if (err.message === 'INVALID_DEFAULT_EXPORT') { | |
| throw err; | |
| } | |
| console.error(err); | |
| throw Object.defineProperty(new Error(`Failed to collect page data for ${page}`), "__NEXT_ERROR_CODE", { | |
| value: "E414", | |
| enumerable: false, | |
| configurable: true | |
| }); | |
| }); | |
| } | |
| function reduceAppConfig(segments) { | |
| const config = {}; | |
| for (const segment of segments){ | |
| const { dynamic, fetchCache, preferredRegion, revalidate, runtime, maxDuration } = segment.config || {}; | |
| // TODO: should conflicting configs here throw an error | |
| // e.g. if layout defines one region but page defines another | |
| if (typeof preferredRegion !== 'undefined') { | |
| config.preferredRegion = preferredRegion; | |
| } | |
| if (typeof dynamic !== 'undefined') { | |
| config.dynamic = dynamic; | |
| } | |
| if (typeof fetchCache !== 'undefined') { | |
| config.fetchCache = fetchCache; | |
| } | |
| if (typeof revalidate !== 'undefined') { | |
| config.revalidate = revalidate; | |
| } | |
| // Any revalidate number overrides false, and shorter revalidate overrides | |
| // longer (initially). | |
| if (typeof revalidate === 'number' && (typeof config.revalidate !== 'number' || revalidate < config.revalidate)) { | |
| config.revalidate = revalidate; | |
| } | |
| if (typeof runtime !== 'undefined') { | |
| config.runtime = runtime; | |
| } | |
| if (typeof maxDuration !== 'undefined') { | |
| config.maxDuration = maxDuration; | |
| } | |
| } | |
| return config; | |
| } | |
| async function hasCustomGetInitialProps({ page, distDir, checkingApp, sriEnabled }) { | |
| const { ComponentMod } = await (0, _loadcomponents.loadComponents)({ | |
| distDir, | |
| page: page, | |
| isAppPath: false, | |
| isDev: false, | |
| sriEnabled, | |
| needsManifestsForLegacyReasons: true | |
| }); | |
| let mod = ComponentMod; | |
| if (checkingApp) { | |
| // @ts-expect-error very dynamic code | |
| mod = await mod._app || mod.default || mod; | |
| } else { | |
| // @ts-expect-error very dynamic code | |
| mod = mod.default || mod; | |
| } | |
| mod = await mod; | |
| // @ts-expect-error very dynamic code | |
| return mod.getInitialProps !== mod.origGetInitialProps; | |
| } | |
| async function getDefinedNamedExports({ page, distDir, sriEnabled }) { | |
| const { ComponentMod } = await (0, _loadcomponents.loadComponents)({ | |
| distDir, | |
| page: page, | |
| isAppPath: false, | |
| isDev: false, | |
| sriEnabled, | |
| needsManifestsForLegacyReasons: true | |
| }); | |
| return Object.keys(ComponentMod).filter((key)=>{ | |
| return typeof ComponentMod[key] !== 'undefined'; | |
| }); | |
| } | |
| function detectConflictingPaths(combinedPages, ssgPages, additionalGeneratedSSGPaths) { | |
| const conflictingPaths = new Map(); | |
| const dynamicSsgPages = [ | |
| ...ssgPages | |
| ].filter((page)=>(0, _isdynamic.isDynamicRoute)(page)); | |
| const additionalSsgPathsByPath = {}; | |
| additionalGeneratedSSGPaths.forEach((paths, pathsPage)=>{ | |
| additionalSsgPathsByPath[pathsPage] ||= {}; | |
| paths.forEach((curPath)=>{ | |
| const currentPath = curPath.toLowerCase(); | |
| additionalSsgPathsByPath[pathsPage][currentPath] = curPath; | |
| }); | |
| }); | |
| additionalGeneratedSSGPaths.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 = additionalGeneratedSSGPaths.get(page) == null ? undefined : additionalSsgPathsByPath[page][lowerPath]; | |
| return conflictingPath; | |
| }); | |
| if (conflictingPage && conflictingPath) { | |
| conflictingPaths.set(lowerPath, [ | |
| { | |
| path: curPath, | |
| page: pathsPage | |
| }, | |
| { | |
| path: conflictingPath, | |
| page: conflictingPage | |
| } | |
| ]); | |
| } | |
| } | |
| }); | |
| }); | |
| if (conflictingPaths.size > 0) { | |
| let conflictingPathsOutput = ''; | |
| conflictingPaths.forEach((pathItems)=>{ | |
| pathItems.forEach((pathItem, idx)=>{ | |
| const isDynamic = pathItem.page !== pathItem.path; | |
| if (idx > 0) { | |
| conflictingPathsOutput += 'conflicts with '; | |
| } | |
| conflictingPathsOutput += `path: "${pathItem.path}"${isDynamic ? ` from page: "${pathItem.page}" ` : ' '}`; | |
| }); | |
| conflictingPathsOutput += '\n'; | |
| }); | |
| _log.error('Conflicting paths returned from getStaticPaths, paths must be unique per page.\n' + 'See more info here: https://nextjs.org/docs/messages/conflicting-ssg-paths\n\n' + conflictingPathsOutput); | |
| process.exit(1); | |
| } | |
| } | |
| async function copyTracedFiles(dir, distDir, pageKeys, appPageKeys, tracingRoot, serverConfig, middlewareManifest, hasNodeMiddleware, hasInstrumentationHook, staticPages) { | |
| const outputPath = _path.default.join(distDir, 'standalone'); | |
| // Clean up standalone directory first. | |
| await _fs.promises.rm(outputPath, { | |
| recursive: true, | |
| force: true | |
| }); | |
| let moduleType = false; | |
| const nextConfig = { | |
| ...serverConfig, | |
| distDir: `./${_path.default.relative(dir, distDir)}` | |
| }; | |
| try { | |
| const packageJsonPath = _path.default.join(distDir, '../package.json'); | |
| const packageJsonContent = await _fs.promises.readFile(packageJsonPath, 'utf8'); | |
| const packageJson = JSON.parse(packageJsonContent); | |
| moduleType = packageJson.type === 'module'; | |
| // we always copy the package.json to the standalone | |
| // folder to ensure any resolving logic is maintained | |
| const packageJsonOutputPath = _path.default.join(outputPath, _path.default.relative(tracingRoot, dir), 'package.json'); | |
| await _fs.promises.mkdir(_path.default.dirname(packageJsonOutputPath), { | |
| recursive: true | |
| }); | |
| await _fs.promises.writeFile(packageJsonOutputPath, packageJsonContent); | |
| } catch {} | |
| const copiedFiles = new Set(); | |
| async function handleTraceFiles(traceFilePath) { | |
| const traceData = JSON.parse(await _fs.promises.readFile(traceFilePath, 'utf8')); | |
| const copySema = new _asyncsema.Sema(10, { | |
| capacity: traceData.files.length | |
| }); | |
| const traceFileDir = _path.default.dirname(traceFilePath); | |
| await Promise.all(traceData.files.map(async (relativeFile)=>{ | |
| await copySema.acquire(); | |
| const tracedFilePath = _path.default.join(traceFileDir, relativeFile); | |
| const fileOutputPath = _path.default.join(outputPath, _path.default.relative(tracingRoot, tracedFilePath)); | |
| if (!copiedFiles.has(fileOutputPath)) { | |
| copiedFiles.add(fileOutputPath); | |
| await _fs.promises.mkdir(_path.default.dirname(fileOutputPath), { | |
| recursive: true | |
| }); | |
| const symlink = await _fs.promises.readlink(tracedFilePath).catch(()=>null); | |
| if (symlink) { | |
| try { | |
| await _fs.promises.symlink(symlink, fileOutputPath); | |
| } catch (err) { | |
| // Windows doesn't support creating symlinks without elevated privileges, unless | |
| // "Developer Mode" is turned on. If we failed to crate a symlink due to EPERM, try | |
| // creating a junction point instead. | |
| // | |
| // Ideally we'd just preserve the input file type (junction point or symlink), but | |
| // there's no API in node.js to differentiate between a junction point and a symlink, | |
| // so we just try making a symlink first. Symlinks are preferred because they support | |
| // relative paths and non-directory (file) targets. | |
| if (process.platform === 'win32' && err.code === 'EPERM' && _path.default.isAbsolute(symlink)) { | |
| try { | |
| await _fs.promises.symlink(symlink, fileOutputPath, 'junction'); | |
| } catch (junctionErr) { | |
| if (junctionErr.code !== 'EEXIST') { | |
| throw junctionErr; | |
| } | |
| } | |
| } else if (err.code !== 'EEXIST') { | |
| throw err; | |
| } | |
| } | |
| } else { | |
| await _fs.promises.copyFile(tracedFilePath, fileOutputPath); | |
| } | |
| } | |
| await copySema.release(); | |
| })); | |
| } | |
| async function handleEdgeFunction(page) { | |
| var _page_wasm, _page_assets; | |
| async function handleFile(file) { | |
| const originalPath = _path.default.join(distDir, file); | |
| const fileOutputPath = _path.default.join(outputPath, _path.default.relative(tracingRoot, distDir), file); | |
| await _fs.promises.mkdir(_path.default.dirname(fileOutputPath), { | |
| recursive: true | |
| }); | |
| await _fs.promises.copyFile(originalPath, fileOutputPath); | |
| } | |
| await Promise.all([ | |
| page.files.map(handleFile), | |
| (_page_wasm = page.wasm) == null ? void 0 : _page_wasm.map((file)=>handleFile(file.filePath)), | |
| (_page_assets = page.assets) == null ? void 0 : _page_assets.map((file)=>handleFile(file.filePath)) | |
| ]); | |
| } | |
| const edgeFunctionHandlers = []; | |
| for (const middleware of Object.values(middlewareManifest.middleware)){ | |
| if (isMiddlewareFilename(middleware.name)) { | |
| edgeFunctionHandlers.push(handleEdgeFunction(middleware)); | |
| } | |
| } | |
| for (const page of Object.values(middlewareManifest.functions)){ | |
| edgeFunctionHandlers.push(handleEdgeFunction(page)); | |
| } | |
| await Promise.all(edgeFunctionHandlers); | |
| for (const page of pageKeys){ | |
| if (middlewareManifest.functions.hasOwnProperty(page)) { | |
| continue; | |
| } | |
| const route = (0, _normalizepagepath.normalizePagePath)(page); | |
| if (staticPages.has(route)) { | |
| continue; | |
| } | |
| const pageFile = _path.default.join(distDir, 'server', 'pages', `${(0, _normalizepagepath.normalizePagePath)(page)}.js`); | |
| const pageTraceFile = `${pageFile}.nft.json`; | |
| await handleTraceFiles(pageTraceFile).catch((err)=>{ | |
| if (err.code !== 'ENOENT' || page !== '/404' && page !== '/500') { | |
| _log.warn(`Failed to copy traced files for ${pageFile}`, err); | |
| } | |
| }); | |
| } | |
| if (hasNodeMiddleware) { | |
| const middlewareFile = _path.default.join(distDir, 'server', 'middleware.js'); | |
| const middlewareTrace = `${middlewareFile}.nft.json`; | |
| await handleTraceFiles(middlewareTrace); | |
| } | |
| if (appPageKeys) { | |
| for (const page of appPageKeys){ | |
| if (middlewareManifest.functions.hasOwnProperty(page)) { | |
| continue; | |
| } | |
| const pageFile = _path.default.join(distDir, 'server', 'app', `${page}.js`); | |
| const pageTraceFile = `${pageFile}.nft.json`; | |
| await handleTraceFiles(pageTraceFile).catch((err)=>{ | |
| _log.warn(`Failed to copy traced files for ${pageFile}`, err); | |
| }); | |
| } | |
| } | |
| if (hasInstrumentationHook) { | |
| await handleTraceFiles(_path.default.join(distDir, 'server', 'instrumentation.js.nft.json')); | |
| } | |
| await handleTraceFiles(_path.default.join(distDir, 'next-server.js.nft.json')); | |
| const serverOutputPath = _path.default.join(outputPath, _path.default.relative(tracingRoot, dir), 'server.js'); | |
| await _fs.promises.mkdir(_path.default.dirname(serverOutputPath), { | |
| recursive: true | |
| }); | |
| await _fs.promises.writeFile(serverOutputPath, `${moduleType ? `performance.mark('next-start'); | |
| import path from 'node:path' | |
| import { fileURLToPath } from 'node:url' | |
| import module from 'node:module' | |
| const require = module.createRequire(import.meta.url) | |
| const __dirname = fileURLToPath(new URL('.', import.meta.url)) | |
| ` : `const path = require('path')`} | |
| const dir = path.join(__dirname) | |
| process.env.NODE_ENV = 'production' | |
| process.chdir(__dirname) | |
| const currentPort = parseInt(process.env.PORT, 10) || 3000 | |
| const hostname = process.env.HOSTNAME || '0.0.0.0' | |
| let keepAliveTimeout = parseInt(process.env.KEEP_ALIVE_TIMEOUT, 10) | |
| const nextConfig = ${JSON.stringify(nextConfig)} | |
| process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(nextConfig) | |
| require('next') | |
| const { startServer } = require('next/dist/server/lib/start-server') | |
| if ( | |
| Number.isNaN(keepAliveTimeout) || | |
| !Number.isFinite(keepAliveTimeout) || | |
| keepAliveTimeout < 0 | |
| ) { | |
| keepAliveTimeout = undefined | |
| } | |
| startServer({ | |
| dir, | |
| isDev: false, | |
| config: nextConfig, | |
| hostname, | |
| port: currentPort, | |
| allowRetry: false, | |
| keepAliveTimeout, | |
| }).catch((err) => { | |
| console.error(err); | |
| process.exit(1); | |
| });`); | |
| } | |
| function isReservedPage(page) { | |
| return RESERVED_PAGE.test(page); | |
| } | |
| function isAppBuiltinPage(page) { | |
| return /next[\\/]dist[\\/](esm[\\/])?client[\\/]components[\\/]builtin[\\/]/.test(page); | |
| } | |
| function isCustomErrorPage(page) { | |
| return page === '/404' || page === '/500'; | |
| } | |
| function isMiddlewareFile(file) { | |
| return file === `/${_constants.MIDDLEWARE_FILENAME}` || file === `/src/${_constants.MIDDLEWARE_FILENAME}` || file === `/${_constants.PROXY_FILENAME}` || file === `/src/${_constants.PROXY_FILENAME}`; | |
| } | |
| function isProxyFile(file) { | |
| return file === `/${_constants.PROXY_FILENAME}` || file === `/src/${_constants.PROXY_FILENAME}`; | |
| } | |
| function isInstrumentationHookFile(file) { | |
| return file === `/${_constants.INSTRUMENTATION_HOOK_FILENAME}` || file === `/src/${_constants.INSTRUMENTATION_HOOK_FILENAME}`; | |
| } | |
| function getPossibleInstrumentationHookFilenames(folder, extensions) { | |
| const files = []; | |
| for (const extension of extensions){ | |
| files.push(_path.default.join(folder, `${_constants.INSTRUMENTATION_HOOK_FILENAME}.${extension}`), _path.default.join(folder, `src`, `${_constants.INSTRUMENTATION_HOOK_FILENAME}.${extension}`)); | |
| } | |
| return files; | |
| } | |
| function getPossibleMiddlewareFilenames(folder, extensions) { | |
| return extensions.flatMap((extension)=>[ | |
| _path.default.join(folder, `${_constants.MIDDLEWARE_FILENAME}.${extension}`), | |
| _path.default.join(folder, `${_constants.PROXY_FILENAME}.${extension}`) | |
| ]); | |
| } | |
| class NestedMiddlewareError extends Error { | |
| constructor(nestedFileNames, mainDir, pagesOrAppDir){ | |
| super(`Nested Middleware is not allowed, found:\n` + `${nestedFileNames.map((file)=>`pages${file}`).join('\n')}\n` + `Please move your code to a single file at ${_path.default.join(_path.default.posix.sep, _path.default.relative(mainDir, _path.default.resolve(pagesOrAppDir, '..')), 'middleware')} instead.\n` + `Read More - https://nextjs.org/docs/messages/nested-middleware`); | |
| } | |
| } | |
| function getSupportedBrowsers(dir, isDevelopment) { | |
| let browsers; | |
| try { | |
| const browsersListConfig = _browserslist.default.loadConfig({ | |
| path: dir, | |
| env: isDevelopment ? 'development' : 'production' | |
| }); | |
| // Running `browserslist` resolves `extends` and other config features into a list of browsers | |
| if (browsersListConfig && browsersListConfig.length > 0) { | |
| browsers = (0, _browserslist.default)(browsersListConfig); | |
| } | |
| } catch {} | |
| // When user has browserslist use that target | |
| if (browsers && browsers.length > 0) { | |
| return browsers; | |
| } | |
| // Uses modern browsers as the default. | |
| return _constants1.MODERN_BROWSERSLIST_TARGET; | |
| } | |
| function shouldUseReactServerCondition(layer) { | |
| return Boolean(layer && _constants.WEBPACK_LAYERS.GROUP.serverOnly.includes(layer)); | |
| } | |
| function isWebpackClientOnlyLayer(layer) { | |
| return Boolean(layer && _constants.WEBPACK_LAYERS.GROUP.clientOnly.includes(layer)); | |
| } | |
| function isWebpackDefaultLayer(layer) { | |
| return layer === null || layer === undefined || layer === _constants.WEBPACK_LAYERS.pagesDirBrowser || layer === _constants.WEBPACK_LAYERS.pagesDirEdge || layer === _constants.WEBPACK_LAYERS.pagesDirNode; | |
| } | |
| function isWebpackBundledLayer(layer) { | |
| return Boolean(layer && _constants.WEBPACK_LAYERS.GROUP.bundled.includes(layer)); | |
| } | |
| function isWebpackAppPagesLayer(layer) { | |
| return Boolean(layer && _constants.WEBPACK_LAYERS.GROUP.appPages.includes(layer)); | |
| } | |
| function collectMeta({ status, headers }) { | |
| const meta = {}; | |
| if (status !== 200) { | |
| meta.status = status; | |
| } | |
| if (headers && Object.keys(headers).length) { | |
| meta.headers = {}; | |
| // normalize header values as initialHeaders | |
| // must be Record<string, string> | |
| for(const key in headers){ | |
| // set-cookie is already handled - the middleware cookie setting case | |
| // isn't needed for the prerender manifest since it can't read cookies | |
| if (key === 'x-middleware-set-cookie') continue; | |
| let value = headers[key]; | |
| if (Array.isArray(value)) { | |
| if (key === 'set-cookie') { | |
| value = value.join(','); | |
| } else { | |
| value = value[value.length - 1]; | |
| } | |
| } | |
| if (typeof value === 'string') { | |
| meta.headers[key] = value; | |
| } | |
| } | |
| } | |
| return meta; | |
| } | |
| const RSPACK_DEFAULT_LAYERS_REGEX = new RegExp(`^(|${[ | |
| _constants.WEBPACK_LAYERS.pagesDirBrowser, | |
| _constants.WEBPACK_LAYERS.pagesDirEdge, | |
| _constants.WEBPACK_LAYERS.pagesDirNode | |
| ].join('|')})$`); | |
| function pageToRoute(page, sourcePage) { | |
| const routeRegex = (0, _routeregex.getNamedRouteRegex)(page, { | |
| prefixRouteKeys: true | |
| }); | |
| return { | |
| sourcePage, | |
| page, | |
| regex: (0, _loadcustomroutes.normalizeRouteRegex)(routeRegex.re.source), | |
| routeKeys: routeRegex.routeKeys, | |
| namedRegex: routeRegex.namedRegex | |
| }; | |
| } | |
| //# sourceMappingURL=utils.js.map |