@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/client/components/router-reducer/fetch-server-response.js

@@ -6,7 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     createFetch: null,
     createFromNextReadableStream: null,
-    fetchServerResponse: null
+    decodeStaticStage: null,
+    fetchServerResponse: null,
+    processFetch: null,
+    resolveStaticStageData: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -21,23 +24,36 @@ _export(exports, {
     createFromNextReadableStream: function() {
         return createFromNextReadableStream;
     },
+    decodeStaticStage: function() {
+        return decodeStaticStage;
+    },
     fetchServerResponse: function() {
         return fetchServerResponse;
+    },
+    processFetch: function() {
+        return processFetch;
+    },
+    resolveStaticStageData: function() {
+        return resolveStaticStageData;
     }
 });
 const _client = require("react-server-dom-webpack/client");
+const _invarianterror = require("../../../shared/lib/invariant-error");
 const _approuterheaders = require("../app-router-headers");
 const _appcallserver = require("../../app-call-server");
 const _appfindsourcemapurl = require("../../app-find-source-map-url");
 const _flightdatahelpers = require("../../flight-data-helpers");
-const _appbuildid = require("../../app-build-id");
 const _setcachebustingsearchparam = require("./set-cache-busting-search-param");
 const _routeparams = require("../../route-params");
 const _deploymentid = require("../../../shared/lib/deployment-id");
+const _navigationbuildid = require("../../navigation-build-id");
+const _constants = require("../../../lib/constants");
+const _cache = require("../segment-cache/cache");
+const _bfcache = require("../segment-cache/bfcache");
 const createFromReadableStream = _client.createFromReadableStream;
 const createFromFetch = _client.createFromFetch;
 let createDebugChannel;
-if (process.env.NODE_ENV !== 'production' && process.env.__NEXT_REACT_DEBUG_CHANNEL) {
+if (process.env.__NEXT_DEV_SERVER && process.env.__NEXT_REACT_DEBUG_CHANNEL) {
     createDebugChannel = require('../../dev/debug-channel').createDebugChannel;
 }
 function doMpaNavigation(url) {
@@ -99,8 +115,6 @@ async function fetchServerResponse(url, options) {
         const contentType = res.headers.get('content-type') || '';
         const interception = !!res.headers.get('vary')?.includes(_approuterheaders.NEXT_URL);
         const postponed = !!res.headers.get(_approuterheaders.NEXT_DID_POSTPONE_HEADER);
-        const staleTimeHeaderSeconds = res.headers.get(_approuterheaders.NEXT_ROUTER_STALE_TIME_HEADER);
-        const staleTime = staleTimeHeaderSeconds !== null ? parseInt(staleTimeHeaderSeconds, 10) * 1000 : -1;
         let isFlightResponse = contentType.startsWith(_approuterheaders.RSC_CONTENT_TYPE_HEADER);
         if (process.env.NODE_ENV === 'production') {
             if (process.env.__NEXT_CONFIG_OUTPUT === 'export') {
@@ -128,32 +142,52 @@ async function fetchServerResponse(url, options) {
         if (process.env.NODE_ENV !== 'production' && !process.env.TURBOPACK) {
             await require('../../dev/hot-reloader/app/hot-reloader-app').waitForWebpackRuntimeHotUpdate();
         }
-        let flightResponsePromise = res.flightResponse;
+        let flightResponsePromise = res.flightResponsePromise;
         if (flightResponsePromise === null) {
             // Typically, `createFetch` would have already started decoding the
             // Flight response. If it hasn't, though, we need to decode it now.
             // TODO: This should only be reachable if legacy PPR is enabled (i.e. PPR
             // without Cache Components). Remove this branch once legacy PPR
             // is deleted.
-            const flightStream = postponed ? createUnclosingPrefetchStream(res.body) : res.body;
-            flightResponsePromise = createFromNextReadableStream(flightStream, headers);
+            flightResponsePromise = createFromNextReadableStream(res.body, headers, {
+                allowPartialStream: postponed
+            });
         }
-        const flightResponse = await flightResponsePromise;
-        if ((0, _appbuildid.getAppBuildId)() !== flightResponse.b) {
+        const [flightResponse, cacheData] = await Promise.all([
+            flightResponsePromise,
+            res.cacheData
+        ]);
+        if ((res.headers.get(_constants.NEXT_NAV_DEPLOYMENT_ID_HEADER) ?? flightResponse.b) !== (0, _navigationbuildid.getNavigationBuildId)()) {
+            // The server build does not match the client build.
             return doMpaNavigation(res.url);
         }
         const normalizedFlightData = (0, _flightdatahelpers.normalizeFlightData)(flightResponse.f);
         if (typeof normalizedFlightData === 'string') {
             return doMpaNavigation(normalizedFlightData);
         }
+        const staticStageData = cacheData !== null ? await resolveStaticStageData(cacheData, flightResponse, headers) : null;
         return {
             flightData: normalizedFlightData,
             canonicalUrl: canonicalUrl,
-            renderedSearch: (0, _routeparams.getRenderedSearch)(res),
+            // TODO: We should be able to read this from the rewrite header, not the
+            // Flight response. Theoretically they should always agree, but there are
+            // currently some cases where it's incorrect for interception routes. We
+            // can always trust the value in the response body. However, per-segment
+            // prefetch responses don't embed the value in the body; they rely on the
+            // header alone. So we need to investigate why the header is sometimes
+            // wrong for interception routes.
+            renderedSearch: flightResponse.q,
             couldBeIntercepted: interception,
-            prerendered: flightResponse.S,
+            supportsPerSegmentPrefetching: flightResponse.S,
             postponed,
-            staleTime,
+            // The dynamicStaleTime is only present in the response body when
+            // a page exports unstable_dynamicStaleTime and this is a dynamic render.
+            // When absent (UnknownDynamicStaleTime), the client falls back to the
+            // global DYNAMIC_STALETIME_MS. The value is in seconds.
+            dynamicStaleTime: flightResponse.d ?? _bfcache.UnknownDynamicStaleTime,
+            staticStageData,
+            runtimePrefetchStream: flightResponse.p ?? null,
+            responseHeaders: res.headers,
             debugInfo: flightResponsePromise._debugInfo ?? null
         };
     } catch (err) {
@@ -166,6 +200,87 @@ async function fetchServerResponse(url, options) {
         return originalUrl.toString();
     }
 }
+async function processFetch(response) {
+    if (process.env.__NEXT_CACHE_COMPONENTS) {
+        if (!response.body) {
+            throw Object.defineProperty(new _invarianterror.InvariantError('Expected RSC navigation response to have a body'), "__NEXT_ERROR_CODE", {
+                value: "E1088",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        const { stream, isPartial } = await (0, _cache.stripIsPartialByte)(response.body);
+        let responseStream;
+        let cacheData;
+        if (process.env.__NEXT_EXPERIMENTAL_CACHED_NAVIGATIONS) {
+            const [stream1, stream2] = stream.tee();
+            responseStream = stream1;
+            cacheData = {
+                isResponsePartial: isPartial,
+                responseBodyClone: stream2
+            };
+        } else {
+            responseStream = stream;
+            cacheData = {
+                isResponsePartial: isPartial
+            };
+        }
+        const strippedResponse = new Response(responseStream, {
+            headers: response.headers,
+            status: response.status,
+            statusText: response.statusText
+        });
+        // The Response constructor doesn't preserve `url` or `redirected` from
+        // the original. We need both: `url` for React DevTools and `redirected`
+        // for the redirect replay logic below.
+        Object.defineProperty(strippedResponse, 'url', {
+            value: response.url
+        });
+        Object.defineProperty(strippedResponse, 'redirected', {
+            value: response.redirected
+        });
+        return {
+            response: strippedResponse,
+            cacheData
+        };
+    }
+    return {
+        response,
+        cacheData: null
+    };
+}
+async function resolveStaticStageData(cacheData, flightResponse, headers) {
+    const { isResponsePartial, responseBodyClone } = cacheData;
+    if (responseBodyClone) {
+        if (!isResponsePartial) {
+            // Fully static — cache the entire decoded response as-is.
+            responseBodyClone.cancel();
+            return {
+                response: flightResponse,
+                isResponsePartial: false
+            };
+        }
+        if (flightResponse.l !== undefined) {
+            // Partially static — truncate the body clone at the byte boundary and
+            // decode it.
+            const response = await decodeStaticStage(responseBodyClone, flightResponse.l, headers);
+            return {
+                response,
+                isResponsePartial: true
+            };
+        }
+        // No caching — cancel the unused clone.
+        responseBodyClone.cancel();
+    }
+    return null;
+}
+async function decodeStaticStage(responseBodyClone, staticStageByteLengthPromise, headers) {
+    const staticStageByteLength = await staticStageByteLengthPromise;
+    const truncatedStream = truncateStream(responseBodyClone, staticStageByteLength);
+    return createFromNextReadableStream(truncatedStream, headers, {
+        allowPartialStream: true
+    });
+}
 async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode, signal) {
     // TODO: In output: "export" mode, the headers do nothing. Omit them (and the
     // cache busting search param) from the request so they're
@@ -177,7 +292,7 @@ async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode,
     if (deploymentId) {
         headers['x-deployment-id'] = deploymentId;
     }
-    if (process.env.NODE_ENV !== 'production') {
+    if (process.env.__NEXT_DEV_SERVER) {
         if (self.__next_r) {
             headers[_approuterheaders.NEXT_HTML_REQUEST_ID_HEADER] = self.__next_r;
         }
@@ -198,17 +313,16 @@ async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode,
     // track them separately.
     let fetchUrl = new URL(url);
     (0, _setcachebustingsearchparam.setCacheBustingSearchParam)(fetchUrl, headers);
-    let fetchPromise = fetch(fetchUrl, fetchOptions);
+    let processed = fetch(fetchUrl, fetchOptions).then(processFetch);
+    let fetchPromise = processed.then(({ response })=>response);
     // Immediately pass the fetch promise to the Flight client so that the debug
     // info includes the latency from the client to the server. The internal timer
     // in React starts as soon as `createFromFetch` is called.
     //
-    // The only case where we don't do this is during a prefetch, because we have
-    // to do some extra processing of the response stream (see
-    // `createUnclosingPrefetchStream`). But this is fine, because a top-level
-    // prefetch response never blocks a navigation; if it hasn't already been
-    // written into the cache by the time the navigation happens, the router will
-    // go straight to a dynamic request.
+    // The only case where we don't do this is during a prefetch, because a
+    // top-level prefetch response never blocks a navigation; if it hasn't already
+    // been written into the cache by the time the navigation happens, the router
+    // will go straight to a dynamic request.
     let flightResponsePromise = shouldImmediatelyDecode ? createFromNextFetch(fetchPromise, headers) : null;
     let browserResponse = await fetchPromise;
     // If the server responds with a redirect (e.g. 307), and the redirected
@@ -254,7 +368,8 @@ async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode,
             // TODO: We should abort the previous request.
             fetchUrl = new URL(responseUrl);
             (0, _setcachebustingsearchparam.setCacheBustingSearchParam)(fetchUrl, headers);
-            fetchPromise = fetch(fetchUrl, fetchOptions);
+            processed = fetch(fetchUrl, fetchOptions).then(processFetch);
+            fetchPromise = processed.then(({ response })=>response);
             flightResponsePromise = shouldImmediatelyDecode ? createFromNextFetch(fetchPromise, headers) : null;
             browserResponse = await fetchPromise;
             // We just performed a manual redirect, so this is now true.
@@ -282,15 +397,17 @@ async function createFetch(url, headers, fetchPriority, shouldImmediatelyDecode,
         // This is the exact promise returned by `createFromFetch`. It contains
         // debug information that we need to transfer to any derived promises that
         // are later rendered by React.
-        flightResponse: flightResponsePromise
+        flightResponsePromise: flightResponsePromise,
+        cacheData: processed.then(({ cacheData })=>cacheData)
     };
     return rscResponse;
 }
-function createFromNextReadableStream(flightStream, requestHeaders) {
+function createFromNextReadableStream(flightStream, requestHeaders, options) {
     return createFromReadableStream(flightStream, {
         callServer: _appcallserver.callServer,
         findSourceMapURL: _appfindsourcemapurl.findSourceMapURL,
-        debugChannel: createDebugChannel && createDebugChannel(requestHeaders)
+        debugChannel: createDebugChannel && createDebugChannel(requestHeaders),
+        unstable_allowPartialStream: options?.allowPartialStream
     });
 }
 function createFromNextFetch(promiseForResponse, requestHeaders) {
@@ -300,33 +417,33 @@ function createFromNextFetch(promiseForResponse, requestHeaders) {
         debugChannel: createDebugChannel && createDebugChannel(requestHeaders)
     });
 }
-function createUnclosingPrefetchStream(originalFlightStream) {
-    // When PPR is enabled, prefetch streams may contain references that never
-    // resolve, because that's how we encode dynamic data access. In the decoded
-    // object returned by the Flight client, these are reified into hanging
-    // promises that suspend during render, which is effectively what we want.
-    // The UI resolves when it switches to the dynamic data stream
-    // (via useDeferredValue(dynamic, static)).
-    //
-    // However, the Flight implementation currently errors if the server closes
-    // the response before all the references are resolved. As a cheat to work
-    // around this, we wrap the original stream in a new stream that never closes,
-    // and therefore doesn't error.
-    const reader = originalFlightStream.getReader();
+function truncateStream(stream, byteLength) {
+    const reader = stream.getReader();
+    let remaining = byteLength;
     return new ReadableStream({
         async pull (controller) {
-            while(true){
-                const { done, value } = await reader.read();
-                if (!done) {
-                    // Pass to the target stream and keep consuming the Flight response
-                    // from the server.
-                    controller.enqueue(value);
-                    continue;
-                }
-                // The server stream has closed. Exit, but intentionally do not close
-                // the target stream.
+            if (remaining <= 0) {
+                reader.cancel();
+                controller.close();
                 return;
             }
+            const { done, value } = await reader.read();
+            if (done) {
+                controller.close();
+                return;
+            }
+            if (value.byteLength <= remaining) {
+                controller.enqueue(value);
+                remaining -= value.byteLength;
+            } else {
+                controller.enqueue(value.subarray(0, remaining));
+                remaining = 0;
+                reader.cancel();
+                controller.close();
+            }
+        },
+        cancel () {
+            reader.cancel();
         }
     });
 }

package/standalone/node_modules/next/dist/client/components/router-reducer/is-navigating-to-new-root-layout.js

@@ -8,10 +8,11 @@ Object.defineProperty(exports, "isNavigatingToNewRootLayout", {
         return isNavigatingToNewRootLayout;
     }
 });
+const _approutertypes = require("../../../shared/lib/app-router-types");
 function isNavigatingToNewRootLayout(currentTree, nextTree) {
     // Compare segments
     const currentTreeSegment = currentTree[0];
-    const nextTreeSegment = nextTree[0];
+    const nextTreeSegment = nextTree.segment;
     // If any segment is different before we find the root layout, the root layout has changed.
     // E.g. /same/(group1)/layout.js -> /same/(group2)/layout.js
     // First segment is 'same' for both, keep looking. (group1) changed to (group2) before the root layout was found, it must have changed.
@@ -25,21 +26,28 @@ function isNavigatingToNewRootLayout(currentTree, nextTree) {
         return true;
     }
     // Current tree root layout found
-    if (currentTree[4]) {
+    const currentIsRootLayout = ((currentTree[4] ?? 0) & _approutertypes.PrefetchHint.IsRootLayout) !== 0;
+    const nextIsRootLayout = (nextTree.prefetchHints & _approutertypes.PrefetchHint.IsRootLayout) !== 0;
+    if (currentIsRootLayout) {
         // If the next tree doesn't have the root layout flag, it must have changed.
-        return !nextTree[4];
+        return !nextIsRootLayout;
     }
     // Current tree didn't have its root layout here, must have changed.
-    if (nextTree[4]) {
+    if (nextIsRootLayout) {
         return true;
     }
-    // We can't assume it's `parallelRoutes.children` here in case the root layout is `app/@something/layout.js`
-    // But it's not possible to be more than one parallelRoutes before the root layout is found
-    // TODO-APP: change to traverse all parallel routes
-    const currentTreeChild = Object.values(currentTree[1])[0];
-    const nextTreeChild = Object.values(nextTree[1])[0];
-    if (!currentTreeChild || !nextTreeChild) return true;
-    return isNavigatingToNewRootLayout(currentTreeChild, nextTreeChild);
+    const slots = nextTree.slots;
+    const currentTreeChildren = currentTree[1];
+    if (slots !== null) {
+        for(const slot in slots){
+            const nextTreeChild = slots[slot];
+            const currentTreeChild = currentTreeChildren[slot];
+            if (currentTreeChild === undefined || isNavigatingToNewRootLayout(currentTreeChild, nextTreeChild)) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {