qalita 2.5.4__py3-none-any.whl → 2.6.1__py3-none-any.whl

qalita/_frontend/node_modules/next/dist/client/components/router-reducer/reducers/server-action-reducer.js

@@ -16,14 +16,7 @@ const _client = require("react-server-dom-webpack/client");
 const _assignlocation = require("../../../assign-location");
 const _createhreffromurl = require("../create-href-from-url");
 const _navigatereducer = require("./navigate-reducer");
-const _applyrouterstatepatchtotree = require("../apply-router-state-patch-to-tree");
-const _isnavigatingtonewrootlayout = require("../is-navigating-to-new-root-layout");
-const _handlemutable = require("../handle-mutable");
-const _filllazyitemstillleafwithhead = require("../fill-lazy-items-till-leaf-with-head");
-const _approuter = require("../../app-router");
 const _hasinterceptionrouteincurrenttree = require("./has-interception-route-in-current-tree");
-const _handlesegmentmismatch = require("../handle-segment-mismatch");
-const _refetchinactiveparallelsegments = require("../refetch-inactive-parallel-segments");
 const _flightdatahelpers = require("../../../flight-data-helpers");
 const _redirect = require("../../redirect");
 const _redirecterror = require("../../redirect-error");
@@ -31,6 +24,11 @@ const _removebasepath = require("../../../remove-base-path");
 const _hasbasepath = require("../../../has-base-path");
 const _serverreferenceinfo = require("../../../../shared/lib/server-reference-info");
 const _cache = require("../../segment-cache/cache");
+const _deploymentid = require("../../../../shared/lib/deployment-id");
+const _navigation = require("../../segment-cache/navigation");
+const _actionrevalidationkind = require("../../../../shared/lib/action-revalidation-kind");
+const _approuterutils = require("../../app-router-utils");
+const _pprnavigations = require("../ppr-navigations");
 const createFromFetch = _client.createFromFetch;
 let createDebugChannel;
 if (process.env.NODE_ENV !== 'production' && process.env.__NEXT_REACT_DEBUG_CHANNEL) {
@@ -51,8 +49,9 @@ async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
         [_approuterheaders.ACTION_HEADER]: actionId,
         [_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER]: (0, _flightdatahelpers.prepareFlightRouterStateForRequest)(state.tree)
     };
-    if (process.env.NEXT_DEPLOYMENT_ID) {
-        headers['x-deployment-id'] = process.env.NEXT_DEPLOYMENT_ID;
+    const deploymentId = (0, _deploymentid.getDeploymentId)();
+    if (deploymentId) {
+        headers['x-deployment-id'] = deploymentId;
     }
     if (nextUrl) {
         headers[_approuterheaders.NEXT_URL] = nextUrl;
@@ -81,7 +80,7 @@ async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
         });
     }
     const redirectHeader = res.headers.get('x-action-redirect');
-    const [location, _redirectType] = redirectHeader?.split(';') || [];
+    const [location1, _redirectType] = redirectHeader?.split(';') || [];
     let redirectType;
     switch(_redirectType){
         case 'push':
@@ -94,18 +93,17 @@ async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
             redirectType = undefined;
     }
     const isPrerender = !!res.headers.get(_approuterheaders.NEXT_IS_PRERENDER_HEADER);
