@farm.js/core 0.1.47 → 0.1.49

package/dist/chunk-TUPKMMXT.mjs

@@ -0,0 +1,173 @@
+import {
+  writeFileIfChanged
+} from "./chunk-Q5B4LNON.mjs";
+
+// src/env-types.ts
+import * as fs from "fs";
+import * as path from "path";
+var DEFAULT_OUT_FILE = "farm-env.d.ts";
+var CONFIG_FILENAMES = [
+  "farm.config.ts",
+  "farm.config.tsx",
+  "farm.config.mts",
+  "farm.config.cts",
+  "farm.config.js",
+  "farm.config.jsx",
+  "farm.config.mjs",
+  "farm.config.cjs",
+  "config.ts",
+  "config.tsx",
+  "config.mts",
+  "config.cts",
+  "config.js",
+  "config.jsx",
+  "config.mjs",
+  "config.cjs"
+];
+async function generateEnvTypes(options) {
+  const root = path.resolve(options.root);
+  const srcDir = options.srcDir || "src";
+  const outFile = options.outFile || DEFAULT_OUT_FILE;
+  const outPath = path.isAbsolute(outFile) ? outFile : path.join(root, srcDir, outFile);
+  const content = createEnvTypeDeclarations(options, outPath);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  writeFileIfChanged(outPath, content);
+  return outPath;
+}
+function createEnvTypeDeclarations(options, outPath) {
+  const root = path.resolve(options.root);
+  const configPath = findConfigPath(root, options.configPath);
+  const configPaths = [
+    ...(options.layerConfigPaths ?? []).filter((value) => fs.existsSync(value)),
+    ...configPath ? [configPath] : []
+  ];
+  const content = configPaths.length > 1 ? createLayeredConfigBackedEnvTypes(outPath, configPaths) : configPaths.length === 1 ? createConfigBackedEnvTypes(outPath, configPaths[0]) : createEmptyEnvTypes();
+  return content;
+}
+function createLayeredConfigBackedEnvTypes(outPath, configPaths) {
+  const imports = configPaths.map(
+    (configPath, index) => `import type FarmConfig${index} from ${JSON.stringify(toTypeImportPath(outPath, configPath))};`
+  ).join("\n");
+  const resolvedTypes = configPaths.map(
+    (_configPath, index) => `
+type FarmConfigEnv${index} = typeof FarmConfig${index} extends { env?: infer TEnv }
+  ? NonNullable<TEnv>
+  : never;
+type FarmResolvedEnv${index} = [FarmConfigEnv${index}] extends [never]
+  ? { server: {}; public: {} }
+  : InferEnv<FarmConfigEnv${index}>;`
+  ).join("\n");
+  const mergedTypes = configPaths.slice(1).map(
+    (_configPath, index) => `type FarmMergedEnv${index + 1} = MergeFarmEnv<${index === 0 ? "FarmResolvedEnv0" : `FarmMergedEnv${index}`}, FarmResolvedEnv${index + 1}>;`
+  ).join("\n");
+  const finalType = `FarmMergedEnv${configPaths.length - 1}`;
+  return `/**
+ * Auto-generated env types from Farm layers and farm.config.
+ * Regenerated on dev start, build, and farm generate.
+ */
+${imports}
+import type { InferEnv } from "@farm.js/core/env";
+
+type MergeFarmEnv<TBase, TOverride> = {
+  server: Omit<TBase extends { server: infer T } ? T : {}, keyof (TOverride extends { server: infer T } ? T : {})> &
+    (TOverride extends { server: infer T } ? T : {});
+  public: Omit<TBase extends { public: infer T } ? T : {}, keyof (TOverride extends { public: infer T } ? T : {})> &
+    (TOverride extends { public: infer T } ? T : {});
+};
+${resolvedTypes}
+${mergedTypes}
+
+type FarmResolvedEnv = ${finalType};
+
+declare module "@farm.js/core/env" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+declare module "@farm.js/core" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+export {};
+`;
+}
+function findConfigPath(root, configPath) {
+  if (configPath) {
+    const resolvedPath = path.isAbsolute(configPath) ? configPath : path.join(root, configPath);
+    return fs.existsSync(resolvedPath) ? resolvedPath : null;
+  }
+  for (const filename of CONFIG_FILENAMES) {
+    const resolvedPath = path.join(root, filename);
+    if (fs.existsSync(resolvedPath)) {
+      return resolvedPath;
+    }
+  }
+  return null;
+}
+function createConfigBackedEnvTypes(outPath, configPath) {
+  const configImportPath = toTypeImportPath(outPath, configPath);
+  return `/**
+ * Auto-generated env types from farm.config.
+ * Regenerated on dev start, build, and farm generate.
+ */
+import type FarmConfig from ${JSON.stringify(configImportPath)};
+import type { InferEnv } from "@farm.js/core/env";
+
+type FarmConfigEnv = typeof FarmConfig extends { env?: infer TEnv } ? NonNullable<TEnv> : never;
+type FarmResolvedEnv = [FarmConfigEnv] extends [never]
+  ? { server: {}; public: {} }
+  : InferEnv<FarmConfigEnv>;
+
+declare module "@farm.js/core/env" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+declare module "@farm.js/core" {
+  interface FarmEnvTypes {
+    server: FarmResolvedEnv["server"];
+    public: FarmResolvedEnv["public"];
+  }
+}
+
+export {};
+`;
+}
+function createEmptyEnvTypes() {
+  return `/**
+ * Auto-generated env types from farm.config.
+ * Regenerated on dev start, build, and farm generate.
+ */
+declare module "@farm.js/core/env" {
+  interface FarmEnvTypes {
+    server: {};
+    public: {};
+  }
+}
+
+declare module "@farm.js/core" {
+  interface FarmEnvTypes {
+    server: {};
+    public: {};
+  }
+}
+
+export {};
+`;
+}
+function toTypeImportPath(outPath, targetPath) {
+  const relativePath = path.relative(path.dirname(outPath), targetPath).replace(/\\/g, "/").replace(/\.(tsx?|jsx?|mjs|cjs|mts|cts)$/, "");
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+
+export {
+  generateEnvTypes,
+  createEnvTypeDeclarations
+};

package/dist/chunk-TVCFY3KK.cjs

@@ -0,0 +1,217 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+var _chunkCQL5ZGFUcjs = require('./chunk-CQL5ZGFU.cjs');
+
+// src/client/island-codec.ts
+var TYPED_ARRAYS = {
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  BigInt64Array,
+  BigUint64Array
+};
+function toBase64(bytes) {
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += 32768) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
+  }
+  return btoa(binary);
+}
+function fromBase64(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+function farmTagged(tag, value) {
+  return value === void 0 ? { [_chunkCQL5ZGFUcjs.FARM_TAG]: tag } : { [_chunkCQL5ZGFUcjs.FARM_TAG]: tag, [_chunkCQL5ZGFUcjs.FARM_TAG_VALUE]: value };
+}
+function needsFarmObjectTag(object) {
+  return Object.prototype.hasOwnProperty.call(object, _chunkCQL5ZGFUcjs.FARM_TAG);
+}
+function encodeFarmLeaf(value) {
+  switch (typeof value) {
+    case "undefined":
+      return farmTagged("u");
+    case "bigint":
+      return farmTagged("B", value.toString());
+    case "number":
+      if (Number.isNaN(value)) return farmTagged("n", "NaN");
+      if (value === Infinity) return farmTagged("n", "Infinity");
+      if (value === -Infinity) return farmTagged("n", "-Infinity");
+      if (Object.is(value, -0)) return farmTagged("n", "-0");
+      return void 0;
+    case "object":
+      break;
+    default:
+      return void 0;
+  }
+  if (value === null) return void 0;
+  if (value instanceof Date) {
+    return farmTagged("D", Number.isNaN(value.getTime()) ? null : value.toISOString());
+  }
+  if (typeof URL === "function" && value instanceof URL) return farmTagged("U", value.href);
+  if (value instanceof RegExp) return farmTagged("R", [value.source, value.flags]);
+  if (value instanceof ArrayBuffer) {
+    return farmTagged("Y", ["ArrayBuffer", toBase64(new Uint8Array(value))]);
+  }
+  if (ArrayBuffer.isView(value)) {
+    const name = value instanceof DataView ? "DataView" : value.constructor.name;
+    if (name !== "DataView" && !(name in TYPED_ARRAYS)) return void 0;
+    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return farmTagged("Y", [name, toBase64(bytes)]);
+  }
+  return void 0;
+}
+var NOT_A_FARM_MARKER = /* @__PURE__ */ Symbol.for("farm.codec.not-a-marker");
+function farmPlainObject(entries) {
+  const object = {};
+  for (const [key, value] of entries) {
+    Object.defineProperty(object, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  return object;
+}
+function decodeFarmTagged(object, decodeChild) {
+  const tag = object[_chunkCQL5ZGFUcjs.FARM_TAG];
+  const data = object[_chunkCQL5ZGFUcjs.FARM_TAG_VALUE];
+  switch (tag) {
+    case _chunkCQL5ZGFUcjs.FARM_REFERENCE_TAG:
+    case _chunkCQL5ZGFUcjs.FARM_SLOT_TAG:
+    case _chunkCQL5ZGFUcjs.FARM_ACTION_TAG:
+      return NOT_A_FARM_MARKER;
+    case _chunkCQL5ZGFUcjs.FARM_OBJECT_TAG:
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        return farmPlainObject(
+          Object.entries(data).map(([key, value]) => [key, decodeChild(value)])
+        );
+      }
+      break;
+    case "u":
+      return void 0;
+    case "n":
+      if (data === "NaN") return Number.NaN;
+      if (data === "Infinity") return Infinity;
+      if (data === "-Infinity") return -Infinity;
+      if (data === "-0") return -0;
+      break;
+    case "B":
+      if (typeof data === "string" && /^-?\d+$/.test(data)) return BigInt(data);
+      break;
+    case "D":
+      if (data === null) return new Date(Number.NaN);
+      if (typeof data === "string") return new Date(data);
+      break;
+    case "U":
+      if (typeof data === "string") return new URL(data);
+      break;
+    case "R":
+      if (Array.isArray(data) && typeof data[0] === "string" && typeof data[1] === "string") {
+        return new RegExp(data[0], data[1]);
+      }
+      break;
+    case "Y": {
+      if (!Array.isArray(data) || typeof data[0] !== "string" || typeof data[1] !== "string") break;
+      const bytes = fromBase64(data[1]);
+      if (data[0] === "ArrayBuffer") return bytes.buffer;
+      if (data[0] === "DataView") return new DataView(bytes.buffer);
+      const TypedArray = Object.prototype.hasOwnProperty.call(TYPED_ARRAYS, data[0]) ? TYPED_ARRAYS[data[0]] : void 0;
+      if (!TypedArray || bytes.byteLength % TypedArray.BYTES_PER_ELEMENT !== 0) break;
+      return new TypedArray(
+        bytes.buffer,
+        0,
+        bytes.byteLength / TypedArray.BYTES_PER_ELEMENT
+      );
+    }
+    case "M":
+      if (Array.isArray(data) && data.every((entry) => Array.isArray(entry) && entry.length === 2)) {
+        return new Map(data.map(([key, value]) => [decodeChild(key), decodeChild(value)]));
+      }
+      break;
+    case "S":
+      if (Array.isArray(data)) return new Set(data.map(decodeChild));
+      break;
+    default:
+      throw new TypeError(`unknown ${JSON.stringify(tag)} tag`);
+  }
+  throw new TypeError(`malformed ${JSON.stringify(tag)} tag`);
+}
+function encodeFarmJson(value, seen = /* @__PURE__ */ new Set()) {
+  const leaf = encodeFarmLeaf(value);
+  if (leaf) return leaf;
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") return value;
+  if (typeof value !== "object") throw new TypeError(`${typeof value} values are not serializable`);
+  if (seen.has(value)) throw new TypeError("circular values are not serializable");
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((entry) => encodeFarmJson(entry, seen));
+    if (value instanceof Map) {
+      return farmTagged(
+        "M",
+        Array.from(value, ([key, entry]) => [
+          encodeFarmJson(key, seen),
+          encodeFarmJson(entry, seen)
+        ])
+      );
+    }
+    if (value instanceof Set) {
+      return farmTagged(
+        "S",
+        Array.from(value, (entry) => encodeFarmJson(entry, seen))
+      );
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("class instances are not serializable");
+    }
+    const encoded = Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, encodeFarmJson(entry, seen)])
+    );
+    return needsFarmObjectTag(value) ? farmTagged(_chunkCQL5ZGFUcjs.FARM_OBJECT_TAG, encoded) : encoded;
+  } finally {
+    seen.delete(value);
+  }
+}
+function decodeFarmJson(value) {
+  if (Array.isArray(value)) return value.map(decodeFarmJson);
+  if (!value || typeof value !== "object") return value;
+  if (_chunkCQL5ZGFUcjs.getFarmTag.call(void 0, value) !== void 0) {
+    const decoded = decodeFarmTagged(value, decodeFarmJson);
+    if (decoded === NOT_A_FARM_MARKER) {
+      throw new TypeError(
+        `a ${JSON.stringify(value[_chunkCQL5ZGFUcjs.FARM_TAG])} reference is not allowed here`
+      );
+    }
+    return decoded;
+  }
+  if (needsFarmObjectTag(value)) throw new TypeError('malformed "$" tag');
+  return farmPlainObject(Object.entries(value).map(([key, entry]) => [key, decodeFarmJson(entry)]));
+}
+
+
+
+
+
+
+
+
+
+
+exports.farmTagged = farmTagged; exports.needsFarmObjectTag = needsFarmObjectTag; exports.encodeFarmLeaf = encodeFarmLeaf; exports.NOT_A_FARM_MARKER = NOT_A_FARM_MARKER; exports.farmPlainObject = farmPlainObject; exports.decodeFarmTagged = decodeFarmTagged; exports.encodeFarmJson = encodeFarmJson; exports.decodeFarmJson = decodeFarmJson;

