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

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

@@ -2,10 +2,26 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "navigate", {
-    enumerable: true,
-    get: function() {
+0 && (module.exports = {
+    convertServerPatchToFullTree: null,
+    navigate: null,
+    navigateToSeededRoute: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    convertServerPatchToFullTree: function() {
+        return convertServerPatchToFullTree;
+    },
+    navigate: function() {
         return navigate;
+    },
+    navigateToSeededRoute: function() {
+        return navigateToSeededRoute;
     }
 });
 const _fetchserverresponse = require("../router-reducer/fetch-server-response");
@@ -15,7 +31,7 @@ const _cache = require("./cache");
 const _cachekey = require("./cache-key");
 const _segment = require("../../../shared/lib/segment");
 const _types = require("./types");
-function navigate(url, currentUrl, currentCacheNode, currentFlightRouterState, nextUrl, shouldScroll, accumulation) {
+function navigate(url, currentUrl, currentCacheNode, currentFlightRouterState, nextUrl, freshnessPolicy, shouldScroll, accumulation) {
     const now = Date.now();
     const href = url.href;
     // We special case navigations to the exact same URL as the current location.
@@ -36,12 +52,7 @@ function navigate(url, currentUrl, currentCacheNode, currentFlightRouterState, n
     // Also note that this only refreshes the dynamic data, not static/ cached
     // data. If the page segment is fully static and prefetched, the request is
     // skipped. (This is also how refresh() works.)
-    const isSamePageNavigation = // TODO: This is not the only place we read from the location, but we should
-    // consider storing the current URL in the router state instead of reading
-    // from the location object. In practice I don't think this matters much
-    // since we keep them in sync anyway, but having two sources of truth can
-    // lead to subtle bugs and race conditions.
-    href === window.location.href;
+    const isSamePageNavigation = href === currentUrl.href;
     const cacheKey = (0, _cachekey.createCacheKey)(href, nextUrl);
     const route = (0, _cache.readRouteCacheEntry)(now, cacheKey);
     if (route !== null && route.status === _cache.EntryStatus.Fulfilled) {
@@ -60,7 +71,7 @@ function navigate(url, currentUrl, currentCacheNode, currentFlightRouterState, n
         // the URL.
         const newCanonicalUrl = route.canonicalUrl + url.hash;
         const renderedSearch = route.renderedSearch;
-        return navigateUsingPrefetchedRouteTree(now, url, currentUrl, nextUrl, isSamePageNavigation, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, newCanonicalUrl, renderedSearch, shouldScroll, url.hash);
+        return navigateUsingPrefetchedRouteTree(now, url, currentUrl, nextUrl, isSamePageNavigation, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, newCanonicalUrl, renderedSearch, freshnessPolicy, shouldScroll);
     }
     // There was no matching route tree in the cache. Let's see if we can
     // construct an "optimistic" route tree.
@@ -83,7 +94,7 @@ function navigate(url, currentUrl, currentCacheNode, currentFlightRouterState, n
             const isPrefetchHeadPartial = headSnapshot.isPartial;
             const newCanonicalUrl = optimisticRoute.canonicalUrl + url.hash;
             const newRenderedSearch = optimisticRoute.renderedSearch;
-            return navigateUsingPrefetchedRouteTree(now, url, currentUrl, nextUrl, isSamePageNavigation, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, newCanonicalUrl, newRenderedSearch, shouldScroll, url.hash);
+            return navigateUsingPrefetchedRouteTree(now, url, currentUrl, nextUrl, isSamePageNavigation, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, newCanonicalUrl, newRenderedSearch, freshnessPolicy, shouldScroll);
         }
     }
     // There's no matching prefetch for this route in the cache.
@@ -93,58 +104,58 @@ function navigate(url, currentUrl, currentCacheNode, currentFlightRouterState, n
     }
     return {
         tag: _types.NavigationResultTag.Async,
-        data: navigateDynamicallyWithNoPrefetch(now, url, currentUrl, nextUrl, isSamePageNavigation, currentCacheNode, currentFlightRouterState, shouldScroll, url.hash, collectedDebugInfo)
+        data: navigateDynamicallyWithNoPrefetch(now, url, currentUrl, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, shouldScroll, collectedDebugInfo)
     };
 }
-function navigateUsingPrefetchedRouteTree(now, url, currentUrl, nextUrl, isSamePageNavigation, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, canonicalUrl, renderedSearch, shouldScroll, hash) {
+function navigateToSeededRoute(now, url, canonicalUrl, navigationSeed, currentUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, shouldScroll) {
+    // A version of navigate() that accepts the target route tree as an argument
+    // rather than reading it from the prefetch cache.
+    const accumulation = {
+        scrollableSegments: null,
+        separateRefreshUrls: null
+    };
+    const isSamePageNavigation = url.href === currentUrl.href;
+    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, currentCacheNode, currentFlightRouterState, navigationSeed.tree, freshnessPolicy, navigationSeed.data, navigationSeed.head, null, null, false, isSamePageNavigation, accumulation);
+    if (task !== null) {
+        (0, _pprnavigations.spawnDynamicRequests)(task, url, nextUrl, freshnessPolicy, accumulation);
+        return navigationTaskToResult(task, canonicalUrl, navigationSeed.renderedSearch, accumulation.scrollableSegments, shouldScroll, url.hash);
+    }
+    // Could not perform a SPA navigation. Revert to a full-page (MPA) navigation.
+    return {
+        tag: _types.NavigationResultTag.MPA,
+        data: canonicalUrl
+    };
+}
+function navigateUsingPrefetchedRouteTree(now, url, currentUrl, nextUrl, isSamePageNavigation, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, canonicalUrl, renderedSearch, freshnessPolicy, shouldScroll) {
     // Recursively construct a prefetch tree by reading from the Segment Cache. To
     // maintain compatibility, we output the same data structures as the old
     // prefetching implementation: FlightRouterState and CacheNodeSeedData.
     // TODO: Eventually updateCacheNodeOnNavigation (or the equivalent) should
     // read from the Segment Cache directly. It's only structured this way for now
     // so we can share code with the old prefetching implementation.
-    const scrollableSegments = [];
-    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, scrollableSegments);
+    const accumulation = {
+        scrollableSegments: null,
+        separateRefreshUrls: null
+    };
+    const seedData = null;
+    const seedHead = null;
+    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, freshnessPolicy, seedData, seedHead, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, accumulation);
     if (task !== null) {
-        const dynamicRequestTree = task.dynamicRequestTree;
-        if (dynamicRequestTree !== null) {
-            const promiseForDynamicServerResponse = (0, _fetchserverresponse.fetchServerResponse)(new URL(canonicalUrl, url.origin), {
-                flightRouterState: dynamicRequestTree,
-                nextUrl
-            });
-            (0, _pprnavigations.listenForDynamicRequest)(task, promiseForDynamicServerResponse);
-        } else {
-        // The prefetched tree does not contain dynamic holes — it's
-        // fully static. We can skip the dynamic request.
-        }
-        return navigationTaskToResult(task, currentCacheNode, canonicalUrl, renderedSearch, scrollableSegments, shouldScroll, hash);
+        (0, _pprnavigations.spawnDynamicRequests)(task, url, nextUrl, freshnessPolicy, accumulation);
+        return navigationTaskToResult(task, canonicalUrl, renderedSearch, accumulation.scrollableSegments, shouldScroll, url.hash);
     }
-    // The server sent back an empty tree patch. There's nothing to update, except
-    // possibly the URL.
+    // Could not perform a SPA navigation. Revert to a full-page (MPA) navigation.
     return {
-        tag: _types.NavigationResultTag.NoOp,
-        data: {
-            canonicalUrl,
-            shouldScroll
-        }
+        tag: _types.NavigationResultTag.MPA,
+        data: canonicalUrl
     };
 }
-function navigationTaskToResult(task, currentCacheNode, canonicalUrl, renderedSearch, scrollableSegments, shouldScroll, hash) {
-    const flightRouterState = task.route;
-    if (flightRouterState === null) {
-        // When no router state is provided, it signals that we should perform an
-        // MPA navigation.
-        return {
-            tag: _types.NavigationResultTag.MPA,
-            data: canonicalUrl
-        };
-    }
-    const newCacheNode = task.node;
+function navigationTaskToResult(task, canonicalUrl, renderedSearch, scrollableSegments, shouldScroll, hash) {
     return {
         tag: _types.NavigationResultTag.Success,
         data: {
-            flightRouterState,
-            cacheNode: newCacheNode !== null ? newCacheNode : currentCacheNode,
+            flightRouterState: task.route,
+            cacheNode: task.node,
             canonicalUrl,
             renderedSearch,
             scrollableSegments,
@@ -187,10 +198,17 @@ function readRenderSnapshotFromCache(now, route, tree) {
                     const promiseForFulfilledEntry = (0, _cache.waitForSegmentCacheEntry)(segmentEntry);
                     rsc = promiseForFulfilledEntry.then((entry)=>entry !== null ? entry.rsc : null);
                     loading = promiseForFulfilledEntry.then((entry)=>entry !== null ? entry.loading : null);
-                    // Since we don't know yet whether the segment is partial or fully
-                    // static, we must assume it's partial; we can't skip the
-                    // dynamic request.
-                    isPartial = true;
+                    // Because the request is still pending, we typically don't know yet
+                    // whether the response will be partial. We shouldn't skip this segment
+                    // during the dynamic navigation request. Otherwise, we might need to
+                    // do yet another request to fill in the remaining data, creating
+                    // a waterfall.
+                    //
+                    // The one exception is if this segment is being fetched with via
+                    // prefetch={true} (i.e. the "force stale" or "full" strategy). If so,
+                    // we can assume the response will be full. This field is set to `false`
+                    // for such segments.
+                    isPartial = segmentEntry.isPartial;
                     break;
                 }
             case _cache.EntryStatus.Empty:
@@ -247,7 +265,7 @@ function readHeadSnapshotFromCache(now, route) {
                 {
                     const promiseForFulfilledEntry = (0, _cache.waitForSegmentCacheEntry)(segmentEntry);
                     rsc = promiseForFulfilledEntry.then((entry)=>entry !== null ? entry.rsc : null);
-                    isPartial = true;
+                    isPartial = segmentEntry.isPartial;
                     break;
                 }
             case _cache.EntryStatus.Empty:
@@ -262,7 +280,18 @@ function readHeadSnapshotFromCache(now, route) {
         isPartial
     };
 }
-async function navigateDynamicallyWithNoPrefetch(now, url, currentUrl, nextUrl, isSamePageNavigation, currentCacheNode, currentFlightRouterState, shouldScroll, hash, collectedDebugInfo) {
+// Used to request all the dynamic data for a route, rather than just a subset,
+// e.g. during a refresh or a revalidation. Typically this gets constructed
+// during the normal flow when diffing the route tree, but for an unprefetched
+// navigation, where we don't know the structure of the target route, we use
+// this instead.
+const DynamicRequestTreeForEntireRoute = [
+    '',
+    {},
+    null,
+    'refetch'
+];
+async function navigateDynamicallyWithNoPrefetch(now, url, currentUrl, nextUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, shouldScroll, collectedDebugInfo) {
     // Runs when a navigation happens but there's no cached prefetch we can use.
     // Don't bother to wait for a prefetch response; go straight to a full
     // navigation that contains both static and dynamic data in a single stream.
@@ -274,8 +303,24 @@ async function navigateDynamicallyWithNoPrefetch(now, url, currentUrl, nextUrl,
     // use the same server response to write the actual data into the CacheNode
     // tree. So it's the same flow as the "happy path" (prefetch, then
     // navigation), except we use a single server response for both stages.
+    let dynamicRequestTree;
+    switch(freshnessPolicy){
+        case _pprnavigations.FreshnessPolicy.Default:
+        case _pprnavigations.FreshnessPolicy.HistoryTraversal:
+            dynamicRequestTree = currentFlightRouterState;
+            break;
+        case _pprnavigations.FreshnessPolicy.Hydration:
+        case _pprnavigations.FreshnessPolicy.RefreshAll:
+        case _pprnavigations.FreshnessPolicy.HMRRefresh:
+            dynamicRequestTree = DynamicRequestTreeForEntireRoute;
+            break;
+        default:
+            freshnessPolicy;
+            dynamicRequestTree = currentFlightRouterState;
+            break;
+    }
     const promiseForDynamicServerResponse = (0, _fetchserverresponse.fetchServerResponse)(url, {
-        flightRouterState: currentFlightRouterState,
+        flightRouterState: dynamicRequestTree,
         nextUrl
     });
     const result = await promiseForDynamicServerResponse;
@@ -294,65 +339,50 @@ async function navigateDynamicallyWithNoPrefetch(now, url, currentUrl, nextUrl,
     // Since the response format of dynamic requests and prefetches is slightly
     // different, we'll need to massage the data a bit. Create FlightRouterState
     // tree that simulates what we'd receive as the result of a prefetch.
-    const prefetchFlightRouterState = simulatePrefetchTreeUsingDynamicTreePatch(currentFlightRouterState, flightData);
-    // In our simulated prefetch payload, we pretend that there's no seed data
-    // nor a prefetch head.
-    const prefetchSeedData = null;
-    const prefetchHead = null;
-    const isPrefetchHeadPartial = true;
-    // Now we proceed exactly as we would for normal navigation.
-    const scrollableSegments = [];
-    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, currentCacheNode, currentFlightRouterState, prefetchFlightRouterState, prefetchSeedData, prefetchHead, isPrefetchHeadPartial, isSamePageNavigation, scrollableSegments);
-    if (task !== null) {
-        // In this case, we've already sent the dynamic request, so we don't
-        // actually use the request tree created by `startPPRNavigation`,
-        // except to check if it contains dynamic holes.
-        //
-        // This is almost always true, but it could be false if all the segment data
-        // was present in the cache, but the route tree was not. E.g. navigating
-        // to a URL that was not prefetched but rewrites to a different URL
-        // that was.
-        const hasDynamicHoles = task.dynamicRequestTree !== null;
-        if (hasDynamicHoles) {
-            (0, _pprnavigations.listenForDynamicRequest)(task, promiseForDynamicServerResponse);
-        } else {
-        // The prefetched tree does not contain dynamic holes — it's
-        // fully static. We don't need to process the server response further.
-        }
-        return navigationTaskToResult(task, currentCacheNode, (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl), renderedSearch, scrollableSegments, shouldScroll, hash);
-    }
-    // The server sent back an empty tree patch. There's nothing to update, except
-    // possibly the URL.
-    return {
-        tag: _types.NavigationResultTag.NoOp,
-        data: {
-            canonicalUrl: (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl),
-            shouldScroll
-        }
-    };
+    const navigationSeed = convertServerPatchToFullTree(currentFlightRouterState, flightData, renderedSearch);
+    return navigateToSeededRoute(now, url, (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl), navigationSeed, currentUrl, currentCacheNode, currentFlightRouterState, freshnessPolicy, nextUrl, shouldScroll);
 }
-function simulatePrefetchTreeUsingDynamicTreePatch(currentTree, flightData) {
-    // Takes the current FlightRouterState and applies the router state patch
-    // received from the server, to create a full FlightRouterState tree that we
-    // can pretend was returned by a prefetch.
+function convertServerPatchToFullTree(currentTree, flightData, renderedSearch) {
+    // During a client navigation or prefetch, the server sends back only a patch
+    // for the parts of the tree that have changed.
+    //
+    // This applies the patch to the base tree to create a full representation of
+    // the resulting tree.
     //
-    // (It sounds similar to what applyRouterStatePatch does, but it doesn't need
-    // to handle stuff like interception routes or diffing since that will be
-    // handled later.)
+    // The return type includes a full FlightRouterState tree and a full
+    // CacheNodeSeedData tree. (Conceptually these are the same tree, and should
+    // eventually be unified, but there's still lots of existing code that
+    // operates on FlightRouterState trees alone without the CacheNodeSeedData.)
+    //
+    // TODO: This similar to what apply-router-state-patch-to-tree does. It
+    // will eventually fully replace it. We should get rid of all the remaining
+    // places where we iterate over the server patch format. This should also
+    // eventually replace normalizeFlightData.
     let baseTree = currentTree;
-    for (const { segmentPath, tree: treePatch } of flightData){
-        // If the server sends us multiple tree patches, we only need to clone the
-        // base tree when applying the first patch. After the first patch, we can
-        // apply the remaining patches in place without copying.
-        const canMutateInPlace = baseTree !== currentTree;
-        baseTree = simulatePrefetchTreeUsingDynamicTreePatchImpl(baseTree, treePatch, segmentPath, canMutateInPlace, 0);
+    let baseData = null;
+    let head = null;
+    for (const { segmentPath, tree: treePatch, seedData: dataPatch, head: headPatch } of flightData){
+        const result = convertServerPatchToFullTreeImpl(baseTree, baseData, treePatch, dataPatch, segmentPath, 0);
+        baseTree = result.tree;
+        baseData = result.data;
+        // This is the same for all patches per response, so just pick an
+        // arbitrary one
+        head = headPatch;
     }
-    return baseTree;
+    return {
+        tree: baseTree,
+        data: baseData,
+        renderedSearch,
+        head
+    };
 }
-function simulatePrefetchTreeUsingDynamicTreePatchImpl(baseRouterState, patch, segmentPath, canMutateInPlace, index) {
+function convertServerPatchToFullTreeImpl(baseRouterState, baseData, treePatch, dataPatch, segmentPath, index) {
     if (index === segmentPath.length) {
         // We reached the part of the tree that we need to patch.
-        return patch;
+        return {
+            tree: treePatch,
+            data: dataPatch
+        };
     }
     // segmentPath represents the parent path of subtree. It's a repeating
     // pattern of parallel route key and segment:
@@ -361,50 +391,63 @@ function simulatePrefetchTreeUsingDynamicTreePatchImpl(baseRouterState, patch, s
     //
     // This path tells us which part of the base tree to apply the tree patch.
     //
-    // NOTE: In the case of a fully dynamic request with no prefetch, we receive
-    // the FlightRouterState patch in the same request as the dynamic data.
-    // Therefore we don't need to worry about diffing the segment values; we can
-    // assume the server sent us a correct result.
+    // NOTE: We receive the FlightRouterState patch in the same request as the
+    // seed data patch. Therefore we don't need to worry about diffing the segment
+    // values; we can assume the server sent us a correct result.
     const updatedParallelRouteKey = segmentPath[index];
     // const segment: Segment = segmentPath[index + 1] <-- Not used, see note above
-    const baseChildren = baseRouterState[1];
-    const newChildren = {};
-    for(const parallelRouteKey in baseChildren){
+    const baseTreeChildren = baseRouterState[1];
+    const baseSeedDataChildren = baseData !== null ? baseData[1] : null;
+    const newTreeChildren = {};
+    const newSeedDataChildren = {};
+    for(const parallelRouteKey in baseTreeChildren){
+        const childBaseRouterState = baseTreeChildren[parallelRouteKey];
+        const childBaseSeedData = baseSeedDataChildren !== null ? baseSeedDataChildren[parallelRouteKey] ?? null : null;
         if (parallelRouteKey === updatedParallelRouteKey) {
-            const childBaseRouterState = baseChildren[parallelRouteKey];
-            newChildren[parallelRouteKey] = simulatePrefetchTreeUsingDynamicTreePatchImpl(childBaseRouterState, patch, segmentPath, canMutateInPlace, // Advance the index by two and keep cloning until we reach
+            const result = convertServerPatchToFullTreeImpl(childBaseRouterState, childBaseSeedData, treePatch, dataPatch, segmentPath, // Advance the index by two and keep cloning until we reach
             // the end of the segment path.
             index + 2);
+            newTreeChildren[parallelRouteKey] = result.tree;
+            newSeedDataChildren[parallelRouteKey] = result.data;
         } else {
             // This child is not being patched. Copy it over as-is.
-            newChildren[parallelRouteKey] = baseChildren[parallelRouteKey];
+            newTreeChildren[parallelRouteKey] = childBaseRouterState;
+            newSeedDataChildren[parallelRouteKey] = childBaseSeedData;
         }
     }
-    if (canMutateInPlace) {
-        // We can mutate the base tree in place, because the base tree is already
-        // a clone.
-        baseRouterState[1] = newChildren;
-        return baseRouterState;
-    }
+    let clonedTree;
+    let clonedSeedData;
     // Clone all the fields except the children.
-    //
-    // Based on equivalent logic in apply-router-state-patch-to-tree, but should
-    // confirm whether we need to copy all of these fields. Not sure the server
-    // ever sends, e.g. the refetch marker.
-    const clone = [
+    // Clone the FlightRouterState tree. Based on equivalent logic in
+    // apply-router-state-patch-to-tree, but should confirm whether we need to
+    // copy all of these fields. Not sure the server ever sends, e.g. the
+    // refetch marker.
+    clonedTree = [
         baseRouterState[0],
-        newChildren
+        newTreeChildren
     ];
     if (2 in baseRouterState) {
-        clone[2] = baseRouterState[2];
+        clonedTree[2] = baseRouterState[2];
     }
     if (3 in baseRouterState) {
-        clone[3] = baseRouterState[3];
+        clonedTree[3] = baseRouterState[3];
     }
     if (4 in baseRouterState) {
-        clone[4] = baseRouterState[4];
+        clonedTree[4] = baseRouterState[4];
     }
-    return clone;
+    // Clone the CacheNodeSeedData tree.
+    const isEmptySeedDataPartial = true;
+    clonedSeedData = [
+        null,
+        newSeedDataChildren,
+        null,
+        isEmptySeedDataPartial,
+        false
+    ];
+    return {
+        tree: clonedTree,
+        data: clonedSeedData
+    };
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {