@jsenv/navi 0.16.2 → 0.16.4

package/dist/jsenv_navi.js

@@ -7522,7 +7522,6 @@ setBaseUrl(
 // Pattern registry for building relationships before routes are created
 const patternRegistry = new Map(); // pattern -> patternData
 const patternRelationships = new Map(); // pattern -> relationships
-let patternsRegistered = false;
 
 // Function to detect signals in route patterns and connect them
 const detectSignals = (routePattern) => {
@@ -8433,8 +8432,6 @@ const setupPatterns = (patternDefinitions) => {
       originalPattern: currentPattern,
     });
   }
-
-  patternsRegistered = true;
 };
 
 /**
@@ -8444,25 +8441,12 @@ const getPatternData = (urlPatternRaw) => {
   return patternRegistry.get(urlPatternRaw);
 };
 
-/**
- * Get pattern relationships for route creation
- */
-const getPatternRelationships = () => {
-  if (!patternsRegistered) {
-    throw new Error(
-      "Patterns must be registered before accessing relationships",
-    );
-  }
-  return patternRelationships;
-};
-
 /**
  * Clear all registered patterns
  */
 const clearPatterns = () => {
   patternRegistry.clear();
   patternRelationships.clear();
-  patternsRegistered = false;
 };
 
 const resolveRouteUrl = (relativeUrl) => {
@@ -8487,6 +8471,22 @@ const resolveRouteUrl = (relativeUrl) => {
  */
 
 
+// Helper to check if one route pattern is a parent of another
+const isParentRoute = (parentPattern, childPattern) => {
+  // Normalize patterns by removing query parts and trailing slashes
+  const normalizePath = (pattern) => {
+    const pathPart = pattern.split("?")[0];
+    return pathPart.replace(/\/$/, "") || "/";
+  };
+
+  const parentPath = normalizePath(parentPattern);
+  const childPath = normalizePath(childPattern);
+
+  // Parent route is a parent if child path starts with parent path
+  // and child has additional segments
+  return childPath.startsWith(parentPath) && childPath !== parentPath;
+};
+
 // Controls what happens to actions when their route stops matching:
 // 'abort' - Cancel the action immediately when route stops matching
 // 'keep-loading' - Allow action to continue running after route stops matching
@@ -8679,41 +8679,6 @@ const getRoutePrivateProperties = (route) => {
   return routePrivatePropertiesMap.get(route);
 };
 
-/**
- * Get child routes of a given route
- */
-const getRouteChildren = (route) => {
-  const children = [];
-  const routePrivateProperties = getRoutePrivateProperties(route);
-  if (!routePrivateProperties) {
-    return children;
-  }
-
-  const { originalPattern } = routePrivateProperties;
-  const relationships = getPatternRelationships();
-  const relationshipData = relationships.get(originalPattern);
-
-  if (!relationshipData || !relationshipData.children) {
-    return children;
-  }
-
-  // Find child routes
-  for (const childPattern of relationshipData.children) {
-    for (const otherRoute of routeSet) {
-      const otherRoutePrivateProperties = getRoutePrivateProperties(otherRoute);
-      if (
-        otherRoutePrivateProperties &&
-        otherRoutePrivateProperties.originalPattern === childPattern
-      ) {
-        children.push(otherRoute);
-        break;
-      }
-    }
-  }
-
-  return children;
-};
-
 const registerRoute = (routePattern) => {
   const urlPatternRaw = routePattern.originalPattern;
   const patternData = getPatternData(urlPatternRaw);
@@ -8807,21 +8772,35 @@ const registerRoute = (routePattern) => {
       );
     }
 
-    // URL -> Signal synchronization
+    // URL -> Signal synchronization with parent-child route hierarchy checking
     effect(() => {
       const matching = matchingSignal.value;
       const params = rawParamsSignal.value;
       const urlParamValue = params[paramName];
 
-      if (!matching) {
-        return;
-      }
-      if (debug) {
-        console.debug(
-          `[stateSignal] URL -> Signal: ${paramName}=${urlParamValue}`,
-        );
+      if (matching) {
+        // When route matches, sync signal with URL parameter value
+        // This ensures URL is the source of truth
+        stateSignal.value = urlParamValue;
+      } else {
+        // When route doesn't match, check if we're navigating to a parent route
+        const currentRoutePattern = routePattern.cleanPattern;
+        const parentRouteMatching = Array.from(routeSet).find((otherRoute) => {
+          if (otherRoute === route || !otherRoute.matching) return false;
+
+          const otherRouteProperties = getRoutePrivateProperties(otherRoute);
+          const otherPattern = otherRouteProperties.routePattern.cleanPattern;
+
+          // Check if the other route is a parent of this route
+          return isParentRoute(otherPattern, currentRoutePattern);
+        });
+
+        if (parentRouteMatching) {
+          // We're navigating to a parent route - clear this signal to reflect the hierarchy
+          const defaultValue = routePattern.parameterDefaults?.[paramName];
+          stateSignal.value = defaultValue;
+        }
       }
-      stateSignal.value = urlParamValue;
     });
 
     // Signal -> URL synchronization
@@ -8866,38 +8845,48 @@ const registerRoute = (routePattern) => {
       return null;
     }
 
-    // Walk down the hierarchy updating action params and tracking most specific route
-    let currentRoute = route;
-    let mostSpecificRoute;
+    // Find all matching routes and update their actions, then delegate to most specific
+    const allMatchingRoutes = Array.from(routeSet).filter((r) => r.matching);
 
-    while (currentRoute) {
-      if (!currentRoute.matching) {
-        break;
-      }
-
-      // Update the most specific route as we go
-      mostSpecificRoute = currentRoute;
-      // Update action params
-      if (currentRoute.action) {
-        const currentRoutePrivateProperties =
-          getRoutePrivateProperties(currentRoute);
-        if (currentRoutePrivateProperties) {
-          const { routePattern: currentRoutePattern } =
-            currentRoutePrivateProperties;
-          const currentResolvedParams = currentRoutePattern.resolveParams();
+    // Update action params on all matching routes
+    for (const matchingRoute of allMatchingRoutes) {
+      if (matchingRoute.action) {
+        const matchingRoutePrivateProperties =
+          getRoutePrivateProperties(matchingRoute);
+        if (matchingRoutePrivateProperties) {
+          const { routePattern: matchingRoutePattern } =
+            matchingRoutePrivateProperties;
+          const currentResolvedParams = matchingRoutePattern.resolveParams();
           const updatedActionParams = {
             ...currentResolvedParams,
             ...newParams,
           };
-          currentRoute.action.replaceParams(updatedActionParams);
+          matchingRoute.action.replaceParams(updatedActionParams);
         }
       }
+    }
 
-      // Find the first matching child to continue down the hierarchy
-      const children = getRouteChildren(currentRoute);
-      currentRoute = children.find((child) => child.matching) || null;
+    // Find the most specific route (the one with the longest pattern path)
+    let mostSpecificRoute = route;
+    let maxSegments = route.pattern.split("/").filter((s) => s !== "").length;
+
+    for (const matchingRoute of allMatchingRoutes) {
+      const segments = matchingRoute.pattern
+        .split("/")
+        .filter((s) => s !== "").length;
+      if (segments > maxSegments) {
+        maxSegments = segments;
+        mostSpecificRoute = matchingRoute;
+      }
     }
-    return mostSpecificRoute.redirectTo(newParams);
+
+    // If we found a more specific route, delegate to it; otherwise handle it ourselves
+    if (mostSpecificRoute !== route) {
+      return mostSpecificRoute.redirectTo(newParams);
+    }
+
+    // This route is the most specific, handle the redirect ourselves
+    return route.redirectTo(newParams);
   };
   route.buildRelativeUrl = (params) => {
     // buildMostPreciseUrl now handles parameter resolution internally