.

node_modules/next/dist/esm/export/routes/app-page.js

@@ -0,0 +1,199 @@
+import { isDynamicUsageError } from '../helpers/is-dynamic-usage-error';
+import { NEXT_CACHE_TAGS_HEADER, NEXT_META_SUFFIX, RSC_SUFFIX, RSC_SEGMENTS_DIR_SUFFIX, RSC_SEGMENT_SUFFIX } from '../../lib/constants';
+import { hasNextSupport } from '../../server/ci-info';
+import { lazyRenderAppPage } from '../../server/route-modules/app-page/module.render';
+import { isBailoutToCSRError } from '../../shared/lib/lazy-dynamic/bailout-to-csr';
+import { NodeNextRequest, NodeNextResponse } from '../../server/base-http/node';
+import { NEXT_IS_PRERENDER_HEADER } from '../../client/components/app-router-headers';
+import { AfterRunner } from '../../server/after/run-with-after';
+import { stringifyResumeDataCache } from '../../server/resume-data-cache/resume-data-cache';
+import { UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY, UNDERSCORE_NOT_FOUND_ROUTE_ENTRY } from '../../shared/lib/entry-constants';
+/**
+ * Renders & exports a page associated with the /app directory
+ */ export async function exportAppPage(req, res, page, path, pathname, query, fallbackRouteParams, partialRenderOpts, htmlFilepath, debugOutput, isDynamicError, fileWriter, sharedContext) {
+    const afterRunner = new AfterRunner();
+    const renderOpts = {
+        ...partialRenderOpts,
+        waitUntil: afterRunner.context.waitUntil,
+        onClose: afterRunner.context.onClose,
+        onAfterTaskError: afterRunner.context.onTaskError
+    };
+    let isDefaultNotFound = false;
+    let isDefaultGlobalError = false;
+    // If the page is `/_not-found`, then we should update the page to be `/404`.
+    if (page === UNDERSCORE_NOT_FOUND_ROUTE_ENTRY) {
+        isDefaultNotFound = true;
+        pathname = '/404';
+    }
+    // If the page is `/_global-error`, then we should update the page to be `/500`.
+    if (page === UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY) {
+        isDefaultGlobalError = true;
+        pathname = '/500';
+    }
+    try {
+        const result = await lazyRenderAppPage(new NodeNextRequest(req), new NodeNextResponse(res), pathname, query, fallbackRouteParams, renderOpts, undefined, sharedContext);
+        const html = result.toUnchunkedString();
+        // TODO(after): if we abort a prerender because of an error in an after-callback
+        // we should probably communicate that better (and not log the error twice)
+        await afterRunner.executeAfter();
+        const { metadata } = result;
+        const { flightData, cacheControl = {
+            revalidate: false,
+            expire: undefined
+        }, postponed, fetchTags, fetchMetrics, segmentData, prefetchHints, renderResumeDataCache } = metadata;
+        // Ensure we don't postpone without having PPR enabled.
+        if (postponed && !renderOpts.experimental.isRoutePPREnabled) {
+            throw Object.defineProperty(new Error('Invariant: page postponed without PPR being enabled'), "__NEXT_ERROR_CODE", {
+                value: "E156",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (cacheControl.revalidate === 0) {
+            if (isDynamicError) {
+                throw Object.defineProperty(new Error(`Page with dynamic = "error" encountered dynamic data method on ${path}.`), "__NEXT_ERROR_CODE", {
+                    value: "E388",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+            const { staticBailoutInfo = {} } = metadata;
+            if (debugOutput && (staticBailoutInfo == null ? void 0 : staticBailoutInfo.description)) {
+                logDynamicUsageWarning({
+                    path,
+                    description: staticBailoutInfo.description,
+                    stack: staticBailoutInfo.stack
+                });
+            }
+            return {
+                cacheControl,
+                fetchMetrics
+            };
+        }
+        // If page data isn't available, it means that the page couldn't be rendered
+        // properly so long as we don't have unknown route params. When a route doesn't
+        // have unknown route params, there will not be any flight data.
+        let hasStaticRsc = false;
+        if (!flightData) {
+            if (!fallbackRouteParams || fallbackRouteParams.size === 0 || renderOpts.cacheComponents) {
+                throw Object.defineProperty(new Error(`Invariant: failed to get page data for ${path}`), "__NEXT_ERROR_CODE", {
+                    value: "E194",
+                    enumerable: false,
+                    configurable: true
+                });
+            }
+        } else {
+            const hasFallbackParams = fallbackRouteParams != null && fallbackRouteParams.size > 0;
+            const shouldWriteRsc = !renderOpts.experimental.isRoutePPREnabled || !postponed && !hasFallbackParams;
+            hasStaticRsc = shouldWriteRsc;
+            // With PPR enabled, we normally skip writing .rsc because it may contain
+            // dynamic data. However, for fully static outputs (no postponed state and
+            // no fallback params), we can safely emit the route .rsc to support
+            // static navigations.
+            if (shouldWriteRsc) {
+                fileWriter.append(htmlFilepath.replace(/\.html$/, RSC_SUFFIX), flightData);
+            }
+        }
+        let segmentPaths;
+        if (segmentData) {
+            // Emit the per-segment prefetch data. We emit them as separate files
+            // so that the cache handler has the option to treat each as a
+            // separate entry.
+            segmentPaths = [];
+            const segmentsDir = htmlFilepath.replace(/\.html$/, RSC_SEGMENTS_DIR_SUFFIX);
+            for (const [segmentPath, buffer] of segmentData){
+                segmentPaths.push(segmentPath);
+                const segmentDataFilePath = segmentsDir + segmentPath + RSC_SEGMENT_SUFFIX;
+                fileWriter.append(segmentDataFilePath, buffer);
+            }
+        }
+        const headers = {
+            ...metadata.headers
+        };
+        // If we're writing the file to disk, we know it's a prerender.
+        headers[NEXT_IS_PRERENDER_HEADER] = '1';
+        if (fetchTags) {
+            headers[NEXT_CACHE_TAGS_HEADER] = fetchTags;
+        }
+        // Writing static HTML to a file.
+        fileWriter.append(htmlFilepath, html);
+        const isParallelRoute = /\/@\w+/.test(page);
+        const isNonSuccessfulStatusCode = res.statusCode > 300;
+        // When PPR is enabled, we don't always send 200 for routes that have been
+        // pregenerated, so we should grab the status code from the mocked
+        // response.
+        let status = renderOpts.experimental.isRoutePPREnabled ? res.statusCode : undefined;
+        if (isDefaultNotFound) {
+            // Override the default /_not-found page status code to 404
+            status = 404;
+        } else if (isDefaultGlobalError) {
+            // Override the default /_global-error page status code to 500
+            status = 500;
+        } else if (isNonSuccessfulStatusCode && !isParallelRoute) {
+            // If it's parallel route the status from mock response is 404
+            status = res.statusCode;
+        }
+        // Writing the request metadata to a file.
+        const meta = {
+            status,
+            headers,
+            postponed,
+            segmentPaths,
+            prefetchHints
+        };
+        fileWriter.append(htmlFilepath.replace(/\.html$/, NEXT_META_SUFFIX), JSON.stringify(meta, null, 2));
+        return {
+            // Filter the metadata if the environment does not have next support.
+            metadata: hasNextSupport ? meta : {
+                segmentPaths: meta.segmentPaths,
+                prefetchHints: meta.prefetchHints
+            },
+            hasEmptyStaticShell: Boolean(postponed) && html === '',
+            hasPostponed: Boolean(postponed),
+            hasStaticRsc,
+            cacheControl,
+            fetchMetrics,
+            renderResumeDataCache: renderResumeDataCache ? await stringifyResumeDataCache(renderResumeDataCache, renderOpts.cacheComponents) : undefined
+        };
+    } catch (err) {
+        if (!isDynamicUsageError(err)) {
+            throw err;
+        }
+        // We should fail rendering if a client side rendering bailout
+        // occurred at the page level.
+        if (isBailoutToCSRError(err)) {
+            throw err;
+        }
+        let fetchMetrics;
+        if (debugOutput) {
+            const store = renderOpts.store;
+            const { dynamicUsageDescription, dynamicUsageStack } = store;
+            fetchMetrics = store.fetchMetrics;
+            logDynamicUsageWarning({
+                path,
+                description: dynamicUsageDescription ?? '',
+                stack: dynamicUsageStack
+            });
+        }
+        return {
+            cacheControl: {
+                revalidate: 0,
+                expire: undefined
+            },
+            fetchMetrics
+        };
+    }
+}
+function logDynamicUsageWarning({ path, description, stack }) {
+    const errMessage = Object.defineProperty(new Error(`Static generation failed due to dynamic usage on ${path}, reason: ${description}`), "__NEXT_ERROR_CODE", {
+        value: "E381",
+        enumerable: false,
+        configurable: true
+    });
+    if (stack) {
+        errMessage.stack = errMessage.message + stack.substring(stack.indexOf('\n'));
+    }
+    console.warn(errMessage);
+}
+
+//# sourceMappingURL=app-page.js.map

node_modules/next/dist/esm/export/routes/app-route.js

@@ -0,0 +1,116 @@
+import { INFINITE_CACHE, NEXT_BODY_SUFFIX, NEXT_CACHE_TAGS_HEADER, NEXT_META_SUFFIX } from '../../lib/constants';
+import { NodeNextRequest } from '../../server/base-http/node';
+import { NextRequestAdapter, signalFromNodeResponse } from '../../server/web/spec-extension/adapters/next-request';
+import { toNodeOutgoingHttpHeaders } from '../../server/web/utils';
+import { isDynamicUsageError } from '../helpers/is-dynamic-usage-error';
+import { isStaticGenEnabled } from '../../server/route-modules/app-route/helpers/is-static-gen-enabled';
+import { isMetadataRoute } from '../../lib/metadata/is-metadata-route';
+import { normalizeAppPath } from '../../shared/lib/router/utils/app-paths';
+import { AfterRunner } from '../../server/after/run-with-after';
+export var ExportedAppRouteFiles = /*#__PURE__*/ function(ExportedAppRouteFiles) {
+    ExportedAppRouteFiles["BODY"] = "BODY";
+    ExportedAppRouteFiles["META"] = "META";
+    return ExportedAppRouteFiles;
+}({});
+export async function exportAppRoute(req, res, params, page, module, incrementalCache, cacheLifeProfiles, htmlFilepath, fileWriter, cacheComponents, experimental, buildId) {
+    // Ensure that the URL is absolute.
+    req.url = `http://localhost:3000${req.url}`;
+    // Adapt the request and response to the Next.js request and response.
+    const request = NextRequestAdapter.fromNodeNextRequest(new NodeNextRequest(req), signalFromNodeResponse(res));
+    const afterRunner = new AfterRunner();
+    // Create the context for the handler. This contains the params from
+    // the route and the context for the request.
+    const context = {
+        params,
+        previewProps: {
+            previewModeEncryptionKey: '',
+            previewModeId: '',
+            previewModeSigningKey: ''
+        },
+        renderOpts: {
+            cacheComponents,
+            experimental,
+            isBuildTimePrerendering: true,
+            supportsDynamicResponse: false,
+            incrementalCache,
+            waitUntil: afterRunner.context.waitUntil,
+            onClose: afterRunner.context.onClose,
+            onAfterTaskError: afterRunner.context.onTaskError,
+            cacheLifeProfiles
+        },
+        sharedContext: {
+            buildId
+        }
+    };
+    try {
+        const userland = module.userland;
+        // we don't bail from the static optimization for
+        // metadata routes, since it's app-route we can always append /route suffix.
+        const routePath = normalizeAppPath(page) + '/route';
+        const isPageMetadataRoute = isMetadataRoute(routePath);
+        if (!isStaticGenEnabled(userland) && !isPageMetadataRoute && // We don't disable static gen when cacheComponents is enabled because we
+        // expect that anything dynamic in the GET handler will make it dynamic
+        // and thus avoid the cache surprises that led to us removing static gen
+        // unless specifically opted into
+        cacheComponents !== true) {
+            return {
+                cacheControl: {
+                    revalidate: 0,
+                    expire: undefined
+                }
+            };
+        }
+        const response = await module.handle(request, context);
+        const isValidStatus = response.status < 400 || response.status === 404;
+        if (!isValidStatus) {
+            return {
+                cacheControl: {
+                    revalidate: 0,
+                    expire: undefined
+                }
+            };
+        }
+        const blob = await response.blob();
+        // TODO(after): if we abort a prerender because of an error in an after-callback
+        // we should probably communicate that better (and not log the error twice)
+        await afterRunner.executeAfter();
+        const revalidate = typeof context.renderOpts.collectedRevalidate === 'undefined' || context.renderOpts.collectedRevalidate >= INFINITE_CACHE ? false : context.renderOpts.collectedRevalidate;
+        const expire = typeof context.renderOpts.collectedExpire === 'undefined' || context.renderOpts.collectedExpire >= INFINITE_CACHE ? undefined : context.renderOpts.collectedExpire;
+        const headers = toNodeOutgoingHttpHeaders(response.headers);
+        const cacheTags = context.renderOpts.collectedTags;
+        if (cacheTags) {
+            headers[NEXT_CACHE_TAGS_HEADER] = cacheTags;
+        }
+        if (!headers['content-type'] && blob.type) {
+            headers['content-type'] = blob.type;
+        }
+        // Writing response body to a file.
+        const body = Buffer.from(await blob.arrayBuffer());
+        fileWriter.append(htmlFilepath.replace(/\.html$/, NEXT_BODY_SUFFIX), body);
+        // Write the request metadata to a file.
+        const meta = {
+            status: response.status,
+            headers
+        };
+        fileWriter.append(htmlFilepath.replace(/\.html$/, NEXT_META_SUFFIX), JSON.stringify(meta));
+        return {
+            cacheControl: {
+                revalidate,
+                expire
+            },
+            metadata: meta
+        };
+    } catch (err) {
+        if (!isDynamicUsageError(err)) {
+            throw err;
+        }
+        return {
+            cacheControl: {
+                revalidate: 0,
+                expire: undefined
+            }
+        };
+    }
+}
+
+//# sourceMappingURL=app-route.js.map

node_modules/next/dist/esm/export/routes/pages.js

@@ -0,0 +1,78 @@
+import RenderResult from '../../server/render-result';
+import { join } from 'path';
+import { HTML_CONTENT_TYPE_HEADER, NEXT_DATA_SUFFIX, SERVER_PROPS_EXPORT_ERROR } from '../../lib/constants';
+import { isBailoutToCSRError } from '../../shared/lib/lazy-dynamic/bailout-to-csr';
+import { lazyRenderPagesPage } from '../../server/route-modules/pages/module.render';
+/**
+ * Renders & exports a page associated with the /pages directory
+ */ export async function exportPagesPage(req, res, path, page, query, params, htmlFilepath, htmlFilename, pagesDataDir, buildExport, isDynamic, sharedContext, renderContext, hasOrigQueryValues, renderOpts, components, fileWriter) {
+    if (components.getServerSideProps) {
+        throw Object.defineProperty(new Error(`Error for page ${page}: ${SERVER_PROPS_EXPORT_ERROR}`), "__NEXT_ERROR_CODE", {
+            value: "E15",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    // for non-dynamic SSG pages we should have already
+    // prerendered the file
+    if (!buildExport && components.getStaticProps && !isDynamic) {
+        return;
+    }
+    // Pages router merges page params (e.g. [lang]) with query params
+    // primarily to support them both being accessible on `useRouter().query`.
+    // If we extracted dynamic params from the path, we need to merge them
+    // back into the query object.
+    const searchAndDynamicParams = {
+        ...query,
+        ...params
+    };
+    if (components.getStaticProps && !htmlFilepath.endsWith('.html')) {
+        // make sure it ends with .html if the name contains a dot
+        htmlFilepath += '.html';
+        htmlFilename += '.html';
+    }
+    let renderResult;
+    if (typeof components.Component === 'string') {
+        renderResult = RenderResult.fromStatic(components.Component, HTML_CONTENT_TYPE_HEADER);
+        if (hasOrigQueryValues) {
+            throw Object.defineProperty(new Error(`\nError: you provided query values for ${path} which is an auto-exported page. These can not be applied since the page can no longer be re-rendered on the server. To disable auto-export for this page add \`getInitialProps\`\n`), "__NEXT_ERROR_CODE", {
+                value: "E505",
+                enumerable: false,
+                configurable: true
+            });
+        }
+    } else {
+        /**
+     * This sets environment variable to be used at the time of SSR by head.tsx.
+     * Using this from process.env allows targeting SSR by calling
+     * `process.env.__NEXT_OPTIMIZE_CSS`.
+     */ if (renderOpts.optimizeCss) {
+            process.env.__NEXT_OPTIMIZE_CSS = JSON.stringify(true);
+        }
+        try {
+            renderResult = await lazyRenderPagesPage(req, res, page, searchAndDynamicParams, renderOpts, sharedContext, renderContext);
+        } catch (err) {
+            if (!isBailoutToCSRError(err)) throw err;
+        }
+    }
+    const ssgNotFound = renderResult == null ? void 0 : renderResult.metadata.isNotFound;
+    const html = renderResult && !renderResult.isNull ? renderResult.toUnchunkedString() : '';
+    const metadata = (renderResult == null ? void 0 : renderResult.metadata) || {};
+    if (metadata.pageData) {
+        const dataFile = join(pagesDataDir, htmlFilename.replace(/\.html$/, NEXT_DATA_SUFFIX));
+        fileWriter.append(dataFile, JSON.stringify(metadata.pageData));
+    }
+    if (!ssgNotFound) {
+        // don't attempt writing to disk if getStaticProps returned not found
+        fileWriter.append(htmlFilepath, html);
+    }
+    return {
+        cacheControl: metadata.cacheControl ?? {
+            revalidate: false,
+            expire: undefined
+        },
+        ssgNotFound
+    };
+}
+
+//# sourceMappingURL=pages.js.map

node_modules/next/dist/esm/export/routes/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

node_modules/next/dist/esm/export/routes/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/export/routes/types.ts"],"sourcesContent":["import type { OutgoingHttpHeaders } from 'node:http'\nimport type { PrefetchHints } from '../../shared/lib/app-router-types'\n\nexport type RouteMetadata = {\n  status: number | undefined\n  headers: OutgoingHttpHeaders | undefined\n  postponed: string | undefined\n  segmentPaths: Array<string> | undefined\n  prefetchHints: PrefetchHints | undefined\n}\n"],"names":[],"mappings":"AAGA,WAMC","ignoreList":[0]}