@jsenv/navi 0.16.1 → 0.16.3

package/dist/jsenv_navi.js

@@ -7528,15 +7528,24 @@ const detectSignals = (routePattern) => {
   const signalConnections = [];
   let updatedPattern = routePattern;
 
-  // Look for signals in the new syntax: :paramName={navi_state_signal:id} or ?paramName={navi_state_signal:id} or &paramName={navi_state_signal:id}
-  // Using curly braces to avoid conflicts with underscores in signal IDs
-  const signalParamRegex = /([?:&])(\w+)=(\{navi_state_signal:[^}]+\})/g;
+  // Look for signals in two formats:
+  // 1. Expected format: :paramName={navi_state_signal:id} or ?paramName={navi_state_signal:id} or &paramName={navi_state_signal:id}
+  // 2. Typoe format (missing = sign): &paramName{navi_state_signal:id}
+  const signalParamRegex = /([?:&])(\w+)(=)?(\{navi_state_signal:[^}]+\})/g;
   let match;
 
   while ((match = signalParamRegex.exec(routePattern)) !== null) {
-    const [fullMatch, prefix, paramName, signalString] = match;
+    const [fullMatch, prefix, paramName, equalSign, signalString] = match;
 
-    // Extract the signal ID from the new format: {navi_state_signal:id}
+    // Emit warning if equal sign is missing
+    if (!equalSign) {
+      console.warn(
+        `[detectSignals] Missing '=' sign in route pattern: "${prefix}${paramName}${signalString}". ` +
+          `Consider using "${prefix}${paramName}=${signalString}" for better clarity.`,
+      );
+    }
+
+    // Extract the signal ID from the format: {navi_state_signal:id}
     const signalIdMatch = signalString.match(/\{navi_state_signal:([^}]+)\}/);
     if (!signalIdMatch) {
       console.warn(
@@ -7553,13 +7562,10 @@ const detectSignals = (routePattern) => {
 
       let replacement;
       if (prefix === ":") {
-        // Path parameter: :section=__jsenv_signal_1__ becomes :section
+        // Path parameter: :section={navi_state_signal:...} becomes :section
         replacement = `${prefix}${paramName}`;
-      } else if (prefix === "?") {
-        // First search parameter: ?city=__jsenv_signal_1__ becomes ?city
-        replacement = `${prefix}${paramName}`;
-      } else if (prefix === "&") {
-        // Additional search parameter: &lon=__jsenv_signal_1__ becomes &lon
+      } else if (prefix === "?" || prefix === "&") {
+        // Query parameter: ?city={navi_state_signal:...} or &lon{navi_state_signal:...} becomes ?city or &lon
         replacement = `${prefix}${paramName}`;
       }
       updatedPattern = updatedPattern.replace(fullMatch, replacement);
@@ -7606,6 +7612,7 @@ const createRoutePattern = (pattern) => {
     const result = matchUrl(parsedPattern, url, {
       parameterDefaults,
       baseUrl,
+      connections,
     });
 
     return result;
@@ -7985,7 +7992,11 @@ const checkIfLiteralCanBeOptional = (literalValue, patternRegistry) => {
 /**
  * Match a URL against a parsed pattern
  */
-const matchUrl = (parsedPattern, url, { parameterDefaults, baseUrl }) => {
+const matchUrl = (
+  parsedPattern,
+  url,
+  { parameterDefaults, baseUrl, connections = [] },
+) => {
   // Parse the URL
   const urlObj = new URL(url, baseUrl);
   let pathname = urlObj.pathname;
@@ -8007,14 +8018,14 @@ const matchUrl = (parsedPattern, url, { parameterDefaults, baseUrl }) => {
   // OR when URL exactly matches baseUrl (treating baseUrl as root)
   if (parsedPattern.segments.length === 0) {
     if (pathname === "/" || pathname === "") {
-      return extractSearchParams(urlObj);
+      return extractSearchParams(urlObj, connections);
     }
 
     // Special case: if URL exactly matches baseUrl, treat as root route
     if (baseUrl) {
       const baseUrlObj = new URL(baseUrl);
       if (originalPathname === baseUrlObj.pathname) {
-        return extractSearchParams(urlObj);
+        return extractSearchParams(urlObj, connections);
       }
     }
 
@@ -8109,7 +8120,7 @@ const matchUrl = (parsedPattern, url, { parameterDefaults, baseUrl }) => {
   // If pattern has trailing slash or wildcard, allow extra segments (no additional check needed)
 
   // Add search parameters
-  const searchParams = extractSearchParams(urlObj);
+  const searchParams = extractSearchParams(urlObj, connections);
   Object.assign(params, searchParams);
 
   // Apply remaining parameter defaults for unmatched parameters
@@ -8125,10 +8136,29 @@ const matchUrl = (parsedPattern, url, { parameterDefaults, baseUrl }) => {
 /**
  * Extract search parameters from URL
  */
-const extractSearchParams = (urlObj) => {
+const extractSearchParams = (urlObj, connections = []) => {
   const params = {};
+
+  // Create a map for quick signal type lookup
+  const signalTypes = new Map();
+  for (const connection of connections) {
+    if (connection.options.type) {
+      signalTypes.set(connection.paramName, connection.options.type);
+    }
+  }
+
   for (const [key, value] of urlObj.searchParams) {
-    params[key] = value;
+    const signalType = signalTypes.get(key);
+
+    // Cast value based on signal type
+    if (signalType === "number" || signalType === "float") {
+      const numberValue = Number(value);
+      params[key] = isNaN(numberValue) ? value : numberValue;
+    } else if (signalType === "boolean") {
+      params[key] = value === "true" || value === "1";
+    } else {
+      params[key] = value;
+    }
   }
   return params;
 };
@@ -8784,12 +8814,48 @@ const registerRoute = (routePattern) => {
       );
       return null;
     }
-    if (route.action) {
-      // For action: merge with resolved params (includes defaults) so action gets complete params
-      const currentResolvedParams = routePattern.resolveParams();
-      const updatedActionParams = { ...currentResolvedParams, ...newParams };
-      route.action.replaceParams(updatedActionParams);
+
+    // Find all matching routes and update their actions, then delegate to most specific
+    const allMatchingRoutes = Array.from(routeSet).filter((r) => r.matching);
+
+    // 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,
+          };
+          matchingRoute.action.replaceParams(updatedActionParams);
+        }
+      }
     }
+
+    // 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;
+      }
+    }
+
+    // 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) => {