-    let revalidatedParts;
+    let revalidationKind = _actionrevalidationkind.ActionDidNotRevalidate;
     try {
-        const revalidatedHeader = JSON.parse(res.headers.get('x-action-revalidated') || '[[],0,0]');
-        revalidatedParts = {
-            paths: revalidatedHeader[0] || [],
-            tag: !!revalidatedHeader[1],
-            cookie: revalidatedHeader[2]
-        };
-    } catch (e) {
-        revalidatedParts = NO_REVALIDATED_PARTS;
-    }
-    const redirectLocation = location ? (0, _assignlocation.assignLocation)(location, new URL(state.canonicalUrl, window.location.href)) : undefined;
+        const revalidationHeader = res.headers.get('x-action-revalidated');
+        if (revalidationHeader) {
+            const parsedKind = JSON.parse(revalidationHeader);
+            if (parsedKind === _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic || parsedKind === _actionrevalidationkind.ActionDidRevalidateDynamicOnly) {
+                revalidationKind = parsedKind;
+            }
+        }
+    } catch  {}
+    const redirectLocation = location1 ? (0, _assignlocation.assignLocation)(location1, new URL(state.canonicalUrl, window.location.href)) : undefined;
     const contentType = res.headers.get('content-type');
     const isRscResponse = !!(contentType && contentType.startsWith(_approuterheaders.RSC_CONTENT_TYPE_HEADER));
     // Handle invalid server action responses.
@@ -123,6 +121,8 @@ async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
     }
     let actionResult;
     let actionFlightData;
+    let actionFlightDataRenderedSearch;
+    let actionFlightDataCouldBeIntercepted;
     if (isRscResponse) {
         const response = await createFromFetch(Promise.resolve(res), {
             callServer: _appcallserver.callServer,
@@ -132,30 +132,33 @@ async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
         });
         // An internal redirect can send an RSC response, but does not have a useful `actionResult`.
         actionResult = redirectLocation ? undefined : response.a;
-        actionFlightData = (0, _flightdatahelpers.normalizeFlightData)(response.f);
+        const maybeFlightData = (0, _flightdatahelpers.normalizeFlightData)(response.f);
+        if (maybeFlightData !== '') {
+            actionFlightData = maybeFlightData;
+            actionFlightDataRenderedSearch = response.q;
+            actionFlightDataCouldBeIntercepted = response.i;
+        }
     } else {
         // An external redirect doesn't contain RSC data.
         actionResult = undefined;
         actionFlightData = undefined;
+        actionFlightDataRenderedSearch = undefined;
+        actionFlightDataCouldBeIntercepted = undefined;
     }
     return {
         actionResult,
         actionFlightData,
+        actionFlightDataRenderedSearch,
+        actionFlightDataCouldBeIntercepted,
         redirectLocation,
         redirectType,
-        revalidatedParts,
+        revalidationKind,
         isPrerender
     };
 }
