@farm.js/core 0.1.0-beta.0

package/dist/environment.cjs

@@ -0,0 +1,96 @@
+"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);
+
+// src/environment.ts
+var environment_exports = {};
+__export(environment_exports, {
+  FarmEnvironmentError: () => FarmEnvironmentError,
+  createClientOnlyFn: () => createClientOnlyFn,
+  createIsomorphicFn: () => createIsomorphicFn,
+  createServerOnlyFn: () => createServerOnlyFn
+});
+module.exports = __toCommonJS(environment_exports);
+var _FarmEnvironmentError = class _FarmEnvironmentError extends Error {
+  constructor(api, expected, actual) {
+    super(`${api}() can only be called on the ${expected}. It was called on the ${actual}.`);
+    this.api = api;
+    this.expected = expected;
+    this.actual = actual;
+    this.code = "FARM_ENVIRONMENT_MISMATCH";
+    this.name = "FarmEnvironmentError";
+  }
+};
+__name(_FarmEnvironmentError, "FarmEnvironmentError");
+var FarmEnvironmentError = _FarmEnvironmentError;
+function createServerOnlyFn(implementation, compiledActualEnvironment) {
+  if (compiledActualEnvironment) {
+    return createMismatchFunction("createServerOnlyFn", "server", compiledActualEnvironment);
+  }
+  if (getRuntimeEnvironment() !== "server") {
+    return createMismatchFunction("createServerOnlyFn", "server");
+  }
+  assertFunction(implementation, "createServerOnlyFn");
+  return implementation;
+}
+__name(createServerOnlyFn, "createServerOnlyFn");
+function createClientOnlyFn(implementation, compiledActualEnvironment) {
+  if (compiledActualEnvironment) {
+    return createMismatchFunction("createClientOnlyFn", "client", compiledActualEnvironment);
+  }
+  if (getRuntimeEnvironment() !== "client") {
+    return createMismatchFunction("createClientOnlyFn", "client");
+  }
+  assertFunction(implementation, "createClientOnlyFn");
+  return implementation;
+}
+__name(createClientOnlyFn, "createClientOnlyFn");
+function createIsomorphicFn(options) {
+  if (!options || typeof options !== "object") {
+    throw new TypeError("createIsomorphicFn requires server and client functions");
+  }
+  assertFunction(options.server, "createIsomorphicFn server");
+  assertFunction(options.client, "createIsomorphicFn client");
+  return getRuntimeEnvironment() === "server" ? options.server : options.client;
+}
+__name(createIsomorphicFn, "createIsomorphicFn");
+function getRuntimeEnvironment() {
+  return typeof window === "undefined" ? "server" : "client";
+}
+__name(getRuntimeEnvironment, "getRuntimeEnvironment");
+function createMismatchFunction(api, expected, actual = expected === "server" ? "client" : "server") {
+  return /* @__PURE__ */ __name(function farmEnvironmentBoundary() {
+    throw new FarmEnvironmentError(api, expected, actual);
+  }, "farmEnvironmentBoundary");
+}
+__name(createMismatchFunction, "createMismatchFunction");
+function assertFunction(value, label) {
+  if (typeof value !== "function") {
+    throw new TypeError(`${label} must be a function`);
+  }
+}
+__name(assertFunction, "assertFunction");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FarmEnvironmentError,
+  createClientOnlyFn,
+  createIsomorphicFn,
+  createServerOnlyFn
+});
+//# sourceMappingURL=environment.cjs.map

package/dist/environment.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/environment.ts"],"sourcesContent":["type AnyEnvironmentFunction = (...args: never[]) => unknown;\n\nexport type FarmEnvironment = \"server\" | \"client\";\n\nexport interface FarmIsomorphicFnOptions<TArgs extends unknown[], TServerResult, TClientResult> {\n  server: (...args: TArgs) => TServerResult;\n  client: (...args: TArgs) => TClientResult;\n}\n\nexport class FarmEnvironmentError extends Error {\n  readonly code = \"FARM_ENVIRONMENT_MISMATCH\";\n\n  constructor(\n    readonly api: \"createServerOnlyFn\" | \"createClientOnlyFn\",\n    readonly expected: FarmEnvironment,\n    readonly actual: FarmEnvironment,\n  ) {\n    super(`${api}() can only be called on the ${expected}. It was called on the ${actual}.`);\n    this.name = \"FarmEnvironmentError\";\n  }\n}\n\nexport function createServerOnlyFn<TFunction extends AnyEnvironmentFunction>(\n  implementation: TFunction,\n): TFunction;\nexport function createServerOnlyFn(\n  implementation: AnyEnvironmentFunction | undefined,\n  compiledActualEnvironment?: FarmEnvironment,\n): AnyEnvironmentFunction {\n  if (compiledActualEnvironment) {\n    return createMismatchFunction(\"createServerOnlyFn\", \"server\", compiledActualEnvironment);\n  }\n  if (getRuntimeEnvironment() !== \"server\") {\n    return createMismatchFunction(\"createServerOnlyFn\", \"server\");\n  }\n\n  assertFunction(implementation, \"createServerOnlyFn\");\n  return implementation;\n}\n\nexport function createClientOnlyFn<TFunction extends AnyEnvironmentFunction>(\n  implementation: TFunction,\n): TFunction;\nexport function createClientOnlyFn(\n  implementation: AnyEnvironmentFunction | undefined,\n  compiledActualEnvironment?: FarmEnvironment,\n): AnyEnvironmentFunction {\n  if (compiledActualEnvironment) {\n    return createMismatchFunction(\"createClientOnlyFn\", \"client\", compiledActualEnvironment);\n  }\n  if (getRuntimeEnvironment() !== \"client\") {\n    return createMismatchFunction(\"createClientOnlyFn\", \"client\");\n  }\n\n  assertFunction(implementation, \"createClientOnlyFn\");\n  return implementation;\n}\n\nexport function createIsomorphicFn<TArgs extends unknown[], TServerResult, TClientResult>(\n  options: FarmIsomorphicFnOptions<TArgs, TServerResult, TClientResult>,\n): (...args: TArgs) => TServerResult | TClientResult {\n  if (!options || typeof options !== \"object\") {\n    throw new TypeError(\"createIsomorphicFn requires server and client functions\");\n  }\n\n  assertFunction(options.server, \"createIsomorphicFn server\");\n  assertFunction(options.client, \"createIsomorphicFn client\");\n\n  return getRuntimeEnvironment() === \"server\" ? options.server : options.client;\n}\n\nfunction getRuntimeEnvironment(): FarmEnvironment {\n  return typeof window === \"undefined\" ? \"server\" : \"client\";\n}\n\nfunction createMismatchFunction(\n  api: \"createServerOnlyFn\" | \"createClientOnlyFn\",\n  expected: FarmEnvironment,\n  actual: FarmEnvironment = expected === \"server\" ? \"client\" : \"server\",\n) {\n  return function farmEnvironmentBoundary(): never {\n    throw new FarmEnvironmentError(api, expected, actual);\n  };\n}\n\nfunction assertFunction(value: unknown, label: string): asserts value is AnyEnvironmentFunction {\n  if (typeof value !== \"function\") {\n    throw new TypeError(`${label} must be a function`);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASO,IAAM,wBAAN,MAAM,8BAA6B,MAAM;AAAA,EAG9C,YACW,KACA,UACA,QACT;AACA,UAAM,GAAG,GAAG,gCAAgC,QAAQ,0BAA0B,MAAM,GAAG;AAJ9E;AACA;AACA;AALX,SAAS,OAAO;AAQd,SAAK,OAAO;AAAA,EACd;AACF;AAXgD;AAAzC,IAAM,uBAAN;AAgBA,SAAS,mBACd,gBACA,2BACwB;AACxB,MAAI,2BAA2B;AAC7B,WAAO,uBAAuB,sBAAsB,UAAU,yBAAyB;AAAA,EACzF;AACA,MAAI,sBAAsB,MAAM,UAAU;AACxC,WAAO,uBAAuB,sBAAsB,QAAQ;AAAA,EAC9D;AAEA,iBAAe,gBAAgB,oBAAoB;AACnD,SAAO;AACT;AAbgB;AAkBT,SAAS,mBACd,gBACA,2BACwB;AACxB,MAAI,2BAA2B;AAC7B,WAAO,uBAAuB,sBAAsB,UAAU,yBAAyB;AAAA,EACzF;AACA,MAAI,sBAAsB,MAAM,UAAU;AACxC,WAAO,uBAAuB,sBAAsB,QAAQ;AAAA,EAC9D;AAEA,iBAAe,gBAAgB,oBAAoB;AACnD,SAAO;AACT;AAbgB;AAeT,SAAS,mBACd,SACmD;AACnD,MAAI,CAAC,WAAW,OAAO,YAAY,UAAU;AAC3C,UAAM,IAAI,UAAU,yDAAyD;AAAA,EAC/E;AAEA,iBAAe,QAAQ,QAAQ,2BAA2B;AAC1D,iBAAe,QAAQ,QAAQ,2BAA2B;AAE1D,SAAO,sBAAsB,MAAM,WAAW,QAAQ,SAAS,QAAQ;AACzE;AAXgB;AAahB,SAAS,wBAAyC;AAChD,SAAO,OAAO,WAAW,cAAc,WAAW;AACpD;AAFS;AAIT,SAAS,uBACP,KACA,UACA,SAA0B,aAAa,WAAW,WAAW,UAC7D;AACA,SAAO,gCAAS,0BAAiC;AAC/C,UAAM,IAAI,qBAAqB,KAAK,UAAU,MAAM;AAAA,EACtD,GAFO;AAGT;AARS;AAUT,SAAS,eAAe,OAAgB,OAAwD;AAC9F,MAAI,OAAO,UAAU,YAAY;AAC/B,UAAM,IAAI,UAAU,GAAG,KAAK,qBAAqB;AAAA,EACnD;AACF;AAJS;","names":[]}

package/dist/environment.d.mts

@@ -0,0 +1,18 @@
+type AnyEnvironmentFunction = (...args: never[]) => unknown;
+type FarmEnvironment = "server" | "client";
+interface FarmIsomorphicFnOptions<TArgs extends unknown[], TServerResult, TClientResult> {
+    server: (...args: TArgs) => TServerResult;
+    client: (...args: TArgs) => TClientResult;
+}
+declare class FarmEnvironmentError extends Error {
+    readonly api: "createServerOnlyFn" | "createClientOnlyFn";
+    readonly expected: FarmEnvironment;
+    readonly actual: FarmEnvironment;
+    readonly code = "FARM_ENVIRONMENT_MISMATCH";
+    constructor(api: "createServerOnlyFn" | "createClientOnlyFn", expected: FarmEnvironment, actual: FarmEnvironment);
+}
+declare function createServerOnlyFn<TFunction extends AnyEnvironmentFunction>(implementation: TFunction): TFunction;
+declare function createClientOnlyFn<TFunction extends AnyEnvironmentFunction>(implementation: TFunction): TFunction;
+declare function createIsomorphicFn<TArgs extends unknown[], TServerResult, TClientResult>(options: FarmIsomorphicFnOptions<TArgs, TServerResult, TClientResult>): (...args: TArgs) => TServerResult | TClientResult;
+
+export { type FarmEnvironment, FarmEnvironmentError, type FarmIsomorphicFnOptions, createClientOnlyFn, createIsomorphicFn, createServerOnlyFn };

package/dist/environment.d.ts

@@ -0,0 +1,18 @@
+type AnyEnvironmentFunction = (...args: never[]) => unknown;
+type FarmEnvironment = "server" | "client";
+interface FarmIsomorphicFnOptions<TArgs extends unknown[], TServerResult, TClientResult> {
+    server: (...args: TArgs) => TServerResult;
+    client: (...args: TArgs) => TClientResult;
+}
+declare class FarmEnvironmentError extends Error {
+    readonly api: "createServerOnlyFn" | "createClientOnlyFn";
+    readonly expected: FarmEnvironment;
+    readonly actual: FarmEnvironment;
+    readonly code = "FARM_ENVIRONMENT_MISMATCH";
+    constructor(api: "createServerOnlyFn" | "createClientOnlyFn", expected: FarmEnvironment, actual: FarmEnvironment);
+}
+declare function createServerOnlyFn<TFunction extends AnyEnvironmentFunction>(implementation: TFunction): TFunction;
+declare function createClientOnlyFn<TFunction extends AnyEnvironmentFunction>(implementation: TFunction): TFunction;
+declare function createIsomorphicFn<TArgs extends unknown[], TServerResult, TClientResult>(options: FarmIsomorphicFnOptions<TArgs, TServerResult, TClientResult>): (...args: TArgs) => TServerResult | TClientResult;
+
+export { type FarmEnvironment, FarmEnvironmentError, type FarmIsomorphicFnOptions, createClientOnlyFn, createIsomorphicFn, createServerOnlyFn };

package/dist/environment.mjs

@@ -0,0 +1,14 @@
+import {
+  FarmEnvironmentError,
+  createClientOnlyFn,
+  createIsomorphicFn,
+  createServerOnlyFn
+} from "./chunk-J23HNLFY.mjs";
+import "./chunk-CGILA3WO.mjs";
+export {
+  FarmEnvironmentError,
+  createClientOnlyFn,
+  createIsomorphicFn,
+  createServerOnlyFn
+};
+//# sourceMappingURL=environment.mjs.map

package/dist/environment.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/headers.cjs

@@ -0,0 +1,126 @@
+"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);
+
+// src/headers.ts
+var headers_exports = {};
+__export(headers_exports, {
+  cookies: () => cookies,
+  headers: () => headers
+});
+module.exports = __toCommonJS(headers_exports);
+
+// src/server/request.ts
+var import_node_async_hooks = require("async_hooks");
+
+// src/server/request-bridge.ts
+var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
+function getGlobalState() {
+  return globalThis;
+}
+__name(getGlobalState, "getGlobalState");
+function _setCurrentRequestResolver(resolver) {
+  getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY] = resolver;
+}
+__name(_setCurrentRequestResolver, "_setCurrentRequestResolver");
+
+// src/server/request.ts
+var REQUEST_STORAGE_KEY = /* @__PURE__ */ Symbol.for("@farm.js/core/request-storage");
+function getRequestStore() {
+  const runtime = globalThis;
+  const existing = runtime[REQUEST_STORAGE_KEY];
+  if (existing instanceof import_node_async_hooks.AsyncLocalStorage) {
+    return existing;
+  }
+  const storage = new import_node_async_hooks.AsyncLocalStorage();
+  runtime[REQUEST_STORAGE_KEY] = storage;
+  return storage;
+}
+__name(getRequestStore, "getRequestStore");
+var requestStore = getRequestStore();
+_setCurrentRequestResolver(() => requestStore.getStore());
+function getCurrentRequest() {
+  const request = requestStore.getStore();
+  if (!request) {
+    throw new Error(
+      "No current request is available. getCurrentRequest() can only be used during server rendering."
+    );
+  }
+  return request;
+}
+__name(getCurrentRequest, "getCurrentRequest");
+
+// src/headers.ts
+function headers() {
+  return new Headers(getCurrentRequest().headers);
+}
+__name(headers, "headers");
+function cookies() {
+  const cookieHeader = getCurrentRequest().headers.get("cookie") || "";
+  const parsed = parseCookieHeader(cookieHeader);
+  return {
+    get(name) {
+      return parsed.find((cookie) => cookie.name === name);
+    },
+    getAll(name) {
+      return name ? parsed.filter((cookie) => cookie.name === name) : [...parsed];
+    },
+    has(name) {
+      return parsed.some((cookie) => cookie.name === name);
+    },
+    toString() {
+      return cookieHeader;
+    },
+    [Symbol.iterator]() {
+      return parsed[Symbol.iterator]();
+    }
+  };
+}
+__name(cookies, "cookies");
+function parseCookieHeader(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: decodeCookiePart(part),
+        value: ""
+      };
+    }
+    return {
+      name: decodeCookiePart(part.slice(0, separatorIndex).trim()),
+      value: decodeCookiePart(part.slice(separatorIndex + 1).trim())
+    };
+  }).filter((cookie) => cookie.name.length > 0);
+}
+__name(parseCookieHeader, "parseCookieHeader");
+function decodeCookiePart(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+__name(decodeCookiePart, "decodeCookiePart");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cookies,
+  headers
+});
+//# sourceMappingURL=headers.cjs.map

package/dist/headers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/headers.ts","../src/server/request.ts","../src/server/request-bridge.ts"],"sourcesContent":["import { getCurrentRequest } from \"./server/request\";\n\nexport interface RequestCookie {\n  name: string;\n  value: string;\n}\n\nexport interface ReadonlyHeaders extends Iterable<[string, string]> {\n  get(name: string): string | null;\n  has(name: string): boolean;\n  forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;\n  entries(): IterableIterator<[string, string]>;\n  keys(): IterableIterator<string>;\n  values(): IterableIterator<string>;\n}\n\nexport interface ReadonlyRequestCookies extends Iterable<RequestCookie> {\n  get(name: string): RequestCookie | undefined;\n  getAll(name?: string): RequestCookie[];\n  has(name: string): boolean;\n  toString(): string;\n}\n\nexport function headers(): ReadonlyHeaders {\n  return new Headers(getCurrentRequest().headers) as ReadonlyHeaders;\n}\n\nexport function cookies(): ReadonlyRequestCookies {\n  const cookieHeader = getCurrentRequest().headers.get(\"cookie\") || \"\";\n  const parsed = parseCookieHeader(cookieHeader);\n\n  return {\n    get(name) {\n      return parsed.find((cookie) => cookie.name === name);\n    },\n    getAll(name) {\n      return name ? parsed.filter((cookie) => cookie.name === name) : [...parsed];\n    },\n    has(name) {\n      return parsed.some((cookie) => cookie.name === name);\n    },\n    toString() {\n      return cookieHeader;\n    },\n    [Symbol.iterator]() {\n      return parsed[Symbol.iterator]();\n    },\n  };\n}\n\nfunction parseCookieHeader(header: string): RequestCookie[] {\n  if (!header.trim()) return [];\n\n  return header\n    .split(\";\")\n    .map((part) => part.trim())\n    .filter(Boolean)\n    .map((part) => {\n      const separatorIndex = part.indexOf(\"=\");\n      if (separatorIndex === -1) {\n        return {\n          name: decodeCookiePart(part),\n          value: \"\",\n        };\n      }\n\n      return {\n        name: decodeCookiePart(part.slice(0, separatorIndex).trim()),\n        value: decodeCookiePart(part.slice(separatorIndex + 1).trim()),\n      };\n    })\n    .filter((cookie) => cookie.name.length > 0);\n}\n\nfunction decodeCookiePart(value: string) {\n  try {\n    return decodeURIComponent(value);\n  } catch {\n    return value;\n  }\n}\n","import { AsyncLocalStorage } from \"node:async_hooks\";\nimport type { FarmRequest } from \"../types\";\nimport { _setCurrentRequestResolver } from \"./request-bridge\";\n\nconst REQUEST_STORAGE_KEY = Symbol.for(\"@farm.js/core/request-storage\");\n\nfunction getRequestStore(): AsyncLocalStorage<Request> {\n  const runtime = globalThis as typeof globalThis & Record<PropertyKey, unknown>;\n  const existing = runtime[REQUEST_STORAGE_KEY];\n  if (existing instanceof AsyncLocalStorage) {\n    return existing as AsyncLocalStorage<Request>;\n  }\n\n  const storage = new AsyncLocalStorage<Request>();\n  runtime[REQUEST_STORAGE_KEY] = storage;\n  return storage;\n}\n\nconst requestStore = getRequestStore();\n\n_setCurrentRequestResolver(() => requestStore.getStore());\n\nexport function createWebRequestFromFarmRequest(req: FarmRequest): Request {\n  const forwardedHost = req.headers[\"x-forwarded-host\"];\n  const host = Array.isArray(forwardedHost)\n    ? forwardedHost[0]\n    : forwardedHost || req.headers.host || \"localhost\";\n  const forwardedProto = req.headers[\"x-forwarded-proto\"];\n  const proto = Array.isArray(forwardedProto) ? forwardedProto[0] : forwardedProto || \"http\";\n  const fullUrl = new URL(req.url || \"/\", `${proto}://${host}`).toString();\n\n  const headers = new Headers();\n  for (const [key, value] of Object.entries(req.headers)) {\n    if (value == null) {\n      continue;\n    }\n\n    if (Array.isArray(value)) {\n      for (const item of value) {\n        headers.append(key, item);\n      }\n      continue;\n    }\n\n    headers.set(key, value);\n  }\n\n  return new Request(fullUrl, {\n    method: req.method,\n    headers,\n  });\n}\n\nexport async function _runWithCurrentRequest<T>(\n  request: Request,\n  fn: () => Promise<T> | T,\n): Promise<T> {\n  return requestStore.run(request, fn);\n}\n\nexport function getCurrentRequest(): Request {\n  const request = requestStore.getStore();\n  if (!request) {\n    throw new Error(\n      \"No current request is available. getCurrentRequest() can only be used during server rendering.\",\n    );\n  }\n\n  return request;\n}\n","type CurrentRequestResolver = () => Request | undefined;\n\nconst CURRENT_REQUEST_RESOLVER_KEY = Symbol.for(\"farm.currentRequestResolver\");\n\ntype GlobalWithCurrentRequestResolver = typeof globalThis & {\n  [CURRENT_REQUEST_RESOLVER_KEY]?: CurrentRequestResolver;\n};\n\nfunction getGlobalState(): GlobalWithCurrentRequestResolver {\n  return globalThis as GlobalWithCurrentRequestResolver;\n}\n\nexport function _setCurrentRequestResolver(resolver: CurrentRequestResolver | undefined): void {\n  getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY] = resolver;\n}\n\nexport function _resolveCurrentRequest(): Request | undefined {\n  return getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY]?.();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,8BAAkC;;;ACElC,IAAM,+BAA+B,uBAAO,IAAI,6BAA6B;AAM7E,SAAS,iBAAmD;AAC1D,SAAO;AACT;AAFS;AAIF,SAAS,2BAA2B,UAAoD;AAC7F,iBAAe,EAAE,4BAA4B,IAAI;AACnD;AAFgB;;;ADRhB,IAAM,sBAAsB,uBAAO,IAAI,+BAA+B;AAEtE,SAAS,kBAA8C;AACrD,QAAM,UAAU;AAChB,QAAM,WAAW,QAAQ,mBAAmB;AAC5C,MAAI,oBAAoB,2CAAmB;AACzC,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,IAAI,0CAA2B;AAC/C,UAAQ,mBAAmB,IAAI;AAC/B,SAAO;AACT;AAVS;AAYT,IAAM,eAAe,gBAAgB;AAErC,2BAA2B,MAAM,aAAa,SAAS,CAAC;AAwCjD,SAAS,oBAA6B;AAC3C,QAAM,UAAU,aAAa,SAAS;AACtC,MAAI,CAAC,SAAS;AACZ,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AATgB;;;ADrCT,SAAS,UAA2B;AACzC,SAAO,IAAI,QAAQ,kBAAkB,EAAE,OAAO;AAChD;AAFgB;AAIT,SAAS,UAAkC;AAChD,QAAM,eAAe,kBAAkB,EAAE,QAAQ,IAAI,QAAQ,KAAK;AAClE,QAAM,SAAS,kBAAkB,YAAY;AAE7C,SAAO;AAAA,IACL,IAAI,MAAM;AACR,aAAO,OAAO,KAAK,CAAC,WAAW,OAAO,SAAS,IAAI;AAAA,IACrD;AAAA,IACA,OAAO,MAAM;AACX,aAAO,OAAO,OAAO,OAAO,CAAC,WAAW,OAAO,SAAS,IAAI,IAAI,CAAC,GAAG,MAAM;AAAA,IAC5E;AAAA,IACA,IAAI,MAAM;AACR,aAAO,OAAO,KAAK,CAAC,WAAW,OAAO,SAAS,IAAI;AAAA,IACrD;AAAA,IACA,WAAW;AACT,aAAO;AAAA,IACT;AAAA,IACA,CAAC,OAAO,QAAQ,IAAI;AAClB,aAAO,OAAO,OAAO,QAAQ,EAAE;AAAA,IACjC;AAAA,EACF;AACF;AArBgB;AAuBhB,SAAS,kBAAkB,QAAiC;AAC1D,MAAI,CAAC,OAAO,KAAK,EAAG,QAAO,CAAC;AAE5B,SAAO,OACJ,MAAM,GAAG,EACT,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,EACzB,OAAO,OAAO,EACd,IAAI,CAAC,SAAS;AACb,UAAM,iBAAiB,KAAK,QAAQ,GAAG;AACvC,QAAI,mBAAmB,IAAI;AACzB,aAAO;AAAA,QACL,MAAM,iBAAiB,IAAI;AAAA,QAC3B,OAAO;AAAA,MACT;AAAA,IACF;AAEA,WAAO;AAAA,MACL,MAAM,iBAAiB,KAAK,MAAM,GAAG,cAAc,EAAE,KAAK,CAAC;AAAA,MAC3D,OAAO,iBAAiB,KAAK,MAAM,iBAAiB,CAAC,EAAE,KAAK,CAAC;AAAA,IAC/D;AAAA,EACF,CAAC,EACA,OAAO,CAAC,WAAW,OAAO,KAAK,SAAS,CAAC;AAC9C;AAtBS;AAwBT,SAAS,iBAAiB,OAAe;AACvC,MAAI;AACF,WAAO,mBAAmB,KAAK;AAAA,EACjC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AANS;","names":[]}

