@semiont/frontend 0.3.2 → 0.3.4

package/standalone/node_modules/next/dist/client/components/router-reducer/reducers/committed-state.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    getLastCommittedTree: null,
+    setLastCommittedTree: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getLastCommittedTree: function() {
+        return getLastCommittedTree;
+    },
+    setLastCommittedTree: function() {
+        return setLastCommittedTree;
+    }
+});
+// The tree from the last state that was committed to the browser history
+// (i.e., the last state for which HistoryUpdater's useInsertionEffect ran).
+// This lets the server-patch reducer distinguish between retrying a
+// navigation that already pushed a history entry vs one whose transition
+// suspended and never committed.
+//
+// Currently only used by the server-patch retry logic, but this module is a
+// stepping stone toward a broader refactor of the navigation queue. The
+// existing AppRouter action queue will eventually be replaced by a more
+// reactive model that explicitly tracks pending vs committed navigation
+// state. This file will likely evolve into (or be subsumed by) that new
+// implementation.
+let lastCommittedTree = null;
+function getLastCommittedTree() {
+    return lastCommittedTree;
+}
+function setLastCommittedTree(tree) {
+    lastCommittedTree = tree;
+}
+
+if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
+  Object.defineProperty(exports.default, '__esModule', { value: true });
+  Object.assign(exports.default, exports);
+  module.exports = exports.default;
+}
+
+//# sourceMappingURL=committed-state.js.map

package/standalone/node_modules/next/dist/client/components/router-reducer/reducers/find-head-in-cache.js

