inital commit

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

@@ -0,0 +1,213 @@
+import { isDynamicUsageError } from '../helpers/is-dynamic-usage-error';
+import { NEXT_CACHE_TAGS_HEADER, NEXT_META_SUFFIX, RSC_PREFETCH_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';
+export async function prospectiveRenderAppPage(req, res, page, pathname, query, fallbackRouteParams, partialRenderOpts, sharedContext) {
+    const afterRunner = new AfterRunner();
+    // If the page is `/_not-found`, then we should update the page to be `/404`.
+    // UNDERSCORE_NOT_FOUND_ROUTE value used here, however we don't want to import it here as it causes constants to be inlined which we don't want here.
+    if (page === '/_not-found/page') {
+        pathname = '/404';
+    }
+    try {
+        await lazyRenderAppPage(new NodeNextRequest(req), new NodeNextResponse(res), pathname, query, fallbackRouteParams, {
+            ...partialRenderOpts,
+            waitUntil: afterRunner.context.waitUntil,
+            onClose: afterRunner.context.onClose,
+            onAfterTaskError: afterRunner.context.onTaskError
+        }, undefined, false, sharedContext);
+        // 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();
+    } 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;
+        }
+    }
+}
+/**
+ * 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;
+    // If the page is `/_not-found`, then we should update the page to be `/404`.
+    // UNDERSCORE_NOT_FOUND_ROUTE value used here, however we don't want to import it here as it causes constants to be inlined which we don't want here.
+    if (page === '/_not-found/page') {
+        isDefaultNotFound = true;
+        pathname = '/404';
+    }
+    try {
+        const result = await lazyRenderAppPage(new NodeNextRequest(req), new NodeNextResponse(res), pathname, query, fallbackRouteParams, renderOpts, undefined, false, 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 } = 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.
+        if (!flightData && (!fallbackRouteParams || fallbackRouteParams.size === 0)) {
+            throw Object.defineProperty(new Error(`Invariant: failed to get page data for ${path}`), "__NEXT_ERROR_CODE", {
+                value: "E194",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (flightData) {
+            // If PPR is enabled, we want to emit a prefetch rsc file for the page
+            // instead of the standard rsc. This is because the standard rsc will
+            // contain the dynamic data. We do this if any routes have PPR enabled so
+            // that the cache read/write is the same.
+            if (renderOpts.experimental.isRoutePPREnabled) {
+                // If PPR is enabled, we should emit the flight data as the prefetch
+                // payload.
+                // TODO: This will eventually be replaced by the per-segment prefetch
+                // output below.
+                fileWriter.append(htmlFilepath.replace(/\.html$/, RSC_PREFETCH_SUFFIX), flightData);
+            } else {
+                // Writing the RSC payload to a file if we don't have PPR enabled.
+                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 (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
+        };
+        fileWriter.append(htmlFilepath.replace(/\.html$/, NEXT_META_SUFFIX), JSON.stringify(meta, null, 2));
+        return {
+            // Only include the metadata if the environment has next support.
+            metadata: hasNextSupport ? meta : undefined,
+            hasEmptyPrelude: Boolean(postponed) && html === '',
+            hasPostponed: Boolean(postponed),
+            cacheControl,
+            fetchMetrics
+        };
+    } 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,125 @@
+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 { hasNextSupport } from '../../server/ci-info';
+import { isStaticGenEnabled } from '../../server/route-modules/app-route/helpers/is-static-gen-enabled';
+import { isMetadataRouteFile } 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, 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,
+        prerenderManifest: {
+            version: 4,
+            routes: {},
+            dynamicRoutes: {},
+            preview: {
+                previewModeEncryptionKey: '',
+                previewModeId: '',
+                previewModeSigningKey: ''
+            },
+            notFoundRoutes: []
+        },
+        renderOpts: {
+            experimental,
+            nextExport: true,
+            supportsDynamicResponse: false,
+            incrementalCache,
+            waitUntil: afterRunner.context.waitUntil,
+            onClose: afterRunner.context.onClose,
+            onAfterTaskError: afterRunner.context.onTaskError,
+            cacheLifeProfiles
+        },
+        sharedContext: {
+            buildId
+        }
+    };
+    if (hasNextSupport) {
+        context.renderOpts.isRevalidate = true;
+    }
+    try {
+        const userland = module.userland;
+        // we don't bail from the static optimization for
+        // metadata routes
+        const normalizedPage = normalizeAppPath(page);
+        const isMetadataRoute = isMetadataRouteFile(normalizedPage, [], false);
+        if (!isStaticGenEnabled(userland) && !isMetadataRoute && // We don't disable static gen when dynamicIO 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
+        experimental.dynamicIO !== 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,137 @@
+import RenderResult from '../../server/render-result';
+import { join } from 'path';
+import { isInAmpMode } from '../../shared/lib/amp-mode';
+import { NEXT_DATA_SUFFIX, SERVER_PROPS_EXPORT_ERROR } from '../../lib/constants';
+import { isBailoutToCSRError } from '../../shared/lib/lazy-dynamic/bailout-to-csr';
+import AmpHtmlValidator from 'next/dist/compiled/amphtml-validator';
+import { FileType, fileExists } from '../../lib/file-exists';
+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, ampPath, subFolders, outDir, ampValidatorPath, pagesDataDir, buildExport, isDynamic, sharedContext, renderContext, hasOrigQueryValues, renderOpts, components, fileWriter) {
+    var _components_pageConfig, _components_pageConfig1;
+    const ampState = {
+        ampFirst: ((_components_pageConfig = components.pageConfig) == null ? void 0 : _components_pageConfig.amp) === true,
+        hasQuery: Boolean(query.amp),
+        hybrid: ((_components_pageConfig1 = components.pageConfig) == null ? void 0 : _components_pageConfig1.amp) === 'hybrid'
+    };
+    if (!ampValidatorPath) {
+        ampValidatorPath = require.resolve('next/dist/compiled/amphtml-validator/validator_wasm.js');
+    }
+    const inAmpMode = isInAmpMode(ampState);
+    const hybridAmp = ampState.hybrid;
+    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);
+        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 ampValidations = [];
+    const validateAmp = async (rawAmpHtml, ampPageName, validatorPath)=>{
+        const validator = await AmpHtmlValidator.getInstance(validatorPath);
+        const result = validator.validateString(rawAmpHtml);
+        const errors = result.errors.filter((e)=>e.severity === 'ERROR');
+        const warnings = result.errors.filter((e)=>e.severity !== 'ERROR');
+        if (warnings.length || errors.length) {
+            ampValidations.push({
+                page: ampPageName,
+                result: {
+                    errors,
+                    warnings
+                }
+            });
+        }
+    };
+    const html = renderResult && !renderResult.isNull ? renderResult.toUnchunkedString() : '';
+    let ampRenderResult;
+    if (inAmpMode && !renderOpts.ampSkipValidation) {
+        if (!ssgNotFound) {
+            await validateAmp(html, path, ampValidatorPath);
+        }
+    } else if (hybridAmp) {
+        const ampHtmlFilename = subFolders ? join(ampPath, 'index.html') : `${ampPath}.html`;
+        const ampHtmlFilepath = join(outDir, ampHtmlFilename);
+        const exists = await fileExists(ampHtmlFilepath, FileType.File);
+        if (!exists) {
+            try {
+                ampRenderResult = await lazyRenderPagesPage(req, res, page, {
+                    ...searchAndDynamicParams,
+                    amp: '1'
+                }, renderOpts, sharedContext, renderContext);
+            } catch (err) {
+                if (!isBailoutToCSRError(err)) throw err;
+            }
+            const ampHtml = ampRenderResult && !ampRenderResult.isNull ? ampRenderResult.toUnchunkedString() : '';
+            if (!renderOpts.ampSkipValidation) {
+                await validateAmp(ampHtml, page + '?amp=1', ampValidatorPath);
+            }
+            fileWriter.append(ampHtmlFilepath, ampHtml);
+        }
+    }
+    const metadata = (renderResult == null ? void 0 : renderResult.metadata) || (ampRenderResult == null ? void 0 : ampRenderResult.metadata) || {};
+    if (metadata.pageData) {
+        const dataFile = join(pagesDataDir, htmlFilename.replace(/\.html$/, NEXT_DATA_SUFFIX));
+        fileWriter.append(dataFile, JSON.stringify(metadata.pageData));
+        if (hybridAmp) {
+            fileWriter.append(dataFile.replace(/\.json$/, '.amp.json'), JSON.stringify(metadata.pageData));
+        }
+    }
+    if (!ssgNotFound) {
+        // don't attempt writing to disk if getStaticProps returned not found
+        fileWriter.append(htmlFilepath, html);
+    }
+    return {
+        ampValidations,
+        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'\n\nexport type RouteMetadata = {\n  status: number | undefined\n  headers: OutgoingHttpHeaders | undefined\n  postponed: string | undefined\n  segmentPaths: Array<string> | undefined\n}\n"],"names":[],"mappings":"AAEA,WAKC"}