@devp0nt/route0 1.0.0-next.4 → 1.0.0-next.41

package/dist/cjs/index.cjs

@@ -0,0 +1,561 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  Route0: () => Route0,
+  Routes: () => Routes
+});
+module.exports = __toCommonJS(index_exports);
+class Route0 {
+  definition;
+  pathDefinition;
+  paramsDefinition;
+  searchDefinition;
+  baseUrl;
+  constructor(definition, config = {}) {
+    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 (typeof g?.location?.origin === "string" && g.location.origin.length > 0) {
+        this.baseUrl = g.location.origin;
+      } else {
+        this.baseUrl = "https://example.com";
+      }
+    }
+  }
+  static create(definition, config) {
+    if (typeof definition === "function") {
+      return definition.clone(config);
+    }
+    if (typeof definition === "object") {
+      return definition.clone(config);
+    }
+    const original = new Route0(definition, config);
+    const callable = original.get.bind(original);
+    Object.setPrototypeOf(callable, original);
+    Object.defineProperty(callable, Symbol.toStringTag, {
+      value: original.definition
+    });
+    return callable;
+  }
+  static from(definition) {
+    if (typeof definition === "function") {
+      return definition;
+    }
+    const original = typeof definition === "object" ? definition : new Route0(definition);
+    const callable = original.get.bind(original);
+    Object.setPrototypeOf(callable, original);
+    Object.defineProperty(callable, Symbol.toStringTag, {
+      value: original.definition
+    });
+    return callable;
+  }
+  static _splitPathDefinitionAndSearchTailDefinition(definition) {
+    const i = definition.indexOf("&");
+    if (i === -1) return { pathDefinition: definition, searchTailDefinition: "" };
+    return {
+      pathDefinition: definition.slice(0, i),
+      searchTailDefinition: definition.slice(i)
+    };
+  }
+  static _getAbsPath(baseUrl, pathWithSearch) {
+    return new URL(pathWithSearch, baseUrl).toString().replace(/\/$/, "");
+  }
+  static _getPathDefinitionBydefinition(definition) {
+    const { pathDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(definition);
+    return pathDefinition;
+  }
+  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 _getSearchDefinitionBydefinition(definition) {
+    const { searchTailDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(definition);
+    if (!searchTailDefinition) {
+      return void 0;
+    }
+    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 searchDefinition;
+  }
+  extend(suffixDefinition) {
+    const { pathDefinition: parentPathDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(this.definition);
+    const { pathDefinition: suffixPathDefinition, searchTailDefinition: suffixSearchTailDefinition } = Route0._splitPathDefinitionAndSearchTailDefinition(suffixDefinition);
+    const pathDefinition = `${parentPathDefinition}/${suffixPathDefinition}`.replace(/\/{2,}/g, "/");
+    const definition = `${pathDefinition}${suffixSearchTailDefinition}`;
+    return Route0.create(definition, { baseUrl: this.baseUrl });
+  }
+  // implementation
+  get(...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: false };
+      }
+      const { search, abs, ...params } = input;
+      return { searchInput: search || {}, paramsInput: params, absInput: abs ?? false };
+    })();
+    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 = this.pathDefinition;
+    url = url.replace(/:([A-Za-z0-9_]+)/g, (_m, k) => encodeURIComponent(String(paramsInput?.[k] ?? "")));
+    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 Route0.create(this.definition, config);
+  }
+  getRegexBaseStrictString() {
+    return this.pathDefinition.replace(/:(\w+)/g, "___PARAM___").replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/___PARAM___/g, "([^/]+)");
+  }
+  getRegexBaseString() {
+    return this.getRegexBaseStrictString().replace(/\/+$/, "") + "/?";
+  }
+  getRegexStrictString() {
+    return `^${this.getRegexBaseStrictString()}$`;
+  }
+  getRegexString() {
+    return `^${this.getRegexBaseString()}$`;
+  }
+  getRegexStrict() {
+    return new RegExp(this.getRegexStrictString());
+  }
+  getRegex() {
+    return new RegExp(this.getRegexString());
+  }
+  static getRegexStrictStringGroup(routes) {
+    const patterns = routes.map((route) => route.getRegexStrictString()).join("|");
+    return `(${patterns})`;
+  }
+  static getRegexStrictGroup(routes) {
+    const patterns = this.getRegexStrictStringGroup(routes);
+    return new RegExp(`^(${patterns})$`);
+  }
+  static getRegexStringGroup(routes) {
+    const patterns = routes.map((route) => route.getRegexString()).join("|");
+    return `(${patterns})`;
+  }
+  static getRegexGroup(routes) {
+    const patterns = this.getRegexStringGroup(routes);
+    return new RegExp(`^(${patterns})$`);
+  }
+  static toRelLocation(location) {
+    return {
+      ...location,
+      abs: false,
+      origin: void 0,
+      href: void 0,
+      port: void 0,
+      host: void 0,
+      hostname: void 0
+    };
+  }
+  static toAbsLocation(location, baseUrl) {
+    const relLoc = Route0.toRelLocation(location);
+    const url = new URL(relLoc.hrefRel, baseUrl);
+    return {
+      ...location,
+      abs: true,
+      origin: url.origin,
+      href: url.href,
+      port: url.port,
+      host: url.host,
+      hostname: url.hostname
+    };
+  }
+  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 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(`^${this.getRegexBaseString()}$`);
+    const parentRe = new RegExp(`^${this.getRegexBaseString()}(?:/.*)?$`);
+    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)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Route0,
+  Routes
+});
+//# sourceMappingURL=index.cjs.map