@evoscientist/webui 0.2.4 → 0.2.6

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

@@ -10,8 +10,14 @@ Object.defineProperty(exports, "hmrRefreshReducer", {
 });
 const _refreshreducer = require("./refresh-reducer");
 const _pprnavigations = require("../ppr-navigations");
-function hmrRefreshReducer(state) {
-    return (0, _refreshreducer.refreshDynamicData)(state, _pprnavigations.FreshnessPolicy.HMRRefresh);
+function hmrRefreshReducer(state, action) {
+    // HMR actions may wait behind a Server Action in the router queue. If a newer
+    // generation superseded this one before it started, don't install a refresh
+    // tree whose request is already canceled.
+    if (action.signal?.aborted) {
+        return state;
+    }
+    return (0, _refreshreducer.refreshDynamicData)(state, _pprnavigations.FreshnessPolicy.HMRRefresh, action.signal);
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {

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

@@ -41,9 +41,10 @@ function refreshReducer(state, action) {
         const currentRouterState = state.tree;
         (0, _cache.invalidateSegmentCacheEntries)(currentNextUrl, currentRouterState);
     }
-    return refreshDynamicData(state, _pprnavigations.FreshnessPolicy.RefreshAll);
+    // A full refresh has no HMR generation to cancel.
+    return refreshDynamicData(state, _pprnavigations.FreshnessPolicy.RefreshAll, undefined);
 }
-function refreshDynamicData(state, freshnessPolicy) {
+function refreshDynamicData(state, freshnessPolicy, signal) {
     // During a refresh, invalidate the BFCache, which may contain dynamic data.
     (0, _bfcache.invalidateBfCache)();
     const currentNextUrl = state.nextUrl;
@@ -58,6 +59,7 @@ function refreshDynamicData(state, freshnessPolicy) {
     const currentRenderedSearch = state.renderedSearch;
     const currentFlightRouterState = state.tree;
     const scrollBehavior = _routerreducertypes.ScrollBehavior.NoScroll;
+    const navigationLock = (0, _pprnavigations.getCurrentNavigationLock)();
     // 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
@@ -66,12 +68,17 @@ function refreshDynamicData(state, freshnessPolicy) {
     // 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
+    // If the previous navigation hasn't pushed its history entry yet (React
+    // hasn't committed its state), this refresh may commit in its place, so it
+    // takes over the push. If the navigation does commit first, HistoryUpdater
+    // sees that the URL already matches and replaces instead.
+    const navigateType = state.pushRef.pendingPush ? 'push' : 'replace';
+    return (0, _navigation.navigateToKnownRoute)(now, state, currentUrl, currentCanonicalUrl, refreshSeed, currentUrl, currentRenderedSearch, state.cache, currentFlightRouterState, freshnessPolicy, nextUrlForRefresh, scrollBehavior, navigateType, navigationLock, // A refresh is bound to the shared map.
+    _cache.segmentCacheMap, 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);
+    null, signal);
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {

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

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "restoreReducer", {
 const _computechangedpath = require("../compute-changed-path");
 const _pprnavigations = require("../ppr-navigations");
 const _navigation = require("../../segment-cache/navigation");
+const _cache = require("../../segment-cache/cache");
 const _bfcache = require("../../segment-cache/bfcache");
 function restoreReducer(state, action) {
     // This action is used to restore the router state from the history state.
@@ -40,7 +41,9 @@ function restoreReducer(state, action) {
         scrollRef: null
     };
     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);
+    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, // A history-traversal restore is bound to the shared map.
+    _cache.segmentCacheMap, // A history-traversal restore never restricts to the shell.
+    false);
     if (task === null) {
         return (0, _navigation.completeHardNavigation)(state, restoredUrl, 'replace');
     }
@@ -49,7 +52,17 @@ function restoreReducer(state, action) {
     // mismatch occurs, the retry handler will traverse the known route tree
     // to find and mark the entry.
     null, // History traversal always uses 'replace'.
-    'replace');
+    'replace', // Instant Navigation Testing API: a traversal is not a capture. Spawn its
+    // dynamic requests ungated (null lock) so they render from cache or fetch
+    // normally rather than being withheld behind the lock.
+    null, // A history-traversal restore is bound to the shared map.
+    _cache.segmentCacheMap, // Not an HMR refresh, so there's no request generation to cancel.
+    undefined);
+    // Instant Navigation Testing API: a traversal resets the lock to a fresh
+    // pending scope — releasing any data withheld by prior forward navigations and
+    // returning the panel to "awaiting" — without ending the testing session.
+    // No-op when the testing API is disabled or no lock is held.
+    (0, _pprnavigations.resetNavigationLockToPending)();
     return (0, _navigation.completeTraverseNavigation)(state, restoredUrl, renderedSearch, task.node, task.route, restoredNextUrl);
 }
 

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

@@ -12,6 +12,7 @@ const _appcallserver = require("../../../app-call-server");
 const _appfindsourcemapurl = require("../../../app-find-source-map-url");
 const _approuterheaders = require("../../app-router-headers");
 const _unrecognizedactionerror = require("../../unrecognized-action-error");
+const _fetch = require("../../segment-cache/fetch");
 const _client = require("react-server-dom-webpack/client");
 const _routerreducertypes = require("../router-reducer-types");
 const _assignlocation = require("../../../assign-location");
@@ -39,7 +40,8 @@ let createDebugChannel;
 if (process.env.__NEXT_DEV_SERVER && process.env.__NEXT_REACT_DEBUG_CHANNEL) {
     createDebugChannel = require('../../../dev/debug-channel').createDebugChannel;
 }
-async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
+async function fetchServerAction(state, nextUrl, action) {
+    const { actionId, actionArgs } = action;
     const temporaryReferences = (0, _client.createTemporaryReferenceSet)();
     const info = (0, _serverreferenceinfo.extractInfoFromServerReferenceId)(actionId);
     const usedArgs = (0, _serverreferenceinfo.omitUnusedArgs)(actionArgs, info);
@@ -67,11 +69,35 @@ async function fetchServerAction(state, nextUrl, { actionId, actionArgs }) {
         // then routes those chunks to the debug channel associated with this ID.
         headers[_approuterheaders.NEXT_REQUEST_ID_HEADER] = crypto.getRandomValues(new Uint32Array(1))[0].toString(16);
     }
-    const res = await fetch(state.canonicalUrl, {
-        method: 'POST',
-        headers,
-        body
-    });
+    let res;
+    try {
+        res = await (0, _fetch.fetch)(state.canonicalUrl, {
+            method: 'POST',
+            headers,
+            body
+        });
+        // If the fetch succeeds while we're in the offline state, notify the
+        // offline module so it can short-circuit the polling loop.
+        if (process.env.__NEXT_USE_OFFLINE) {
+            const { notifyOnline } = require('../../offline');
+            notifyOnline();
+        }
+    } catch (err) {
+        if (process.env.__NEXT_USE_OFFLINE) {
+            const { checkOfflineError, getOffline, waitForConnection } = require('../../offline');
+            if (checkOfflineError(err)) {
+                // It's safe to replay the action because the fetch rejection
+                // means the request never reached the server — there are no
+                // side effects to duplicate.
+                const offline = getOffline();
+                if (offline !== null) {
+                    await waitForConnection(offline);
+                }
+                return fetchServerAction(state, nextUrl, action);
+            }
+        }
+        throw err;
+    }
     // Handle server actions that the server didn't recognize.
     const unrecognizedActionHeader = res.headers.get(_approuterheaders.NEXT_ACTION_NOT_FOUND_HEADER);
     if (unrecognizedActionHeader === '1') {
@@ -287,14 +313,17 @@ function serverActionReducer(state, action) {
             // Learn the route pattern so we can predict it for future navigations.
             const metadataVaryPath = redirectSeed.metadataVaryPath;
             if (metadataVaryPath !== null) {
-                (0, _optimisticroutes.discoverKnownRoute)(now, redirectUrl.pathname, nextUrl, null, redirectSeed.routeTree, metadataVaryPath, couldBeIntercepted, redirectCanonicalUrl, isPrerender, false // hasDynamicRewrite
+                (0, _optimisticroutes.discoverKnownRoute)(now, redirectUrl.pathname, redirectUrl.search, nextUrl, null, redirectSeed.routeTree, metadataVaryPath, couldBeIntercepted, redirectCanonicalUrl, isPrerender, false // hasDynamicRewrite
                 );
             }
-            return (0, _navigation.navigateToKnownRoute)(now, state, redirectUrl, redirectCanonicalUrl, redirectSeed, currentUrl, currentRenderedSearch, state.cache, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, null, // Server action redirects don't use route prediction - we already
+            const navigationLock = (0, _pprnavigations.getCurrentNavigationLock)();
+            return (0, _navigation.navigateToKnownRoute)(now, state, redirectUrl, redirectCanonicalUrl, redirectSeed, currentUrl, currentRenderedSearch, state.cache, currentFlightRouterState, freshnessPolicy, nextUrl, scrollBehavior, navigateType, navigationLock, // A server-action redirect navigation is bound to the shared map.
+            _cache.segmentCacheMap, null, // Server action redirects don't use route prediction - we already
             // have the route tree from the server response. If a mismatch occurs
             // during dynamic data fetch, the retry handler will traverse the
             // known route tree to mark the entry as having a dynamic rewrite.
-            null);
+            null, // Not an HMR refresh, so there's no request generation to cancel.
+            undefined);
         }
         // The server did not send back new data. We'll perform a regular, non-
         // seeded navigation — effectively the same as <Link> or router.push().

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

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "serverPatchReducer", {
 const _createhreffromurl = require("../create-href-from-url");
 const _routerreducertypes = require("../router-reducer-types");
 const _navigation = require("../../segment-cache/navigation");
+const _cache = require("../../segment-cache/cache");
 const _refreshreducer = require("./refresh-reducer");
 const _pprnavigations = require("../ppr-navigations");
 function serverPatchReducer(state, action) {
@@ -39,14 +40,22 @@ function serverPatchReducer(state, action) {
     }
     // There have been no new navigations since the mismatched one. Refresh,
     // using the tree we just received from the server.
+    //
+    // The freshness policy comes from the action: a genuine tree mismatch
+    // re-fetches the dynamic data (`RefreshAll`), whereas a redirect that only
+    // changed the canonical URL reuses the data already in the tree
+    // (`HistoryTraversal`), since the data we received is correct.
     const retryCanonicalUrl = (0, _createhreffromurl.createHrefFromUrl)(retryUrl);
     const retryNextUrl = action.nextUrl;
     const scrollBehavior = _routerreducertypes.ScrollBehavior.Default;
+    const navigationLock = (0, _pprnavigations.getCurrentNavigationLock)();
     const now = Date.now();
-    return (0, _navigation.navigateToKnownRoute)(now, state, retryUrl, retryCanonicalUrl, retrySeed, currentUrl, currentRenderedSearch, state.cache, state.tree, _pprnavigations.FreshnessPolicy.RefreshAll, retryNextUrl, scrollBehavior, navigateType, null, // Server patch (retry) navigations don't use route prediction. This is
+    return (0, _navigation.navigateToKnownRoute)(now, state, retryUrl, retryCanonicalUrl, retrySeed, currentUrl, currentRenderedSearch, state.cache, state.tree, action.freshnessPolicy, retryNextUrl, scrollBehavior, navigateType, navigationLock, // A server-patch retry navigation is bound to the shared map.
+    _cache.segmentCacheMap, null, // Server patch (retry) navigations don't use route prediction. This is
     // typically a retry after a previous mismatch, so the route was already
     // marked as having a dynamic rewrite when the mismatch was detected.
-    null);
+    null, // Not an HMR refresh, so there's no request generation to cancel.
+    undefined);
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {

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

@@ -13,7 +13,6 @@ const _navigatereducer = require("./reducers/navigate-reducer");
 const _serverpatchreducer = require("./reducers/server-patch-reducer");
 const _restorereducer = require("./reducers/restore-reducer");
 const _refreshreducer = require("./reducers/refresh-reducer");
-const _hmrrefreshreducer = require("./reducers/hmr-refresh-reducer");
 const _serveractionreducer = require("./reducers/server-action-reducer");
 /**
  * Reducer that handles the app-router state updates.
@@ -37,7 +36,16 @@ const _serveractionreducer = require("./reducers/server-action-reducer");
             }
         case _routerreducertypes.ACTION_HMR_REFRESH:
             {
-                return (0, _hmrrefreshreducer.hmrRefreshReducer)(state);
+                if (process.env.NODE_ENV === 'development') {
+                    const { hmrRefreshReducer } = require('./reducers/hmr-refresh-reducer');
+                    return hmrRefreshReducer(state, action);
+                } else {
+                    throw Object.defineProperty(new Error('hmrRefresh can only be used in development mode. Please use refresh instead.'), "__NEXT_ERROR_CODE", {
+                        value: "E485",
+                        enumerable: false,
+                        configurable: true
+                    });
+                }
             }
         case _routerreducertypes.ACTION_SERVER_ACTION:
             {

package/dist/node_modules/next/dist/client/components/router-transition.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    initializeRouterTransitionModules: null,
+    startRouterTransition: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    initializeRouterTransitionModules: function() {
+        return initializeRouterTransitionModules;
+    },
+    startRouterTransition: function() {
+        return startRouterTransition;
+    }
+});
+const _segment = require("../../shared/lib/segment");
+const _computechangedpath = require("./router-reducer/compute-changed-path");
+let instrumentationModules = [];
+let nextTransitionId = 0;
+function initializeRouterTransitionModules(modules) {
+    instrumentationModules = modules.filter((module1)=>module1 != null);
+}
+function callHooks(invoke) {
+    for (const hooks of instrumentationModules){
+        try {
+            invoke(hooks);
+        } catch (error) {
+            console.error('An instrumentation-client router transition hook failed', error);
+        }
+    }
+}
+function timestamp() {
+    return performance.timeOrigin + performance.now();
+}
+function startRouterTransition(url, type, fromTree, prefetchIntent) {
+    // Positive flag check so the instrumentation-only path is removed by DCE when disabled.
+    if (process.env.__NEXT_INSTRUMENTATION_CLIENT_ROUTER_TRANSITION_EVENTS) {
+        if (!instrumentationModules.some((hooks)=>typeof hooks.onRouterTransitionStart === 'function')) {
+            return;
+        }
+        const id = `${Date.now().toString(36)}-${(++nextTransitionId).toString(36)}`;
+        callHooks((hooks)=>hooks.onRouterTransitionStart?.(url, type, {
+                id,
+                timestamp: timestamp(),
+                fromRoutes: getActiveRoutePaths(fromTree),
+                prefetchIntent
+            }));
+    } else {
+        callHooks((hooks)=>hooks.onRouterTransitionStart?.(url, type, null));
+    }
+}
+function classifySegment(segment) {
+    const sourceSegment = (0, _computechangedpath.segmentToSourcePagePathname)(segment);
+    if (sourceSegment === 'page') {
+        return {
+            path: null,
+            isPage: true
+        };
+    }
+    if (sourceSegment === '' || sourceSegment === '(__SLOT__)' || (0, _segment.isGroupSegment)(sourceSegment)) {
+        return {
+            path: null,
+            isPage: false
+        };
+    }
+    if (sourceSegment === _segment.DEFAULT_SEGMENT_KEY) {
+        return {
+            path: 'default',
+            isPage: false
+        };
+    }
+    if (sourceSegment === _segment.NOT_FOUND_SEGMENT_KEY) {
+        return {
+            path: '_not-found',
+            isPage: false
+        };
+    }
+    return {
+        path: sourceSegment,
+        isPage: false
+    };
+}
+function getActiveRoutePaths(tree) {
+    const routes = [];
+    function visit(node, segments, primary) {
+        const segment = classifySegment(node[0]);
+        const nextSegments = segment.path === null ? segments : [
+            ...segments,
+            segment.path
+        ];
+        const parallelRoutes = node[1];
+        const keys = Object.keys(parallelRoutes);
+        if (keys.length === 0 || segment.isPage) {
+            routes.push({
+                path: `/${nextSegments.join('/')}`,
+                primary
+            });
+            return;
+        }
+        if (parallelRoutes.children !== undefined) {
+            visit(parallelRoutes.children, nextSegments, primary);
+        }
+        for (const key of keys.sort()){
+            if (key === 'children') {
+                continue;
+            }
+            visit(parallelRoutes[key], [
+                ...nextSegments,
+                `@${key}`
+            ], false);
+        }
+    }
+    visit(tree, [], true);
+    return routes.sort((a, b)=>{
+        if (a.primary !== b.primary) {
+            return a.primary ? -1 : 1;
+        }
+        return a.path.localeCompare(b.path);
+    }).map((route)=>route.path);
+}
+
+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=router-transition.js.map

package/dist/node_modules/next/dist/client/components/segment-cache/bfcache.js

@@ -58,7 +58,7 @@ function invalidateBfCache() {
     }
     currentBfCacheVersion++;
 }
-function writeToBFCache(now, varyPath, rsc, prefetchRsc, head, prefetchHead, dynamicStaleAt) {
+function writeToBFCache(now, varyPath, rsc, prefetchRsc, head, prefetchHead, dynamicStaleAt, bfcacheId) {
     if (typeof window === 'undefined') {
         return;
     }
@@ -69,6 +69,7 @@ function writeToBFCache(now, varyPath, rsc, prefetchRsc, head, prefetchHead, dyn
         // SegmentCacheEntry. The head has its own separate cache entry.
         head,
         prefetchHead,
+        bfcacheId,
         ref: null,
         // TODO: This is just a heuristic. Getting the actual size of the segment
         // isn't feasible because it's part of a larger streaming response. The
@@ -81,14 +82,15 @@ function writeToBFCache(now, varyPath, rsc, prefetchRsc, head, prefetchHead, dyn
         // only relevant when staleTimes.dynamic is enabled or unstable_dynamicStaleTime
         // is exported by a page.
         staleAt: dynamicStaleAt,
-        version: currentBfCacheVersion
+        version: currentBfCacheVersion,
+        status: _cachemap.EntryStatus.Fulfilled
     };
     const isRevalidation = false;
     (0, _cachemap.setInCacheMap)(bfcacheMap, varyPath, entry, isRevalidation);
 }
-function writeHeadToBFCache(now, varyPath, head, prefetchHead, dynamicStaleAt) {
+function writeHeadToBFCache(now, varyPath, head, prefetchHead, dynamicStaleAt, bfcacheId) {
     // Read the special "segment" that represents the head data.
-    writeToBFCache(now, varyPath, head, prefetchHead, null, null, dynamicStaleAt);
+    writeToBFCache(now, varyPath, head, prefetchHead, null, null, dynamicStaleAt, bfcacheId);
 }
 function updateBFCacheEntryStaleAt(varyPath, newStaleAt) {
     if (typeof window === 'undefined') {
@@ -96,7 +98,7 @@ function updateBFCacheEntryStaleAt(varyPath, newStaleAt) {
     }
     const isRevalidation = false;
     // Read with staleness bypass (-1) so we can update even stale entries
-    const entry = (0, _cachemap.getFromCacheMap)(-1, currentBfCacheVersion, bfcacheMap, varyPath, isRevalidation);
+    const entry = (0, _cachemap.getFromCacheMap)(-1, currentBfCacheVersion, bfcacheMap, varyPath, isRevalidation, false);
     if (entry !== null) {
         entry.staleAt = newStaleAt;
     }
@@ -109,14 +111,14 @@ function readFromBFCache(varyPath) {
     return (0, _cachemap.getFromCacheMap)(// During a back/forward navigation, it doesn't matter how stale the data
     // might be. Pass -1 instead of the actual current time to bypass
     // staleness checks.
-    -1, currentBfCacheVersion, bfcacheMap, varyPath, isRevalidation);
+    -1, currentBfCacheVersion, bfcacheMap, varyPath, isRevalidation, false);
 }
 function readFromBFCacheDuringRegularNavigation(now, varyPath) {
     if (typeof window === 'undefined') {
         return null;
     }
     const isRevalidation = false;
-    return (0, _cachemap.getFromCacheMap)(now, currentBfCacheVersion, bfcacheMap, varyPath, isRevalidation);
+    return (0, _cachemap.getFromCacheMap)(now, currentBfCacheVersion, bfcacheMap, varyPath, isRevalidation, false);
 }
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {

package/dist/node_modules/next/dist/client/components/segment-cache/cache-key.js

@@ -3,10 +3,22 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "createCacheKey", {
-    enumerable: true,
-    get: function() {
+0 && (module.exports = {
+    createCacheKey: null,
+    splitPathnameIntoParts: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createCacheKey: function() {
         return createCacheKey;
+    },
+    splitPathnameIntoParts: function() {
+        return splitPathnameIntoParts;
     }
 });
 function createCacheKey(originalHref, nextUrl) {
@@ -18,6 +30,22 @@ function createCacheKey(originalHref, nextUrl) {
     };
     return cacheKey;
 }
+function splitPathnameIntoParts(pathname) {
+    const parts = [];
+    let start = 0;
+    for(let i = 0; i < pathname.length; i++){
+        if (pathname.charCodeAt(i) === 47 /* '/' */ ) {
+            if (i > start) {
+                parts.push(pathname.slice(start, i));
+            }
+            start = i + 1;
+        }
+    }
+    if (start < pathname.length) {
+        parts.push(pathname.slice(start));
+    }
+    return parts;
+}
 
 if ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {
   Object.defineProperty(exports.default, '__esModule', { value: true });

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
+    EntryStatus: null,
     Fallback: null,
     createCacheMap: null,
     deleteFromCacheMap: null,
@@ -19,6 +20,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    EntryStatus: function() {
+        return EntryStatus;
+    },
     Fallback: function() {
         return Fallback;
     },
@@ -45,6 +49,13 @@ _export(exports, {
     }
 });
 const _lru = require("./lru");
+var EntryStatus = /*#__PURE__*/ function(EntryStatus) {
+    EntryStatus[EntryStatus["Empty"] = 0] = "Empty";
+    EntryStatus[EntryStatus["Pending"] = 1] = "Pending";
+    EntryStatus[EntryStatus["Fulfilled"] = 2] = "Fulfilled";
+    EntryStatus[EntryStatus["Rejected"] = 3] = "Rejected";
+    return EntryStatus;
+}({});
 const Fallback = {};
 // This is a special internal key that is used for "revalidation" entries. It's
 // an implementation detail that shouldn't leak outside of this module.
@@ -119,8 +130,14 @@ function getOrInitialize(cacheMap, keys, isRevalidation) {
     }
     return entry;
 }
-function getFromCacheMap(now, currentCacheVersion, rootEntry, keys, isRevalidation) {
-    const entry = getEntryWithFallbackImpl(now, currentCacheVersion, rootEntry, keys, isRevalidation, 0);
+function getFromCacheMap(now, currentCacheVersion, rootEntry, keys, isRevalidation, // When true, terminal entries whose status is not Fulfilled are skipped, so
+// the lookup falls through to a less-specific Fallback entry. Use this
+// during a navigation to prefer a Fulfilled shell entry over a more-specific
+// Pending entry that may still be in-flight. Callers that want to also
+// accept non-Fulfilled entries should perform a second lookup with this set
+// to false.
+onlyMatchFulfilled) {
+    const entry = getEntryWithFallbackImpl(now, currentCacheVersion, rootEntry, keys, isRevalidation, 0, onlyMatchFulfilled);
     if (entry === null || entry.value === null) {
         return null;
     }
@@ -131,7 +148,7 @@ function getFromCacheMap(now, currentCacheVersion, rootEntry, keys, isRevalidati
 function isValueExpired(now, currentCacheVersion, value) {
     return value.staleAt <= now || value.version < currentCacheVersion;
 }
-function lazilyEvictIfNeeded(now, currentCacheVersion, entry) {
+function lazilyEvictIfNeeded(now, currentCacheVersion, entry, onlyMatchFulfilled) {
     // We have a matching entry, but before we can return it, we need to check if
     // it's still fresh. Otherwise it should be treated the same as a cache miss.
     if (entry.value === null) {
@@ -145,16 +162,25 @@ function lazilyEvictIfNeeded(now, currentCacheVersion, entry) {
         deleteMapEntry(entry);
         return null;
     }
+    if (onlyMatchFulfilled && value.status !== 2) {
+        // The entry is fresh but is not Fulfilled. Treat as a non-match so the
+        // recursion can continue and try a Fallback entry.
+        return null;
+    }
     // The matched entry has not expired. Return it.
     return entry;
 }
-function getEntryWithFallbackImpl(now, currentCacheVersion, entry, keys, isRevalidation, previousKey) {
+function getEntryWithFallbackImpl(now, currentCacheVersion, entry, keys, isRevalidation, previousKey, onlyMatchFulfilled) {
     // This is similar to getExactEntry, but if an exact match is not found for
     // a key, it will return the fallback entry instead. This is recursive at
     // every level, e.g. an entry with keypath [a, Fallback, c, Fallback] is
     // valid match for [a, b, c, d].
     //
     // It will return the most specific match available.
+    //
+    // When `onlyMatchFulfilled` is true, terminal entries that aren't Fulfilled
+    // are treated as non-matches, so the recursion will continue searching for
+    // a Fallback match. See getFromCacheMap for the rationale.
     let key;
     let remainingKeys;
     if (keys !== null) {
@@ -167,19 +193,14 @@ function getEntryWithFallbackImpl(now, currentCacheVersion, entry, keys, isReval
         remainingKeys = null;
     } else {
         // There are no more keys. This is the terminal entry.
-        // TODO: When performing a lookup during a navigation, as opposed to a
-        // prefetch, we may want to skip entries that are Pending if there's also
-        // a Fulfilled fallback entry. Tricky to say, though, since if it's
-        // already pending, it's likely to stream in soon. Maybe we could do this
-        // just on slow connections and offline mode.
-        return lazilyEvictIfNeeded(now, currentCacheVersion, entry);
+        return lazilyEvictIfNeeded(now, currentCacheVersion, entry, onlyMatchFulfilled);
     }
     const map = entry.map;
     if (map !== null) {
         const existingEntry = map.get(key);
         if (existingEntry !== undefined) {
             // Found an exact match for this key. Keep searching.
-            const result = getEntryWithFallbackImpl(now, currentCacheVersion, existingEntry, remainingKeys, isRevalidation, key);
+            const result = getEntryWithFallbackImpl(now, currentCacheVersion, existingEntry, remainingKeys, isRevalidation, key, onlyMatchFulfilled);
             if (result !== null) {
                 return result;
             }
@@ -188,7 +209,7 @@ function getEntryWithFallbackImpl(now, currentCacheVersion, entry, keys, isReval
         const fallbackEntry = map.get(Fallback);
         if (fallbackEntry !== undefined) {
             // Found a fallback for this key. Keep searching.
-            return getEntryWithFallbackImpl(now, currentCacheVersion, fallbackEntry, remainingKeys, isRevalidation, key);
+            return getEntryWithFallbackImpl(now, currentCacheVersion, fallbackEntry, remainingKeys, isRevalidation, key, onlyMatchFulfilled);
         }
     }
     return null;