@@ -30,26 +30,25 @@ function findHeadInCacheImpl(cache, parallelRoutes, keyPrefix, keyPrefixWithoutS
     if ('children' in parallelRoutes) {
         parallelRoutesKeys.unshift('children');
     }
-    for (const key of parallelRoutesKeys){
-        const [segment, childParallelRoutes] = parallelRoutes[key];
-        // If the parallel is not matched and using the default segment,
-        // skip searching the head from it.
-        if (segment === _segment.DEFAULT_SEGMENT_KEY) {
-            continue;
-        }
-        const childSegmentMap = cache.parallelRoutes.get(key);
-        if (!childSegmentMap) {
-            continue;
-        }
-        const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segment);
-        const cacheKeyWithoutSearchParams = (0, _createroutercachekey.createRouterCacheKey)(segment, true);
-        const cacheNode = childSegmentMap.get(cacheKey);
-        if (!cacheNode) {
-            continue;
-        }
-        const item = findHeadInCacheImpl(cacheNode, childParallelRoutes, keyPrefix + '/' + cacheKey, keyPrefix + '/' + cacheKeyWithoutSearchParams);
-        if (item) {
-            return item;
+    const slots = cache.slots;
+    if (slots !== null) {
+        for (const key of parallelRoutesKeys){
+            const [segment, childParallelRoutes] = parallelRoutes[key];
+            // If the parallel is not matched and using the default segment,
+            // skip searching the head from it.
+            if (segment === _segment.DEFAULT_SEGMENT_KEY) {
+                continue;
+            }
+            const childCacheNode = slots[key];
+            if (!childCacheNode) {
+                continue;
+            }
+            const cacheKey = (0, _createroutercachekey.createRouterCacheKey)(segment);
+            const cacheKeyWithoutSearchParams = (0, _createroutercachekey.createRouterCacheKey)(segment, true);
+            const item = findHeadInCacheImpl(childCacheNode, childParallelRoutes, keyPrefix + '/' + cacheKey, keyPrefix + '/' + cacheKeyWithoutSearchParams);
+            if (item) {
+                return item;
+            }
         }
     }
     return null;

package/standalone/node_modules/next/dist/client/components/router-reducer/reducers/navigate-reducer.js

@@ -5,9 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 0 && (module.exports = {
     DYNAMIC_STALETIME_MS: null,
     STATIC_STALETIME_MS: null,
-    generateSegmentsFromPatch: null,
-    handleExternalUrl: null,
-    handleNavigationResult: null,
     navigateReducer: null
 });
 function _export(target, all) {
@@ -23,140 +20,31 @@ _export(exports, {
     STATIC_STALETIME_MS: function() {
         return STATIC_STALETIME_MS;
     },
-    generateSegmentsFromPatch: function() {
-        return generateSegmentsFromPatch;
-    },
-    handleExternalUrl: function() {
-        return handleExternalUrl;
-    },
-    handleNavigationResult: function() {
-        return handleNavigationResult;
-    },
     navigateReducer: function() {
         return navigateReducer;
     }
 });
-const _createhreffromurl = require("../create-href-from-url");
-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) {
-    mutable.mpaNavigation = true;
-    mutable.canonicalUrl = url;
-    mutable.pendingPush = pendingPush;
-    mutable.scrollableSegments = undefined;
-    return (0, _handlemutable.handleMutable)(state, mutable);
-}
-function generateSegmentsFromPatch(flightRouterPatch) {
-    const segments = [];
-    const [segment, parallelRoutes] = flightRouterPatch;
-    if (Object.keys(parallelRoutes).length === 0) {
-        return [
-            [
-                segment
-            ]
-        ];
-    }
-    for (const [parallelRouteKey, parallelRoute] of Object.entries(parallelRoutes)){
-        for (const childSegment of generateSegmentsFromPatch(parallelRoute)){
-            // If the segment is empty, it means we are at the root of the tree
-            if (segment === '') {
-                segments.push([
-                    parallelRouteKey,
-                    ...childSegment
-                ]);
-            } else {
-                segments.push([
-                    segment,
-                    parallelRouteKey,
-                    ...childSegment
-                ]);
-            }
-        }
-    }
-    return segments;
-}
-function handleNavigationResult(url, state, mutable, pendingPush, result) {
-    switch(result.tag){
-        case _types.NavigationResultTag.MPA:
-            {
-                // Perform an MPA navigation.
-                const newUrl = result.data;
-                return handleExternalUrl(state, mutable, newUrl, pendingPush);
-            }
-        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;
-                // 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
-                // navigations are always same-origin.
-                url.pathname === oldUrl.pathname && url.search === oldUrl.search && url.hash !== oldUrl.hash;
-                if (onlyHashChange) {
-                    // The only updated part of the URL is the hash.
-                    mutable.onlyHashChange = true;
-                    mutable.shouldScroll = result.data.shouldScroll;
-                    mutable.hashFragment = url.hash;
-                    // Setting this to an empty array triggers a scroll for all new and
-                    // updated segments. See `ScrollAndFocusHandler` for more details.
-                    mutable.scrollableSegments = [];
-                }
-                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.
-                // TODO: This matches the current behavior but we need to do something
-                // better here if the network fails.
-                ()=>{
-                    return state;
-                });
-            }
-        default:
-            {
-                result;
-                return state;
-            }
-    }
-}
 function navigateReducer(state, action) {
-    const { url, isExternalUrl, navigateType, shouldScroll } = action;
-    const mutable = {};
-    const href = (0, _createhreffromurl.createHrefFromUrl)(url);
-    const pendingPush = navigateType === 'push';
-    mutable.preserveCustomHistoryState = false;
-    mutable.pendingPush = pendingPush;
+    const { url, isExternalUrl, navigateType, scrollBehavior } = action;
     if (isExternalUrl) {
-        return handleExternalUrl(state, mutable, url.toString(), pendingPush);
+        return (0, _navigation.completeHardNavigation)(state, url, navigateType);
     }
     // Handles case where `<meta http-equiv="refresh">` tag is present,
     // which will trigger an MPA navigation.
     if (document.getElementById('__next-page-redirect')) {
-        return handleExternalUrl(state, mutable, href, pendingPush);
+        return (0, _navigation.completeHardNavigation)(state, url, navigateType);
     }
     // Temporary glue code between the router reducer and the new navigation
     // 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, _pprnavigations.FreshnessPolicy.Default, shouldScroll, mutable);
-    return handleNavigationResult(url, state, mutable, pendingPush, result);
+    const currentRenderedSearch = state.renderedSearch;
+    return (0, _navigation.navigate)(state, url, currentUrl, currentRenderedSearch, state.cache, state.tree, state.nextUrl, _pprnavigations.FreshnessPolicy.Default, scrollBehavior, navigateType);
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {

package/standalone/node_modules/next/dist/client/components/router-reducer/reducers/refresh-reducer.js

@@ -20,21 +20,32 @@ _export(exports, {
         return refreshReducer;
     }
 });
-const _navigatereducer = require("./navigate-reducer");
+const _routerreducertypes = require("../router-reducer-types");
 const _navigation = require("../../segment-cache/navigation");
 const _cache = require("../../segment-cache/cache");
 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);
