@sifxprime/krouter 0.5.166 → 0.5.168

package/app/node_modules/next/dist/client/components/segment-cache/optimistic-routes.js

@@ -68,6 +68,7 @@ _export(exports, {
     }
 });
 const _approutertypes = require("../../../shared/lib/app-router-types");
+const _segment = require("../../../shared/lib/segment");
 const _cache = require("./cache");
 const _cachemap = require("./cache-map");
 const _routeparams = require("../../route-params");
@@ -99,40 +100,38 @@ function createEmptyPart() {
         dynamicChildParamName: null,
         dynamicChildParamType: null,
         pattern: null,
-        hasConflictingDynamicChildren: false
+        hasConflictingDynamicChildren: false,
+        hasDynamicRewrite: false
     };
 }
 // The root of the known route tree.
 let knownRouteTreeRoot = createEmptyPart();
-function discoverKnownRoute(now, pathname, search, nextUrl, pendingEntry, routeTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite) {
-    const tree = routeTree;
+function discoverKnownRoute(now, pathname, search, nextUrl, pendingEntry, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching, hasDynamicRewrite) {
+    const tree = root.tree;
     const pathnameParts = (0, _cachekey.splitPathnameIntoParts)(pathname);
     if (pendingEntry !== null) {
         // Fulfill the pending entry first
-        const fulfilledEntry = (0, _cache.fulfillRouteCacheEntry)(now, pendingEntry, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
-        if (hasDynamicRewrite) {
-            fulfilledEntry.hasDynamicRewrite = true;
-        }
+        const fulfilledEntry = (0, _cache.fulfillRouteCacheEntry)(now, pendingEntry, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
         // Populate the known route tree (handles rewrite detection internally).
         // The entry is already in the cache; this just stores it as a pattern
         // if the URL matches the route structure.
-        discoverKnownRoutePart(knownRouteTreeRoot, tree, pathnameParts, 0, fulfilledEntry, now, pathname, search, nextUrl, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite);
+        discoverKnownRoutePart(knownRouteTreeRoot, tree, pathnameParts, 0, fulfilledEntry, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching, hasDynamicRewrite);
         return fulfilledEntry;
     }
     // No pending entry - discoverKnownRoutePart will create one and insert it
     // into the cache, or return an existing pattern if one exists.
-    return discoverKnownRoutePart(knownRouteTreeRoot, tree, pathnameParts, 0, null, now, pathname, search, nextUrl, tree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite);
+    return discoverKnownRoutePart(knownRouteTreeRoot, tree, pathnameParts, 0, null, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching, hasDynamicRewrite);
 }
 /**
  * Bail out of populating the known route tree when discovery detects that the
  * URL doesn't match the route structure (a rewrite). The route entry is still
  * inserted into the cache for direct lookup — we just don't store it as a
  * pattern, since the URL and the tree describe different shapes.
- */ function handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching) {
+ */ function handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching) {
     if (existingEntry !== null) {
         return existingEntry;
     }
-    return (0, _cache.writeRouteIntoCache)(now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+    return (0, _cache.writeRouteIntoCache)(now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
 }
 /**
  * Gets or creates the dynamic child node for a KnownRoutePart. A node can
@@ -167,7 +166,7 @@ function discoverKnownRoute(now, pathname, search, nextUrl, pendingEntry, routeT
  * If a URL/route mismatch is detected (rewrite), we stop building the known
  * route tree but still cache the route entry for direct lookup.
  */ function discoverKnownRoutePart(parentKnownRoutePart, routeTree, pathnameParts, partIndex, existingEntry, // These are passed through unchanged for entry creation at the leaf
-now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite) {
+now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching, hasDynamicRewrite) {
     const segment = routeTree.segment;
     const urlPart = partIndex < pathnameParts.length ? pathnameParts[partIndex] : null;
     let knownRoutePart = parentKnownRoutePart;
@@ -179,7 +178,7 @@ now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted,
             // match, the URL doesn't fit the route shape — the response was
             // rewrite-affected. Bail out.
             if (urlPart === null || urlPart !== segment) {
-                return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+                return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
             }
             if (parentKnownRoutePart.staticChildren === null) {
                 parentKnownRoutePart.staticChildren = new Map();
@@ -206,12 +205,12 @@ now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted,
             // must consume at least one URL part at runtime. If discovery reached
             // this segment with no URL parts left to consume, the URL doesn't fit
             // the route shape — the response was rewrite-affected. Bail out.
-            return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+            return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
         }
         if (staticSiblings !== null && urlPart !== null && staticSiblings.includes(urlPart)) {
             // The route tree says this is a dynamic sibling, but the canonical URL
             // is a known static sibling. This is a mismatch.
-            return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+            return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
         }
         // The param's cache key holds the value parsed from the *rendered*
         // pathname. If the URL part(s) this segment would consume don't equal
@@ -226,7 +225,7 @@ now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted,
                     // Canonicalize the URL part to the same encoded form the server used
                     // for the cache key.
                     if (urlPart !== null && (0, _routeparams.canonicalizeURLPart)(urlPart) !== paramCacheKey) {
-                        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+                        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
                     }
                     break;
                 }
@@ -239,7 +238,7 @@ now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted,
                     // rewrite that appended segments the URL doesn't have.
                     const joinedRemainingParts = pathnameParts.slice(partIndex).map(_routeparams.canonicalizeURLPart).join('/');
                     if (joinedRemainingParts !== paramCacheKey) {
-                        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+                        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
                     }
                     break;
                 }
@@ -260,7 +259,7 @@ now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted,
             // at this level with a different param. Mark the level as conflicted
             // so matching bails out, and don't store a pattern via this branch.
             parentKnownRoutePart.hasConflictingDynamicChildren = true;
-            return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+            return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
         }
         // URL matches route structure. Build the known route tree.
         knownRoutePart = discoverDynamicChild(parentKnownRoutePart, paramName, paramType);
@@ -304,7 +303,7 @@ now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted,
             if (childRouteTree.refreshState !== null) {
                 continue;
             }
-            const result = discoverKnownRoutePart(knownRoutePart, childRouteTree, pathnameParts, nextPartIndex, existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching, hasDynamicRewrite);
+            const result = discoverKnownRoutePart(knownRoutePart, childRouteTree, pathnameParts, nextPartIndex, existingEntry, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching, hasDynamicRewrite);
             // All parallel route branches share the same URL, so they should all
             // reach compatible leaf nodes. We capture any result.
             resultFromChildren = result;
@@ -314,22 +313,22 @@ now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted,
         }
         // Defensive fallback: no children returned a result. This shouldn't happen
         // for valid route trees, but handle it gracefully.
-        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
     }
     // Reached a page node (`__PAGE__` leaf). If there are still URL parts
     // left to consume, the route tree is shorter than the URL, which means
     // the URL doesn't match the route structure (likely a rewrite).
     if (nextPartIndex < pathnameParts.length) {
-        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
+        return handleMismatchDueToRewrite(existingEntry, now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
+    }
+    // Reached a page node: the URL terminates here.
+    if (hasDynamicRewrite) {
+        knownRoutePart.hasDynamicRewrite = true;
     }
-    // Reached a page node. Create/get the route cache entry and store as a
-    // pattern. First, check if there's already a pattern for this route.
+    // Create/get the route cache entry and store as a pattern. First, check if
+    // there's already a pattern for this route.
     const existingPattern = readPattern(now, knownRoutePart);
     if (existingPattern !== null) {
-        // If this route has a dynamic rewrite, mark the existing pattern.
-        if (hasDynamicRewrite) {
-            existingPattern.hasDynamicRewrite = true;
-        }
         return existingPattern;
     }
     // Get or create the entry
@@ -340,10 +339,7 @@ now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted,
         entry = existingEntry;
     } else {
         // Create the entry and insert it into the route cache map.
-        entry = (0, _cache.writeRouteIntoCache)(now, pathname, search, nextUrl, fullTree, metadataVaryPath, couldBeIntercepted, canonicalUrl, supportsPerSegmentPrefetching);
-    }
-    if (hasDynamicRewrite) {
-        entry.hasDynamicRewrite = true;
+        entry = (0, _cache.writeRouteIntoCache)(now, pathname, search, nextUrl, root, couldBeIntercepted, canonicalUrl, renderedSearch, supportsPerSegmentPrefetching);
     }
     // Store as pattern
     knownRoutePart.pattern = entry;
