@devp0nt/route0 1.0.0-next.72 → 1.0.0-next.74

package/dist/cjs/index.cjs

@@ -24,12 +24,12 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_flat0 = require("@devp0nt/flat0");
 const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-const getPathSegments = (definition) => {
+const getRouteSegments = (definition) => {
   if (definition === "" || definition === "/") return [];
   return definition.split("/").filter(Boolean);
 };
-const getPathTokens = (definition) => {
-  const segments = getPathSegments(definition);
+const getRouteTokens = (definition) => {
+  const segments = getRouteSegments(definition);
   return segments.map((segment) => {
     const param = segment.match(/^:([A-Za-z0-9_]+)(\?)?$/);
     if (param) {
@@ -45,8 +45,8 @@ const getPathTokens = (definition) => {
     return { kind: "static", value: segment };
   });
 };
-const getPathRegexBaseStrictString = (definition) => {
-  const tokens = getPathTokens(definition);
+const getRouteRegexBaseStrictString = (definition) => {
+  const tokens = getRouteTokens(definition);
   if (tokens.length === 0) return "";
   let pattern = "";
   for (const token of tokens) {
@@ -66,20 +66,20 @@ const getPathRegexBaseStrictString = (definition) => {
   }
   return pattern;
 };
-const getPathCaptureKeys = (definition) => {
+const getRouteCaptureKeys = (definition) => {
   const keys = [];
-  for (const token of getPathTokens(definition)) {
+  for (const token of getRouteTokens(definition)) {
     if (token.kind === "param") keys.push(token.name);
     if (token.kind === "wildcard") keys.push("*");
   }
   return keys;
 };
 const getPathParamsDefinition = (definition) => {
-  const entries = getPathTokens(definition).filter((t) => t.kind !== "static").map((t) => t.kind === "param" ? [t.name, !t.optional] : ["*", !t.optional]);
+  const entries = getRouteTokens(definition).filter((t) => t.kind !== "static").map((t) => t.kind === "param" ? [t.name, !t.optional] : ["*", !t.optional]);
   return Object.fromEntries(entries);
 };
-const validatePathDefinition = (definition) => {
-  const segments = getPathSegments(definition);
+const validateRouteDefinition = (definition) => {
+  const segments = getRouteSegments(definition);
   const wildcardSegments = segments.filter((segment) => segment.includes("*"));
   if (wildcardSegments.length === 0) return;
   if (wildcardSegments.length > 1) {
@@ -95,11 +95,42 @@ const validatePathDefinition = (definition) => {
   }
 };
 const stripTrailingWildcard = (definition) => definition.replace(/\*\??$/, "");
+const normalizePathname = (pathname) => {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.slice(0, -1);
+  }
+  return pathname;
+};
+const getNormalizedPathnameFromInput = (hrefOrHrefRelOrLocation) => {
+  if (hrefOrHrefRelOrLocation instanceof URL) {
+    return normalizePathname(hrefOrHrefRelOrLocation.pathname);
+  }
+  if (typeof hrefOrHrefRelOrLocation !== "string") {
+    if (typeof hrefOrHrefRelOrLocation.pathname === "string") {
+      return normalizePathname(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 normalizePathname(url.pathname);
+};
 class Route0 {
   definition;
   params;
   _origin;
   _callable;
+  _regexBaseStrictString;
+  _regexBaseString;
+  _regexStrictString;
+  _regexString;
+  _regexStrict;
+  _regex;
+  _regexAncestor;
+  _captureKeys;
+  _normalizedDefinition;
+  _definitionParts;
   Infer = null;
   /** Base URL used when generating absolute URLs (`abs: true`). */
   get origin() {
@@ -114,7 +145,7 @@ class Route0 {
     this._origin = origin;
   }
   constructor(definition, config = {}) {
-    validatePathDefinition(definition);
+    validateRouteDefinition(definition);
     this.definition = definition;
     this.params = Route0._getParamsDefinitionByDefinition(definition);
     const { origin } = config;
@@ -257,34 +288,80 @@ class Route0 {
   getParamsKeys() {
     return Object.keys(this.params);
   }
-  getPathTokens() {
-    return getPathTokens(this.definition);
+  getTokens() {
+    return getRouteTokens(this.definition);
   }
   /** Clones route with optional config override. */
   clone(config) {
     return Route0.create(this.definition, config);
   }
-  getRegexBaseStrictString() {
-    return getPathRegexBaseStrictString(this.definition);
+  get regexBaseStrictString() {
+    if (this._regexBaseStrictString === void 0) {
+      this._regexBaseStrictString = getRouteRegexBaseStrictString(this.definition);
+    }
+    return this._regexBaseStrictString;
   }
-  getRegexBaseString() {
-    return this.getRegexBaseStrictString().replace(/\/+$/, "") + "/?";
+  get regexBaseString() {
+    if (this._regexBaseString === void 0) {
+      this._regexBaseString = this.regexBaseStrictString.replace(/\/+$/, "") + "/?";
+    }
+    return this._regexBaseString;
   }
-  getRegexStrictString() {
-    return `^${this.getRegexBaseStrictString()}$`;
+  get regexStrictString() {
+    if (this._regexStrictString === void 0) {
+      this._regexStrictString = `^${this.regexBaseStrictString}$`;
+    }
+    return this._regexStrictString;
   }
-  getRegexString() {
-    return `^${this.getRegexBaseString()}$`;
+  get regexString() {
+    if (this._regexString === void 0) {
+      this._regexString = `^${this.regexBaseString}$`;
+    }
+    return this._regexString;
   }
-  getRegexStrict() {
-    return new RegExp(this.getRegexStrictString());
+  get regexStrict() {
+    if (this._regexStrict === void 0) {
+      this._regexStrict = new RegExp(this.regexStrictString);
+    }
+    return this._regexStrict;
   }
-  getRegex() {
-    return new RegExp(this.getRegexString());
+  get regex() {
+    if (this._regex === void 0) {
+      this._regex = new RegExp(this.regexString);
+    }
+    return this._regex;
+  }
+  get regexAncestor() {
+    if (this._regexAncestor === void 0) {
+      this._regexAncestor = new RegExp(`^${this.regexBaseString}(?:/.*)?$`);
+    }
+    return this._regexAncestor;
+  }
+  get captureKeys() {
+    if (this._captureKeys === void 0) {
+      this._captureKeys = getRouteCaptureKeys(this.definition);
+    }
+    return this._captureKeys;
+  }
+  get normalizedDefinition() {
+    if (this._normalizedDefinition === void 0) {
+      this._normalizedDefinition = this.definition.length > 1 && this.definition.endsWith("/") ? this.definition.slice(0, -1) : this.definition;
+    }
+    return this._normalizedDefinition;
+  }
+  get definitionParts() {
+    if (this._definitionParts === void 0) {
+      this._definitionParts = this.normalizedDefinition === "/" ? ["/"] : this.normalizedDefinition.split("/").filter(Boolean);
+    }
+    return this._definitionParts;
+  }
+  /** Fast pathname check without building a full location object. */
+  isExactPathnameMatch(pathname) {
+    return this.regex.test(normalizePathname(pathname));
   }
   /** Creates a grouped strict regex pattern string from many routes. */
   static getRegexStrictStringGroup(routes) {
-    const patterns = routes.map((route) => route.getRegexStrictString()).join("|");
+    const patterns = routes.map((route) => route.regexStrictString).join("|");
     return `(${patterns})`;
   }
   /** Creates a strict grouped regex from many routes. */
@@ -294,7 +371,7 @@ class Route0 {
   }
   /** Creates a grouped regex pattern string from many routes. */
   static getRegexStringGroup(routes) {
-    const patterns = routes.map((route) => route.getRegexString()).join("|");
+    const patterns = routes.map((route) => route.regexString).join("|");
     return `(${patterns})`;
   }
   /** Creates a grouped regex from many routes. */
@@ -378,11 +455,11 @@ class Route0 {
     const location = Route0.getLocation(hrefOrHrefRelOrLocation);
     location.route = this.definition;
     location.params = {};
-    const pathname = location.pathname.length > 1 && location.pathname.endsWith("/") ? location.pathname.slice(0, -1) : location.pathname;
-    const paramNames = getPathCaptureKeys(this.definition);
-    const def = this.definition.length > 1 && this.definition.endsWith("/") ? this.definition.slice(0, -1) : this.definition;
-    const exactRe = new RegExp(`^${this.getRegexBaseString()}$`);
-    const ancestorRe = new RegExp(`^${this.getRegexBaseString()}(?:/.*)?$`);
+    const pathname = normalizePathname(location.pathname);
+    const paramNames = this.captureKeys;
+    const defParts = this.definitionParts;
+    const exactRe = this.regex;
+    const ancestorRe = this.regexAncestor;
     const exactMatch = pathname.match(exactRe);
     const ancestorMatch = pathname.match(ancestorRe);
     const exact = !!exactMatch;
@@ -400,9 +477,7 @@ class Route0 {
     } else {
       location.params = {};
     }
-    const getParts = (path) => path === "/" ? ["/"] : path.split("/").filter(Boolean);
-    const defParts = getParts(def);
-    const pathParts = getParts(pathname);
+    const pathParts = pathname === "/" ? ["/"] : pathname.split("/").filter(Boolean);
     let isPrefix = true;
     if (pathParts.length > defParts.length) {
       isPrefix = false;
@@ -540,11 +615,11 @@ class Route0 {
   };
   /** True when path structure is equal (param names are ignored). */
   isSame(other) {
-    return getPathTokens(this.definition).map((t) => {
+    return getRouteTokens(this.definition).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("/") === getPathTokens(other.definition).map((t) => {
+    }).join("/") === getRouteTokens(other.definition).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"}`;
@@ -603,10 +678,10 @@ class Route0 {
   isConflict(other) {
     if (!other) return false;
     other = Route0.create(other);
-    const thisRegex = this.getRegex();
-    const otherRegex = other.getRegex();
+    const thisRegex = this.regex;
+    const otherRegex = other.regex;
     const makeCandidates = (definition) => {
-      const tokens = getPathTokens(definition);
+      const tokens = getRouteTokens(definition);
       const values = (token) => {
         if (token.kind === "static") return [token.value];
         if (token.kind === "param") return token.optional ? ["", "x"] : ["x"];
@@ -733,8 +808,12 @@ class Routes {
   }
   _getLocation(hrefOrHrefRelOrLocation) {
     const input = hrefOrHrefRelOrLocation;
+    const pathname = getNormalizedPathnameFromInput(input);
     for (const route of this._ordered) {
-      const loc = route.getLocation(hrefOrHrefRelOrLocation);
+      if (!route.isExactPathnameMatch(pathname)) {
+        continue;
+      }
+      const loc = route.getLocation(input);
       if (loc.exact) {
         return loc;
       }