@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-AXVRUDMB.cjs

@@ -0,0 +1,203 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } 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; } async function _asyncOptionalChain(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 = await fn(value); } else if (op === 'call' || op === 'optionalCall') { value = await fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+var _chunkKORZ6PREcjs = require('./chunk-KORZ6PRE.cjs');
+
+
+var _chunk4DCWVSL2cjs = require('./chunk-4DCWVSL2.cjs');
+
+
+var _chunkCFG4QERRcjs = require('./chunk-CFG4QERR.cjs');
+
+// src/metadata-image.ts
+var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element");
+var REACT_TRANSITIONAL_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element");
+var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+function isResponse(value) {
+  return typeof Response !== "undefined" && (value instanceof Response || Boolean(
+    value && typeof value === "object" && typeof value.arrayBuffer === "function" && value.headers
+  ));
+}
+function isThenable(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && typeof value.then === "function"
+  );
+}
+function isReactElement(value) {
+  if (!value || typeof value !== "object") return false;
+  const marker = value.$$typeof;
+  return marker === REACT_ELEMENT_TYPE || marker === REACT_TRANSITIONAL_ELEMENT_TYPE;
+}
+function isMetadataImageElement(value, renderer) {
+  return renderer ? renderer.isValidElement(value) : isReactElement(value);
+}
+async function prepareMetadataImageNode(node, renderer) {
+  if (isThenable(node)) {
+    return prepareMetadataImageNode(await node, renderer);
+  }
+  if (Array.isArray(node)) {
+    return Promise.all(node.map((child) => prepareMetadataImageNode(child, renderer)));
+  }
+  if (!isMetadataImageElement(node, renderer)) {
+    return node;
+  }
+  const element = node;
+  const type = element.type;
+  const props = element.props || {};
+  if (typeof type === "function") {
+    if (_optionalChain([type, 'access', _ => _.prototype, 'optionalAccess', _2 => _2.isReactComponent])) {
+      throw new Error(
+        "Metadata image components must be stateless function components; React class components are not supported."
+      );
+    }
+    return prepareMetadataImageNode(await type(props), renderer);
+  }
+  if (type && typeof type === "object") {
+    if (type.$$typeof === REACT_MEMO_TYPE) {
+      const { createElement: createElement2 } = await import("react");
+      return prepareMetadataImageNode(createElement2(type.type, props), renderer);
+    }
+    if (type.$$typeof === REACT_FORWARD_REF_TYPE) {
+      return prepareMetadataImageNode(await type.render(props, null), renderer);
+    }
+    if (type.$$typeof === REACT_LAZY_TYPE) {
+      const { createElement: createElement2 } = await import("react");
+      let resolvedType;
+      try {
+        resolvedType = type._init(type._payload);
+      } catch (suspension) {
+        if (suspension && typeof suspension.then === "function") {
+          await suspension;
+          resolvedType = type._init(type._payload);
+        } else {
+          throw suspension;
+        }
+      }
+      return prepareMetadataImageNode(createElement2(resolvedType, props), renderer);
+    }
+  }
+  const preparedChildren = await prepareMetadataImageNode(props.children, renderer);
+  const preparedProps = { ...props };
+  if (typeof preparedProps.className === "string") {
+    preparedProps.tw = [preparedProps.tw, preparedProps.className].filter(Boolean).join(" ");
+    delete preparedProps.className;
+  }
+  delete preparedProps.children;
+  const createElement = await _asyncNullishCoalesce(await _asyncOptionalChain([renderer, 'optionalAccess', async _3 => _3.createElement]), async () => ( (await import("react")).createElement));
+  return createElement(type, {
+    ...preparedProps,
+    key: element.key,
+    children: preparedChildren
+  });
+}
+async function normalizeFonts(fonts) {
+  if (!_optionalChain([fonts, 'optionalAccess', _4 => _4.length])) return void 0;
+  return Promise.all(
+    fonts.map(async (font) => {
+      const data = await font.data;
+      const arrayBuffer = ArrayBuffer.isView(data) ? toArrayBuffer(data) : data;
+      return { ...font, data: arrayBuffer };
+    })
+  );
+}
+function resolveCacheControl(revalidate) {
+  if (revalidate === false) {
+    return "public, max-age=31536000, immutable";
+  }
+  if (typeof revalidate === "number" && Number.isFinite(revalidate) && revalidate > 0) {
+    return `public, s-maxage=${Math.floor(revalidate)}, stale-while-revalidate=300`;
+  }
+  return "public, max-age=0, must-revalidate";
+}
+function toArrayBuffer(value) {
+  if (value instanceof ArrayBuffer) return value;
+  const bytes = new Uint8Array(value.byteLength);
+  bytes.set(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  return bytes.buffer;
+}
+async function createEntityTag(body) {
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", body);
+  const hash = Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 32);
+  return `"${hash}"`;
+}
+async function finalizeMetadataImageResponse(body, headers, options) {
+  const responseHeaders = new Headers(headers);
+  const etag = await createEntityTag(body);
+  responseHeaders.set("ETag", etag);
+  responseHeaders.set("Content-Length", String(body.byteLength));
+  responseHeaders.set("X-Content-Type-Options", "nosniff");
+  if (_chunkCFG4QERRcjs.matchesFarmIfNoneMatch.call(void 0, options.ifNoneMatch, etag)) {
+    return new Response(null, { status: 304, headers: responseHeaders });
+  }
+  return new Response(_optionalChain([options, 'access', _5 => _5.method, 'optionalAccess', _6 => _6.toUpperCase, 'call', _7 => _7()]) === "HEAD" ? null : body, {
+    status: 200,
+    headers: responseHeaders
+  });
+}
+async function loadVercelOg() {
+  try {
+    return await import("@vercel/og");
+  } catch (error) {
+    if (!_chunkKORZ6PREcjs.isMissingPackageError.call(void 0, error, "@vercel/og")) throw error;
+    throw _chunkKORZ6PREcjs.withOptionalPeerCause.call(void 0, 
+      new Error(
+        `Rendering a metadata image from JSX needs @vercel/og, which is not installed. ${_chunkKORZ6PREcjs.VERCEL_OG_INSTALL_HINT}`
+      ),
+      error
+    );
+  }
+}
+async function createFarmMetadataImageResponse(value, imageModule, options = {}) {
+  const method = (options.method || "GET").toUpperCase();
+  if (method !== "GET" && method !== "HEAD") {
+    return new Response(null, { status: 405, headers: { Allow: "GET, HEAD" } });
+  }
+  if (isResponse(value)) {
+    return method === "HEAD" ? _chunk4DCWVSL2cjs.omitFarmResponseBody.call(void 0, value) : value;
+  }
+  const cacheControl = resolveCacheControl(imageModule.revalidate);
+  const explicitContentType = _optionalChain([imageModule, 'access', _8 => _8.contentType, 'optionalAccess', _9 => _9.split, 'call', _10 => _10(";", 1), 'access', _11 => _11[0], 'optionalAccess', _12 => _12.trim, 'call', _13 => _13(), 'access', _14 => _14.toLowerCase, 'call', _15 => _15()]);
+  const { renderer } = options;
+  const isElement = isMetadataImageElement(value, renderer);
+  if (isElement && explicitContentType !== "image/svg+xml") {
+    const { ImageResponse } = await loadVercelOg();
+    const element = await prepareMetadataImageNode(value, renderer);
+    const response = new ImageResponse(element, {
+      width: _optionalChain([imageModule, 'access', _16 => _16.size, 'optionalAccess', _17 => _17.width]) || 1200,
+      height: _optionalChain([imageModule, 'access', _18 => _18.size, 'optionalAccess', _19 => _19.height]) || 630,
+      fonts: await normalizeFonts(imageModule.fonts),
+      emoji: imageModule.emoji,
+      debug: imageModule.debug,
+      headers: { "cache-control": cacheControl }
+    });
+    const headers = new Headers(response.headers);
+    headers.set("Cache-Control", cacheControl);
+    return finalizeMetadataImageResponse(await response.arrayBuffer(), headers, options);
+  }
+  let body;
+  if (typeof value === "string") {
+    body = toArrayBuffer(new TextEncoder().encode(value));
+  } else if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    body = toArrayBuffer(value);
+  } else if (isElement) {
+    const markup = renderer ? await renderer.renderToString(value) : (await import("react-dom/server")).renderToStaticMarkup(value);
+    body = toArrayBuffer(new TextEncoder().encode(markup));
+  } else {
+    throw new Error("Metadata image must return a Response, string, bytes, or React element");
+  }
+  return finalizeMetadataImageResponse(
+    body,
+    {
+      "Content-Type": imageModule.contentType || "image/svg+xml; charset=utf-8",
+      "Cache-Control": cacheControl
+    },
+    options
+  );
+}
+
+
+
+exports.createFarmMetadataImageResponse = createFarmMetadataImageResponse;

package/dist/chunk-AY2YD5ZX.mjs

@@ -0,0 +1,34 @@
+// src/request-cookies.ts
+function parseRequestCookieHeader(header) {
+  if (!header?.trim()) return [];
+  return header.split(";").map((part) => part.trim()).filter(Boolean).map((part) => {
+    const separatorIndex = part.indexOf("=");
+    if (separatorIndex === -1) {
+      return {
+        name: decodeCookieName(part),
+        value: ""
+      };
+    }
+    return {
+      name: decodeCookieName(part.slice(0, separatorIndex).trim()),
+      value: decodeCookiePart(part.slice(separatorIndex + 1).trim())
+    };
+  }).filter((cookie) => cookie.name.length > 0);
+}
+var RESERVED_PREFIX = /^__(host|secure)-/i;
+function decodeCookieName(raw) {
+  const decoded = decodeCookiePart(raw);
+  return RESERVED_PREFIX.test(decoded) && !RESERVED_PREFIX.test(raw) ? raw : decoded;
+}
+function decodeCookiePart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+export {
+  parseRequestCookieHeader,
+  decodeCookieName
+};

package/dist/chunk-AYP2YFVN.mjs

@@ -0,0 +1,168 @@
+// src/routing/specificity.ts
+var AmbiguousRouteError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AmbiguousRouteError";
+  }
+};
+var NonTerminalCatchAllRouteError = class extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "NonTerminalCatchAllRouteError";
+  }
+};
+var DuplicateRouteParameterError = class extends AmbiguousRouteError {
+  constructor(message) {
+    super(message);
+    this.name = "DuplicateRouteParameterError";
+  }
+};
+var ReservedRouteParameterError = class extends AmbiguousRouteError {
+  constructor(message) {
+    super(message);
+    this.name = "ReservedRouteParameterError";
+  }
+};
+var BrowserUnstableRouteError = class extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "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;
+}
+function compareRoutePatternSpecificity(left, right, syntax = "page") {
+  return compareRouteSpecificity(
+    getRoutePatternSpecificity(left, syntax),
+    getRoutePatternSpecificity(right, syntax)
+  );
+}
+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}".`
+      );
+    }
+  }
+}
+function hasControlCharacter(value) {
+  return Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+}
+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);
+  }
+}
+function splitRoutePattern(pattern, syntax) {
+  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
+    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
+  );
+}
+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}".`
+    );
+  }
+}
+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);
+}
+function getRoutePatternSpecificity(pattern, syntax = "page") {
+  assertTerminalCatchAll(pattern, syntax);
+  return splitRoutePattern(pattern, syntax).map(
+    (segment) => getPatternSegmentSpecificity(segment, syntax)
+  );
+}
+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";
+}
+
+export {
+  AmbiguousRouteError,
+  NonTerminalCatchAllRouteError,
+  compareRouteSpecificity,
+  compareRoutePatternSpecificity,
+  assertBrowserStableRoutePath,
+  assertUniqueRouteParameters,
+  assertTerminalCatchAll,
+  getRoutePatternShape,
+  getRoutePatternSpecificity
+};