package/dist/headers.d.mts

@@ -0,0 +1,22 @@
+interface RequestCookie {
+    name: string;
+    value: string;
+}
+interface ReadonlyHeaders extends Iterable<[string, string]> {
+    get(name: string): string | null;
+    has(name: string): boolean;
+    forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
+    entries(): IterableIterator<[string, string]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+}
+interface ReadonlyRequestCookies extends Iterable<RequestCookie> {
+    get(name: string): RequestCookie | undefined;
+    getAll(name?: string): RequestCookie[];
+    has(name: string): boolean;
+    toString(): string;
+}
+declare function headers(): ReadonlyHeaders;
+declare function cookies(): ReadonlyRequestCookies;
+
+export { type ReadonlyHeaders, type ReadonlyRequestCookies, type RequestCookie, cookies, headers };

package/dist/headers.d.ts

@@ -0,0 +1,22 @@
+interface RequestCookie {
+    name: string;
+    value: string;
+}
+interface ReadonlyHeaders extends Iterable<[string, string]> {
+    get(name: string): string | null;
+    has(name: string): boolean;
+    forEach(callbackfn: (value: string, key: string, parent: Headers) => void, thisArg?: any): void;
+    entries(): IterableIterator<[string, string]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+}
+interface ReadonlyRequestCookies extends Iterable<RequestCookie> {
+    get(name: string): RequestCookie | undefined;
+    getAll(name?: string): RequestCookie[];
+    has(name: string): boolean;
+    toString(): string;
+}
+declare function headers(): ReadonlyHeaders;
+declare function cookies(): ReadonlyRequestCookies;
+
+export { type ReadonlyHeaders, type ReadonlyRequestCookies, type RequestCookie, cookies, headers };

package/dist/headers.mjs

@@ -0,0 +1,12 @@
+import {
+  cookies,
+  headers
+} from "./chunk-AZ7YUVNR.mjs";
+import "./chunk-RHIFZZUI.mjs";
+import "./chunk-LM2YNO4U.mjs";
+import "./chunk-CGILA3WO.mjs";
+export {
+  cookies,
+  headers
+};
+//# sourceMappingURL=headers.mjs.map

package/dist/headers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/i18n/client.cjs