package/dist/chunk-TXK4D46O.mjs

@@ -0,0 +1,22 @@
+// src/search-params.ts
+function searchParamsToObject(searchParams) {
+  const output = {};
+  searchParams.forEach((value, key) => {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") return;
+    const existing = Object.prototype.hasOwnProperty.call(output, key) ? output[key] : void 0;
+    if (existing !== void 0) {
+      if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        output[key] = [existing, value];
+      }
+    } else {
+      output[key] = value;
+    }
+  });
+  return output;
+}
+
+export {
+  searchParamsToObject
+};

package/dist/chunk-UAQD67HM.mjs

@@ -0,0 +1,154 @@
+// 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 = request.headers.get(FARM_DEPLOYMENT_ID_HEADER)?.trim();
+  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,
+        options.cookiePath ?? "/",
+        options.secureCookie ?? false
+      )
+    );
+  }
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function getFarmResponseDeploymentId(response) {
+  return response.headers.get(FARM_DEPLOYMENT_ID_HEADER)?.trim() || 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 {
+      return value;
+    }
+  }
+  return void 0;
+}
+function isSafeRequestMethod(method) {
+  return ["GET", "HEAD", "OPTIONS", "QUERY"].includes(method.toUpperCase());
+}
+
+export {
+  FARM_DEPLOYMENT_ID_HEADER,
+  FARM_DEPLOYMENT_MISMATCH_HEADER,
+  FARM_DEPLOYMENT_COOKIE,
+  FARM_DEPLOYMENT_MISMATCH_CODE,
+  FARM_DEPLOYMENT_MISMATCH_STATUS,
+  getFarmPresetRuntime,
+  FarmDeploymentMismatchError,
+  normalizeFarmDeploymentId,
+  createFarmDeploymentRequestHeaders,
+  getFarmRequestDeploymentId,
+  getFarmDeploymentMismatch,
+  createFarmDeploymentMismatchResponse,
+  withFarmDeploymentResponse,
+  getFarmResponseDeploymentId,
+  isFarmDeploymentMismatchResponse,
+  createFarmDeploymentMismatchError,
+  createFarmDeploymentCookie
+};