@@ -373,13 +369,20 @@ function matchKnownRoute(now, pathname, search) {
     if (pattern.couldBeIntercepted) {
         return null;
     }
+    // Closed parameters affect whether the route exists, even when none of its
+    // components read them. Resolve the target URL on the server instead of
+    // combining a predicted tree with UI cached for an allowed parameter value.
+    if (pattern.root.tree.prefetchHints & (_approutertypes.PrefetchHint.IsClosedParam | _approutertypes.PrefetchHint.SubtreeHasClosedParams)) {
+        return null;
+    }
     // "Reify" the pattern: clone the template tree with concrete param values.
     // This substitutes resolved params (e.g., slug: "hello") into dynamic
     // segments and recomputes vary paths for correct segment cache keying.
+    const renderedSearch = (0, _routeparams.normalizeRenderedSearch)(search);
     const acc = {
         metadataVaryPath: null
     };
-    const reifiedTree = reifyRouteTree(pattern.tree, resolvedParams, search, null, acc);
+    const reifiedTree = reifyRouteTree(pattern.root.tree, resolvedParams, renderedSearch, null, acc);
     // The metadata tree is a flat page node without the intermediate layout
     // structure. Clone it with the updated metadata vary path collected during
     // the main tree traversal.
@@ -388,30 +391,27 @@ function matchKnownRoute(now, pathname, search) {
         // This shouldn't be reachable for a valid route tree.
         return null;
     }
-    const reifiedMetadata = (0, _cache.createMetadataRouteTree)(metadataVaryPath);
-    // Create a synthetic (predicted) entry and store it as the new pattern.
-    //
-    // Why replace the pattern? We intentionally update the pattern with this
-    // synthetic entry so that if our prediction was wrong (server returns a
-    // different pathname due to dynamic rewrite), the entry gets marked with
-    // hasDynamicRewrite. Future predictions for this route will see the flag
-    // and bail out to server resolution instead of making the same mistake.
+    const reifiedMetadata = (0, _cache.createMetadataRouteTree)(metadataVaryPath, reifiedTree.prefetchHints, null);
+    // Create a synthetic (predicted) entry. It's not inserted into the route
+    // cache; it lives only as long as the task or navigation that read it. It
+    // records the node it was predicted from so that if the prediction turns
+    // out to be wrong (the server renders a different tree due to a dynamic
+    // rewrite), the node can be marked and the shape is never predicted again
+    // (see KnownRoutePart.hasDynamicRewrite).
     const syntheticEntry = {
         canonicalUrl: pathname + search,
         status: _cache.EntryStatus.Fulfilled,
         blockedTasks: null,
-        tree: reifiedTree,
-        metadata: reifiedMetadata,
+        root: (0, _cache.createRootRouteTree)(reifiedTree, reifiedMetadata),
         couldBeIntercepted: pattern.couldBeIntercepted,
         supportsPerSegmentPrefetching: pattern.supportsPerSegmentPrefetching,
-        hasDynamicRewrite: false,
-        renderedSearch: search,
+        predictedFrom: matchedPart,
+        renderedSearch,
         ref: null,
         size: pattern.size,
         staleAt: pattern.staleAt,
         version: pattern.version
     };
-    matchedPart.pattern = syntheticEntry;
     return syntheticEntry;
 }
 /**
@@ -434,9 +434,9 @@ function matchKnownRoute(now, pathname, search) {
     // /blog/featured would incorrectly match /blog/[slug].
     if (part.staticChildren === null) {
         // The only safe match is a direct pattern when no URL parts remain.
-        if (urlPart === null) {
+        if (urlPart === null && !part.hasDynamicRewrite) {
             const pattern = readPattern(now, part);
-            if (pattern !== null && !pattern.hasDynamicRewrite) {
+            if (pattern !== null) {
                 return {
                     part,
                     pattern
@@ -477,12 +477,14 @@ function matchKnownRoute(now, pathname, search) {
         const dynamicPart = part.dynamicChild;
         const paramName = part.dynamicChildParamName;
         const paramType = part.dynamicChildParamType;
-        const dynamicPattern = readPattern(now, dynamicPart);
+        // Catch-alls terminate at the dynamic child, so a dynamic rewrite marked
+        // there rules out predicting any URL that would end in it.
+        const dynamicPattern = dynamicPart.hasDynamicRewrite ? null : readPattern(now, dynamicPart);
         switch(paramType){
             case 'c':
                 // Required catch-all [...param]: consumes 1+ URL parts
-                if (dynamicPattern !== null && !dynamicPattern.hasDynamicRewrite && urlPart !== null) {
-                    resolvedParams.set(paramName, pathnameParts.slice(partIndex).join('/'));
+                if (dynamicPattern !== null && urlPart !== null) {
+                    resolvedParams.set(paramName, pathnameParts.slice(partIndex).map(_routeparams.canonicalizeURLPart).join('/'));
                     return {
                         part: dynamicPart,
                         pattern: dynamicPattern
@@ -492,9 +494,9 @@ function matchKnownRoute(now, pathname, search) {
             case 'oc':
                 {
                     // Optional catch-all [[...param]]: consumes 0+ URL parts
-                    if (dynamicPattern !== null && !dynamicPattern.hasDynamicRewrite) {
+                    if (dynamicPattern !== null) {
                         if (urlPart !== null) {
-                            resolvedParams.set(paramName, pathnameParts.slice(partIndex).join('/'));
+                            resolvedParams.set(paramName, pathnameParts.slice(partIndex).map(_routeparams.canonicalizeURLPart).join('/'));
                             return {
                                 part: dynamicPart,
                                 pattern: dynamicPattern
@@ -502,8 +504,8 @@ function matchKnownRoute(now, pathname, search) {
                         }
                         // urlPart is null - can match with zero parts, but a direct pattern
                         // (e.g., page.tsx alongside [[...param]]) takes precedence.
-                        const directPattern = readPattern(now, part);
-                        if (directPattern === null || directPattern.hasDynamicRewrite) {
+                        const directPattern = part.hasDynamicRewrite ? null : readPattern(now, part);
+                        if (directPattern === null) {
                             resolvedParams.set(paramName, '');
                             return {
                                 part: dynamicPart,
@@ -518,7 +520,7 @@ function matchKnownRoute(now, pathname, search) {
                 // Unlike catch-all which terminates here, regular dynamic must
                 // continue recursing to find the leaf pattern.
                 if (urlPart !== null) {
-                    resolvedParams.set(paramName, urlPart);
+                    resolvedParams.set(paramName, (0, _routeparams.canonicalizeURLPart)(urlPart));
                     return matchKnownRoutePart(now, dynamicPart, pathnameParts, partIndex + 1, resolvedParams);
                 }
                 break;
@@ -540,9 +542,9 @@ function matchKnownRoute(now, pathname, search) {
     }
     // No children matched. If we've consumed all URL parts, check for a direct
     // pattern at this node (the route terminates here).
-    if (urlPart === null) {
+    if (urlPart === null && !part.hasDynamicRewrite) {
         const pattern = readPattern(now, part);
-        if (pattern !== null && !pattern.hasDynamicRewrite) {
+        if (pattern !== null) {
             return {
                 part,
                 pattern
@@ -603,37 +605,30 @@ function matchKnownRoute(now, pathname, search) {
             newSlots.set(key, reifyRouteTree(childPattern, resolvedParams, search, partialVaryPath, acc));
         }
     }
-    if (pattern.isPage) {
+    let newVaryPath;
+    if (originalSegment === _segment.PAGE_SEGMENT_KEY) {
         // Page segment: finalize with search params
-        const newVaryPath = (0, _varypath.finalizePageVaryPath)(pattern.requestKey, search, partialVaryPath);
-        // Collect metadata vary path (first page wins, same as original algorithm)
+        newVaryPath = (0, _varypath.finalizeVaryPath)(pattern.requestKey, search, partialVaryPath);
+        // Collect metadata vary path (first page wins; see getHeadRequestKey)
         if (acc.metadataVaryPath === null) {
-            acc.metadataVaryPath = (0, _varypath.finalizeMetadataVaryPath)(pattern.requestKey, search, partialVaryPath);
+            acc.metadataVaryPath = (0, _varypath.finalizeVaryPath)((0, _cache.getHeadRequestKey)(pattern.requestKey), search, partialVaryPath);
         }
-        return {
-            requestKey: pattern.requestKey,
-            segment: newSegment,
-            shellVaryPath: (0, _varypath.getShellSegmentVaryPath)(newVaryPath),
-            refreshState: pattern.refreshState,
-            varyPath: newVaryPath,
-            isPage: true,
-            slots: newSlots,
-            prefetchHints: pattern.prefetchHints
-        };
     } else {
         // Layout segment: finalize without search params
-        const newVaryPath = (0, _varypath.finalizeLayoutVaryPath)(pattern.requestKey, partialVaryPath);
-        return {
-            requestKey: pattern.requestKey,
-            segment: newSegment,
-            shellVaryPath: (0, _varypath.getShellSegmentVaryPath)(newVaryPath),
-            refreshState: pattern.refreshState,
-            varyPath: newVaryPath,
-            isPage: false,
-            slots: newSlots,
-            prefetchHints: pattern.prefetchHints
-        };
+        newVaryPath = (0, _varypath.finalizeVaryPath)(pattern.requestKey, null, partialVaryPath);
     }
+    return {
+        requestKey: pattern.requestKey,
+        segment: newSegment,
+        shellVaryPath: (0, _varypath.getShellSegmentVaryPath)(newVaryPath),
+        refreshState: pattern.refreshState,
+        // Route cache patterns never carry seed data (see
+        // stripDataFromRouteTree), so neither do trees reified from them.
+        data: null,
+        varyPath: newVaryPath,
+        slots: newSlots,
+        prefetchHints: pattern.prefetchHints
+    };
 }
 function resetKnownRoutes() {
     knownRouteTreeRoot = createEmptyPart();