@devp0nt/route0 1.0.0-next.3 → 1.0.0-next.31

package/dist/esm/index.js

@@ -1,20 +1,20 @@
 class Route0 {
-  pathOriginalDefinition;
+  definition;
   pathDefinition;
   paramsDefinition;
-  queryDefinition;
+  searchDefinition;
   baseUrl;
   constructor(definition, config = {}) {
-    this.pathOriginalDefinition = definition;
-    this.pathDefinition = Route0._getPathDefinitionByOriginalDefinition(definition);
-    this.paramsDefinition = Route0._getParamsDefinitionByRouteDefinition(definition);
-    this.queryDefinition = Route0._getQueryDefinitionByRouteDefinition(definition);
+    this.definition = definition;
+    this.pathDefinition = Route0._getPathDefinitionBydefinition(definition);
+    this.paramsDefinition = Route0._getParamsDefinitionBydefinition(definition);
+    this.searchDefinition = Route0._getSearchDefinitionBydefinition(definition);
     const { baseUrl } = config;
     if (baseUrl && typeof baseUrl === "string" && baseUrl.length) {
       this.baseUrl = baseUrl;
     } else {
       const g = globalThis;
-      if (g?.location?.origin) {
+      if (typeof g?.location?.origin === "string" && g.location.origin.length > 0) {
         this.baseUrl = g.location.origin;
       } else {
         this.baseUrl = "https://example.com";
@@ -22,113 +22,463 @@ class Route0 {
     }
   }
   static create(definition, config) {
-    const original = new Route0(
-      definition,
-      config
-    );
+    if (typeof definition === "function") {
+      return definition;
+    }
+    const original = typeof definition === "object" ? definition : new Route0(definition, config);
     const callable = original.get.bind(original);
-    const proxy = new Proxy(callable, {
-      get(_target, prop, receiver) {
-        const value = original[prop];
-        if (typeof value === "function") {
-          return value.bind(original);
-        }
-        return value;
-      },
-      set(_target, prop, value, receiver) {
-        ;
-        original[prop] = value;
-        return true;
-      },
-      has(_target, prop) {
-        return prop in original;
-      }
+    Object.setPrototypeOf(callable, original);
+    Object.defineProperty(callable, Symbol.toStringTag, {
+      value: original.definition
     });
-    Object.setPrototypeOf(proxy, Route0.prototype);
-    return proxy;
+    return callable;
   }
-  static _splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition) {
-    const i = pathOriginalDefinition.indexOf("&");
-    if (i === -1) return { pathDefinition: pathOriginalDefinition, queryTailDefinition: "" };
+  static _splitPathDefinitionAndSearchTailDefinition(definition) {
+    const i = definition.indexOf("&");
+    if (i === -1) return { pathDefinition: definition, searchTailDefinition: "" };
     return {
-      pathDefinition: pathOriginalDefinition.slice(0, i),
-      queryTailDefinition: pathOriginalDefinition.slice(i)
+      pathDefinition: definition.slice(0, i),
+      searchTailDefinition: definition.slice(i)
     };
   }
-  static _getAbsPath(baseUrl, pathWithQuery) {
-    return new URL(pathWithQuery, baseUrl).toString().replace(/\/$/, "");
+  static _getAbsPath(baseUrl, pathWithSearch) {
+    return new URL(pathWithSearch, baseUrl).toString().replace(/\/$/, "");
   }
-  static _getPathDefinitionByOriginalDefinition(pathOriginalDefinition) {
-    const { pathDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition);
+  static _getPathDefinitionBydefinition(definition) {
+    const { pathDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(definition);
     return pathDefinition;
   }
-  static _getParamsDefinitionByRouteDefinition(pathOriginalDefinition) {
-    const { pathDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition);
+  static _getParamsDefinitionBydefinition(definition) {
+    const { pathDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(definition);
     const matches = Array.from(pathDefinition.matchAll(/:([A-Za-z0-9_]+)/g));
     const paramsDefinition = Object.fromEntries(matches.map((m) => [m[1], true]));
+    const keysCount = Object.keys(paramsDefinition).length;
+    if (keysCount === 0) {
+      return void 0;
+    }
     return paramsDefinition;
   }
-  static _getQueryDefinitionByRouteDefinition(pathOriginalDefinition) {
-    const { queryTailDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(pathOriginalDefinition);
-    if (!queryTailDefinition) {
-      return {};
+  static _getSearchDefinitionBydefinition(definition) {
+    const { searchTailDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(definition);
+    if (!searchTailDefinition) {
+      return void 0;
     }
-    const keys = queryTailDefinition.split("&").map(Boolean);
-    const queryDefinition = Object.fromEntries(keys.map((k) => [k, true]));
-    return queryDefinition;
-  }
-  static overrideMany(routes, config) {
-    const result = {};
-    for (const [key, value] of Object.entries(routes)) {
-      ;
-      result[key] = value.clone(config);
+    const keys = searchTailDefinition.split("&").filter(Boolean);
+    const searchDefinition = Object.fromEntries(keys.map((k) => [k, true]));
+    const keysCount = Object.keys(searchDefinition).length;
+    if (keysCount === 0) {
+      return void 0;
     }
-    return result;
+    return searchDefinition;
   }
   extend(suffixDefinition) {
-    const { pathDefinition: parentPathDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(
-      this.pathOriginalDefinition
-    );
-    const { pathDefinition: suffixPathDefinition, queryTailDefinition: suffixQueryTailDefinition } = Route0._splitPathDefinitionAndQueryTailDefinition(suffixDefinition);
+    const { pathDefinition: parentPathDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(this.definition);
+    const { pathDefinition: suffixPathDefinition, searchTailDefinition: suffixSearchTailDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(suffixDefinition);
     const pathDefinition = `${parentPathDefinition}/${suffixPathDefinition}`.replace(/\/{2,}/g, "/");
-    const pathOriginalDefinition = `${pathDefinition}${suffixQueryTailDefinition}`;
-    return Route0.create(pathOriginalDefinition, { baseUrl: this.baseUrl });
+    const definition = `${pathDefinition}${suffixSearchTailDefinition}`;
+    return Route0.create(definition, { baseUrl: this.baseUrl });
   }
   // implementation
   get(...args) {
-    const { queryInput, paramsInput, absInput } = (() => {
+    const { searchInput, paramsInput, absInput } = (() => {
       if (args.length === 0) {
-        return { queryInput: {}, paramsInput: {}, absInput: false };
+        return { searchInput: {}, paramsInput: {}, absInput: false };
       }
       const input = args[0];
       if (typeof input !== "object" || input === null) {
-        return { queryInput: {}, paramsInput: {}, absInput: false };
+        return { searchInput: {}, paramsInput: {}, absInput: false };
       }
-      const { query, abs, ...params } = input;
-      return { queryInput: query || {}, paramsInput: params, absInput: abs ?? false };
+      const { search, abs, ...params } = input;
+      return { searchInput: search || {}, paramsInput: params, absInput: abs ?? false };
     })();
-    const neededParamsKeys = Object.keys(this.paramsDefinition);
+    const neededParamsKeys = this.paramsDefinition ? Object.keys(this.paramsDefinition) : [];
     const providedParamsKeys = Object.keys(paramsInput);
     const notProvidedKeys = neededParamsKeys.filter((k) => !providedParamsKeys.includes(k));
     if (notProvidedKeys.length) {
       Object.assign(paramsInput, Object.fromEntries(notProvidedKeys.map((k) => [k, "undefined"])));
     }
-    let url = String(this.pathDefinition);
+    let url = this.pathDefinition;
     url = url.replace(/:([A-Za-z0-9_]+)/g, (_m, k) => encodeURIComponent(String(paramsInput?.[k] ?? "")));
-    const queryInputStringified = Object.fromEntries(Object.entries(queryInput).map(([k, v]) => [k, String(v)]));
-    url = [url, new URLSearchParams(queryInputStringified).toString()].filter(Boolean).join("?");
+    const searchInputStringified = Object.fromEntries(Object.entries(searchInput).map(([k, v]) => [k, String(v)]));
+    url = [url, new URLSearchParams(searchInputStringified).toString()].filter(Boolean).join("?");
     url = url.replace(/\/{2,}/g, "/");
     url = absInput ? Route0._getAbsPath(this.baseUrl, url) : url;
     return url;
   }
+  // implementation
+  flat(...args) {
+    const { searchInput, paramsInput, absInput } = (() => {
+      if (args.length === 0) {
+        return { searchInput: {}, paramsInput: {}, absInput: false };
+      }
+      const input = args[0];
+      if (typeof input !== "object" || input === null) {
+        return { searchInput: {}, paramsInput: {}, absInput: args[1] ?? false };
+      }
+      const paramsKeys = this.getParamsKeys();
+      const paramsInput2 = paramsKeys.reduce((acc, key) => {
+        if (input[key] !== void 0) {
+          acc[key] = input[key];
+        }
+        return acc;
+      }, {});
+      const searchKeys = this.getSearchKeys();
+      const searchInput2 = Object.keys(input).filter((k) => {
+        if (searchKeys.includes(k)) {
+          return true;
+        }
+        if (paramsKeys.includes(k)) {
+          return false;
+        }
+        return true;
+      }).reduce((acc, key) => {
+        acc[key] = input[key];
+        return acc;
+      }, {});
+      return { searchInput: searchInput2, paramsInput: paramsInput2, absInput: args[1] ?? false };
+    })();
+    return this.get({ ...paramsInput, search: searchInput, abs: absInput });
+  }
+  getParamsKeys() {
+    return Object.keys(this.paramsDefinition || {});
+  }
+  getSearchKeys() {
+    return Object.keys(this.searchDefinition || {});
+  }
+  getFlatKeys() {
+    return [...this.getSearchKeys(), ...this.getParamsKeys()];
+  }
   getDefinition() {
     return this.pathDefinition;
   }
   clone(config) {
-    return new Route0(this.pathOriginalDefinition, config);
+    return new Route0(this.definition, config);
+  }
+  getRegexString() {
+    const pattern = this.pathDefinition.replace(/\/+$/, "").replace(/:(\w+)/g, "___PARAM___").replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/___PARAM___/g, "([^/]+)");
+    return pattern || "/";
+  }
+  getRegex() {
+    const inner = this.getRegexString();
+    if (inner === "/") return /^\/?$/;
+    return new RegExp(`^${inner}/?$`);
+  }
+  static getRegexStringGroup(routes) {
+    return routes.map((route) => route.getRegexString()).join("|");
+  }
+  static getRegexGroup(routes) {
+    const patterns = routes.map((route) => {
+      const inner = route.getRegexString();
+      if (inner === "/") return "/?";
+      return `${inner}/?`;
+    });
+    return new RegExp(`^(${patterns.join("|")})$`);
+  }
+  static getLocation(hrefOrHrefRelOrLocation) {
+    if (hrefOrHrefRelOrLocation instanceof URL) {
+      return Route0.getLocation(hrefOrHrefRelOrLocation.href);
+    }
+    if (typeof hrefOrHrefRelOrLocation !== "string") {
+      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);
+    const searchParams = Object.fromEntries(url.searchParams.entries());
+    let pathname = url.pathname;
+    if (pathname.length > 1 && pathname.endsWith("/")) {
+      pathname = pathname.slice(0, -1);
+    }
+    const hrefRel = pathname + url.search + url.hash;
+    const location = {
+      pathname,
+      search: url.search,
+      hash: url.hash,
+      origin: abs ? url.origin : void 0,
+      href: abs ? url.href : void 0,
+      hrefRel,
+      abs,
+      // extra host-related fields (available even for relative with dummy base)
+      host: abs ? url.host : void 0,
+      hostname: abs ? url.hostname : void 0,
+      port: abs ? url.port || void 0 : void 0,
+      // specific to UnknownLocation
+      searchParams,
+      params: void 0,
+      route: void 0,
+      exact: false,
+      parent: false,
+      children: false
+    };
+    return location;
+  }
+  getLocation(hrefOrHrefRelOrLocation) {
+    if (hrefOrHrefRelOrLocation instanceof URL) {
+      return this.getLocation(hrefOrHrefRelOrLocation.href);
+    }
+    if (typeof hrefOrHrefRelOrLocation !== "string") {
+      hrefOrHrefRelOrLocation = hrefOrHrefRelOrLocation.href || hrefOrHrefRelOrLocation.hrefRel;
+    }
+    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 pattern = this.getRegexString();
+    const paramNames = [];
+    const def = this.pathDefinition.length > 1 && this.pathDefinition.endsWith("/") ? this.pathDefinition.slice(0, -1) : this.pathDefinition;
+    def.replace(/:([A-Za-z0-9_]+)/g, (_m, name) => {
+      paramNames.push(String(name));
+      return "";
+    });
+    const exactRe = new RegExp(`^${pattern}$`);
+    const parentRe = new RegExp(`^${pattern}(?:/.*)?$`);
+    const exactMatch = pathname.match(exactRe);
+    if (exactMatch) {
+      const values = exactMatch.slice(1);
+      const params = Object.fromEntries(paramNames.map((n, i) => [n, decodeURIComponent(values[i] ?? "")]));
+      location.params = params;
+    } else {
+      location.params = {};
+    }
+    const exact = !!exactMatch;
+    const parent = !exact && parentRe.test(pathname);
+    const getParts = (path) => path === "/" ? ["/"] : path.split("/").filter(Boolean);
+    const defParts = getParts(def);
+    const pathParts = getParts(pathname);
+    let isPrefix = true;
+    if (pathParts.length > defParts.length) {
+      isPrefix = false;
+    } else {
+      for (let i = 0; i < pathParts.length; i++) {
+        const defPart = defParts[i];
+        const pathPart = pathParts[i];
+        if (!defPart) {
+          isPrefix = false;
+          break;
+        }
+        if (defPart.startsWith(":")) continue;
+        if (defPart !== pathPart) {
+          isPrefix = false;
+          break;
+        }
+      }
+    }
+    const children = !exact && isPrefix;
+    return {
+      ...location,
+      exact,
+      parent,
+      children
+    };
+  }
+  isSame(other) {
+    return this.pathDefinition.replace(/:([A-Za-z0-9_]+)/g, "__PARAM__") === other.pathDefinition.replace(/:([A-Za-z0-9_]+)/g, "__PARAM__");
+  }
+  static isSame(a, b) {
+    if (!a) {
+      if (!b) return true;
+      return false;
+    }
+    if (!b) {
+      return false;
+    }
+    return Route0.create(a).isSame(Route0.create(b));
+  }
+  isChildren(other) {
+    if (!other) return false;
+    other = Route0.create(other);
+    const getParts = (path) => path === "/" ? ["/"] : path.split("/").filter(Boolean);
+    if (other.pathDefinition === "/" && this.pathDefinition !== "/") {
+      return true;
+    }
+    const thisParts = getParts(this.pathDefinition);
+    const otherParts = getParts(other.pathDefinition);
+    if (thisParts.length <= otherParts.length) return false;
+    for (let i = 0; i < otherParts.length; i++) {
+      const otherPart = otherParts[i];
+      const thisPart = thisParts[i];
+      if (otherPart.startsWith(":")) continue;
+      if (otherPart !== thisPart) return false;
+    }
+    return true;
+  }
+  isParent(other) {
+    if (!other) return false;
+    other = Route0.create(other);
+    const getParts = (path) => path === "/" ? ["/"] : path.split("/").filter(Boolean);
+    if (this.pathDefinition === "/" && other.pathDefinition !== "/") {
+      return true;
+    }
+    const thisParts = getParts(this.pathDefinition);
+    const otherParts = getParts(other.pathDefinition);
+    if (thisParts.length >= otherParts.length) return false;
+    for (let i = 0; i < thisParts.length; i++) {
+      const thisPart = thisParts[i];
+      const otherPart = otherParts[i];
+      if (thisPart.startsWith(":")) continue;
+      if (thisPart !== otherPart) return false;
+    }
+    return true;
+  }
+  isConflict(other) {
+    if (!other) return false;
+    other = Route0.create(other);
+    const getParts = (path) => {
+      if (path === "/") return ["/"];
+      return path.split("/").filter(Boolean);
+    };
+    const thisParts = getParts(this.pathDefinition);
+    const otherParts = getParts(other.pathDefinition);
+    if (thisParts.length !== otherParts.length) {
+      return false;
+    }
+    for (let i = 0; i < thisParts.length; i++) {
+      const thisPart = thisParts[i];
+      const otherPart = otherParts[i];
+      if (thisPart.startsWith(":") && otherPart.startsWith(":")) {
+        continue;
+      }
+      if (thisPart.startsWith(":") || otherPart.startsWith(":")) {
+        continue;
+      }
+      if (thisPart !== otherPart) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isMoreSpecificThan(other) {
+    if (!other) return false;
+    other = Route0.create(other);
+    const getParts = (path) => {
+      if (path === "/") return ["/"];
+      return path.split("/").filter(Boolean);
+    };
+    const thisParts = getParts(this.pathDefinition);
+    const otherParts = getParts(other.pathDefinition);
+    for (let i = 0; i < Math.min(thisParts.length, otherParts.length); i++) {
+      const thisIsStatic = !thisParts[i].startsWith(":");
+      const otherIsStatic = !otherParts[i].startsWith(":");
+      if (thisIsStatic && !otherIsStatic) return true;
+      if (!thisIsStatic && otherIsStatic) return false;
+    }
+    return this.pathDefinition < other.pathDefinition;
+  }
+}
+class Routes {
+  routes;
+  pathsOrdering;
+  keysOrdering;
+  ordered;
+  _;
+  constructor({
+    routes,
+    isHydrated = false,
+    pathsOrdering,
+    keysOrdering,
+    ordered
+  }) {
+    this.routes = isHydrated ? routes : Routes.hydrate(routes);
+    if (!pathsOrdering || !keysOrdering || !ordered) {
+      const ordering = Routes.makeOrdering(this.routes);
+      this.pathsOrdering = ordering.pathsOrdering;
+      this.keysOrdering = ordering.keysOrdering;
+      this.ordered = this.keysOrdering.map((key) => this.routes[key]);
+    } else {
+      this.pathsOrdering = pathsOrdering;
+      this.keysOrdering = keysOrdering;
+      this.ordered = ordered;
+    }
+    this._ = {
+      getLocation: this.getLocation.bind(this),
+      override: this.override.bind(this),
+      pathsOrdering: this.pathsOrdering,
+      keysOrdering: this.keysOrdering,
+      ordered: this.ordered
+    };
+  }
+  static create(routes) {
+    const instance = new Routes({ routes });
+    return Routes.prettify(instance);
+  }
+  static prettify(instance) {
+    Object.setPrototypeOf(instance, Routes.prototype);
+    Object.defineProperty(instance, Symbol.toStringTag, {
+      value: "Routes"
+    });
+    Object.assign(instance, {
+      override: instance.override.bind(instance)
+    });
+    Object.assign(instance, instance.routes);
+    return instance;
+  }
+  static hydrate(routes) {
+    const result = {};
+    for (const key in routes) {
+      if (Object.prototype.hasOwnProperty.call(routes, key)) {
+        const value = routes[key];
+        result[key] = typeof value === "string" ? Route0.create(value) : value;
+      }
+    }
+    return result;
+  }
+  getLocation(hrefOrHrefRelOrLocation) {
+    const input = hrefOrHrefRelOrLocation;
+    for (const route of this.ordered) {
+      const loc = route.getLocation(hrefOrHrefRelOrLocation);
+      if (loc.exact) {
+        return loc;
+      }
+    }
+    return typeof input === "string" ? Route0.getLocation(input) : Route0.getLocation(input);
+  }
+  static makeOrdering(routes) {
+    const hydrated = Routes.hydrate(routes);
+    const entries = Object.entries(hydrated);
+    const getParts = (path) => {
+      if (path === "/") return ["/"];
+      return path.split("/").filter(Boolean);
+    };
+    entries.sort(([_keyA, routeA], [_keyB, routeB]) => {
+      const partsA = getParts(routeA.pathDefinition);
+      const partsB = getParts(routeB.pathDefinition);
+      if (partsA.length !== partsB.length) {
+        return partsA.length - partsB.length;
+      }
+      if (routeA.isConflict(routeB)) {
+        if (routeA.isMoreSpecificThan(routeB)) return -1;
+        if (routeB.isMoreSpecificThan(routeA)) return 1;
+      }
+      return routeA.pathDefinition.localeCompare(routeB.pathDefinition);
+    });
+    const pathsOrdering = entries.map(([_key, route]) => route.definition);
+    const keysOrdering = entries.map(([_key, route]) => _key);
+    return { pathsOrdering, keysOrdering };
+  }
+  override(config) {
+    const newRoutes = {};
+    for (const key in this.routes) {
+      if (Object.prototype.hasOwnProperty.call(this.routes, key)) {
+        newRoutes[key] = this.routes[key].clone(config);
+      }
+    }
+    const instance = new Routes({
+      routes: newRoutes,
+      isHydrated: true,
+      pathsOrdering: this.pathsOrdering,
+      keysOrdering: this.keysOrdering,
+      ordered: this.keysOrdering.map((key) => newRoutes[key])
+    });
+    return Routes.prettify(instance);
   }
+  static _ = {
+    prettify: Routes.prettify.bind(Routes),
+    hydrate: Routes.hydrate.bind(Routes),
+    makeOrdering: Routes.makeOrdering.bind(Routes)
+  };
 }
 export {
-  Route0
+  Route0,
+  Routes
 };
 //# sourceMappingURL=index.js.map