@jsenv/navi 0.16.23 → 0.16.25

package/dist/jsenv_navi.js

@@ -7723,7 +7723,11 @@ const createRoutePattern = (pattern) => {
     }
   }
 
-  const parsedPattern = parsePattern(cleanPattern, parameterDefaults);
+  const parsedPattern = parsePattern(
+    cleanPattern,
+    parameterDefaults,
+    connections,
+  );
 
   // Create signalSet to track all signals this pattern depends on
   const signalSet = new Set();
@@ -9334,7 +9338,11 @@ const canParameterReachChildRoute = (
 /**
  * Parse a route pattern string into structured segments
  */
-const parsePattern = (pattern, parameterDefaults = new Map()) => {
+const parsePattern = (
+  pattern,
+  parameterDefaults = new Map(),
+  connections = [],
+) => {
   // Handle root route
   if (pattern === "/") {
     return {
@@ -9403,7 +9411,27 @@ const parsePattern = (pattern, parameterDefaults = new Map()) => {
     if (seg.startsWith(":")) {
       // Parameter segment
       const paramName = seg.slice(1).replace("?", ""); // Remove : and optional ?
-      const isOptional = seg.endsWith("?") || parameterDefaults.has(paramName);
+
+      // Check if parameter should be optional:
+      // 1. Explicitly marked with ?
+      // 2. Has a default value
+      // 3. Connected signal has undefined value and no explicit default (allows /map to match /map/:panel)
+      let isOptional = seg.endsWith("?") || parameterDefaults.has(paramName);
+
+      if (!isOptional) {
+        // Check if connected signal has undefined value (making parameter optional for index routes)
+        const connection = connections.find(
+          (conn) => conn.paramName === paramName,
+        );
+        if (
+          connection &&
+          connection.signal &&
+          connection.signal.value === undefined &&
+          !parameterDefaults.has(paramName)
+        ) {
+          isOptional = true;
+        }
+      }
 
       return {
         type: "param",
@@ -9597,14 +9625,18 @@ const matchUrl = (
   // Check for remaining URL segments
   // Patterns with trailing slashes can match additional URL segments (like wildcards)
   // Patterns without trailing slashes should match exactly (unless they're wildcards)
+  // BUT: if pattern has children, it can also match additional segments (hierarchical matching)
+  const hasChildren =
+    patternObj && patternObj.children && patternObj.children.length > 0;
   if (
     !parsedPattern.wildcard &&
     !parsedPattern.trailingSlash &&
+    !hasChildren &&
     urlSegmentIndex < urlSegments.length
   ) {
-    return null; // Pattern without trailing slash should not match extra segments
+    return null; // Pattern without trailing slash/wildcard/children should not match extra segments
   }
-  // If pattern has trailing slash or wildcard, allow extra segments (no additional check needed)
+  // If pattern has trailing slash, wildcard, or children, allow extra segments
 
   // Add search parameters
   const searchParams = extractSearchParams(urlObj, connections);
@@ -10262,77 +10294,107 @@ const updateRoutes = (
           }
           stateSignal.value = urlParamValue;
         } else {
-          // When route doesn't match, check if we're navigating to a parent route
-          let parentRouteMatching = false;
+          // Route doesn't match - check if any matching route extracts this parameter
+          let parameterExtractedByMatchingRoute = false;
+          let matchingRouteInSameFamily = false;
+
           for (const otherRoute of routeSet) {
             if (otherRoute === route || !otherRoute.matching) {
               continue;
             }
             const otherRouteProperties = getRoutePrivateProperties(otherRoute);
+            const otherParams = otherRouteProperties.rawParamsSignal.value;
+
+            // Check if this matching route extracts the parameter
+            if (paramName in otherParams) {
+              parameterExtractedByMatchingRoute = true;
+            }
+
+            // Check if this matching route is in the same family using parent-child relationships
+            const thisPatternObj = routePattern;
             const otherPatternObj = otherRouteProperties.routePattern;
 
-            // Check if the other route pattern is a parent of this route pattern
-            // Using the built relationships in the pattern objects
-            let currentParent = routePattern.parent;
-            let foundParent = false;
+            // Routes are in same family if they share a hierarchical relationship:
+            // 1. One is parent/ancestor of the other
+            // 2. They share a common parent/ancestor
+            let inSameFamily = false;
+
+            // Check if other route is ancestor of this route
+            let currentParent = thisPatternObj.parent;
             while (currentParent) {
               if (currentParent === otherPatternObj) {
-                foundParent = true;
+                inSameFamily = true;
                 break;
               }
               currentParent = currentParent.parent;
             }
 
-            if (!foundParent) {
-              continue;
+            // Check if this route is ancestor of other route
+            if (!inSameFamily) {
+              currentParent = otherPatternObj.parent;
+              while (currentParent) {
+                if (currentParent === thisPatternObj) {
+                  inSameFamily = true;
+                  break;
+                }
+                currentParent = currentParent.parent;
+              }
             }
 
-            // Found a parent route that's matching, but check if there's a more specific
-            // sibling route also matching (indicating sibling navigation, not parent navigation)
-            let hasMatchingSibling = false;
-            for (const siblingCandidateRoute of routeSet) {
-              if (
-                siblingCandidateRoute === route ||
-                siblingCandidateRoute === otherRoute ||
-                !siblingCandidateRoute.matching
-              ) {
-                continue;
+            // Check if they share a common parent (siblings or cousins)
+            if (!inSameFamily) {
+              const thisAncestors = new Set();
+              currentParent = thisPatternObj.parent;
+              while (currentParent) {
+                thisAncestors.add(currentParent);
+                currentParent = currentParent.parent;
               }
 
-              const siblingProperties = getRoutePrivateProperties(
-                siblingCandidateRoute,
-              );
-              const siblingPatternObj = siblingProperties.routePattern;
-
-              // Check if this is a sibling (shares the same parent)
-              if (siblingPatternObj.parent === currentParent) {
-                hasMatchingSibling = true;
-                break;
+              currentParent = otherPatternObj.parent;
+              while (currentParent) {
+                if (thisAncestors.has(currentParent)) {
+                  inSameFamily = true;
+                  break;
+                }
+                currentParent = currentParent.parent;
               }
             }
 
-            // Only treat as parent navigation if no sibling is matching
-            if (!hasMatchingSibling) {
-              parentRouteMatching = true;
-              break; // Found the parent route, no need to check other routes
+            if (inSameFamily) {
+              matchingRouteInSameFamily = true;
             }
           }
 
-          if (parentRouteMatching) {
-            // We're navigating to a parent route - clear this signal to reflect the hierarchy
+          // Only reset signal if:
+          // 1. We're navigating within the same route family (not to completely unrelated routes)
+          // 2. AND no matching route extracts this parameter from URL
+          // 3. AND parameter has no default value (making it truly optional)
+          if (matchingRouteInSameFamily && !parameterExtractedByMatchingRoute) {
             const defaultValue = routePattern.parameterDefaults?.get(paramName);
-            if (debug) {
+            if (defaultValue === undefined) {
+              // Parameter is not extracted within same family and has no default - reset it
+              if (debug) {
+                console.debug(
+                  `[route] Same family navigation, ${paramName} not extracted and has no default: resetting signal`,
+                );
+              }
+              stateSignal.value = undefined;
+            } else if (debug) {
+              // Parameter has a default value - preserve current signal value
               console.debug(
-                `[route] Parent route ${parentRouteMatching} matching: clearing ${paramName} signal to default: ${defaultValue}`,
+                `[route] Parameter ${paramName} has default value ${defaultValue}: preserving signal value: ${stateSignal.value}`,
               );
             }
-            stateSignal.value = defaultValue;
           } else if (debug) {
-            // We're navigating to a different route family - preserve signal for future URL building
-            // Keep current signal value unchanged
-            console.debug(
-              `[route] Different route family: preserving ${paramName} signal value: ${stateSignal.value}`,
-            );
+            if (!matchingRouteInSameFamily) {
+              console.debug(
+                `[route] Different route family: preserving ${paramName} signal value: ${stateSignal.value}`,
+              );
+            } else {
+              console.debug(
+                `[route] Parameter ${paramName} extracted by matching route: preserving signal value: ${stateSignal.value}`,
+              );
+            }
           }
         }
       }
@@ -10514,10 +10576,20 @@ const registerRoute = (routePattern) => {
   const rawParamsSignal = signal(ROUTE_NOT_MATCHING_PARAMS);
   const paramsSignal = computed(() => {
     const rawParams = rawParamsSignal.value;
-    // Pattern system handles parameter defaults, routes just work with raw params
-    return rawParams || {};
+    const resolvedParams = routePattern.resolveParams(rawParams);
+    return resolvedParams;
   });
   const visitedSignal = signal(false);
+
+  // Keep route.params synchronized with computed paramsSignal
+  // This ensures route.params includes parameters from child routes
+  effect(() => {
+    const computedParams = paramsSignal.value;
+    if (route.params !== computedParams) {
+      route.params = computedParams;
+    }
+  });
+
   for (const { signal: stateSignal, paramName, options = {} } of connections) {
     const { debug } = options;