@farm.js/core 0.1.17 → 0.1.18

package/dist/router.cjs

@@ -1,478 +1,15 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/router.ts
-var router_exports = {};
-__export(router_exports, {
-  buildFarmRoutePath: () => buildFarmRoutePath,
-  createFarmRouter: () => createFarmRouter,
-  isFarmRouteActive: () => isFarmRouteActive,
-  matchFarmRoute: () => matchFarmRoute
-});
-module.exports = __toCommonJS(router_exports);
 
-// src/routing/specificity.ts
-var _AmbiguousRouteError = class _AmbiguousRouteError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AmbiguousRouteError";
-  }
-};
-__name(_AmbiguousRouteError, "AmbiguousRouteError");
-var AmbiguousRouteError = _AmbiguousRouteError;
-var _NonTerminalCatchAllRouteError = class _NonTerminalCatchAllRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "NonTerminalCatchAllRouteError";
-  }
-};
-__name(_NonTerminalCatchAllRouteError, "NonTerminalCatchAllRouteError");
-var NonTerminalCatchAllRouteError = _NonTerminalCatchAllRouteError;
-var _DuplicateRouteParameterError = class _DuplicateRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "DuplicateRouteParameterError";
-  }
-};
-__name(_DuplicateRouteParameterError, "DuplicateRouteParameterError");
-var DuplicateRouteParameterError = _DuplicateRouteParameterError;
-var _ReservedRouteParameterError = class _ReservedRouteParameterError extends AmbiguousRouteError {
-  constructor(message) {
-    super(message);
-    this.name = "ReservedRouteParameterError";
-  }
-};
-__name(_ReservedRouteParameterError, "ReservedRouteParameterError");
-var ReservedRouteParameterError = _ReservedRouteParameterError;
-var _BrowserUnstableRouteError = class _BrowserUnstableRouteError extends TypeError {
-  constructor(message) {
-    super(message);
-    this.name = "BrowserUnstableRouteError";
-  }
-};
-__name(_BrowserUnstableRouteError, "BrowserUnstableRouteError");
-var BrowserUnstableRouteError = _BrowserUnstableRouteError;
-var SEGMENT_RANK = {
-  static: 4,
-  dynamic: 3,
-  "catch-all": 1,
-  "optional-catch-all": 0
-};
-var ROUTE_END_RANK = 2;
-function compareRouteSpecificity(left, right) {
-  const length = Math.max(left.length, right.length);
-  for (let index = 0; index < length; index++) {
-    const leftRank = index < left.length ? SEGMENT_RANK[left[index]] : ROUTE_END_RANK;
-    const rightRank = index < right.length ? SEGMENT_RANK[right[index]] : ROUTE_END_RANK;
-    if (leftRank !== rightRank) return rightRank - leftRank;
-  }
-  return 0;
-}
-__name(compareRouteSpecificity, "compareRouteSpecificity");
-var ROUTER_PARAMETER_NAME = "[A-Za-z0-9_$-]+";
-var PAGE_PARAMETER_PATTERN = /^(?:\[\[\.\.\.(.+)\]\]|\[\.\.\.(.+)\]|\[(.+)\])$/;
-var ROUTER_PARAMETER_PATTERN = /^(?:\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]|\[\.\.\.([A-Za-z0-9_$-]+)\]|\[([A-Za-z0-9_$-]+)\]|:([A-Za-z0-9_$-]+)|\*([A-Za-z0-9_$-]+)\??)$/;
-var RESERVED_PARAMETER_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function assertBrowserStableRoutePath(pattern) {
-  if (pattern.includes("\\") || hasControlCharacter(pattern)) {
-    throw new BrowserUnstableRouteError(
-      `Route path "${pattern}" cannot contain backslashes or control characters.`
-    );
-  }
-  for (const segment of pattern.split("/").filter(Boolean)) {
-    if (segment.startsWith("(") && segment.endsWith(")") || segment.startsWith("[") && segment.endsWith("]")) {
-      continue;
-    }
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
-      throw new BrowserUnstableRouteError(
-        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
-      );
-    }
-  }
-}
-__name(assertBrowserStableRoutePath, "assertBrowserStableRoutePath");
-function hasControlCharacter(value) {
-  return Array.from(value).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  });
-}
-__name(hasControlCharacter, "hasControlCharacter");
-function assertUniqueRouteParameters(pattern, syntax = "page") {
-  const parameterPattern = syntax === "router" ? ROUTER_PARAMETER_PATTERN : PAGE_PARAMETER_PATTERN;
-  const names = /* @__PURE__ */ new Set();
-  for (const segment of splitRoutePattern(pattern, syntax)) {
-    const match = parameterPattern.exec(segment);
-    const name = match?.slice(1).find(Boolean);
-    if (!name) continue;
-    if (RESERVED_PARAMETER_NAMES.has(name)) {
-      throw new ReservedRouteParameterError(
-        `Route parameter "${name}" in route "${pattern}" is reserved. Use a different parameter name.`
-      );
-    }
-    if (names.has(name)) {
-      throw new DuplicateRouteParameterError(
-        `Duplicate route parameter "${name}" in route "${pattern}". Each dynamic segment must use a unique name.`
-      );
-    }
-    names.add(name);
-  }
-}
-__name(assertUniqueRouteParameters, "assertUniqueRouteParameters");
-function splitRoutePattern(pattern, syntax) {
-  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
-    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
-  );
-}
-__name(splitRoutePattern, "splitRoutePattern");
-function assertTerminalCatchAll(pattern, syntax = "page") {
-  const segments = splitRoutePattern(pattern, syntax);
-  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
-  const catchAllPattern = new RegExp(
-    syntax === "router" ? `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\]|\\*${parameterName}\\??)$` : `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\])$`
-  );
-  const catchAllIndex = segments.findIndex((segment) => catchAllPattern.test(segment));
-  if (catchAllIndex >= 0 && catchAllIndex !== segments.length - 1) {
-    throw new NonTerminalCatchAllRouteError(
-      `Catch-all segment "${segments[catchAllIndex]}" must be the final segment in route "${pattern}".`
-    );
-  }
-}
-__name(assertTerminalCatchAll, "assertTerminalCatchAll");
-function getRoutePatternShape(pattern, syntax = "page") {
-  assertTerminalCatchAll(pattern, syntax);
-  const segments = splitRoutePattern(pattern, syntax).map((segment) => {
-    const specificity = getPatternSegmentSpecificity(segment, syntax);
-    if (specificity !== "static") return specificity;
-    try {
-      return `static:${decodeURIComponent(segment)}`;
-    } catch {
-      return `static:${segment}`;
-    }
-  });
-  return segments.length === 0 ? "/" : JSON.stringify(segments);
-}
-__name(getRoutePatternShape, "getRoutePatternShape");
-function getPatternSegmentSpecificity(segment, syntax) {
-  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
-  const supportsColonAndStar = syntax === "router";
-  if (new RegExp(`^\\[\\[\\.\\.\\.${parameterName}\\]\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}\\?$`).test(segment)) {
-    return "optional-catch-all";
-  }
-  if (new RegExp(`^\\[\\.\\.\\.${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}$`).test(segment)) {
-    return "catch-all";
-  }
-  if (new RegExp(`^\\[${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^:${parameterName}$`).test(segment)) {
-    return "dynamic";
-  }
-  return "static";
-}
-__name(getPatternSegmentSpecificity, "getPatternSegmentSpecificity");
 
