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/hmr-refresh-reducer.js

@@ -8,83 +8,11 @@ Object.defineProperty(exports, "hmrRefreshReducer", {
         return hmrRefreshReducer;
     }
 });
-const _fetchserverresponse = require("../fetch-server-response");
-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 _handlemutable = require("../handle-mutable");
-const _applyflightdata = require("../apply-flight-data");
-const _approuter = require("../../app-router");
-const _handlesegmentmismatch = require("../handle-segment-mismatch");
-const _hasinterceptionrouteincurrenttree = require("./has-interception-route-in-current-tree");
-// A version of refresh reducer that keeps the cache around instead of wiping all of it.
-function hmrRefreshReducerImpl(state, action) {
-    const { origin } = action;
-    const mutable = {};
-    const href = state.canonicalUrl;
-    mutable.preserveCustomHistoryState = false;
-    const cache = (0, _approuter.createEmptyCacheNode)();
-    // If the current tree was intercepted, the nextUrl should be included in the request.
-    // This is to ensure that the refresh request doesn't get intercepted, accidentally triggering the interception route.
-    const includeNextUrl = (0, _hasinterceptionrouteincurrenttree.hasInterceptionRouteInCurrentTree)(state.tree);
-    // TODO-APP: verify that `href` is not an external url.
-    // Fetch data from the root of the tree.
-    const navigatedAt = Date.now();
-    cache.lazyData = (0, _fetchserverresponse.fetchServerResponse)(new URL(href, origin), {
-        flightRouterState: [
-            state.tree[0],
-            state.tree[1],
-            state.tree[2],
-            'refetch'
-        ],
-        nextUrl: includeNextUrl ? state.nextUrl : null,
-        isHmrRefresh: true
-    });
-    return cache.lazyData.then((result)=>{
-        // Handle case when navigating to page in `pages` from `app`
-        if (typeof result === 'string') {
-            return (0, _navigatereducer.handleExternalUrl)(state, mutable, result, state.pushRef.pendingPush);
-        }
-        const { flightData, canonicalUrl, renderedSearch } = result;
-        // Remove cache.lazyData as it has been resolved at this point.
-        cache.lazyData = null;
-        let currentTree = state.tree;
-        let currentCache = state.cache;
-        for (const normalizedFlightData of flightData){
-            const { tree: treePatch, isRootRender } = normalizedFlightData;
-            if (!isRootRender) {
-                // TODO-APP: handle this case better
-                console.log('REFRESH FAILED');
-                return state;
-            }
-            const newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTree)(// TODO-APP: remove ''
-            [
-                ''
-            ], currentTree, treePatch, state.canonicalUrl);
-            if (newTree === null) {
-                return (0, _handlesegmentmismatch.handleSegmentMismatch)(state, action, treePatch);
-            }
-            if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
-                return (0, _navigatereducer.handleExternalUrl)(state, mutable, href, state.pushRef.pendingPush);
-            }
-            const applied = (0, _applyflightdata.applyFlightData)(navigatedAt, currentCache, cache, normalizedFlightData);
-            if (applied) {
-                mutable.cache = cache;
-                currentCache = cache;
-            }
-            mutable.patchedTree = newTree;
-            mutable.renderedSearch = renderedSearch;
-            mutable.canonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl);
-            currentTree = newTree;
-        }
-        return (0, _handlemutable.handleMutable)(state, mutable);
-    }, ()=>state);
+const _refreshreducer = require("./refresh-reducer");
+const _pprnavigations = require("../ppr-navigations");
+function hmrRefreshReducer(state) {
+    return (0, _refreshreducer.refreshDynamicData)(state, _pprnavigations.FreshnessPolicy.HMRRefresh);
 }
-function hmrRefreshReducerNoop(state, _action) {
-    return state;
-}
-const hmrRefreshReducer = process.env.NODE_ENV === 'production' ? hmrRefreshReducerNoop : hmrRefreshReducerImpl;
 
 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/navigate-reducer.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", {
     STATIC_STALETIME_MS: null,
     generateSegmentsFromPatch: null,
     handleExternalUrl: null,
