@devp0nt/route0 1.0.0-next.80 → 1.0.0-next.82

package/dist/esm/index.js

@@ -1,12 +1,6 @@
 import { parse as parseSearchQuery, stringify as stringifySearchQuery } from "@devp0nt/flat0";
 const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const collapseDuplicateSlashes = (value) => value.replace(/\/{2,}/g, "/");
-const normalizeSlashPath = (value) => {
-  const collapsed = collapseDuplicateSlashes(value);
-  if (collapsed === "" || collapsed === "/") return "/";
-  const withLeadingSlash = collapsed.startsWith("/") ? collapsed : `/${collapsed}`;
-  return withLeadingSlash.length > 1 && withLeadingSlash.endsWith("/") ? withLeadingSlash.slice(0, -1) : withLeadingSlash;
-};
 class Route0 {
   definition;
   params;
@@ -26,16 +20,16 @@ class Route0 {
   _captureKeys;
   _normalizedDefinition;
   _definitionParts;
+  static normalizeSlash = (value) => {
+    const collapsed = collapseDuplicateSlashes(value);
+    if (collapsed === "" || collapsed === "/") return "/";
+    const withLeadingSlash = collapsed.startsWith("/") ? collapsed : `/${collapsed}`;
+    return withLeadingSlash.length > 1 && withLeadingSlash.endsWith("/") ? withLeadingSlash.slice(0, -1) : withLeadingSlash;
+  };
   static _getRouteSegments(definition) {
     if (definition === "" || definition === "/") return [];
     return definition.split("/").filter(Boolean);
   }
-  static _normalizeRouteDefinition(definition) {
-    return normalizeSlashPath(definition);
-  }
-  static _normalizePathname(pathname) {
-    return Route0._normalizeRouteDefinition(pathname);
-  }
   static _validateRouteDefinition(definition) {
     const segments = Route0._getRouteSegments(definition);
     const wildcardSegments = segments.filter((segment) => segment.includes("*"));
@@ -66,7 +60,7 @@ class Route0 {
     this._origin = origin;
   }
   constructor(definition, config = {}) {
-    const normalizedDefinition = Route0._normalizeRouteDefinition(definition);
+    const normalizedDefinition = Route0.normalizeSlash(definition);
     Route0._validateRouteDefinition(normalizedDefinition);
     this.definition = normalizedDefinition;
     this.params = this.pathParamsDefinition;
@@ -98,7 +92,7 @@ class Route0 {
       return definition.clone(config);
     }
     const original = new Route0(
-      Route0._normalizeRouteDefinition(definition),
+      Route0.normalizeSlash(definition),
       config
     );
     return original._callable;
@@ -113,7 +107,7 @@ class Route0 {
       return definition;
     }
     const original = typeof definition === "object" ? definition : new Route0(
-      Route0._normalizeRouteDefinition(definition)
+      Route0.normalizeSlash(definition)
     );
     return original._callable;
   }
@@ -125,7 +119,7 @@ class Route0 {
   }
   /** Extends the current route definition by appending a suffix route. */
   extend(suffixDefinition) {
-    const definition = Route0._normalizeRouteDefinition(`${this.definitionWithoutTrailingWildcard}/${suffixDefinition}`);
+    const definition = Route0.normalizeSlash(`${this.definitionWithoutTrailingWildcard}/${suffixDefinition}`);
     return Route0.create(
       definition,
       {
@@ -200,7 +194,7 @@ class Route0 {
     });
     url = url.replace(/\*\?/g, () => String(paramsInput["*"] ?? ""));
     url = url.replace(/\*/g, () => String(paramsInput["*"] ?? ""));
-    const searchString = stringifySearchQuery(searchInput);
+    const searchString = stringifySearchQuery(searchInput, { arrayIndexes: false });
     url = [url, searchString].filter(Boolean).join("?");
     url = collapseDuplicateSlashes(url);
     url = absInput ? Route0._getAbsPath(absOriginInput || this.origin, url) : url;
@@ -382,15 +376,34 @@ class Route0 {
     }
     return this._definitionParts;
   }
-  /** Fast pathname exact match check without building a full location object. */
-  isExactPathnameMatch(pathname) {
-    return this.regex.test(Route0._normalizePathname(pathname));
+  /** Fast pathname exact match check without building a full relation object. */
+  isExact(pathname, normalize = true) {
+    const normalizedPathname = normalize ? Route0.normalizeSlash(pathname) : pathname;
+    return this.regex.test(normalizedPathname);
   }
-  /** Fast pathname exact or ancestor match check without building a full location object. */
-  isExactOrAncestorPathnameMatch(pathname) {
-    const normalizedPathname = Route0._normalizePathname(pathname);
+  /** Fast pathname exact or ancestor match check without building a full relation object. */
+  isExactOrAncestor(pathname, normalize = true) {
+    const normalizedPathname = normalize ? Route0.normalizeSlash(pathname) : pathname;
     return this.regex.test(normalizedPathname) || this.regexAncestor.test(normalizedPathname);
   }
+  /** True when route is ancestor of pathname (pathname is deeper). */
+  isAncestor(pathname, normalize = true) {
+    const normalizedPathname = normalize ? Route0.normalizeSlash(pathname) : pathname;
+    return !this.regex.test(normalizedPathname) && this.regexAncestor.test(normalizedPathname);
+  }
+  /** True when route is descendant of pathname (pathname is shallower). */
+  isDescendant(pathname, normalize = true) {
+    const normalizedPathname = normalize ? Route0.normalizeSlash(pathname) : pathname;
+    if (this.regex.test(normalizedPathname) || this.regexAncestor.test(normalizedPathname)) {
+      return false;
+    }
+    for (const matcher of this.regexDescendantMatchers) {
+      if (normalizedPathname.match(matcher.regex)) {
+        return true;
+      }
+    }
+    return false;
+  }
   /** Creates a grouped regex pattern string from many routes. */
   static getRegexStringGroup(routes) {
     const patterns = routes.map((route) => route.regexString).join("|");
@@ -437,11 +450,16 @@ class Route0 {
     const abs = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(hrefOrHrefRelOrLocation);
     const base = abs ? void 0 : "http://example.com";
     const url = new URL(hrefOrHrefRelOrLocation, base);
-    const search = parseSearchQuery(url.search);
     const hrefRel = url.pathname + url.search + url.hash;
+    let _search;
     const location = {
       pathname: url.pathname,
-      search,
+      get search() {
+        if (_search === void 0) {
+          _search = parseSearchQuery(url.search);
+        }
+        return _search;
+      },
       searchString: url.search,
       hash: url.hash,
       origin: abs ? url.origin : void 0,
@@ -454,73 +472,91 @@ class Route0 {
       port: abs ? url.port || void 0 : void 0,
       // specific to UnknownLocation
       params: void 0,
-      route: void 0,
-      known: false,
-      exact: false,
-      ancestor: false,
-      descendant: false,
-      unmatched: false
+      route: void 0
     };
     return location;
   }
-  getLocation(hrefOrHrefRelOrLocation) {
+  getRelation(hrefOrHrefRelOrLocation) {
     if (hrefOrHrefRelOrLocation instanceof URL) {
-      return this.getLocation(hrefOrHrefRelOrLocation.href);
+      return this.getRelation(hrefOrHrefRelOrLocation.href);
     }
     if (typeof hrefOrHrefRelOrLocation !== "string") {
       hrefOrHrefRelOrLocation = hrefOrHrefRelOrLocation.href || hrefOrHrefRelOrLocation.hrefRel;
     }
-    const location = Route0.getLocation(hrefOrHrefRelOrLocation);
-    location.route = this.definition;
-    location.params = {};
-    const pathname = Route0._normalizePathname(location.pathname);
+    const pathname = Route0.normalizeSlash(new URL(hrefOrHrefRelOrLocation, "http://example.com").pathname);
     const paramNames = this.captureKeys;
     const exactRe = this.regex;
-    const ancestorRe = this.regexAncestor;
     const exactMatch = pathname.match(exactRe);
+    if (exactMatch) {
+      const values = exactMatch.slice(1, 1 + paramNames.length);
+      const params = Object.fromEntries(
+        paramNames.map((n, i) => {
+          const value = values[i];
+          return [n, value === void 0 ? void 0 : decodeURIComponent(value)];
+        })
+      );
+      return {
+        type: "exact",
+        route: this.definition,
+        params,
+        exact: true,
+        ancestor: false,
+        descendant: false,
+        unmatched: false
+      };
+    }
+    const ancestorRe = this.regexAncestor;
     const ancestorMatch = pathname.match(ancestorRe);
-    const exact = !!exactMatch;
-    const ancestor = !exact && !!ancestorMatch;
-    const paramsMatch = exactMatch || (ancestor ? ancestorMatch : null);
-    if (paramsMatch) {
-      const values = paramsMatch.slice(1, 1 + paramNames.length);
+    if (ancestorMatch) {
+      const values = ancestorMatch.slice(1, 1 + paramNames.length);
       const params = Object.fromEntries(
         paramNames.map((n, i) => {
           const value = values[i];
           return [n, value === void 0 ? void 0 : decodeURIComponent(value)];
         })
       );
-      location.params = params;
-    } else {
-      location.params = {};
+      return {
+        type: "ancestor",
+        route: this.definition,
+        params,
+        exact: false,
+        ancestor: true,
+        descendant: false,
+        unmatched: false
+      };
     }
-    let descendant = false;
     let descendantMatch = null;
     let descendantCaptureKeys = [];
-    if (!exact && !ancestor) {
-      for (const matcher of this.regexDescendantMatchers) {
-        const match = pathname.match(matcher.regex);
-        if (!match) continue;
-        descendant = true;
-        descendantMatch = match;
-        descendantCaptureKeys = matcher.captureKeys;
-        break;
-      }
-    }
-    const unmatched = !exact && !ancestor && !descendant;
-    if (descendant && descendantMatch) {
+    for (const matcher of this.regexDescendantMatchers) {
+      const match = pathname.match(matcher.regex);
+      if (!match) continue;
+      descendantMatch = match;
+      descendantCaptureKeys = matcher.captureKeys;
+      break;
+    }
+    if (descendantMatch) {
       const values = descendantMatch.slice(1, 1 + descendantCaptureKeys.length);
-      location.params = Object.fromEntries(
+      const params = Object.fromEntries(
         descendantCaptureKeys.map((key, index) => [key, decodeURIComponent(values[index])])
       );
+      return {
+        type: "descendant",
+        route: this.definition,
+        params,
+        exact: false,
+        ancestor: false,
+        descendant: true,
+        unmatched: false
+      };
     }
     return {
-      ...location,
-      known: true,
-      exact,
-      ancestor,
-      descendant,
-      unmatched
+      type: "unmatched",
+      route: this.definition,
+      params: {},
+      exact: false,
+      ancestor: false,
+      descendant: false,
+      unmatched: true
     };
   }
   _validateParamsInput(input) {
@@ -609,90 +645,106 @@ class Route0 {
     parse: (value) => this._parseSchemaResult(this._validateParamsInput(value)),
     safeParse: (value) => this._safeParseSchemaResult(this._validateParamsInput(value))
   };
-  /** True when path structure is equal (param names are ignored). */
-  isSame(other) {
-    const thisShape = this.routeTokens.map((t) => {
-      if (t.kind === "static") return `s:${t.value}`;
-      if (t.kind === "param") return `p:${t.optional ? "o" : "r"}`;
-      return `w:${t.prefix}:${t.optional ? "o" : "r"}`;
-    }).join("/");
-    const otherRoute = Route0.from(other);
-    const otherShape = otherRoute.routeTokens.map((t) => {
-      if (t.kind === "static") return `s:${t.value}`;
-      if (t.kind === "param") return `p:${t.optional ? "o" : "r"}`;
-      return `w:${t.prefix}:${t.optional ? "o" : "r"}`;
-    }).join("/");
-    return thisShape === otherShape;
-  }
-  /** Static convenience wrapper for `isSame`. */
-  static isSame(a, b) {
-    if (!a) {
-      if (!b) return true;
-      return false;
-    }
-    if (!b) {
-      return false;
-    }
-    return Route0.create(a).isSame(Route0.create(b));
-  }
-  /** True when current route is more specific/deeper than `other`. */
-  isDescendant(other) {
-    if (!other) return false;
-    other = Route0.create(other);
-    const getParts = (path) => path === "/" ? ["/"] : path.split("/").filter(Boolean);
-    if (other.definition === "/" && this.definition !== "/") {
-      return true;
-    }
-    const thisParts = getParts(this.definition);
-    const otherParts = getParts(other.definition);
-    if (thisParts.length <= otherParts.length) return false;
-    const matchesPatternPart = (patternPart, valuePart) => {
-      if (patternPart.startsWith(":")) return { match: true, wildcard: false };
-      const wildcardIndex = patternPart.indexOf("*");
-      if (wildcardIndex >= 0) {
-        const prefix = patternPart.slice(0, wildcardIndex);
-        return { match: prefix.length === 0 || valuePart.startsWith(prefix), wildcard: true };
-      }
-      return { match: patternPart === valuePart, wildcard: false };
-    };
-    for (let i = 0; i < otherParts.length; i++) {
-      const otherPart = otherParts[i];
-      const thisPart = thisParts[i];
-      const result = matchesPatternPart(otherPart, thisPart);
-      if (!result.match) return false;
-      if (result.wildcard) return true;
-    }
-    return true;
-  }
-  /** True when current route is broader/shallower than `other`. */
-  isAncestor(other) {
-    if (!other) return false;
-    other = Route0.create(other);
-    const getParts = (path) => path === "/" ? ["/"] : path.split("/").filter(Boolean);
-    if (this.definition === "/" && other.definition !== "/") {
-      return true;
-    }
-    const thisParts = getParts(this.definition);
-    const otherParts = getParts(other.definition);
-    if (thisParts.length >= otherParts.length) return false;
-    const matchesPatternPart = (patternPart, valuePart) => {
-      if (patternPart.startsWith(":")) return { match: true, wildcard: false };
-      const wildcardIndex = patternPart.indexOf("*");
-      if (wildcardIndex >= 0) {
-        const prefix = patternPart.slice(0, wildcardIndex);
-        return { match: prefix.length === 0 || valuePart.startsWith(prefix), wildcard: true };
-      }
-      return { match: patternPart === valuePart, wildcard: false };
-    };
-    for (let i = 0; i < thisParts.length; i++) {
-      const thisPart = thisParts[i];
-      const otherPart = otherParts[i];
-      const result = matchesPatternPart(thisPart, otherPart);
-      if (!result.match) return false;
-      if (result.wildcard) return true;
-    }
-    return true;
-  }
+  // /** True when path structure is equal (param names are ignored). */
+  // isSame(other: AnyRoute): boolean {
+  //   const thisShape = this.routeTokens
+  //     .map((t) => {
+  //       if (t.kind === 'static') return `s:${t.value}`
+  //       if (t.kind === 'param') return `p:${t.optional ? 'o' : 'r'}`
+  //       return `w:${t.prefix}:${t.optional ? 'o' : 'r'}`
+  //     })
+  //     .join('/')
+  //   const otherRoute = Route0.from(other) as Route0<string, UnknownSearchInput>
+  //   const otherShape = otherRoute.routeTokens
+  //     .map((t) => {
+  //       if (t.kind === 'static') return `s:${t.value}`
+  //       if (t.kind === 'param') return `p:${t.optional ? 'o' : 'r'}`
+  //       return `w:${t.prefix}:${t.optional ? 'o' : 'r'}`
+  //     })
+  //     .join('/')
+  //   return thisShape === otherShape
+  // }
+  // /** Static convenience wrapper for `isSame`. */
+  // static isSame(a: AnyRoute | string | undefined, b: AnyRoute | string | undefined): boolean {
+  //   if (!a) {
+  //     if (!b) return true
+  //     return false
+  //   }
+  //   if (!b) {
+  //     return false
+  //   }
+  //   return Route0.create(a).isSame(Route0.create(b))
+  // }
+  // /** True when current route is more specific/deeper than `other`. */
+  // isDescendant(other: AnyRoute | string | undefined): boolean {
+  //   if (!other) return false
+  //   other = Route0.create(other)
+  //   // this is a descendant of other if:
+  //   // - paths are not exactly the same
+  //   // - other's path is a prefix of this path, matching params as wildcards
+  //   const getParts = (path: string) => (path === '/' ? ['/'] : path.split('/').filter(Boolean))
+  //   // Root is ancestor of any non-root; thus any non-root is a descendant of root
+  //   if (other.definition === '/' && this.definition !== '/') {
+  //     return true
+  //   }
+  //   const thisParts = getParts(this.definition)
+  //   const otherParts = getParts(other.definition)
+  //   // A descendant must be deeper
+  //   if (thisParts.length <= otherParts.length) return false
+  //   const matchesPatternPart = (patternPart: string, valuePart: string): { match: boolean; wildcard: boolean } => {
+  //     if (patternPart.startsWith(':')) return { match: true, wildcard: false }
+  //     const wildcardIndex = patternPart.indexOf('*')
+  //     if (wildcardIndex >= 0) {
+  //       const prefix = patternPart.slice(0, wildcardIndex)
+  //       return { match: prefix.length === 0 || valuePart.startsWith(prefix), wildcard: true }
+  //     }
+  //     return { match: patternPart === valuePart, wildcard: false }
+  //   }
+  //   for (let i = 0; i < otherParts.length; i++) {
+  //     const otherPart = otherParts[i]
+  //     const thisPart = thisParts[i]
+  //     const result = matchesPatternPart(otherPart, thisPart)
+  //     if (!result.match) return false
+  //     if (result.wildcard) return true
+  //   }
+  //   // Not equal (depth already ensures not equal)
+  //   return true
+  // }
+  // /** True when current route is broader/shallower than `other`. */
+  // isAncestor(other: AnyRoute | string | undefined): boolean {
+  //   if (!other) return false
+  //   other = Route0.create(other)
+  //   // this is an ancestor of other if:
+  //   // - paths are not exactly the same
+  //   // - this path is a prefix of other path, matching params as wildcards
+  //   const getParts = (path: string) => (path === '/' ? ['/'] : path.split('/').filter(Boolean))
+  //   // Root is ancestor of any non-root path
+  //   if (this.definition === '/' && other.definition !== '/') {
+  //     return true
+  //   }
+  //   const thisParts = getParts(this.definition)
+  //   const otherParts = getParts(other.definition)
+  //   // An ancestor must be shallower
+  //   if (thisParts.length >= otherParts.length) return false
+  //   const matchesPatternPart = (patternPart: string, valuePart: string): { match: boolean; wildcard: boolean } => {
+  //     if (patternPart.startsWith(':')) return { match: true, wildcard: false }
+  //     const wildcardIndex = patternPart.indexOf('*')
+  //     if (wildcardIndex >= 0) {
+  //       const prefix = patternPart.slice(0, wildcardIndex)
+  //       return { match: prefix.length === 0 || valuePart.startsWith(prefix), wildcard: true }
+  //     }
+  //     return { match: patternPart === valuePart, wildcard: false }
+  //   }
+  //   for (let i = 0; i < thisParts.length; i++) {
+  //     const thisPart = thisParts[i]
+  //     const otherPart = otherParts[i]
+  //     const result = matchesPatternPart(thisPart, otherPart)
+  //     if (!result.match) return false
+  //     if (result.wildcard) return true
+  //   }
+  //   // Not equal (depth already ensures not equal)
+  //   return true
+  // }
   /** True when two route patterns can match the same concrete URL. */
   isOverlap(other) {
     if (!other) return false;
@@ -750,21 +802,6 @@ class Route0 {
   }
 }
 class Routes {
-  static _getNormalizedPathnameFromInput(hrefOrHrefRelOrLocation) {
-    if (hrefOrHrefRelOrLocation instanceof URL) {
-      return normalizeSlashPath(hrefOrHrefRelOrLocation.pathname);
-    }
-    if (typeof hrefOrHrefRelOrLocation !== "string") {
-      if (typeof hrefOrHrefRelOrLocation.pathname === "string") {
-        return normalizeSlashPath(hrefOrHrefRelOrLocation.pathname);
-      }
-      hrefOrHrefRelOrLocation = hrefOrHrefRelOrLocation.href || hrefOrHrefRelOrLocation.hrefRel;
-    }
-    const abs = /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(hrefOrHrefRelOrLocation);
-    const base = abs ? void 0 : "http://example.com";
-    const url = new URL(hrefOrHrefRelOrLocation, base);
-    return normalizeSlashPath(url.pathname);
-  }
   _routes;
   _pathsOrdering;
   _keysOrdering;
@@ -828,17 +865,17 @@ class Routes {
   }
   _getLocation(hrefOrHrefRelOrLocation) {
     const input = hrefOrHrefRelOrLocation;
-    const pathname = Routes._getNormalizedPathnameFromInput(input);
+    const location = Route0.getLocation(input);
     for (const route of this._ordered) {
-      if (!route.isExactPathnameMatch(pathname)) {
-        continue;
-      }
-      const loc = route.getLocation(input);
-      if (loc.exact) {
-        return loc;
+      if (route.isExact(location.pathname, false)) {
+        const relation = route.getRelation(input);
+        return Object.assign(location, {
+          route: route.definition,
+          params: relation.params
+        });
       }
     }
-    return typeof input === "string" ? Route0.getLocation(input) : Route0.getLocation(input);
+    return location;
   }
   static makeOrdering(routes) {
     const hydrated = Routes.hydrate(routes);