-// src/routing/matcher.ts
-function parseRoutePattern(pattern) {
-  assertBrowserStableRoutePath(pattern);
-  assertTerminalCatchAll(pattern, "router");
-  assertUniqueRouteParameters(pattern, "router");
-  return splitRoutePattern2(pattern).filter((part) => !isRouteGroup(part)).map((part) => {
-    const optionalCatchAll = part.match(/^\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]$/);
-    if (optionalCatchAll) {
-      return {
-        type: "dynamic",
-        name: optionalCatchAll[1],
-        catchAll: true,
-        optional: true
-      };
-    }
-    const catchAll = part.match(/^\[\.\.\.([A-Za-z0-9_$-]+)\]$/);
-    if (catchAll) {
-      return {
-        type: "dynamic",
-        name: catchAll[1],
-        catchAll: true,
-        optional: false
-      };
-    }
-    const dynamic = part.match(/^\[([A-Za-z0-9_$-]+)\]$/) || part.match(/^:([A-Za-z0-9_$-]+)$/);
-    if (dynamic) {
-      return {
-        type: "dynamic",
-        name: dynamic[1],
-        catchAll: false,
-        optional: false
-      };
-    }
-    const star = part.match(/^\*([A-Za-z0-9_$-]+)(\?)?$/);
-    if (star) {
-      return {
-        type: "dynamic",
-        name: star[1],
-        catchAll: true,
-        optional: !!star[2]
-      };
-    }
-    return {
-      type: "static",
-      value: decodePathSegment(part)
-    };
-  });
-}
-__name(parseRoutePattern, "parseRoutePattern");
-function matchSegmentParts(segments, parts, allowTrailingSegments = false) {
-  const params = {};
-  if (segments.length === 0) {
-    return parts.length === 0 ? params : null;
-  }
-  let pathIndex = 0;
-  for (const segment of segments) {
-    if (segment.type === "static") {
-      if (decodePathSegment(parts[pathIndex] || "") !== segment.value) return null;
-      pathIndex++;
-      continue;
-    }
-    if (segment.catchAll) {
-      const remaining = parts.slice(pathIndex).map(decodePathSegment);
-      if (remaining.length === 0 && !segment.optional) return null;
-      params[segment.name] = remaining.join("/");
-      pathIndex = parts.length;
-      continue;
-    }
-    const value = parts[pathIndex];
-    if (!value) return null;
-    params[segment.name] = decodePathSegment(value);
-    pathIndex++;
-  }
-  return allowTrailingSegments || pathIndex === parts.length ? params : null;
-}
-__name(matchSegmentParts, "matchSegmentParts");
-function normalizePathname(value) {
-  const raw = value || "/";
-  let pathname = raw;
-  try {
-    pathname = new URL(raw, "http://farm.local").pathname;
-  } catch {
-    pathname = raw.split(/[?#]/, 1)[0] || "/";
-  }
-  pathname = pathname.replace(/\\/g, "/").replace(/\/+/g, "/");
-  if (!pathname.startsWith("/")) pathname = `/${pathname}`;
-  if (pathname.length > 1) pathname = pathname.replace(/\/+$/, "");
-  return pathname || "/";
-}
-__name(normalizePathname, "normalizePathname");
-function splitPathname(pathname) {
-  return splitNormalizedPathname(normalizePathname(pathname));
-}
-__name(splitPathname, "splitPathname");
-function splitNormalizedPathname(pathname) {
-  return pathname.split("/").filter(Boolean);
-}
-__name(splitNormalizedPathname, "splitNormalizedPathname");
-function normalizeRoutePattern(value) {
-  let pathname = (value || "/").replace(/\\/g, "/").replace(/\/+/g, "/");
-  if (!pathname.startsWith("/")) pathname = `/${pathname}`;
-  if (pathname.length > 1) pathname = pathname.replace(/\/+$/, "");
-  return pathname || "/";
-}
-__name(normalizeRoutePattern, "normalizeRoutePattern");
-function splitRoutePattern2(pattern) {
-  return normalizeRoutePattern(pattern).split("/").filter(Boolean);
-}
-__name(splitRoutePattern2, "splitRoutePattern");
-function isRouteGroup(part) {
-  return part.startsWith("(") && part.endsWith(")");
-}
-__name(isRouteGroup, "isRouteGroup");
-function decodePathSegment(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-__name(decodePathSegment, "decodePathSegment");
 
-// src/router.ts
-function createFarmRouter(routes) {
-  const normalizedRoutes = routes.map(normalizeRouteInput);
-  const patternsByShape = /* @__PURE__ */ new Map();
-  for (const entry of normalizedRoutes) {
-    const shape = getRoutePatternShape(entry.route.path, "router");
-    const existingPattern = patternsByShape.get(shape);
-    if (existingPattern) {
-      throw new AmbiguousRouteError(
-        `Ambiguous route patterns "${existingPattern}" and "${entry.route.path}" match the same URLs. Keep only one route for this URL shape.`
-      );
-    }
-    patternsByShape.set(shape, entry.route.path);
-  }
-  normalizedRoutes.sort(compareRoutes);
-  const exactRoutes = /* @__PURE__ */ new Map();
-  for (const entry of normalizedRoutes) {
-    if (entry.segments.every((segment) => segment.type === "static")) {
-      const pathname = entry.segments.length ? `/${entry.segments.map((segment) => encodePathSegment(segment.value)).join("/")}` : "/";
-      exactRoutes.set(pathname, entry);
-    }
-  }
-  return {
-    routes: normalizedRoutes.map((entry) => entry.route),
-    match(pathname) {
-      const normalizedPathname = normalizePathname(pathname);
-      const exactRoute = exactRoutes.get(normalizedPathname);
-      if (exactRoute) {
-        return {
-          route: exactRoute.route,
-          pathname: normalizedPathname,
-          params: {}
-        };
-      }
-      const parts = splitNormalizedPathname(normalizedPathname);
-      for (const entry of normalizedRoutes) {
-        const params = matchSegmentParts(entry.segments, parts);
-        if (params) {
-          return {
-            route: entry.route,
-            pathname: normalizedPathname,
-            params
-          };
-        }
-      }
-      return null;
-    },
-    build: buildFarmRoutePath,
-    isActive: isFarmRouteActive
-  };
-}
-__name(createFarmRouter, "createFarmRouter");
-function matchFarmRoute(pattern, pathname) {
-  return matchSegments(parseRoutePattern(pattern), normalizePathname(pathname));
-}
-__name(matchFarmRoute, "matchFarmRoute");
-function buildFarmRoutePath(pattern, params = {}, options = {}) {
-  const parts = [];
-  for (const segment of parseRoutePattern(pattern)) {
-    if (segment.type === "static") {
-      parts.push(encodePathSegment(segment.value));
-      continue;
-    }
-    const value = params[segment.name];
-    const values = Array.isArray(value) ? value : value == null ? [] : [value];
-    if (values.length === 0) {
-      if (segment.optional) continue;
-      throw new Error(`Missing route param "${segment.name}" for ${pattern}.`);
-    }
-    if (!segment.catchAll && values.length > 1) {
-      throw new Error(`Route param "${segment.name}" for ${pattern} expects a single value.`);
-    }
-    const encodedValues = values.map((item) => {
-      const value2 = String(item);
-      if (!value2) {
-        throw new Error(
-          `Route param "${segment.name}" for ${pattern} cannot contain an empty path segment.`
-        );
-      }
-      return encodePathSegment(value2);
-    });
-    parts.push(...encodedValues);
-  }
-  let pathname = parts.length ? `/${parts.join("/")}` : "/";
-  if (options.trailingSlash && pathname !== "/") {
-    pathname = `${pathname}/`;
-  }
-  return appendQueryAndHash(pathname, options);
-}
-__name(buildFarmRoutePath, "buildFarmRoutePath");
-function isFarmRouteActive(pattern, pathname, options = {}) {
-  const normalizedPathname = normalizePathname(pathname);
-  const segments = parseRoutePattern(pattern);
-  const parts = splitNormalizedPathname(normalizedPathname);
-  if (matchSegmentParts(segments, parts)) return true;
-  if (options.exact !== false) return false;
-  if (segments.length === 0) return normalizedPathname === "/";
-  return matchSegmentParts(segments, parts, true) !== null;
-}
-__name(isFarmRouteActive, "isFarmRouteActive");
-function normalizeRouteInput(input, index) {
-  const route = typeof input === "string" ? { path: input } : input;
-  const segments = parseRoutePattern(route.path);
-  const path = normalizeRoutePattern(route.path);
-  return {
-    route: {
-      ...route,
-      path
-    },
-    segments,
-    specificity: segments.map(getRouterSegmentSpecificity),
-    index
-  };
-}
-__name(normalizeRouteInput, "normalizeRouteInput");
-function matchSegments(segments, pathname, allowTrailingSegments = false) {
-  return matchSegmentParts(segments, splitPathname(pathname), allowTrailingSegments);
-}
-__name(matchSegments, "matchSegments");
-function compareRoutes(left, right) {
-  const specificity = compareRouteSpecificity(left.specificity, right.specificity);
-  if (specificity !== 0) return specificity;
-  return left.index - right.index;
-}
-__name(compareRoutes, "compareRoutes");
-function getRouterSegmentSpecificity(segment) {
-  if (segment.type === "static") return "static";
-  if (!segment.catchAll) return "dynamic";
-  return segment.optional ? "optional-catch-all" : "catch-all";
-}
-__name(getRouterSegmentSpecificity, "getRouterSegmentSpecificity");
-function encodePathSegment(value) {
-  return encodeURIComponent(value);
-}
-__name(encodePathSegment, "encodePathSegment");
-function appendQueryAndHash(pathname, options) {
-  const search = createSearchParams(options.query);
-  const hash = options.hash ? `#${options.hash.replace(/^#/, "")}` : "";
-  const query = search.toString();
-  return `${pathname}${query ? `?${query}` : ""}${hash}`;
-}
-__name(appendQueryAndHash, "appendQueryAndHash");
-function createSearchParams(query) {
-  if (query instanceof URLSearchParams) return query;
-  const search = new URLSearchParams();
-  if (!query) return search;
-  for (const [key, value] of Object.entries(query)) {
-    const values = Array.isArray(value) ? value : [value];
-    for (const item of values) {
-      if (item == null) continue;
-      search.append(key, String(item));
-    }
-  }
-  return search;
-}
-__name(createSearchParams, "createSearchParams");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  buildFarmRoutePath,
-  createFarmRouter,
-  isFarmRouteActive,
-  matchFarmRoute
-});
+var _chunkSU7MH53Pcjs = require('./chunk-SU7MH53P.cjs');
+require('./chunk-PCOTGFSM.cjs');
+require('./chunk-NO3WWW3N.cjs');
+require('./chunk-S3JO3N4H.cjs');
+
+
+
+
+
+exports.buildFarmRoutePath = _chunkSU7MH53Pcjs.buildFarmRoutePath; exports.createFarmRouter = _chunkSU7MH53Pcjs.createFarmRouter; exports.isFarmRouteActive = _chunkSU7MH53Pcjs.isFarmRouteActive; exports.matchFarmRoute = _chunkSU7MH53Pcjs.matchFarmRoute;