-const NO_REVALIDATED_PARTS = {
-    paths: [],
-    tag: false,
-    cookie: false
-};
 function serverActionReducer(state, action) {
     const { resolve, reject } = action;
     const mutable = {};
-    let currentTree = state.tree;
     mutable.preserveCustomHistoryState = false;
     // only pass along the `nextUrl` param (used for interception routes) if the current route was intercepted.
     // If the route has been intercepted, the action should be as well.
@@ -167,108 +170,118 @@ function serverActionReducer(state, action) {
     // interception route to be matched that used the last
     // next-url.
     (state.previousNextUrl || state.nextUrl) && (0, _hasinterceptionrouteincurrenttree.hasInterceptionRouteInCurrentTree)(state.tree) ? state.previousNextUrl || state.nextUrl : null;
-    const navigatedAt = Date.now();
-    return fetchServerAction(state, nextUrl, action).then(async ({ actionResult, actionFlightData: flightData, redirectLocation, redirectType, revalidatedParts })=>{
-        let redirectHref;
-        // honor the redirect type instead of defaulting to push in case of server actions.
-        if (redirectLocation) {
-            if (redirectType === _redirecterror.RedirectType.replace) {
-                state.pushRef.pendingPush = false;
-                mutable.pendingPush = false;
-            } else {
-                state.pushRef.pendingPush = true;
-                mutable.pendingPush = true;
-            }
-            redirectHref = (0, _createhreffromurl.createHrefFromUrl)(redirectLocation, false);
-            mutable.canonicalUrl = redirectHref;
-        }
-        if (!flightData) {
-            resolve(actionResult);
-            // If there is a redirect but no flight data we need to do a mpaNavigation.
-            if (redirectLocation) {
-                return (0, _navigatereducer.handleExternalUrl)(state, mutable, redirectLocation.href, state.pushRef.pendingPush);
-            }
-            return state;
-        }
-        if (typeof flightData === 'string') {
-            // Handle case when navigating to page in `pages` from `app`
-            resolve(actionResult);
-            return (0, _navigatereducer.handleExternalUrl)(state, mutable, flightData, state.pushRef.pendingPush);
-        }
-        const actionRevalidated = revalidatedParts.paths.length > 0 || revalidatedParts.tag || revalidatedParts.cookie;
-        // Store whether this action triggered any revalidation
-        // The action queue will use this information to potentially
-        // trigger a refresh action if the action was discarded
-        // (ie, due to a navigation, before the action completed)
-        if (actionRevalidated) {
+    return fetchServerAction(state, nextUrl, action).then(async ({ revalidationKind, actionResult, actionFlightData: flightData, actionFlightDataRenderedSearch: flightDataRenderedSearch, actionFlightDataCouldBeIntercepted: flightDataCouldBeIntercepted, redirectLocation, redirectType })=>{
+        if (revalidationKind !== _actionrevalidationkind.ActionDidNotRevalidate) {
+            // Store whether this action triggered any revalidation
+            // The action queue will use this information to potentially
+            // trigger a refresh action if the action was discarded
+            // (ie, due to a navigation, before the action completed)
             action.didRevalidate = true;
-        }
-        for (const normalizedFlightData of flightData){
-            const { tree: treePatch, seedData: cacheNodeSeedData, head, isRootRender } = normalizedFlightData;
-            if (!isRootRender) {
-                // TODO-APP: handle this case better
-                console.log('SERVER ACTION APPLY FAILED');
-                resolve(actionResult);
-                return state;
-            }
-            // Given the path can only have two items the items are only the router state and rsc for the root.
-            const newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTree)(// TODO-APP: remove ''
-            [
-                ''
-            ], currentTree, treePatch, redirectHref ? redirectHref : state.canonicalUrl);
-            if (newTree === null) {
-                resolve(actionResult);
-                return (0, _handlesegmentmismatch.handleSegmentMismatch)(state, action, treePatch);
-            }
-            if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
-                resolve(actionResult);
-                return (0, _navigatereducer.handleExternalUrl)(state, mutable, redirectHref || state.canonicalUrl, state.pushRef.pendingPush);
-            }
-            // The server sent back RSC data for the server action, so we need to apply it to the cache.
-            if (cacheNodeSeedData !== null) {
-                const rsc = cacheNodeSeedData[0];
-                const cache = (0, _approuter.createEmptyCacheNode)();
-                cache.rsc = rsc;
-                cache.prefetchRsc = null;
-                cache.loading = cacheNodeSeedData[2];
-                (0, _filllazyitemstillleafwithhead.fillLazyItemsTillLeafWithHead)(navigatedAt, cache, // Existing cache is not passed in as server actions have to invalidate the entire cache.
-                undefined, treePatch, cacheNodeSeedData, head);
-                mutable.cache = cache;
-                (0, _cache.revalidateEntireCache)(state.nextUrl, newTree);
-                if (actionRevalidated) {
-                    await (0, _refetchinactiveparallelsegments.refreshInactiveParallelSegments)({
-                        navigatedAt,
-                        state,
-                        updatedTree: newTree,
-                        updatedCache: cache,
-                        includeNextUrl: Boolean(nextUrl),
-                        canonicalUrl: mutable.canonicalUrl || state.canonicalUrl
-                    });
-                }
+            // If there was a revalidation, evict the entire prefetch cache.
+            // TODO: Evict only segments with matching tags and/or paths.
+            if (revalidationKind === _actionrevalidationkind.ActionDidRevalidateStaticAndDynamic) {
+                (0, _cache.revalidateEntireCache)(nextUrl, state.tree);
             }
-            mutable.patchedTree = newTree;
-            currentTree = newTree;
         }
-        if (redirectLocation && redirectHref) {
+        const pendingPush = redirectType !== _redirecterror.RedirectType.replace;
+        state.pushRef.pendingPush = pendingPush;
+        mutable.pendingPush = pendingPush;
+        if (redirectLocation !== undefined) {
             // If the action triggered a redirect, the action promise will be rejected with
             // a redirect so that it's handled by RedirectBoundary as we won't have a valid
             // action result to resolve the promise with. This will effectively reset the state of
             // the component that called the action as the error boundary will remount the tree.
             // The status code doesn't matter here as the action handler will have already sent
             // a response with the correct status code.
-            const redirectError = (0, _redirect.getRedirectError)((0, _hasbasepath.hasBasePath)(redirectHref) ? (0, _removebasepath.removeBasePath)(redirectHref) : redirectHref, redirectType || _redirecterror.RedirectType.push);
-            redirectError.handled = true;
-            reject(redirectError);
+            const resolvedRedirectType = redirectType || _redirecterror.RedirectType.push;
+            if ((0, _approuterutils.isExternalURL)(redirectLocation)) {
+                // External redirect. Triggers an MPA navigation.
+                const redirectHref = redirectLocation.href;
+                const redirectError = createRedirectErrorForAction(redirectHref, resolvedRedirectType);
+                reject(redirectError);
+                return (0, _navigatereducer.handleExternalUrl)(state, mutable, redirectHref, pendingPush);
+            } else {
+                // Internal redirect. Triggers an SPA navigation.
+                const redirectWithBasepath = (0, _createhreffromurl.createHrefFromUrl)(redirectLocation, false);
+                const redirectHref = (0, _hasbasepath.hasBasePath)(redirectWithBasepath) ? (0, _removebasepath.removeBasePath)(redirectWithBasepath) : redirectWithBasepath;
+                const redirectError = createRedirectErrorForAction(redirectHref, resolvedRedirectType);
+                reject(redirectError);
+            }
         } else {
+            // If there's no redirect, resolve the action with the result.
             resolve(actionResult);
         }
-        return (0, _handlemutable.handleMutable)(state, mutable);
+        // Check if we can bail out without updating any state.
+        if (// Did the action trigger a redirect?
+        redirectLocation === undefined && // Did the action revalidate any data?
+        revalidationKind === _actionrevalidationkind.ActionDidNotRevalidate && // Did the server render new data?
+        flightData === undefined) {
+            // The action did not trigger any revalidations or redirects. No
+            // navigation is required.
+            return state;
+        }
+        if (flightData === undefined && redirectLocation !== undefined) {
+            // The server redirected, but did not send any Flight data. This implies
+            // an external redirect.
+            // TODO: We should refactor the action response type to be more explicit
+            // about the various response types.
+            return (0, _navigatereducer.handleExternalUrl)(state, mutable, redirectLocation.href, pendingPush);
+        }
+        if (typeof flightData === 'string') {
+            // If the flight data is just a string, something earlier in the
+            // response handling triggered an external redirect.
+            return (0, _navigatereducer.handleExternalUrl)(state, mutable, flightData, pendingPush);
+        }
+        // The action triggered a navigation — either a redirect, a revalidation,
+        // or both.
+        // If there was no redirect, then the target URL is the same as the
+        // current URL.
+        const currentUrl = new URL(state.canonicalUrl, location.origin);
+        const redirectUrl = redirectLocation !== undefined ? redirectLocation : currentUrl;
+        const currentFlightRouterState = state.tree;
+        const shouldScroll = true;
+        // If the action triggered a revalidation of the cache, we should also
+        // refresh all the dynamic data.
+        const freshnessPolicy = revalidationKind === _actionrevalidationkind.ActionDidNotRevalidate ? _pprnavigations.FreshnessPolicy.Default : _pprnavigations.FreshnessPolicy.RefreshAll;
+        // The server may have sent back new data. If so, we will perform a
+        // "seeded" navigation that uses the data from the response.
+        if (flightData !== undefined) {
+            const normalizedFlightData = flightData[0];
+            if (normalizedFlightData !== undefined && // TODO: Currently the server always renders from the root in
+            // response to a Server Action. In the case of a normal redirect
+            // with no revalidation, it should skip over the shared layouts.
+            normalizedFlightData.isRootRender && flightDataRenderedSearch !== undefined && flightDataCouldBeIntercepted !== undefined) {
+                // The server sent back new route data as part of the response. We
+                // will use this to render the new page. If this happens to be only a
+                // subset of the data needed to render the new page, we'll initiate a
+                // new fetch, like we would for a normal navigation.
+                const redirectCanonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(redirectUrl);
+                const navigationSeed = {
+                    tree: normalizedFlightData.tree,
+                    renderedSearch: flightDataRenderedSearch,
+                    data: normalizedFlightData.seedData,
+                    head: normalizedFlightData.head
+                };
+                const now = Date.now();
+                const result = (0, _navigation.navigateToSeededRoute)(now, redirectUrl, redirectCanonicalUrl, navigationSeed, currentUrl, state.cache, currentFlightRouterState, freshnessPolicy, nextUrl, shouldScroll);
+                return (0, _navigatereducer.handleNavigationResult)(redirectUrl, state, mutable, pendingPush, result);
+            }
+        }
+        // The server did not send back new data. We'll perform a regular, non-
+        // seeded navigation — effectively the same as <Link> or router.push().
+        const result = (0, _navigation.navigate)(redirectUrl, currentUrl, state.cache, currentFlightRouterState, nextUrl, freshnessPolicy, shouldScroll, mutable);
+        return (0, _navigatereducer.handleNavigationResult)(redirectUrl, state, mutable, pendingPush, result);
     }, (e)=>{
         // When the server action is rejected we don't update the state and instead call the reject handler of the promise.
         reject(e);
         return state;
     });
 }
+function createRedirectErrorForAction(redirectHref, resolvedRedirectType) {
+    const redirectError = (0, _redirect.getRedirectError)(redirectHref, resolvedRedirectType);
+    redirectError.handled = true;
+    return redirectError;
+}
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });

qalita/_frontend/node_modules/next/dist/client/components/router-reducer/reducers/server-patch-reducer.js

@@ -9,51 +9,42 @@ Object.defineProperty(exports, "serverPatchReducer", {
     }
 });
 const _createhreffromurl = require("../create-href-from-url");
-const _applyrouterstatepatchtotree = require("../apply-router-state-patch-to-tree");
-const _isnavigatingtonewrootlayout = require("../is-navigating-to-new-root-layout");
 const _navigatereducer = require("./navigate-reducer");
-const _applyflightdata = require("../apply-flight-data");
-const _handlemutable = require("../handle-mutable");
-const _approuter = require("../../app-router");
+const _navigation = require("../../segment-cache/navigation");
+const _refreshreducer = require("./refresh-reducer");
+const _pprnavigations = require("../ppr-navigations");
 function serverPatchReducer(state, action) {
-    const { serverResponse, navigatedAt } = action;
     const mutable = {};
     mutable.preserveCustomHistoryState = false;
-    // Handle case when navigating to page in `pages` from `app`
-    if (typeof serverResponse === 'string') {
-        return (0, _navigatereducer.handleExternalUrl)(state, mutable, serverResponse, state.pushRef.pendingPush);
+    // A "retry" is a navigation that happens due to a route mismatch. It's
+    // similar to a refresh, because we will omit any existing dynamic data on
+    // the page. But we seed the retry navigation with the exact tree that the
+    // server just responded with.
+    const retryMpa = action.mpa;
+    const retryUrl = new URL(action.url, location.origin);
+    const retrySeed = action.seed;
+    if (retryMpa || retrySeed === null) {
+        // If the server did not send back data during the mismatch, fall back to
+        // an MPA navigation.
+        return (0, _navigatereducer.handleExternalUrl)(state, mutable, retryUrl.href, false);
     }
-    const { flightData, canonicalUrl, renderedSearch } = serverResponse;
-    let currentTree = state.tree;
-    let currentCache = state.cache;
-    for (const normalizedFlightData of flightData){
-        const { segmentPath: flightSegmentPath, tree: treePatch } = normalizedFlightData;
-        const newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTree)(// TODO-APP: remove ''
-        [
-            '',
-            ...flightSegmentPath
-        ], currentTree, treePatch, state.canonicalUrl);
-        // `applyRouterStatePatchToTree` returns `null` when it determined that the server response is not applicable to the current tree.
-        // In other words, the server responded with a tree that doesn't match what the client is currently rendering.
-        // This can happen if the server patch action took longer to resolve than a subsequent navigation which would have changed the tree.
-        // Previously this case triggered an MPA navigation but it should be safe to simply discard the server response rather than forcing
-        // the entire page to reload.
-        if (newTree === null) {
-            return state;
-        }
-        if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
-            return (0, _navigatereducer.handleExternalUrl)(state, mutable, state.canonicalUrl, state.pushRef.pendingPush);
-        }
-        mutable.canonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl);
-        const cache = (0, _approuter.createEmptyCacheNode)();
-        (0, _applyflightdata.applyFlightData)(navigatedAt, currentCache, cache, normalizedFlightData);
-        mutable.patchedTree = newTree;
-        mutable.renderedSearch = renderedSearch;
-        mutable.cache = cache;
-        currentCache = cache;
-        currentTree = newTree;
+    const currentUrl = new URL(state.canonicalUrl, location.origin);
+    if (action.previousTree !== state.tree) {
+        // There was another, more recent navigation since the once that
+        // mismatched. We can abort the retry, but we still need to refresh the
+        // page to evict any stale dynamic data.
+        return (0, _refreshreducer.refreshReducer)(state);
     }
-    return (0, _handlemutable.handleMutable)(state, mutable);
+    // There have been no new navigations since the mismatched one. Refresh,
+    // using the tree we just received from the server.
+    const retryCanonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(retryUrl);
+    const retryNextUrl = action.nextUrl;
+    // A retry should not create a new history entry.
+    const pendingPush = false;
+    const shouldScroll = true;
+    const now = Date.now();
+    const result = (0, _navigation.navigateToSeededRoute)(now, retryUrl, retryCanonicalUrl, retrySeed, currentUrl, state.cache, state.tree, _pprnavigations.FreshnessPolicy.RefreshAll, retryNextUrl, shouldScroll);
+    return (0, _navigatereducer.handleNavigationResult)(retryUrl, state, mutable, pendingPush, result);
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {

qalita/_frontend/node_modules/next/dist/client/components/router-reducer/router-reducer-types.js

@@ -49,7 +49,6 @@ const ACTION_SERVER_ACTION = 'server-action';
 var PrefetchKind = /*#__PURE__*/ function(PrefetchKind) {
     PrefetchKind["AUTO"] = "auto";
     PrefetchKind["FULL"] = "full";
-    PrefetchKind["TEMPORARY"] = "temporary";
     return PrefetchKind;
 }({});
 

qalita/_frontend/node_modules/next/dist/client/components/router-reducer/router-reducer.js

@@ -33,11 +33,11 @@ const _serveractionreducer = require("./reducers/server-action-reducer");
             }
         case _routerreducertypes.ACTION_REFRESH:
             {
-                return (0, _refreshreducer.refreshReducer)(state, action);
+                return (0, _refreshreducer.refreshReducer)(state);
             }
         case _routerreducertypes.ACTION_HMR_REFRESH:
             {
-                return (0, _hmrrefreshreducer.hmrRefreshReducer)(state, action);
+                return (0, _hmrrefreshreducer.hmrRefreshReducer)(state);
             }
         case _routerreducertypes.ACTION_SERVER_ACTION:
             {

qalita/_frontend/node_modules/next/dist/client/components/segment-cache/cache-map.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
     Fallback: null,
     createCacheMap: null,
     deleteFromCacheMap: null,
+    deleteMapEntry: null,
     getFromCacheMap: null,
     isValueExpired: null,
     setInCacheMap: null,
@@ -27,6 +28,9 @@ _export(exports, {
     deleteFromCacheMap: function() {
         return deleteFromCacheMap;
     },
+    deleteMapEntry: function() {
+        return deleteMapEntry;
+    },
     getFromCacheMap: function() {
         return getFromCacheMap;
     },
@@ -205,22 +209,14 @@ function setMapEntryValue(entry, value) {
         // from the map. We're not calling `deleteMapEntry` here because the
         // entry itself is still in the map. We just want to overwrite its value.
         dropRef(entry.value);
-        // Fill the entry with the updated value.
-        const emptyEntry = entry;
-        emptyEntry.value = null;
-        fillEmptyReference(emptyEntry, value);
-    } else {
-        fillEmptyReference(entry, value);
+        entry.value = null;
     }
-}
-function fillEmptyReference(entry, value) {
     // This value may already be in the map at a different keypath.
     // Grab a reference before we overwrite it.
     const oldEntry = value.ref;
-    const fullEntry = entry;
-    fullEntry.value = value;
-    value.ref = fullEntry;
-    (0, _lru.updateLruSize)(fullEntry, value.size);
+    entry.value = value;
+    value.ref = entry;
+    (0, _lru.updateLruSize)(entry, value.size);
     if (oldEntry !== null && oldEntry !== entry && oldEntry.value === value) {
         // This value is already in the map at a different keypath in the map.
         // Values only exist at a single keypath at a time. Remove it from the
@@ -250,17 +246,16 @@ function dropRef(value) {
 }
 function deleteMapEntry(entry) {
     // Delete the entry from the cache.
-    const emptyEntry = entry;
-    emptyEntry.value = null;
+    entry.value = null;
     (0, _lru.deleteFromLru)(entry);
     // Check if we can garbage collect the entry.
-    const map = emptyEntry.map;
+    const map = entry.map;
     if (map === null) {
         // Since this entry has no value, and also no child entries, we can
         // garbage collect it. Remove it from its parent, and keep garbage
         // collecting the parents until we reach a non-empty entry.
-        let parent = emptyEntry.parent;
-        let key = emptyEntry.key;
+        let parent = entry.parent;
+        let key = entry.key;
         while(parent !== null){
             const parentMap = parent.map;
             if (parentMap !== null) {
@@ -284,7 +279,7 @@ function deleteMapEntry(entry) {
         // "normal" entry, since the normal one was just deleted.
         const revalidatingEntry = map.get(Revalidation);
         if (revalidatingEntry !== undefined && revalidatingEntry.value !== null) {
-            setMapEntryValue(emptyEntry, revalidatingEntry.value);
+            setMapEntryValue(entry, revalidatingEntry.value);
         }
     }
 }

qalita/_frontend/node_modules/next/dist/client/components/segment-cache/cache.js

@@ -111,7 +111,6 @@ const _flightdatahelpers = require("../../flight-data-helpers");
 const _navigatereducer = require("../router-reducer/reducers/navigate-reducer");
 const _links = require("../links");
 const _segment = require("../../../shared/lib/segment");
-const _outputexportprefetchencoding = require("../../../shared/lib/segment-cache/output-export-prefetch-encoding");
 const _types = require("./types");
 const _promisewithresolvers = require("../../../shared/lib/promise-with-resolvers");
 function getStaleTimeMs(staleTimeSeconds) {
@@ -504,6 +503,12 @@ function upgradeToPendingSegment(emptyEntry, fetchStrategy) {
     const pendingEntry = emptyEntry;
     pendingEntry.status = 1;
     pendingEntry.fetchStrategy = fetchStrategy;
+    if (fetchStrategy === _types.FetchStrategy.Full) {
+        // We can assume the response will contain the full segment data. Set this
+        // to false so we know it's OK to omit this segment from any navigation
+        // requests that may happen while the data is still pending.
+        pendingEntry.isPartial = false;
+    }
     // Set the version here, since this is right before the request is initiated.
     // The next time the global cache version is incremented, the entry will
     // effectively be evicted. This happens before initiating the request, rather
@@ -830,28 +835,36 @@ async function fetchRouteOnCacheMiss(entry, task, key) {
             // location, but we shouldn't assume or expect that they also redirect all
             // the segment files, too.
             //
-            // To check whether the page is redirected, we perform a range request of
-            // the first N bytes of the HTML document. The canonical URL is determined
-            // from the response.
+            // To check whether the page is redirected, previously we perform a range
+            // request of 64 bytes of the HTML document to check if the target page
+            // is part of this app (by checking if build id matches). Only if the target
+            // page is part of this app do we determine the final canonical URL.
+            //
+            // However, as mentioned in https://github.com/vercel/next.js/pull/85903,
+            // some popular static hosting providers (like Cloudflare Pages or Render.com)
+            // do not support range requests, in the worst case, the entire HTML instead
+            // of 64 bytes could be returned, which is wasteful.
             //
-            // Then we can use the canonical URL to request the route tree.
+            // So instead, we drops the check for build id here, and simply perform
+            // a HEAD request to rejects 1xx/4xx/5xx responses, and then determine the
+            // final URL after redirects.
             //
             // NOTE: We could embed the route tree into the HTML document, to avoid
             // a second request. We're not doing that currently because it would make
             // the HTML document larger and affect normal page loads.
-            const htmlResponse = await fetch(url, {
-                headers: {
-                    Range: _outputexportprefetchencoding.DOC_PREFETCH_RANGE_HEADER_VALUE
-                }
+            const headResponse = await fetch(url, {
+                method: 'HEAD'
             });
-            const partialHtml = await htmlResponse.text();
-            if (!(0, _outputexportprefetchencoding.doesExportedHtmlMatchBuildId)(partialHtml, (0, _appbuildid.getAppBuildId)())) {
-                // The target page is not part of this app, or it belongs to a
-                // different build.
+            if (headResponse.status < 200 || headResponse.status >= 400) {
+                // The target page responded w/o a successful status code
+                // Could be a WAF serving a 403, or a 5xx from a backend
+                //
+                // Note that we can't use headResponse.ok here, because
+                // Response#ok returns `false` with 3xx responses.
                 rejectRouteCacheEntry(entry, Date.now() + 10 * 1000);
                 return null;
             }
-            urlAfterRedirects = htmlResponse.redirected ? new URL(htmlResponse.url) : url;
+            urlAfterRedirects = headResponse.redirected ? new URL(headResponse.url) : url;
             response = await fetchPrefetchResponse(addSegmentPathToUrlInOutputExportMode(urlAfterRedirects, segmentPath), headers);
         } else {
             // "Server" mode. We can use request headers instead of the pathname.

qalita/_frontend/node_modules/next/dist/client/components/segment-cache/lru.js

@@ -25,6 +25,8 @@ _export(exports, {
     }
 });
 const _cachemap = require("./cache-map");
+// We use an LRU for memory management. We must update this whenever we add or
+// remove a new cache entry, or when an entry changes size.
 let head = null;
 let didScheduleCleanup = false;
 let lruSize = 0;
@@ -126,7 +128,7 @@ function cleanup() {
         if (tail !== null) {
             // Delete the entry from the map. In turn, this will remove it from
             // the LRU.
-            (0, _cachemap.deleteFromCacheMap)(tail.value);
+            (0, _cachemap.deleteMapEntry)(tail);
         }
     }
 }