@jsenv/navi 0.16.28 → 0.16.30

package/dist/jsenv_navi.js

@@ -7812,7 +7812,6 @@ const createRoutePattern = (pattern) => {
 
   const applyOn = (url) => {
     const result = matchUrl(parsedPattern, url, {
-      parameterDefaults,
       baseUrl,
       connections,
       patternObj: patternObject,
@@ -7841,6 +7840,14 @@ const createRoutePattern = (pattern) => {
       }
     }
 
+    // Add static defaults for parameters that are still missing
+    // This handles cases where the URL doesn't contain the parameter and there's no signal value
+    for (const [paramName, defaultValue] of parameterDefaults) {
+      if (!(paramName in resolvedParams)) {
+        resolvedParams[paramName] = defaultValue;
+      }
+    }
+
     // Include active non-default parameters from child routes for URL optimization
     // Only include from child routes that would actually match the current parameters
     const childPatternObjs = patternObject.children || [];
@@ -9584,7 +9591,7 @@ const checkIfLiteralCanBeOptionalWithPatternObj = (
 const matchUrl = (
   parsedPattern,
   url,
-  { parameterDefaults, baseUrl, connections = [], patternObj = null },
+  { baseUrl, connections = [], patternObj = null },
 ) => {
   // Parse the URL
   const urlObj = new URL(url, baseUrl);
@@ -9668,23 +9675,15 @@ const matchUrl = (
       if (urlSegmentIndex >= urlSegments.length) {
         // No URL segment for this parameter
         if (patternSeg.optional) {
-          // Optional parameter - use default if available
-          const defaultValue = parameterDefaults.get(patternSeg.name);
-          if (defaultValue !== undefined) {
-            params[patternSeg.name] = defaultValue;
-          }
+          // Optional parameter - don't add default here, let resolveParams handle it
           continue;
         }
         // Required parameter missing - but check if we can use trailing slash logic
         // If this is the last segment and we have a trailing slash difference, it might still match
         const isLastSegment = i === parsedPattern.segments.length - 1;
         if (isLastSegment && patternHasTrailingSlash && !urlHasTrailingSlash) {
-          // Pattern expects trailing slash segment, URL doesn't have it
-          const defaultValue = parameterDefaults.get(patternSeg.name);
-          if (defaultValue !== undefined) {
-            params[patternSeg.name] = defaultValue;
-            continue;
-          }
+          // Pattern expects trailing slash segment, URL doesn't have it - allow missing optional param
+          continue;
         }
         return null; // Required parameter missing
       }
@@ -9716,12 +9715,8 @@ const matchUrl = (
   const searchParams = extractSearchParams(urlObj, connections);
   Object.assign(params, searchParams);
 
-  // Apply remaining parameter defaults for unmatched parameters
-  for (const [paramName, defaultValue] of parameterDefaults) {
-    if (!(paramName in params)) {
-      params[paramName] = defaultValue;
-    }
-  }
+  // Don't add defaults here - rawParams should only contain what's in the URL
+  // Defaults are handled by resolveParams() to create the final merged parameters
 
   return params;
 };
@@ -10373,19 +10368,7 @@ const updateRoutes = (
         const params = routePrivateProperties.rawParamsSignal.value;
         const urlParamValue = params[paramName];
 
-        if (newMatching) {
-          // When route matches, sync signal with URL parameter value
-          // This ensures URL is the source of truth
-          const currentValue = stateSignal.peek();
-          if (currentValue !== urlParamValue) {
-            if (debug) {
-              console.debug(
-                `[route] Route matching: setting ${paramName} signal to URL value: ${urlParamValue}`,
-              );
-            }
-            stateSignal.value = urlParamValue;
-          }
-        } else {
+        if (!newMatching) {
           // Route doesn't match - check if any matching route extracts this parameter
           let parameterExtractedByMatchingRoute = false;
           let matchingRouteInSameFamily = false;
@@ -10488,7 +10471,39 @@ const updateRoutes = (
               );
             }
           }
+          continue;
         }
+
+        // URL -> Signal sync: When route matches, ensure signal matches URL state
+        // URL is the source of truth for explicit parameters
+        const value = stateSignal.peek();
+        if (urlParamValue === undefined) {
+          // No URL parameter - reset signal to its current default value
+          // (handles both static fallback and dynamic default cases)
+          const defaultValue = options.getDefaultValue();
+          if (value === defaultValue) {
+            // Signal already has correct default value, no sync needed
+            continue;
+          }
+          if (debug) {
+            console.debug(
+              `[route] URL->Signal: ${paramName} not in URL, reset signal to default (${defaultValue})`,
+            );
+          }
+          stateSignal.value = defaultValue;
+          continue;
+        }
+        if (urlParamValue === value) {
+          // Values already match, no sync needed
+          continue;
+        }
+        if (debug) {
+          console.debug(
+            `[route] URL->Signal: ${paramName}=${urlParamValue} in url, sync signal with url`,
+          );
+        }
+        stateSignal.value = urlParamValue;
+        continue;
       }
     }
   });
@@ -10687,28 +10702,49 @@ const registerRoute = (routePattern) => {
 
     if (debug) {
       console.debug(
-        `[route] connecting param "${paramName}" to signal`,
+        `[route] connecting url param "${paramName}" to signal`,
         stateSignal,
       );
     }
 
     // URL -> Signal synchronization now handled in updateRoutes() to eliminate circular dependency
 
-    // Signal -> URL synchronization
+    // Signal -> URL sync: When signal changes, update URL to reflect meaningful state
+    // Only sync non-default values to keep URLs clean (static fallbacks stay invisible)
     effect(() => {
       const value = stateSignal.value;
       const params = rawParamsSignal.value;
       const urlParamValue = params[paramName];
       const matching = matchingSignal.value;
 
-      if (!matching || value === urlParamValue) {
+      if (!matching) {
+        // Route not matching, no URL sync needed
+        return;
+      }
+      if (urlParamValue === undefined) {
+        // No URL parameter exists - check if signal has meaningful value to add
+        const defaultValue = options.getDefaultValue();
+        if (value === defaultValue) {
+          // Signal using default value, keep URL clean (no parameter needed)
+          return;
+        }
+        if (debug) {
+          console.debug(
+            `[route] Signal->URL: ${paramName} adding custom value ${value} to URL (default: ${defaultValue})`,
+          );
+        }
+        route.replaceParams({ [paramName]: value });
+        return;
+      }
+      if (value === urlParamValue) {
+        // Values already match, no sync needed
         return;
       }
-
       if (debug) {
-        console.debug(`[stateSignal] Signal -> URL: ${paramName}=${value}`);
+        console.debug(
+          `[route] Signal->URL: ${paramName} updating URL ${urlParamValue} -> ${value}`,
+        );
       }
-
       route.replaceParams({ [paramName]: value });
     });
   }