@@ -0,0 +1,283 @@
+"use strict";
+"use client";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/i18n/client.tsx
+var client_exports = {};
+__export(client_exports, {
+  _setFarmI18nClientSnapshot: () => _setFarmI18nClientSnapshot,
+  createTranslator: () => createTranslator,
+  format: () => format,
+  getLocale: () => getLocale,
+  getLocaleSource: () => getLocaleSource,
+  setLocale: () => setLocale,
+  t: () => t,
+  useLocale: () => useLocale,
+  useTranslations: () => useTranslations
+});
+module.exports = __toCommonJS(client_exports);
+var import_react = require("react");
+
+// src/i18n/routing.ts
+function resolveFarmLocalePath(pathname, config) {
+  const normalized = normalizePathname(pathname);
+  if (config.routing === "none") {
+    return { pathname: normalized, explicit: false };
+  }
+  const segments = normalized.split("/").filter(Boolean);
+  const firstSegment = segments[0];
+  const locale = config.locales.find(
+    (candidate) => candidate.toLowerCase() === firstSegment?.toLowerCase()
+  );
+  if (!locale) {
+    return { pathname: normalized, explicit: false };
+  }
+  const remaining = segments.slice(1);
+  return {
+    locale,
+    pathname: remaining.length > 0 ? `/${remaining.join("/")}` : "/",
+    explicit: true
+  };
+}
+__name(resolveFarmLocalePath, "resolveFarmLocalePath");
+function localizeFarmPathname(pathname, locale, config) {
+  const internalPathname = resolveFarmLocalePath(pathname, config).pathname;
+  if (config.routing === "none") return internalPathname;
+  if (config.routing === "prefix-except-default" && locale === config.defaultLocale) {
+    return internalPathname;
+  }
+  return internalPathname === "/" ? `/${locale}` : `/${locale}${internalPathname}`;
+}
+__name(localizeFarmPathname, "localizeFarmPathname");
+function localizeFarmHref(href, locale, config) {
+  if (!href.startsWith("/") || href.startsWith("//")) return href;
+  const url = new URL(href, "http://farm.local");
+  url.pathname = localizeFarmPathname(url.pathname, locale, config);
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+__name(localizeFarmHref, "localizeFarmHref");
+function normalizePathname(pathname) {
+  const withLeadingSlash = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  if (withLeadingSlash === "/") return "/";
+  return withLeadingSlash.replace(/\/{2,}/g, "/").replace(/\/$/, "") || "/";
+}
+__name(normalizePathname, "normalizePathname");
+
+// src/i18n/resolver.ts
+function createFarmLocaleCookie(locale, config) {
+  const cookie = config.cookie;
+  let value = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(locale)}`;
+  value += `; Max-Age=${cookie.maxAge}`;
+  value += `; Path=${cookie.path}`;
+  value += `; SameSite=${capitalize(cookie.sameSite)}`;
+  if (cookie.secure) value += "; Secure";
+  return value;
+}
+__name(createFarmLocaleCookie, "createFarmLocaleCookie");
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+__name(capitalize, "capitalize");
+
+// src/i18n/client-runtime.ts
+var import_intl_messageformat = __toESM(require("intl-messageformat"));
+
+// src/i18n/bridge.ts
+var FARM_I18N_SNAPSHOT_RESOLVER = /* @__PURE__ */ Symbol.for("farm.i18n.snapshotResolver");
+function getActiveFarmI18nSnapshot() {
+  if (typeof window !== "undefined" && window.__FARM_I18N__) {
+    return window.__FARM_I18N__;
+  }
+  return globalThis[FARM_I18N_SNAPSHOT_RESOLVER]?.();
+}
+__name(getActiveFarmI18nSnapshot, "getActiveFarmI18nSnapshot");
+
+// src/i18n/client-runtime.ts
+var listeners = /* @__PURE__ */ new Set();
+var compiled = /* @__PURE__ */ new Map();
+var currentSnapshot;
+function getFarmI18nClientState() {
+  return currentSnapshot || getActiveFarmI18nSnapshot();
+}
+__name(getFarmI18nClientState, "getFarmI18nClientState");
+function subscribeFarmI18n(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+__name(subscribeFarmI18n, "subscribeFarmI18n");
+function _hydrateFarmI18n(snapshot) {
+  if (!snapshot) return;
+  const changed = currentSnapshot?.locale !== snapshot.locale;
+  currentSnapshot = snapshot;
+  if (typeof window !== "undefined") window.__FARM_I18N__ = snapshot;
+  if (typeof document !== "undefined") {
+    document.documentElement.lang = snapshot.locale;
+    document.documentElement.dir = snapshot.direction;
+  }
+  if (changed) compiled.clear();
+  for (const listener of listeners) listener();
+}
+__name(_hydrateFarmI18n, "_hydrateFarmI18n");
+var translate = /* @__PURE__ */ __name((key, values, rich = false) => {
+  const snapshot = requireSnapshot();
+  const message = snapshot.messages[key];
+  if (message === void 0) return key;
+  const cacheKey = `${snapshot.locale}\0${key}\0${message}`;
+  let formatter = compiled.get(cacheKey);
+  if (!formatter) {
+    formatter = new import_intl_messageformat.default(message, snapshot.locale);
+    compiled.set(cacheKey, formatter);
+  }
+  const result = formatter.format(values);
+  if (rich) return Array.isArray(result) && result.length === 1 ? result[0] : result;
+  if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
+    throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
+  }
+  return Array.isArray(result) ? result.join("") : String(result);
+}, "translate");
+var t = /* @__PURE__ */ __name(((key, values) => translate(key, values)), "t");
+t.rich = (key, values) => translate(key, values, true);
+t.raw = (key) => requireSnapshot().messages[key] ?? key;
+t.has = (key) => key in requireSnapshot().messages;
+function createFarmClientTranslator() {
+  return ((key, ...args) => t(key, ...args));
+}
+__name(createFarmClientTranslator, "createFarmClientTranslator");
+function requireSnapshot() {
+  const snapshot = getFarmI18nClientState();
+  if (!snapshot) {
+    throw new Error("Farm i18n is not configured or has not been hydrated.");
+  }
+  return snapshot;
+}
+__name(requireSnapshot, "requireSnapshot");
+
+// src/i18n/client.tsx
+function useLocale() {
+  const snapshot = useFarmI18nSnapshot();
+  return (0, import_react.useMemo)(
+    () => ({
+      locale: snapshot.locale,
+      locales: snapshot.locales,
+      direction: snapshot.direction,
+      setLocale
+    }),
+    [snapshot]
+  );
+}
+__name(useLocale, "useLocale");
+function useTranslations() {
+  useFarmI18nSnapshot();
+  return createFarmClientTranslator();
+}
+__name(useTranslations, "useTranslations");
+function getLocale() {
+  return requireSnapshot2().locale;
+}
+__name(getLocale, "getLocale");
+function getLocaleSource() {
+  return requireSnapshot2().source;
+}
+__name(getLocaleSource, "getLocaleSource");
+function createTranslator() {
+  return createFarmClientTranslator();
+}
+__name(createTranslator, "createTranslator");
+function setLocale(locale) {
+  const snapshot = requireSnapshot2();
+  if (!snapshot.locales.includes(locale)) {
+    throw new Error(`Unsupported Farm i18n locale "${locale}".`);
+  }
+  if (typeof window === "undefined") return;
+  document.cookie = createFarmLocaleCookie(locale, { cookie: snapshot.cookie });
+  const currentHref = `${window.location.pathname}${window.location.search}${window.location.hash}`;
+  const nextHref = localizeFarmHref(currentHref, locale, snapshot);
+  window.location.assign(nextHref);
+}
+__name(setLocale, "setLocale");
+function _setFarmI18nClientSnapshot(snapshot) {
+  _hydrateFarmI18n(snapshot);
+}
+__name(_setFarmI18nClientSnapshot, "_setFarmI18nClientSnapshot");
+var format = {
+  number(value, options) {
+    return new Intl.NumberFormat(requireSnapshot2().locale, options).format(value);
+  },
+  currency(value, currency, options = {}) {
+    return new Intl.NumberFormat(requireSnapshot2().locale, {
+      ...options,
+      style: "currency",
+      currency
+    }).format(value);
+  },
+  date(value, options) {
+    return new Intl.DateTimeFormat(requireSnapshot2().locale, options).format(value);
+  },
+  relativeTime(value, unit, options) {
+    return new Intl.RelativeTimeFormat(requireSnapshot2().locale, options).format(value, unit);
+  },
+  list(values, options) {
+    const ListFormat = Intl.ListFormat;
+    return new ListFormat(requireSnapshot2().locale, options).format(Array.from(values));
+  }
+};
+function useFarmI18nSnapshot() {
+  const snapshot = (0, import_react.useSyncExternalStore)(
+    subscribeFarmI18n,
+    getFarmI18nClientState,
+    getFarmI18nClientState
+  );
+  if (!snapshot) {
+    throw new Error("Farm i18n is not configured or has not been hydrated.");
+  }
+  return snapshot;
+}
+__name(useFarmI18nSnapshot, "useFarmI18nSnapshot");
+function requireSnapshot2() {
+  const snapshot = getFarmI18nClientState();
+  if (!snapshot) {
+    throw new Error("Farm i18n is not configured or has not been hydrated.");
+  }
+  return snapshot;
+}
+__name(requireSnapshot2, "requireSnapshot");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _setFarmI18nClientSnapshot,
+  createTranslator,
+  format,
+  getLocale,
+  getLocaleSource,
+  setLocale,
+  t,
+  useLocale,
+  useTranslations
+});
+//# sourceMappingURL=client.cjs.map