@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-NO3WWW3N.cjs

@@ -0,0 +1,192 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/routing/specificity.ts
+var _AmbiguousRouteError = class _AmbiguousRouteError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AmbiguousRouteError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _AmbiguousRouteError, "AmbiguousRouteError");
+var AmbiguousRouteError = _AmbiguousRouteError;
+var _NonTerminalCatchAllRouteError = class _NonTerminalCatchAllRouteError extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "NonTerminalCatchAllRouteError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _NonTerminalCatchAllRouteError, "NonTerminalCatchAllRouteError");
+var NonTerminalCatchAllRouteError = _NonTerminalCatchAllRouteError;
+var _DuplicateRouteParameterError = class _DuplicateRouteParameterError extends AmbiguousRouteError {
+  constructor(message) {
+    super(message);
+    this.name = "DuplicateRouteParameterError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _DuplicateRouteParameterError, "DuplicateRouteParameterError");
+var DuplicateRouteParameterError = _DuplicateRouteParameterError;
+var _ReservedRouteParameterError = class _ReservedRouteParameterError extends AmbiguousRouteError {
+  constructor(message) {
+    super(message);
+    this.name = "ReservedRouteParameterError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _ReservedRouteParameterError, "ReservedRouteParameterError");
+var ReservedRouteParameterError = _ReservedRouteParameterError;
+var _BrowserUnstableRouteError = class _BrowserUnstableRouteError extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "BrowserUnstableRouteError";
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _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;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compareRouteSpecificity, "compareRouteSpecificity");
+function compareRoutePatternSpecificity(left, right, syntax = "page") {
+  return compareRouteSpecificity(
+    getRoutePatternSpecificity(left, syntax),
+    getRoutePatternSpecificity(right, syntax)
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, compareRoutePatternSpecificity, "compareRoutePatternSpecificity");
+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 (e) {
+    }
+    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
+      throw new BrowserUnstableRouteError(
+        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
+      );
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertBrowserStableRoutePath, "assertBrowserStableRoutePath");
+function hasControlCharacter(value) {
+  return Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 = _optionalChain([match, 'optionalAccess', _ => _.slice, 'call', _2 => _2(1), 'access', _3 => _3.find, 'call', _4 => _4(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);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertUniqueRouteParameters, "assertUniqueRouteParameters");
+function splitRoutePattern(pattern, syntax) {
+  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
+    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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}".`
+    );
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, 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 (e2) {
+      return `static:${segment}`;
+    }
+  });
+  return segments.length === 0 ? "/" : JSON.stringify(segments);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRoutePatternShape, "getRoutePatternShape");
+function getRoutePatternSpecificity(pattern, syntax = "page") {
+  assertTerminalCatchAll(pattern, syntax);
+  return splitRoutePattern(pattern, syntax).map(
+    (segment) => getPatternSegmentSpecificity(segment, syntax)
+  );
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRoutePatternSpecificity, "getRoutePatternSpecificity");
+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";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getPatternSegmentSpecificity, "getPatternSegmentSpecificity");
+
+
+
+
+
+
+
+
+
+
+
+exports.AmbiguousRouteError = AmbiguousRouteError; exports.NonTerminalCatchAllRouteError = NonTerminalCatchAllRouteError; exports.compareRouteSpecificity = compareRouteSpecificity; exports.compareRoutePatternSpecificity = compareRoutePatternSpecificity; exports.assertBrowserStableRoutePath = assertBrowserStableRoutePath; exports.assertUniqueRouteParameters = assertUniqueRouteParameters; exports.assertTerminalCatchAll = assertTerminalCatchAll; exports.getRoutePatternShape = getRoutePatternShape; exports.getRoutePatternSpecificity = getRoutePatternSpecificity;