package/dist/chunk-AZQXXXDX.mjs

@@ -0,0 +1,80 @@
+// src/cache-invalidation.ts
+var FARM_CACHE_INVALIDATION_HEADER = "x-farm-cache-invalidations";
+var FARM_CACHE_INVALIDATION_STATE = /* @__PURE__ */ Symbol.for("farm.cacheInvalidationState");
+var globalState = globalThis;
+function getFarmCacheInvalidationState() {
+  return globalState[FARM_CACHE_INVALIDATION_STATE] ?? (globalState[FARM_CACHE_INVALIDATION_STATE] = {
+    listeners: /* @__PURE__ */ new Set(),
+    taskListeners: /* @__PURE__ */ new Set()
+  });
+}
+function warnFarmCacheListenerError(scope, error) {
+  const detail = error instanceof Error ? error.stack ?? error.message : String(error);
+  console.warn(`[farm:cache] ${scope} listener failed: ${detail}`);
+}
+function notifyFarmCacheInvalidation(key, source = "local") {
+  if (typeof key !== "string" || key.length === 0) return;
+  for (const listener of getFarmCacheInvalidationState().listeners) {
+    try {
+      listener(key, source);
+    } catch (error) {
+      warnFarmCacheListenerError("invalidation", error);
+    }
+  }
+}
+function notifyFarmCacheTask(task) {
+  for (const listener of getFarmCacheInvalidationState().taskListeners) {
+    try {
+      listener(task);
+    } catch (error) {
+      warnFarmCacheListenerError("task", error);
+    }
+  }
+}
+function applyFarmCacheInvalidations(keys, source = "local") {
+  if (!Array.isArray(keys)) return;
+  for (const key of keys) {
+    if (typeof key === "string") {
+      notifyFarmCacheInvalidation(key, source);
+    }
+  }
+}
+function encodeFarmCacheInvalidations(keys) {
+  const normalized = Array.from(
+    new Set(keys.filter((key) => typeof key === "string" && key.length > 0))
+  );
+  if (normalized.length === 0) return null;
+  return encodeURIComponent(JSON.stringify(normalized));
+}
+function decodeFarmCacheInvalidations(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(decodeURIComponent(value));
+    return Array.isArray(parsed) ? Array.from(
+      new Set(parsed.filter((key) => typeof key === "string" && key.length > 0))
+    ) : [];
+  } catch {
+    return [];
+  }
+}
+function subscribeFarmCacheInvalidation(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.listeners.add(listener);
+  return () => state.listeners.delete(listener);
+}
+function subscribeFarmCacheTask(listener) {
+  const state = getFarmCacheInvalidationState();
+  state.taskListeners.add(listener);
+  return () => state.taskListeners.delete(listener);
+}
+
+export {
+  FARM_CACHE_INVALIDATION_HEADER,
+  notifyFarmCacheInvalidation,
+  notifyFarmCacheTask,
+  applyFarmCacheInvalidations,
+  encodeFarmCacheInvalidations,
+  decodeFarmCacheInvalidations,
+  subscribeFarmCacheInvalidation,
+  subscribeFarmCacheTask
+};