@farm.js/core 0.1.47 → 0.1.48

package/dist/chunk-DU4VHHPJ.mjs

@@ -0,0 +1,157 @@
+import {
+  resolveFarmI18nMessagePath
+} from "./chunk-MU5V7XHL.mjs";
+
+// src/i18n/catalog.ts
+import { readFile } from "fs/promises";
+import { TYPE, parse } from "@formatjs/icu-messageformat-parser";
+async function readFarmI18nCatalogs(config) {
+  if (!config.enabled) {
+    return { catalogs: {}, signatures: {} };
+  }
+  const catalogs = {};
+  for (const locale of config.locales) {
+    const filePath = resolveFarmI18nMessagePath(config, locale);
+    let source;
+    try {
+      source = await readFile(filePath, "utf8");
+    } catch (error) {
+      throw new Error(
+        `Unable to read Farm i18n catalog for "${locale}" at ${filePath}: ${messageOf(error)}`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(source);
+    } catch (error) {
+      throw new Error(`Invalid JSON in Farm i18n catalog ${filePath}: ${messageOf(error)}`);
+    }
+    catalogs[locale] = flattenFarmI18nCatalog(parsed, filePath);
+  }
+  const reference = catalogs[config.defaultLocale] || {};
+  const signatures = {};
+  for (const [key, message] of Object.entries(reference)) {
+    signatures[key] = analyzeFarmI18nMessage(message, `${config.defaultLocale}:${key}`);
+  }
+  validateFarmI18nCatalogs(config, catalogs, signatures);
+  return { catalogs, signatures };
+}
+function flattenFarmI18nCatalog(input, source = "i18n catalog") {
+  if (!isPlainObject(input)) {
+    throw new Error(`${source} must contain a JSON object at its root.`);
+  }
+  const output = {};
+  const visit = (value, segments) => {
+    if (typeof value === "string") {
+      const key = segments.join(".");
+      if (!key) throw new Error(`${source} contains an empty message key.`);
+      if (Object.prototype.hasOwnProperty.call(output, key)) {
+        throw new Error(`${source} contains duplicate message key "${key}".`);
+      }
+      output[key] = value;
+      return;
+    }
+    if (!isPlainObject(value)) {
+      const key = segments.join(".") || "<root>";
+      throw new Error(`${source} message "${key}" must be a string or nested object.`);
+    }
+    for (const [key, nested] of Object.entries(value)) {
+      if (!key.trim()) throw new Error(`${source} contains an empty message key.`);
+      visit(nested, [...segments, key]);
+    }
+  };
+  visit(input, []);
+  return output;
+}
+function analyzeFarmI18nMessage(message, label = "message") {
+  let ast;
+  try {
+    ast = parse(message, { captureLocation: false });
+  } catch (error) {
+    throw new Error(`Invalid ICU syntax in ${label}: ${messageOf(error)}`);
+  }
+  const signature = {};
+  collectArguments(ast, signature, label);
+  return signature;
+}
+function validateFarmI18nCatalogs(config, catalogs, signatures) {
+  const referenceKeys = Object.keys(catalogs[config.defaultLocale] || {}).sort();
+  for (const locale of config.locales) {
+    const catalog = catalogs[locale] || {};
+    const localeKeys = Object.keys(catalog).sort();
+    const missing = referenceKeys.filter(
+      (key) => !Object.prototype.hasOwnProperty.call(catalog, key)
+    );
+    const extra = localeKeys.filter(
+      (key) => !Object.prototype.hasOwnProperty.call(signatures, key)
+    );
+    if (config.strict && (missing.length > 0 || extra.length > 0)) {
+      const details = [
+        missing.length ? `missing: ${missing.join(", ")}` : "",
+        extra.length ? `extra: ${extra.join(", ")}` : ""
+      ].filter(Boolean).join("; ");
+      throw new Error(
+        `Farm i18n catalog "${locale}" does not match the default catalog (${details}).`
+      );
+    }
+    for (const [key, message] of Object.entries(catalog)) {
+      const actual = analyzeFarmI18nMessage(message, `${locale}:${key}`);
+      const expected = signatures[key];
+      if (!expected || sameSignature(expected, actual)) continue;
+      throw new Error(
+        `Farm i18n message "${key}" in "${locale}" uses different variables than "${config.defaultLocale}".`
+      );
+    }
+  }
+}
+function collectArguments(elements, signature, label) {
+  for (const element of elements) {
+    switch (element.type) {
+      case TYPE.argument:
+        addArgument(signature, element.value, "string", label);
+        break;
+      case TYPE.number:
+      case TYPE.plural:
+        addArgument(signature, element.value, "number", label);
+        break;
+      case TYPE.date:
+      case TYPE.time:
+        addArgument(signature, element.value, "date", label);
+        break;
+      case TYPE.select:
+        addArgument(signature, element.value, "select", label);
+        break;
+      case TYPE.tag:
+        addArgument(signature, element.value, "rich", label);
+        collectArguments(element.children, signature, label);
+        break;
+    }
+    if (element.type === TYPE.plural || element.type === TYPE.select) {
+      for (const option of Object.values(element.options)) {
+        collectArguments(option.value, signature, label);
+      }
+    }
+  }
+}
+function addArgument(signature, name, kind, label) {
+  const existing = signature[name];
+  if (existing && existing !== kind) {
+    throw new Error(`Farm i18n ${label} uses variable "${name}" as both ${existing} and ${kind}.`);
+  }
+  signature[name] = kind;
+}
+function sameSignature(expected, actual) {
+  const expectedEntries = Object.entries(expected).sort(([a], [b]) => a.localeCompare(b));
+  const actualEntries = Object.entries(actual).sort(([a], [b]) => a.localeCompare(b));
+  return JSON.stringify(expectedEntries) === JSON.stringify(actualEntries);
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export {
+  readFarmI18nCatalogs
+};

package/dist/chunk-DUIP64BF.cjs

@@ -0,0 +1,16 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/plugin-integration-context.ts
+var FARM_PLUGIN_INTEGRATION_CONTEXT = /* @__PURE__ */ Symbol.for("@farm.js/core/plugin-integration-context");
+function setFarmPluginIntegrationContext(plugin, integration) {
+  Object.defineProperty(plugin, FARM_PLUGIN_INTEGRATION_CONTEXT, {
+    value: integration
+  });
+}
+function getFarmPluginIntegrationContext(plugin) {
+  const value = plugin[FARM_PLUGIN_INTEGRATION_CONTEXT];
+  return value && typeof value === "object" ? value : void 0;
+}
+
+
+
+
+exports.setFarmPluginIntegrationContext = setFarmPluginIntegrationContext; exports.getFarmPluginIntegrationContext = getFarmPluginIntegrationContext;

package/dist/chunk-DV52ZS53.cjs

@@ -0,0 +1,40 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkSXCL2MINcjs = require('./chunk-SXCL2MIN.cjs');
+
+// src/query/params.ts
+function parseParam(input, key, parser) {
+  const values = input instanceof URLSearchParams ? input.getAll(key) : [_nullishCoalesce(input[key], () => ( ""))];
+  return {
+    raw: values.length > 1 ? values.join(",") : _nullishCoalesce(values[0], () => ( "")),
+    parsed: _chunkSXCL2MINcjs.parseQueryParameter.call(void 0, parser, values)
+  };
+}
+async function loadRouteParams(input, parsers, options = {}) {
+  const resolved = await Promise.resolve(input);
+  const result = {};
+  for (const [key, parser] of Object.entries(parsers)) {
+    const { raw, parsed } = parseParam(resolved, key, parser);
+    if (parsed === null && options.strict) {
+      throw new Error(`Failed to parse route param "${key}" with value "${raw}"`);
+    }
+    result[key] = parsed;
+  }
+  return result;
+}
+function parseRouteParams(input, parsers, options = {}) {
+  const result = {};
+  for (const [key, parser] of Object.entries(parsers)) {
+    const { raw, parsed } = parseParam(input, key, parser);
+    if (parsed === null && options.strict) {
+      throw new Error(`Failed to parse route param "${key}" with value "${raw}"`);
+    }
+    result[key] = parsed;
+  }
+  return result;
+}
+
+
+
+
+exports.loadRouteParams = loadRouteParams; exports.parseRouteParams = parseRouteParams;

package/dist/chunk-DXUXQP2T.cjs

@@ -0,0 +1,142 @@
+"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; }// src/cache-key.ts
+function createRouteDataCacheKey(key) {
+  return createFarmCacheKey(Array.isArray(key) ? key : [key]);
+}
+function createFarmCacheKey(parts) {
+  return stableSerialize(parts);
+}
+function getFunctionCacheIdentity(fn) {
+  const name = fn.name || "anonymous";
+  return `${name}:${hashFunctionSource(String(fn))}`;
+}
+function hashFunctionSource(source) {
+  let hash = 2166136261;
+  for (let index = 0; index < source.length; index++) {
+    hash ^= source.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+function compareCodepoint(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function serializeBinaryBytes(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function serializeCanonicalStringEntries(entries, seen) {
+  const valuesByKey = /* @__PURE__ */ new Map();
+  for (const [key, item] of entries) {
+    const values = valuesByKey.get(key);
+    if (values) values.push(item);
+    else valuesByKey.set(key, [item]);
+  }
+  return Array.from(valuesByKey.keys()).sort(compareCodepoint).flatMap(
+    (key) => valuesByKey.get(key).map((item) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`)
+  ).join(",");
+}
+function isPlainCacheKeyObject(value) {
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype === null) return true;
+  const constructor = _optionalChain([Object, 'access', _ => _.getOwnPropertyDescriptor, 'call', _2 => _2(prototype, "constructor"), 'optionalAccess', _3 => _3.value]);
+  return Object.getPrototypeOf(prototype) === null && typeof constructor === "function" && constructor.name === "Object";
+}
+function getCacheKeyValueType(value) {
+  const prototype = Object.getPrototypeOf(value);
+  const constructor = prototype ? _optionalChain([Object, 'access', _4 => _4.getOwnPropertyDescriptor, 'call', _5 => _5(prototype, "constructor"), 'optionalAccess', _6 => _6.value]) : void 0;
+  if (typeof constructor === "function" && constructor.name) {
+    return constructor.name;
+  }
+  return Object.prototype.toString.call(value).slice(8, -1) || "object";
+}
+function stableSerialize(value, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const valueType = typeof value;
+  if (valueType === "string") return JSON.stringify(value);
+  if (valueType === "number" || valueType === "boolean" || valueType === "bigint") {
+    return `${valueType}:${String(value)}`;
+  }
+  if (valueType === "symbol") {
+    return `symbol:${String(value)}`;
+  }
+  if (valueType === "function") {
+    return `function:${getFunctionCacheIdentity(value)}`;
+  }
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? "date:invalid" : `date:${value.toISOString()}`;
+  }
+  if (value instanceof URL) {
+    return `url:${value.toString()}`;
+  }
+  if (value instanceof RegExp) {
+    return `regexp:${value.toString()}`;
+  }
+  if (value instanceof ArrayBuffer) {
+    return `arraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
+  }
+  if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
+    return `sharedarraybuffer:${serializeBinaryBytes(new Uint8Array(value))}`;
+  }
+  if (ArrayBuffer.isView(value)) {
+    const viewType = Object.prototype.toString.call(value).slice(8, -1);
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return `binary:${viewType}:${serializeBinaryBytes(bytes)}`;
+  }
+  if (value && typeof value === "object") {
+    if (seen.has(value)) {
+      return "[Circular]";
+    }
+    seen.add(value);
+    if (Array.isArray(value)) {
+      const items = [];
+      for (let index = 0; index < value.length; index++) {
+        items.push(
+          Object.prototype.hasOwnProperty.call(value, index) ? stableSerialize(value[index], seen) : "[Hole]"
+        );
+      }
+      seen.delete(value);
+      return `[${items.join(",")}]`;
+    }
+    if (value instanceof Set) {
+      const items = Array.from(value, (item) => stableSerialize(item, seen)).sort(compareCodepoint);
+      seen.delete(value);
+      return `set:[${items.join(",")}]`;
+    }
+    if (value instanceof Map) {
+      const items = Array.from(
+        value,
+        ([key, item]) => `[${stableSerialize(key, seen)},${stableSerialize(item, seen)}]`
+      ).sort(compareCodepoint);
+      seen.delete(value);
+      return `map:[${items.join(",")}]`;
+    }
+    if (value instanceof URLSearchParams) {
+      const serialized2 = serializeCanonicalStringEntries(value, seen);
+      seen.delete(value);
+      return `urlsearchparams:[${serialized2}]`;
+    }
+    if (value instanceof Headers) {
+      const serialized2 = serializeCanonicalStringEntries(value, seen);
+      seen.delete(value);
+      return `headers:[${serialized2}]`;
+    }
+    if (!isPlainCacheKeyObject(value)) {
+      throw new TypeError(
+        `Cache keys do not support ${getCacheKeyValueType(value)} values. Convert the value to an explicit stable string or structured key before caching.`
+      );
+    }
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => compareCodepoint(a, b)
+    );
+    const serialized = entries.map(([key, item]) => `${JSON.stringify(key)}:${stableSerialize(item, seen)}`).join(",");
+    seen.delete(value);
+    return `{${serialized}}`;
+  }
+  return String(value);
+}
+
+
+
+
+
+exports.createRouteDataCacheKey = createRouteDataCacheKey; exports.createFarmCacheKey = createFarmCacheKey; exports.getFunctionCacheIdentity = getFunctionCacheIdentity;

package/dist/chunk-E552H232.cjs

@@ -0,0 +1,154 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return 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; }// src/deployment.ts
+var FARM_DEPLOYMENT_ID_HEADER = "x-farm-deployment-id";
+var FARM_DEPLOYMENT_MISMATCH_HEADER = "x-farm-deployment-mismatch";
+var FARM_DEPLOYMENT_COOKIE = "__farm_deployment";
+var FARM_DEPLOYMENT_MISMATCH_CODE = "FARM_DEPLOYMENT_MISMATCH";
+var FARM_DEPLOYMENT_MISMATCH_STATUS = 409;
+function getFarmPresetRuntime(preset) {
+  if (preset === "cloudflare" || preset === "cloudflare-pages" || preset === "cloudflare-module" || preset === "netlify-edge" || preset === "vercel-edge" || preset === "deno") {
+    return "edge";
+  }
+  if (preset === "node-server" || preset === "vercel" || preset === "netlify" || preset === "aws-lambda" || preset === "azure" || preset === "firebase" || preset === "bun" || preset === "self-host" || preset === "farm") {
+    return "node";
+  }
+  return "unknown";
+}
+var FarmDeploymentMismatchError = class extends Error {
+  constructor(clientDeploymentId, serverDeploymentId) {
+    super("The application was updated while this page was open. Refresh before trying again.");
+    this.clientDeploymentId = clientDeploymentId;
+    this.serverDeploymentId = serverDeploymentId;
+    this.name = "FarmDeploymentMismatchError";
+    this.code = FARM_DEPLOYMENT_MISMATCH_CODE;
+    this.retryable = false;
+  }
+};
+function normalizeFarmDeploymentId(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new TypeError("Farm deploymentId must be a non-empty string");
+  }
+  const normalized = value.trim();
+  if (normalized.length > 200 || /[\u0000-\u001f\u007f]/.test(normalized)) {
+    throw new TypeError("Farm deploymentId must be at most 200 characters without control bytes");
+  }
+  return normalized;
+}
+function createFarmDeploymentRequestHeaders(deploymentId, init) {
+  const headers = new Headers(init);
+  if (deploymentId) {
+    headers.set(FARM_DEPLOYMENT_ID_HEADER, deploymentId);
+  }
+  return headers;
+}
+function getFarmRequestDeploymentId(request) {
+  const headerValue = _optionalChain([request, 'access', _ => _.headers, 'access', _2 => _2.get, 'call', _3 => _3(FARM_DEPLOYMENT_ID_HEADER), 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  if (headerValue) return headerValue;
+  if (isSafeRequestMethod(request.method)) return void 0;
+  return readCookie(request.headers.get("cookie"), FARM_DEPLOYMENT_COOKIE);
+}
+function getFarmDeploymentMismatch(request, serverDeploymentId) {
+  if (!serverDeploymentId) return null;
+  const clientDeploymentId = getFarmRequestDeploymentId(request);
+  if (!clientDeploymentId || clientDeploymentId === serverDeploymentId) return null;
+  return { clientDeploymentId, serverDeploymentId };
+}
+function createFarmDeploymentMismatchResponse(mismatch) {
+  return new Response(
+    JSON.stringify({
+      error: FARM_DEPLOYMENT_MISMATCH_CODE,
+      message: "The application deployment changed. Refresh before retrying this request."
+    }),
+    {
+      status: FARM_DEPLOYMENT_MISMATCH_STATUS,
+      headers: {
+        "Cache-Control": "no-store",
+        "Content-Type": "application/json; charset=utf-8",
+        [FARM_DEPLOYMENT_ID_HEADER]: mismatch.serverDeploymentId,
+        [FARM_DEPLOYMENT_MISMATCH_HEADER]: "1"
+      }
+    }
+  );
+}
+function withFarmDeploymentResponse(response, deploymentId, options = {}) {
+  if (!deploymentId) return response;
+  const headers = new Headers(response.headers);
+  headers.set(FARM_DEPLOYMENT_ID_HEADER, deploymentId);
+  if (options.setCookie) {
+    headers.append(
+      "Set-Cookie",
+      createFarmDeploymentCookie(
+        deploymentId,
+        _nullishCoalesce(options.cookiePath, () => ( "/")),
+        _nullishCoalesce(options.secureCookie, () => ( false))
+      )
+    );
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function getFarmResponseDeploymentId(response) {
+  return _optionalChain([response, 'access', _6 => _6.headers, 'access', _7 => _7.get, 'call', _8 => _8(FARM_DEPLOYMENT_ID_HEADER), 'optionalAccess', _9 => _9.trim, 'call', _10 => _10()]) || void 0;
+}
+function isFarmDeploymentMismatchResponse(response, clientDeploymentId) {
+  const serverDeploymentId = getFarmResponseDeploymentId(response);
+  if (clientDeploymentId && serverDeploymentId && clientDeploymentId !== serverDeploymentId) {
+    return true;
+  }
+  return response.status === FARM_DEPLOYMENT_MISMATCH_STATUS && response.headers.get(FARM_DEPLOYMENT_MISMATCH_HEADER) === "1";
+}
+function createFarmDeploymentMismatchError(response, clientDeploymentId) {
+  return new FarmDeploymentMismatchError(
+    clientDeploymentId,
+    getFarmResponseDeploymentId(response) || "unknown"
+  );
+}
+function createFarmDeploymentCookie(deploymentId, path = "/", secure = false) {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return [
+    `${FARM_DEPLOYMENT_COOKIE}=${encodeURIComponent(deploymentId)}`,
+    `Path=${normalizedPath}`,
+    "HttpOnly",
+    "SameSite=Lax",
+    secure ? "Secure" : ""
+  ].filter(Boolean).join("; ");
+}
+function readCookie(cookieHeader, name) {
+  if (!cookieHeader) return void 0;
+  for (const part of cookieHeader.split(";")) {
+    const separator = part.indexOf("=");
+    if (separator === -1 || part.slice(0, separator).trim() !== name) continue;
+    const value = part.slice(separator + 1).trim();
+    try {
+      return decodeURIComponent(value);
+    } catch (e) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function isSafeRequestMethod(method) {
+  return ["GET", "HEAD", "OPTIONS", "QUERY"].includes(method.toUpperCase());
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FARM_DEPLOYMENT_ID_HEADER = FARM_DEPLOYMENT_ID_HEADER; exports.FARM_DEPLOYMENT_MISMATCH_HEADER = FARM_DEPLOYMENT_MISMATCH_HEADER; exports.FARM_DEPLOYMENT_COOKIE = FARM_DEPLOYMENT_COOKIE; exports.FARM_DEPLOYMENT_MISMATCH_CODE = FARM_DEPLOYMENT_MISMATCH_CODE; exports.FARM_DEPLOYMENT_MISMATCH_STATUS = FARM_DEPLOYMENT_MISMATCH_STATUS; exports.getFarmPresetRuntime = getFarmPresetRuntime; exports.FarmDeploymentMismatchError = FarmDeploymentMismatchError; exports.normalizeFarmDeploymentId = normalizeFarmDeploymentId; exports.createFarmDeploymentRequestHeaders = createFarmDeploymentRequestHeaders; exports.getFarmRequestDeploymentId = getFarmRequestDeploymentId; exports.getFarmDeploymentMismatch = getFarmDeploymentMismatch; exports.createFarmDeploymentMismatchResponse = createFarmDeploymentMismatchResponse; exports.withFarmDeploymentResponse = withFarmDeploymentResponse; exports.getFarmResponseDeploymentId = getFarmResponseDeploymentId; exports.isFarmDeploymentMismatchResponse = isFarmDeploymentMismatchResponse; exports.createFarmDeploymentMismatchError = createFarmDeploymentMismatchError; exports.createFarmDeploymentCookie = createFarmDeploymentCookie;