quran/node_modules/next/dist/server/app-render.js

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.renderToHTMLOrFlight = renderToHTMLOrFlight;
var _react = _interopRequireWildcard(require("react"));
var _querystring = require("querystring");
var _reactServerDomWebpack = require("next/dist/compiled/react-server-dom-webpack");
var _writerBrowserServer = require("next/dist/compiled/react-server-dom-webpack/writer.browser.server");
var _renderResult = _interopRequireDefault(require("./render-result"));
var _nodeWebStreamsHelper = require("./node-web-streams-helper");
var _htmlescape = require("./htmlescape");
var _utils = require("./utils");
var _matchSegments = require("../client/components/match-segments");
var _flushEffects = require("../shared/lib/flush-effects");
var _internalUtils = require("./internal-utils");
function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
function _getRequireWildcardCache() {
    if (typeof WeakMap !== "function") return null;
    var cache = new WeakMap();
    _getRequireWildcardCache = function() {
        return cache;
    };
    return cache;
}
function _interopRequireWildcard(obj) {
    if (obj && obj.__esModule) {
        return obj;
    }
    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
        return {
            default: obj
        };
    }
    var cache = _getRequireWildcardCache();
    if (cache && cache.has(obj)) {
        return cache.get(obj);
    }
    var newObj = {};
    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
    for(var key in obj){
        if (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;
}
// this needs to be required lazily so that `next-server` can set
// the env before we require
const ReactDOMServer = _utils.shouldUseReactRoot ? require("react-dom/server.browser") : require("react-dom/server");
/**
 * Flight Response is always set to application/octet-stream to ensure it does not
 */ class FlightRenderResult extends _renderResult.default {
    constructor(response){
        super(response, {
            contentType: "application/octet-stream"
        });
    }
}
/**
 * Interop between "export default" and "module.exports".
 */ function interopDefault(mod) {
    return mod.default || mod;
}
// tolerate dynamic server errors during prerendering so console
// isn't spammed with unactionable errors
function onError(err) {
    const { DynamicServerError  } = require("../client/components/hooks-server-context");
    if (!(err instanceof DynamicServerError)) {
        console.error(err);
    }
}
let isFetchPatched = false;
// we patch fetch to collect cache information used for
// determining if a page is static or not
function patchFetch() {
    if (isFetchPatched) return;
    isFetchPatched = true;
    const { DynamicServerError  } = require("../client/components/hooks-server-context");
    const { useTrackStaticGeneration  } = require("../client/components/hooks-server");
    const origFetch = global.fetch;
    global.fetch = async (init, opts)=>{
        let staticGenerationContext = {};
        try {
            // eslint-disable-next-line react-hooks/rules-of-hooks
            staticGenerationContext = useTrackStaticGeneration() || {};
        } catch (_) {}
        const { isStaticGeneration , fetchRevalidate , pathname  } = staticGenerationContext;
        if (isStaticGeneration) {
            if (opts && typeof opts === "object") {
                if (opts.cache === "no-store") {
                    staticGenerationContext.revalidate = 0;
                    // TODO: ensure this error isn't logged to the user
                    // seems it's slipping through currently
                    throw new DynamicServerError(`no-store fetch ${init}${pathname ? ` ${pathname}` : ""}`);
                }
                if (typeof opts.revalidate === "number" && (typeof fetchRevalidate === "undefined" || opts.revalidate < fetchRevalidate)) {
                    staticGenerationContext.fetchRevalidate = opts.revalidate;
                }
            }
        }
        return origFetch(init, opts);
    };
}
/**
 * Render Flight stream.
 * This is only used for renderToHTML, the Flight response does not need additional wrappers.
 */ function useFlightResponse(writable, req, serverComponentManifest, rscChunks, flightResponseRef, nonce) {
    if (flightResponseRef.current !== null) {
        return flightResponseRef.current;
    }
    const [renderStream, forwardStream] = (0, _nodeWebStreamsHelper).readableStreamTee(req);
    const res = (0, _reactServerDomWebpack).createFromReadableStream(renderStream, {
        moduleMap: serverComponentManifest.__ssr_module_mapping__
    });
    flightResponseRef.current = res;
    let bootstrapped = false;
    // We only attach CSS chunks to the inlined data.
    const forwardReader = forwardStream.getReader();
    const writer = writable.getWriter();
    const startScriptTag = nonce ? `<script nonce=${JSON.stringify(nonce)}>` : "<script>";
    function process() {
        forwardReader.read().then(({ done , value  })=>{
            if (value) {
                rscChunks.push(value);
            }
            if (!bootstrapped) {
                bootstrapped = true;
                writer.write((0, _nodeWebStreamsHelper).encodeText(`${startScriptTag}(self.__next_s=self.__next_s||[]).push(${(0, _htmlescape).htmlEscapeJsonString(JSON.stringify([
                    0
                ]))})</script>`));
            }
            if (done) {
                flightResponseRef.current = null;
                writer.close();
            } else {
                const responsePartial = (0, _nodeWebStreamsHelper).decodeText(value);
                const scripts = `${startScriptTag}(self.__next_s=self.__next_s||[]).push(${(0, _htmlescape).htmlEscapeJsonString(JSON.stringify([
                    1,
                    responsePartial
                ]))})</script>`;
                writer.write((0, _nodeWebStreamsHelper).encodeText(scripts));
                process();
            }
        });
    }
    process();
    return res;
}
/**
 * Create a component that renders the Flight stream.
 * This is only used for renderToHTML, the Flight response does not need additional wrappers.
 */ function createServerComponentRenderer(ComponentToRender, ComponentMod, { transformStream , serverComponentManifest , serverContexts , rscChunks  }, nonce) {
    // We need to expose the `__webpack_require__` API globally for
    // react-server-dom-webpack. This is a hack until we find a better way.
    if (ComponentMod.__next_app_webpack_require__ || ComponentMod.__next_rsc__) {
        var ref;
        // @ts-ignore
        globalThis.__next_require__ = ComponentMod.__next_app_webpack_require__ || ((ref = ComponentMod.__next_rsc__) == null ? void 0 : ref.__webpack_require__);
        // @ts-ignore
        globalThis.__next_chunk_load__ = ()=>Promise.resolve();
    }
    let RSCStream;
    const createRSCStream = ()=>{
        if (!RSCStream) {
            RSCStream = (0, _writerBrowserServer).renderToReadableStream(/*#__PURE__*/ _react.default.createElement(ComponentToRender, null), serverComponentManifest, {
                context: serverContexts,
                onError
            });
        }
        return RSCStream;
    };
    const flightResponseRef = {
        current: null
    };
    const writable = transformStream.writable;
    return function ServerComponentWrapper() {
        const reqStream = createRSCStream();
        const response = useFlightResponse(writable, reqStream, serverComponentManifest, rscChunks, flightResponseRef, nonce);
        return (0, _react).experimental_use(response);
    };
}
/**
 * Shorten the dynamic param in order to make it smaller when transmitted to the browser.
 */ function getShortDynamicParamType(type) {
    switch(type){
        case "catchall":
            return "c";
        case "optional-catchall":
            return "oc";
        case "dynamic":
            return "d";
        default:
            throw new Error("Unknown dynamic param type");
    }
}
/**
 * Parse dynamic route segment to type of parameter
 */ function getSegmentParam(segment) {
    if (segment.startsWith("[[...") && segment.endsWith("]]")) {
        return {
            type: "optional-catchall",
            param: segment.slice(5, -2)
        };
    }
    if (segment.startsWith("[...") && segment.endsWith("]")) {
        return {
            type: "catchall",
            param: segment.slice(4, -1)
        };
    }
    if (segment.startsWith("[") && segment.endsWith("]")) {
        return {
            type: "dynamic",
            param: segment.slice(1, -1)
        };
    }
    return null;
}
/**
 * Get inline <link> tags based on server CSS manifest. Only used when rendering to HTML.
 */ function getCssInlinedLinkTags(serverComponentManifest, serverCSSManifest, filePath) {
    var ref;
    const layoutOrPageCss = serverCSSManifest[filePath] || ((ref = serverComponentManifest.__client_css_manifest__) == null ? void 0 : ref[filePath]);
    if (!layoutOrPageCss) {
        return [];
    }
    const chunks = new Set();
    for (const css of layoutOrPageCss){
        const mod = serverComponentManifest[css];
        if (mod) {
            for (const chunk of mod.default.chunks){
                chunks.add(chunk);
            }
        }
    }
    return [
        ...chunks
    ];
}
function getScriptNonceFromHeader(cspHeaderValue) {
    var ref;
    const directives = cspHeaderValue// Directives are split by ';'.
    .split(";").map((directive)=>directive.trim());
    // First try to find the directive for the 'script-src', otherwise try to
    // fallback to the 'default-src'.
    const directive1 = directives.find((dir)=>dir.startsWith("script-src")) || directives.find((dir)=>dir.startsWith("default-src"));
    // If no directive could be found, then we're done.
    if (!directive1) {
        return;
    }
    // Extract the nonce from the directive
    const nonce = (ref = directive1.split(" ")// Remove the 'strict-src'/'default-src' string, this can't be the nonce.
    .slice(1).map((source)=>source.trim())// Find the first source with the 'nonce-' prefix.
    .find((source)=>source.startsWith("'nonce-") && source.length > 8 && source.endsWith("'"))) == null ? void 0 : ref.slice(7, -1);
    // If we could't find the nonce, then we're done.
    if (!nonce) {
        return;
    }
    // Don't accept the nonce value if it contains HTML escape characters.
    // Technically, the spec requires a base64'd value, but this is just an
    // extra layer.
    if (_htmlescape.ESCAPE_REGEX.test(nonce)) {
        throw new Error("Nonce value from Content-Security-Policy contained HTML escape characters.\nLearn more: https://nextjs.org/docs/messages/nonce-contained-invalid-characters");
    }
    return nonce;
}
async function renderToHTMLOrFlight(req, res, pathname, query, renderOpts, isPagesDir, isStaticGeneration = false) {
    patchFetch();
    const { CONTEXT_NAMES  } = require("../client/components/hooks-server-context");
    // @ts-expect-error createServerContext exists in react@experimental + react-dom@experimental
    if (typeof _react.default.createServerContext === "undefined") {
        throw new Error('"app" directory requires React.createServerContext which is not available in the version of React you are using. Please update to react@experimental and react-dom@experimental.');
    }
    // don't modify original query object
    query = Object.assign({}, query);
    const { buildManifest , subresourceIntegrityManifest , serverComponentManifest , serverCSSManifest ={} , supportsDynamicHTML , ComponentMod ,  } = renderOpts;
    const isFlight = query.__flight__ !== undefined;
    const isPrefetch = query.__flight_prefetch__ !== undefined;
    // Handle client-side navigation to pages directory
    if (isFlight && isPagesDir) {
        (0, _internalUtils).stripInternalQueries(query);
        const search = (0, _querystring).stringify(query);
        // Empty so that the client-side router will do a full page navigation.
        const flightData = pathname + (search ? `?${search}` : "");
        return new FlightRenderResult((0, _writerBrowserServer).renderToReadableStream(flightData, serverComponentManifest, {
            onError
        }).pipeThrough((0, _nodeWebStreamsHelper).createBufferedTransformStream()));
    }
    // TODO-APP: verify the tree is valid
    // TODO-APP: verify query param is single value (not an array)
    // TODO-APP: verify tree can't grow out of control
    /**
   * Router state provided from the client-side router. Used to handle rendering from the common layout down.
   */ const providedFlightRouterState = isFlight ? query.__flight_router_state_tree__ ? JSON.parse(query.__flight_router_state_tree__) : {} : undefined;
    (0, _internalUtils).stripInternalQueries(query);
    const LayoutRouter = ComponentMod.LayoutRouter;
    const RenderFromTemplateContext = ComponentMod.RenderFromTemplateContext;
    const HotReloader = ComponentMod.HotReloader;
    const headers = req.headers;
    // TODO-APP: fix type of req
    // @ts-expect-error
    const cookies = req.cookies;
    /**
   * The tree created in next-app-loader that holds component segments and modules
   */ const loaderTree = ComponentMod.tree;
    const tryGetPreviewData = process.env.NEXT_RUNTIME === "edge" ? ()=>false : require("./api-utils/node").tryGetPreviewData;
    // Reads of this are cached on the `req` object, so this should resolve
    // instantly. There's no need to pass this data down from a previous
    // invoke, where we'd have to consider server & serverless.
    const previewData = tryGetPreviewData(req, res, renderOpts.previewProps);
    /**
   * Server Context is specifically only available in Server Components.
   * It has to hold values that can't change while rendering from the common layout down.
   * An example of this would be that `headers` are available but `searchParams` are not because that'd mean we have to render from the root layout down on all requests.
   */ const staticGenerationContext = {
        isStaticGeneration,
        pathname
    };
    const serverContexts = [
        [
            "WORKAROUND",
            null
        ],
        [
            CONTEXT_NAMES.HeadersContext,
            headers
        ],
        [
            CONTEXT_NAMES.CookiesContext,
            cookies
        ],
        [
            CONTEXT_NAMES.PreviewDataContext,
            previewData
        ],
        [
            CONTEXT_NAMES.StaticGenerationContext,
            staticGenerationContext
        ], 
    ];
    /**
   * Dynamic parameters. E.g. when you visit `/dashboard/vercel` which is rendered by `/dashboard/[slug]` the value will be {"slug": "vercel"}.
   */ const pathParams = renderOpts.params;
    /**
   * Parse the dynamic segment and return the associated value.
   */ const getDynamicParamFromSegment = (// [slug] / [[slug]] / [...slug]
    segment)=>{
        const segmentParam = getSegmentParam(segment);
        if (!segmentParam) {
            return null;
        }
        const key = segmentParam.param;
        const value = pathParams[key];
        if (!value) {
            // Handle case where optional catchall does not have a value, e.g. `/dashboard/[...slug]` when requesting `/dashboard`
            if (segmentParam.type === "optional-catchall") {
                const type = getShortDynamicParamType(segmentParam.type);
                return {
                    param: key,
                    value: null,
                    type: type,
                    // This value always has to be a string.
                    treeSegment: [
                        key,
                        "",
                        type
                    ]
                };
            }
            return null;
        }
        const type = getShortDynamicParamType(segmentParam.type);
        return {
            param: key,
            // The value that is passed to user code.
            value: value,
            // The value that is rendered in the router tree.
            treeSegment: [
                key,
                Array.isArray(value) ? value.join("/") : value,
                type
            ],
            type: type
        };
    };
    const createFlightRouterStateFromLoaderTree = ([segment, parallelRoutes])=>{
        const dynamicParam = getDynamicParamFromSegment(segment);
        const segmentTree = [
            dynamicParam ? dynamicParam.treeSegment : segment,
            {}, 
        ];
        if (parallelRoutes) {
            segmentTree[1] = Object.keys(parallelRoutes).reduce((existingValue, currentValue)=>{
                existingValue[currentValue] = createFlightRouterStateFromLoaderTree(parallelRoutes[currentValue]);
                return existingValue;
            }, {});
        }
        return segmentTree;
    };
    let defaultRevalidate = false;
    /**
   * Use the provided loader tree to create the React Component tree.
   */ const createComponentTree = async ({ createSegmentPath , loaderTree: [segment, parallelRoutes, { layoutOrPagePath , layout , template , error , loading , page  }, ] , parentParams , firstItem , rootLayoutIncluded  })=>{
        // TODO-APP: enable stylesheet per layout/page
        const stylesheets = layoutOrPagePath ? getCssInlinedLinkTags(serverComponentManifest, serverCSSManifest, layoutOrPagePath) : [];
        const Template = template ? await interopDefault(template()) : _react.default.Fragment;
        const ErrorComponent = error ? await interopDefault(error()) : undefined;
        const Loading = loading ? await interopDefault(loading()) : undefined;
        const isLayout = typeof layout !== "undefined";
        const isPage = typeof page !== "undefined";
        const layoutOrPageMod = isLayout ? await layout() : isPage ? await page() : undefined;
        if (layoutOrPageMod == null ? void 0 : layoutOrPageMod.config) {
            defaultRevalidate = layoutOrPageMod.config.revalidate;
        }
        /**
     * Checks if the current segment is a root layout.
     */ const rootLayoutAtThisLevel = isLayout && !rootLayoutIncluded;
        /**
     * Checks if the current segment or any level above it has a root layout.
     */ const rootLayoutIncludedAtThisLevelOrAbove = rootLayoutIncluded || rootLayoutAtThisLevel;
        // TODO-APP: move these errors to the loader instead?
        // we will also need a migration doc here to link to
        if (typeof (layoutOrPageMod == null ? void 0 : layoutOrPageMod.getServerSideProps) === "function") {
            throw new Error(`getServerSideProps is not supported in app/, detected in ${segment}`);
        }
        if (typeof (layoutOrPageMod == null ? void 0 : layoutOrPageMod.getStaticProps) === "function") {
            throw new Error(`getStaticProps is not supported in app/, detected in ${segment}`);
        }
        /**
     * The React Component to render.
     */ const Component = layoutOrPageMod ? interopDefault(layoutOrPageMod) : undefined;
        // Handle dynamic segment params.
        const segmentParam = getDynamicParamFromSegment(segment);
        /**
     * Create object holding the parent params and current params
     */ const currentParams = // Handle null case where dynamic param is optional
        segmentParam && segmentParam.value !== null ? {
            ...parentParams,
            [segmentParam.param]: segmentParam.value
        } : parentParams;
        // Resolve the segment param
        const actualSegment = segmentParam ? segmentParam.treeSegment : segment;
        // This happens outside of rendering in order to eagerly kick off data fetching for layouts / the page further down
        const parallelRouteMap = await Promise.all(Object.keys(parallelRoutes).map(async (parallelRouteKey)=>{
            const currentSegmentPath = firstItem ? [
                parallelRouteKey
            ] : [
                actualSegment,
                parallelRouteKey
            ];
            const childSegment = parallelRoutes[parallelRouteKey][0];
            const childSegmentParam = getDynamicParamFromSegment(childSegment);
            if (isPrefetch && Loading) {
                const childProp = {
                    // Null indicates the tree is not fully rendered
                    current: null,
                    segment: childSegmentParam ? childSegmentParam.treeSegment : childSegment
                };
                // This is turned back into an object below.
                return [
                    parallelRouteKey,
                    /*#__PURE__*/ _react.default.createElement(LayoutRouter, {
                        parallelRouterKey: parallelRouteKey,
                        segmentPath: createSegmentPath(currentSegmentPath),
                        loading: Loading ? /*#__PURE__*/ _react.default.createElement(Loading, null) : undefined,
                        error: ErrorComponent,
                        template: /*#__PURE__*/ _react.default.createElement(Template, null, /*#__PURE__*/ _react.default.createElement(RenderFromTemplateContext, null)),
                        childProp: childProp,
                        rootLayoutIncluded: rootLayoutIncludedAtThisLevelOrAbove
                    }), 
                ];
            }
            // Create the child component
            const { Component: ChildComponent  } = await createComponentTree({
                createSegmentPath: (child)=>{
                    return createSegmentPath([
                        ...currentSegmentPath,
                        ...child
                    ]);
                },
                loaderTree: parallelRoutes[parallelRouteKey],
                parentParams: currentParams,
                rootLayoutIncluded: rootLayoutIncludedAtThisLevelOrAbove
            });
            const childProp = {
                current: /*#__PURE__*/ _react.default.createElement(ChildComponent, null),
                segment: childSegmentParam ? childSegmentParam.treeSegment : childSegment
            };
            const segmentPath = createSegmentPath(currentSegmentPath);
            // This is turned back into an object below.
            return [
                parallelRouteKey,
                /*#__PURE__*/ _react.default.createElement(LayoutRouter, {
                    parallelRouterKey: parallelRouteKey,
                    segmentPath: segmentPath,
                    error: ErrorComponent,
                    loading: Loading ? /*#__PURE__*/ _react.default.createElement(Loading, null) : undefined,
                    template: /*#__PURE__*/ _react.default.createElement(Template, null, /*#__PURE__*/ _react.default.createElement(RenderFromTemplateContext, null)),
                    childProp: childProp,
                    rootLayoutIncluded: rootLayoutIncludedAtThisLevelOrAbove
                }), 
            ];
        }));
        // Convert the parallel route map into an object after all promises have been resolved.
        const parallelRouteComponents = parallelRouteMap.reduce((list, [parallelRouteKey, Comp])=>{
            list[parallelRouteKey] = Comp;
            return list;
        }, {});
        // When the segment does not have a layout or page we still have to add the layout router to ensure the path holds the loading component
        if (!Component) {
            return {
                Component: ()=>/*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, parallelRouteComponents.children)
            };
        }
        return {
            Component: ()=>{
                let props = {};
                return /*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, stylesheets ? stylesheets.map((href)=>/*#__PURE__*/ _react.default.createElement("link", {
                        rel: "stylesheet",
                        href: `/_next/${href}?ts=${Date.now()}`,
                        // `Precedence` is an opt-in signal for React to handle
                        // resource loading and deduplication, etc:
                        // https://github.com/facebook/react/pull/25060
                        // @ts-ignore
                        precedence: "high",
                        key: href
                    })) : null, /*#__PURE__*/ _react.default.createElement(Component, Object.assign({}, props, parallelRouteComponents, {
                    // TODO-APP: params and query have to be blocked parallel route names. Might have to add a reserved name list.
                    // Params are always the current params that apply to the layout
                    // If you have a `/dashboard/[team]/layout.js` it will provide `team` as a param but not anything further down.
                    params: currentParams
                }, isPage ? {
                    searchParams: query
                } : {})));
            }
        };
    };
    /**
   * Rules of Static & Dynamic HTML:
   *
   *    1.) We must generate static HTML unless the caller explicitly opts
   *        in to dynamic HTML support.
   *
   *    2.) If dynamic HTML support is requested, we must honor that request
   *        or throw an error. It is the sole responsibility of the caller to
   *        ensure they aren't e.g. requesting dynamic HTML for an AMP page.
   *
   * These rules help ensure that other existing features like request caching,
   * coalescing, and ISR continue working as intended.
   */ const generateStaticHTML = supportsDynamicHTML !== true;
    // Handle Flight render request. This is only used when client-side navigating. E.g. when you `router.push('/dashboard')` or `router.reload()`.
    if (isFlight) {
        // TODO-APP: throw on invalid flightRouterState
        /**
     * Use router state to decide at what common layout to render the page.
     * This can either be the common layout between two pages or a specific place to start rendering from using the "refetch" marker in the tree.
     */ const walkTreeWithFlightRouterState = async (loaderTreeToFilter, parentParams, flightRouterState, parentRendered)=>{
            const [segment, parallelRoutes] = loaderTreeToFilter;
            const parallelRoutesKeys = Object.keys(parallelRoutes);
            // Because this function walks to a deeper point in the tree to start rendering we have to track the dynamic parameters up to the point where rendering starts
            const segmentParam = getDynamicParamFromSegment(segment);
            const currentParams = // Handle null case where dynamic param is optional
            segmentParam && segmentParam.value !== null ? {
                ...parentParams,
                [segmentParam.param]: segmentParam.value
            } : parentParams;
            const actualSegment = segmentParam ? segmentParam.treeSegment : segment;
            /**
       * Decide if the current segment is where rendering has to start.
       */ const renderComponentsOnThisLevel = // No further router state available
            !flightRouterState || // Segment in router state does not match current segment
            !(0, _matchSegments).matchSegment(actualSegment, flightRouterState[0]) || // Last item in the tree
            parallelRoutesKeys.length === 0 || // Explicit refresh
            flightRouterState[3] === "refetch";
            if (!parentRendered && renderComponentsOnThisLevel) {
                return [
                    actualSegment,
                    // Create router state using the slice of the loaderTree
                    createFlightRouterStateFromLoaderTree(loaderTreeToFilter),
                    // Check if one level down from the common layout has a loading component. If it doesn't only provide the router state as part of the Flight data.
                    isPrefetch && !Boolean(loaderTreeToFilter[2].loading) ? null : /*#__PURE__*/ _react.default.createElement((await createComponentTree(// This ensures flightRouterPath is valid and filters down the tree
                    {
                        createSegmentPath: (child)=>child,
                        loaderTree: loaderTreeToFilter,
                        parentParams: currentParams,
                        firstItem: true
                    })).Component), 
                ];
            }
            // Walk through all parallel routes.
            for (const parallelRouteKey of parallelRoutesKeys){
                const parallelRoute = parallelRoutes[parallelRouteKey];
                const path = await walkTreeWithFlightRouterState(parallelRoute, currentParams, flightRouterState && flightRouterState[1][parallelRouteKey], parentRendered || renderComponentsOnThisLevel);
                if (typeof path[path.length - 1] !== "string") {
                    return [
                        actualSegment,
                        parallelRouteKey,
                        ...path
                    ];
                }
            }
            return [
                actualSegment
            ];
        };
        // Flight data that is going to be passed to the browser.
        // Currently a single item array but in the future multiple patches might be combined in a single request.
        const flightData = [
            // TODO-APP: change walk to output without ''
            (await walkTreeWithFlightRouterState(loaderTree, {}, providedFlightRouterState)).slice(1), 
        ];
        const readable = (0, _writerBrowserServer).renderToReadableStream(flightData, serverComponentManifest, {
            context: serverContexts,
            onError
        }).pipeThrough((0, _nodeWebStreamsHelper).createBufferedTransformStream());
        if (generateStaticHTML) {
            let staticHtml = Buffer.from((await readable.getReader().read()).value || "").toString();
            return new FlightRenderResult(staticHtml);
        }
        return new FlightRenderResult(readable);
    }
    // Below this line is handling for rendering to HTML.
    // Create full component tree from root to leaf.
    const { Component: ComponentTree  } = await createComponentTree({
        createSegmentPath: (child)=>child,
        loaderTree: loaderTree,
        parentParams: {},
        firstItem: true
    });
    // AppRouter is provided by next-app-loader
    const AppRouter = ComponentMod.AppRouter;
    let serverComponentsInlinedTransformStream = new TransformStream();
    // TODO-APP: validate req.url as it gets passed to render.
    const initialCanonicalUrl = req.url;
    // Get the nonce from the incomming request if it has one.
    const csp = req.headers["content-security-policy"];
    let nonce;
    if (csp && typeof csp === "string") {
        nonce = getScriptNonceFromHeader(csp);
    }
    const serverComponentsRenderOpts = {
        transformStream: serverComponentsInlinedTransformStream,
        serverComponentManifest,
        serverContexts,
        rscChunks: []
    };
    /**
   * A new React Component that renders the provided React Component
   * using Flight which can then be rendered to HTML.
   */ const ServerComponentsRenderer = createServerComponentRenderer(()=>{
        const initialTree = createFlightRouterStateFromLoaderTree(loaderTree);
        return /*#__PURE__*/ _react.default.createElement(AppRouter, {
            hotReloader: HotReloader && /*#__PURE__*/ _react.default.createElement(HotReloader, {
                assetPrefix: renderOpts.assetPrefix || ""
            }),
            initialCanonicalUrl: initialCanonicalUrl,
            initialTree: initialTree
        }, /*#__PURE__*/ _react.default.createElement(ComponentTree, null));
    }, ComponentMod, serverComponentsRenderOpts, nonce);
    const flushEffectsCallbacks = new Set();
    function FlushEffects({ children  }) {
        // Reset flushEffectsHandler on each render
        flushEffectsCallbacks.clear();
        const addFlushEffects = _react.default.useCallback((handler)=>{
            flushEffectsCallbacks.add(handler);
        }, []);
        return /*#__PURE__*/ _react.default.createElement(_flushEffects.FlushEffectsContext.Provider, {
            value: addFlushEffects
        }, children);
    }
    const bodyResult = async ()=>{
        const content = /*#__PURE__*/ _react.default.createElement(FlushEffects, null, /*#__PURE__*/ _react.default.createElement(ServerComponentsRenderer, null));
        const flushEffectHandler = ()=>{
            const flushed = ReactDOMServer.renderToString(/*#__PURE__*/ _react.default.createElement(_react.default.Fragment, null, Array.from(flushEffectsCallbacks).map((callback)=>callback())));
            return flushed;
        };
        try {
            const renderStream = await (0, _nodeWebStreamsHelper).renderToInitialStream({
                ReactDOMServer,
                element: content,
                streamOptions: {
                    nonce,
                    // Include hydration scripts in the HTML
                    bootstrapScripts: subresourceIntegrityManifest ? buildManifest.rootMainFiles.map((src)=>({
                            src: `${renderOpts.assetPrefix || ""}/_next/` + src,
                            integrity: subresourceIntegrityManifest[src]
                        })) : buildManifest.rootMainFiles.map((src)=>`${renderOpts.assetPrefix || ""}/_next/` + src)
                }
            });
            return await (0, _nodeWebStreamsHelper).continueFromInitialStream(renderStream, {
                dataStream: serverComponentsInlinedTransformStream == null ? void 0 : serverComponentsInlinedTransformStream.readable,
                generateStaticHTML: generateStaticHTML,
                flushEffectHandler,
                flushEffectsToHead: true
            });
        } catch (err) {
            // TODO-APP: show error overlay in development. `element` should probably be wrapped in AppRouter for this case.
            const renderStream = await (0, _nodeWebStreamsHelper).renderToInitialStream({
                ReactDOMServer,
                element: /*#__PURE__*/ _react.default.createElement("html", {
                    id: "__next_error__"
                }, /*#__PURE__*/ _react.default.createElement("head", null), /*#__PURE__*/ _react.default.createElement("body", null)),
                streamOptions: {
                    nonce,
                    // Include hydration scripts in the HTML
                    bootstrapScripts: subresourceIntegrityManifest ? buildManifest.rootMainFiles.map((src)=>({
                            src: `${renderOpts.assetPrefix || ""}/_next/` + src,
                            integrity: subresourceIntegrityManifest[src]
                        })) : buildManifest.rootMainFiles.map((src)=>`${renderOpts.assetPrefix || ""}/_next/` + src)
                }
            });
            return await (0, _nodeWebStreamsHelper).continueFromInitialStream(renderStream, {
                dataStream: serverComponentsInlinedTransformStream == null ? void 0 : serverComponentsInlinedTransformStream.readable,
                generateStaticHTML: generateStaticHTML,
                flushEffectHandler,
                flushEffectsToHead: true
            });
        }
    };
    const readable = await bodyResult();
    if (generateStaticHTML) {
        let staticHtml = Buffer.from((await readable.getReader().read()).value || "").toString();
        renderOpts.pageData = Buffer.concat(serverComponentsRenderOpts.rscChunks).toString();
        renderOpts.revalidate = typeof staticGenerationContext.revalidate === "undefined" ? defaultRevalidate : staticGenerationContext.revalidate;
        return new _renderResult.default(staticHtml);
    }
    return new _renderResult.default(readable);
}

//# sourceMappingURL=app-render.js.map