+    handleNavigationResult: null,
     navigateReducer: null
 });
 function _export(target, all) {
@@ -28,6 +29,9 @@ _export(exports, {
     handleExternalUrl: function() {
         return handleExternalUrl;
     },
+    handleNavigationResult: function() {
+        return handleNavigationResult;
+    },
     navigateReducer: function() {
         return navigateReducer;
     }
@@ -37,6 +41,7 @@ const _handlemutable = require("../handle-mutable");
 const _navigation = require("../../segment-cache/navigation");
 const _types = require("../../segment-cache/types");
 const _cache = require("../../segment-cache/cache");
+const _pprnavigations = require("../ppr-navigations");
 const DYNAMIC_STALETIME_MS = Number(process.env.__NEXT_CLIENT_ROUTER_DYNAMIC_STALETIME) * 1000;
 const STATIC_STALETIME_MS = (0, _cache.getStaleTimeMs)(Number(process.env.__NEXT_CLIENT_ROUTER_STATIC_STALETIME));
 function handleExternalUrl(state, mutable, url, pendingPush) {
@@ -83,12 +88,22 @@ function handleNavigationResult(url, state, mutable, pendingPush, result) {
                 const newUrl = result.data;
                 return handleExternalUrl(state, mutable, newUrl, pendingPush);
             }
-        case _types.NavigationResultTag.NoOp:
+        case _types.NavigationResultTag.Success:
             {
-                // The server responded with no change to the current page. However, if
-                // the URL changed, we still need to update that.
-                const newCanonicalUrl = result.data.canonicalUrl;
-                mutable.canonicalUrl = newCanonicalUrl;
+                // Received a new result.
+                mutable.cache = result.data.cacheNode;
+                mutable.patchedTree = result.data.flightRouterState;
+                mutable.renderedSearch = result.data.renderedSearch;
+                mutable.canonicalUrl = result.data.canonicalUrl;
+                // TODO: During a refresh, we don't set the `scrollableSegments`. There's
+                // some confusing and subtle logic in `handleMutable` that decides what
+                // to do when `shouldScroll` is set but `scrollableSegments` is not. I'm
+                // not convinced it's totally coherent but the tests assert on this
+                // particular behavior so I've ported the logic as-is from the previous
+                // router implementation, for now.
+                mutable.scrollableSegments = result.data.scrollableSegments ?? undefined;
+                mutable.shouldScroll = result.data.shouldScroll;
+                mutable.hashFragment = result.data.hash;
                 // Check if the only thing that changed was the hash fragment.
                 const oldUrl = new URL(state.canonicalUrl, url);
                 const onlyHashChange = // We don't need to compare the origins, because client-driven
@@ -105,18 +120,6 @@ function handleNavigationResult(url, state, mutable, pendingPush, result) {
                 }
                 return (0, _handlemutable.handleMutable)(state, mutable);
             }
-        case _types.NavigationResultTag.Success:
-            {
-                // Received a new result.
-                mutable.cache = result.data.cacheNode;
-                mutable.patchedTree = result.data.flightRouterState;
-                mutable.renderedSearch = result.data.renderedSearch;
-                mutable.canonicalUrl = result.data.canonicalUrl;
-                mutable.scrollableSegments = result.data.scrollableSegments;
-                mutable.shouldScroll = result.data.shouldScroll;
-                mutable.hashFragment = result.data.hash;
-                return (0, _handlemutable.handleMutable)(state, mutable);
-            }
         case _types.NavigationResultTag.Async:
             {
                 return result.data.then((asyncResult)=>handleNavigationResult(url, state, mutable, pendingPush, asyncResult), // If the navigation failed, return the current state.
@@ -152,7 +155,7 @@ function navigateReducer(state, action) {
     // implementation. Eventually we'll rewrite the router reducer to a
     // state machine.
     const currentUrl = new URL(state.canonicalUrl, location.origin);
-    const result = (0, _navigation.navigate)(url, currentUrl, state.cache, state.tree, state.nextUrl, shouldScroll, mutable);
+    const result = (0, _navigation.navigate)(url, currentUrl, state.cache, state.tree, state.nextUrl, _pprnavigations.FreshnessPolicy.Default, shouldScroll, mutable);
     return handleNavigationResult(url, state, mutable, pendingPush, result);
 }
 

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

@@ -2,98 +2,61 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "refreshReducer", {
-    enumerable: true,
-    get: function() {
+0 && (module.exports = {
+    refreshDynamicData: null,
+    refreshReducer: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    refreshDynamicData: function() {
+        return refreshDynamicData;
+    },
+    refreshReducer: function() {
         return refreshReducer;
     }
 });
-const _fetchserverresponse = require("../fetch-server-response");
-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 _handlemutable = require("../handle-mutable");
-const _filllazyitemstillleafwithhead = require("../fill-lazy-items-till-leaf-with-head");
-const _approuter = require("../../app-router");
-const _handlesegmentmismatch = require("../handle-segment-mismatch");
-const _hasinterceptionrouteincurrenttree = require("./has-interception-route-in-current-tree");
-const _refetchinactiveparallelsegments = require("../refetch-inactive-parallel-segments");
+const _navigation = require("../../segment-cache/navigation");
 const _cache = require("../../segment-cache/cache");
-function refreshReducer(state, action) {
-    const { origin } = action;
+const _hasinterceptionrouteincurrenttree = require("./has-interception-route-in-current-tree");
+const _pprnavigations = require("../ppr-navigations");
+function refreshReducer(state) {
+    // TODO: Currently, all refreshes purge the prefetch cache. In the future,
+    // only client-side refreshes will have this behavior; the server-side
+    // `refresh` should send new data without purging the prefetch cache.
+    const currentNextUrl = state.nextUrl;
+    const currentRouterState = state.tree;
+    (0, _cache.revalidateEntireCache)(currentNextUrl, currentRouterState);
+    return refreshDynamicData(state, _pprnavigations.FreshnessPolicy.RefreshAll);
+}
+function refreshDynamicData(state, freshnessPolicy) {
+    const currentNextUrl = state.nextUrl;
+    // We always send the last next-url, not the current when performing a dynamic
+    // request. This is because we update the next-url after a navigation, but we
+    // want the same interception route to be matched that used the last next-url.
+    const nextUrlForRefresh = (0, _hasinterceptionrouteincurrenttree.hasInterceptionRouteInCurrentTree)(state.tree) ? state.previousNextUrl || currentNextUrl : null;
+    // A refresh is modeled as a navigation to the current URL, but where any
+    // existing dynamic data (including in shared layouts) is re-fetched.
+    const currentCanonicalUrl = state.canonicalUrl;
+    const currentUrl = new URL(currentCanonicalUrl, location.origin);
+    const currentFlightRouterState = state.tree;
+    const shouldScroll = true;
+    const navigationSeed = {
+        tree: state.tree,
+        renderedSearch: state.renderedSearch,
+        data: null,
+        head: null
+    };
+    const now = Date.now();
+    const result = (0, _navigation.navigateToSeededRoute)(now, currentUrl, currentCanonicalUrl, navigationSeed, currentUrl, state.cache, currentFlightRouterState, freshnessPolicy, nextUrlForRefresh, shouldScroll);
     const mutable = {};
-    const href = state.canonicalUrl;
-    let currentTree = state.tree;
     mutable.preserveCustomHistoryState = false;
-    const cache = (0, _approuter.createEmptyCacheNode)();
-    // If the current tree was intercepted, the nextUrl should be included in the request.
-    // This is to ensure that the refresh request doesn't get intercepted, accidentally triggering the interception route.
-    const includeNextUrl = (0, _hasinterceptionrouteincurrenttree.hasInterceptionRouteInCurrentTree)(state.tree);
-    // TODO-APP: verify that `href` is not an external url.
-    // Fetch data from the root of the tree.
-    cache.lazyData = (0, _fetchserverresponse.fetchServerResponse)(new URL(href, origin), {
-        flightRouterState: [
-            currentTree[0],
-            currentTree[1],
-            currentTree[2],
-            'refetch'
-        ],
-        nextUrl: includeNextUrl ? state.nextUrl : null
-    });
-    const navigatedAt = Date.now();
-    return cache.lazyData.then(async (result)=>{
-        // Handle case when navigating to page in `pages` from `app`
-        if (typeof result === 'string') {
-            return (0, _navigatereducer.handleExternalUrl)(state, mutable, result, state.pushRef.pendingPush);
-        }
-        const { flightData, canonicalUrl, renderedSearch } = result;
-        // Remove cache.lazyData as it has been resolved at this point.
-        cache.lazyData = null;
-        for (const normalizedFlightData of flightData){
-            const { tree: treePatch, seedData: cacheNodeSeedData, head, isRootRender } = normalizedFlightData;
-            if (!isRootRender) {
-                // TODO-APP: handle this case better
-                console.log('REFRESH FAILED');
-                return state;
-            }
-            const newTree = (0, _applyrouterstatepatchtotree.applyRouterStatePatchToTree)(// TODO-APP: remove ''
-            [
-                ''
-            ], currentTree, treePatch, state.canonicalUrl);
-            if (newTree === null) {
-                return (0, _handlesegmentmismatch.handleSegmentMismatch)(state, action, treePatch);
-            }
-            if ((0, _isnavigatingtonewrootlayout.isNavigatingToNewRootLayout)(currentTree, newTree)) {
-                return (0, _navigatereducer.handleExternalUrl)(state, mutable, href, state.pushRef.pendingPush);
-            }
-            mutable.canonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(canonicalUrl);
-            // Handles case where prefetch only returns the router tree patch without rendered components.
-            if (cacheNodeSeedData !== null) {
-                const rsc = cacheNodeSeedData[0];
-                const loading = cacheNodeSeedData[2];
-                cache.rsc = rsc;
-                cache.prefetchRsc = null;
-                cache.loading = loading;
-                (0, _filllazyitemstillleafwithhead.fillLazyItemsTillLeafWithHead)(navigatedAt, cache, // Existing cache is not passed in as `router.refresh()` has to invalidate the entire cache.
-                undefined, treePatch, cacheNodeSeedData, head);
-                (0, _cache.revalidateEntireCache)(state.nextUrl, newTree);
-            }
-            await (0, _refetchinactiveparallelsegments.refreshInactiveParallelSegments)({
-                navigatedAt,
-                state,
-                updatedTree: newTree,
-                updatedCache: cache,
-                includeNextUrl,
-                canonicalUrl: mutable.canonicalUrl || state.canonicalUrl
-            });
-            mutable.cache = cache;
-            mutable.patchedTree = newTree;
-            mutable.renderedSearch = renderedSearch;
-            currentTree = newTree;
-        }
-        return (0, _handlemutable.handleMutable)(state, mutable);
-    }, ()=>state);
+    return (0, _navigatereducer.handleNavigationResult)(currentUrl, state, mutable, false, 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/reducers/restore-reducer.js

@@ -11,9 +11,8 @@ Object.defineProperty(exports, "restoreReducer", {
 const _createhreffromurl = require("../create-href-from-url");
 const _computechangedpath = require("../compute-changed-path");
 const _pprnavigations = require("../ppr-navigations");
+const _navigatereducer = require("./navigate-reducer");
 function restoreReducer(state, action) {
-    const { url, historyState } = action;
-    const href = (0, _createhreffromurl.createHrefFromUrl)(url);
     // This action is used to restore the router state from the history state.
     // However, it's possible that the history state no longer contains the `FlightRouterState`.
     // We will copy over the internal state on pushState/replaceState events, but if a history entry
@@ -22,6 +21,7 @@ function restoreReducer(state, action) {
     // In this case, we'll continue to use the existing tree so the router doesn't get into an invalid state.
     let treeToRestore;
     let renderedSearch;
+    const historyState = action.historyState;
     if (historyState) {
         treeToRestore = historyState.tree;
         renderedSearch = historyState.renderedSearch;
@@ -29,14 +29,26 @@ function restoreReducer(state, action) {
         treeToRestore = state.tree;
         renderedSearch = state.renderedSearch;
     }
-    const oldCache = state.cache;
-    const newCache = process.env.__NEXT_PPR ? // data for any segment whose dynamic data was already received. This
-    // prevents an unnecessary flash back to PPR state during a
-    // back/forward navigation.
-    (0, _pprnavigations.updateCacheNodeOnPopstateRestoration)(oldCache, treeToRestore) : oldCache;
+    const currentUrl = new URL(state.canonicalUrl, location.origin);
+    const restoredUrl = action.url;
+    const restoredCanonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(restoredUrl);
+    const restoredNextUrl = (0, _computechangedpath.extractPathFromFlightRouterState)(treeToRestore) ?? restoredUrl.pathname;
+    const now = Date.now();
+    const accumulation = {
+        scrollableSegments: null,
+        separateRefreshUrls: null
+    };
+    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, state.cache, state.tree, treeToRestore, _pprnavigations.FreshnessPolicy.HistoryTraversal, null, null, null, null, false, false, accumulation);
+    if (task === null) {
+        const mutable = {
+            preserveCustomHistoryState: true
+        };
+        return (0, _navigatereducer.handleExternalUrl)(state, mutable, restoredCanonicalUrl, false);
+    }
+    (0, _pprnavigations.spawnDynamicRequests)(task, restoredUrl, restoredNextUrl, _pprnavigations.FreshnessPolicy.HistoryTraversal, accumulation);
     return {
         // Set canonical url
-        canonicalUrl: href,
+        canonicalUrl: restoredCanonicalUrl,
         renderedSearch,
         pushRef: {
             pendingPush: false,
@@ -45,10 +57,13 @@ function restoreReducer(state, action) {
             preserveCustomHistoryState: true
         },
         focusAndScrollRef: state.focusAndScrollRef,
-        cache: newCache,
+        cache: task.node,
         // Restore provided tree
         tree: treeToRestore,
-        nextUrl: (0, _computechangedpath.extractPathFromFlightRouterState)(treeToRestore) ?? url.pathname,
+        nextUrl: restoredNextUrl,
+        // TODO: We need to restore previousNextUrl, too, which represents the
+        // Next-Url that was used to fetch the data. Anywhere we fetch using the
+        // canonical URL, there should be a corresponding Next-Url.
         previousNextUrl: null,
         debugInfo: null
     };