+const _bfcache = require("../../segment-cache/bfcache");
+function refreshReducer(state, action) {
+    // During a refresh, we invalidate the segment cache but not the route cache.
+    // The route cache contains the tree structure (which segments exist at a
+    // given URL) which doesn't change during a refresh. The segment cache
+    // contains the actual RSC data which needs to be re-fetched.
+    //
+    // The Instant Navigation Testing API can bypass cache invalidation to
+    // preserve prefetched data when refreshing after an MPA navigation. This is
+    // only used for testing and is not exposed in production builds by default.
+    const bypassCacheInvalidation = process.env.__NEXT_EXPOSE_TESTING_API && action.bypassCacheInvalidation;
+    if (!bypassCacheInvalidation) {
+        const currentNextUrl = state.nextUrl;
+        const currentRouterState = state.tree;
+        (0, _cache.invalidateSegmentCacheEntries)(currentNextUrl, currentRouterState);
+    }
     return refreshDynamicData(state, _pprnavigations.FreshnessPolicy.RefreshAll);
 }
 function refreshDynamicData(state, freshnessPolicy) {
+    // During a refresh, invalidate the BFCache, which may contain dynamic data.
+    (0, _bfcache.invalidateBfCache)();
     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
@@ -44,19 +55,23 @@ function refreshDynamicData(state, freshnessPolicy) {
     // existing dynamic data (including in shared layouts) is re-fetched.
     const currentCanonicalUrl = state.canonicalUrl;
     const currentUrl = new URL(currentCanonicalUrl, location.origin);
+    const currentRenderedSearch = state.renderedSearch;
     const currentFlightRouterState = state.tree;
-    const shouldScroll = true;
-    const navigationSeed = {
-        tree: state.tree,
-        renderedSearch: state.renderedSearch,
-        data: null,
-        head: null
-    };
+    const scrollBehavior = _routerreducertypes.ScrollBehavior.NoScroll;
+    // Create a NavigationSeed from the current FlightRouterState.
+    // TODO: Eventually we will store this type directly on the state object
+    // instead of reconstructing it on demand. Part of a larger series of
+    // refactors to unify the various tree types that the client deals with.
     const now = Date.now();
-    const result = (0, _navigation.navigateToSeededRoute)(now, currentUrl, currentCanonicalUrl, navigationSeed, currentUrl, state.cache, currentFlightRouterState, freshnessPolicy, nextUrlForRefresh, shouldScroll);
-    const mutable = {};
-    mutable.preserveCustomHistoryState = false;
-    return (0, _navigatereducer.handleNavigationResult)(currentUrl, state, mutable, false, result);
+    // TODO: Store the dynamic stale time on the top-level state so it's known
+    // during restores and refreshes.
+    const refreshSeed = (0, _navigation.convertServerPatchToFullTree)(now, currentFlightRouterState, null, currentRenderedSearch, _bfcache.UnknownDynamicStaleTime);
+    const navigateType = 'replace';
+    return (0, _navigation.navigateToKnownRoute)(now, state, currentUrl, currentCanonicalUrl, refreshSeed, currentUrl, currentRenderedSearch, state.cache, currentFlightRouterState, freshnessPolicy, nextUrlForRefresh, scrollBehavior, navigateType, null, // Refresh navigations don't use route prediction, so there's no route
+    // cache entry to mark as having a dynamic rewrite on mismatch. If a
+    // mismatch occurs, the retry handler will traverse the known route tree
+    // to find and mark the entry.
+    null);
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {

package/standalone/node_modules/next/dist/client/components/router-reducer/reducers/restore-reducer.js

@@ -8,10 +8,10 @@ Object.defineProperty(exports, "restoreReducer", {
         return restoreReducer;
     }
 });
-const _createhreffromurl = require("../create-href-from-url");
 const _computechangedpath = require("../compute-changed-path");
 const _pprnavigations = require("../ppr-navigations");
-const _navigatereducer = require("./navigate-reducer");
+const _navigation = require("../../segment-cache/navigation");
+const _bfcache = require("../../segment-cache/bfcache");
 function restoreReducer(state, action) {
     // 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`.
@@ -31,42 +31,26 @@ function restoreReducer(state, action) {
     }
     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();
+    // TODO: Store the dynamic stale time on the top-level state so it's known
+    // during restores and refreshes.
     const accumulation = {
-        scrollableSegments: null,
-        separateRefreshUrls: null
+        separateRefreshUrls: null,
+        scrollRef: null
     };
-    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, state.cache, state.tree, treeToRestore, _pprnavigations.FreshnessPolicy.HistoryTraversal, null, null, null, null, false, false, accumulation);
+    const restoreSeed = (0, _navigation.convertServerPatchToFullTree)(now, treeToRestore, null, renderedSearch, _bfcache.UnknownDynamicStaleTime);
+    const task = (0, _pprnavigations.startPPRNavigation)(now, currentUrl, state.renderedSearch, state.cache, state.tree, restoreSeed.routeTree, restoreSeed.metadataVaryPath, _pprnavigations.FreshnessPolicy.HistoryTraversal, null, null, restoreSeed.dynamicStaleAt, false, accumulation);
     if (task === null) {
-        const mutable = {
-            preserveCustomHistoryState: true
-        };
-        return (0, _navigatereducer.handleExternalUrl)(state, mutable, restoredCanonicalUrl, false);
+        return (0, _navigation.completeHardNavigation)(state, restoredUrl, 'replace');
     }
-    (0, _pprnavigations.spawnDynamicRequests)(task, restoredUrl, restoredNextUrl, _pprnavigations.FreshnessPolicy.HistoryTraversal, accumulation);
-    return {
-        // Set canonical url
-        canonicalUrl: restoredCanonicalUrl,
-        renderedSearch,
-        pushRef: {
-            pendingPush: false,
-            mpaNavigation: false,
-            // Ensures that the custom history state that was set is preserved when applying this update.
-            preserveCustomHistoryState: true
-        },
-        focusAndScrollRef: state.focusAndScrollRef,
-        cache: task.node,
-        // Restore provided tree
-        tree: treeToRestore,
-        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
-    };
+    (0, _pprnavigations.spawnDynamicRequests)(task, restoredUrl, restoredNextUrl, _pprnavigations.FreshnessPolicy.HistoryTraversal, accumulation, // History traversal doesn't use route prediction, so there's no route
+    // cache entry to mark as having a dynamic rewrite on mismatch. If a
+    // mismatch occurs, the retry handler will traverse the known route tree
+    // to find and mark the entry.
+    null, // History traversal always uses 'replace'.
+    'replace');
+    return (0, _navigation.completeTraverseNavigation)(state, restoredUrl, renderedSearch, task.node, task.route, restoredNextUrl);
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {