@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-MU5V7XHL.mjs

@@ -1,172 +0,0 @@
-// src/i18n/config.ts
-import path from "path";
-var DEFAULT_FARM_I18N_COOKIE = "farm_locale";
-var DEFAULT_FARM_I18N_COOKIE_MAX_AGE = 60 * 60 * 24 * 365;
-var DEFAULT_DETECTION = ["url", "cookie", "accept-language"];
-function resolveFarmI18nConfig(input, options = {}) {
-  const root = options.root || process.cwd();
-  const basePath = options.basePath || "/";
-  const strictByDefault = options.mode === "production";
-  if (!input) {
-    return {
-      enabled: false,
-      basePath,
-      locales: ["en"],
-      defaultLocale: "en",
-      messages: path.join(root, "src/messages"),
-      routing: "none",
-      detection: [],
-      fallbackLocale: "en",
-      strict: strictByDefault,
-      cookie: {
-        name: DEFAULT_FARM_I18N_COOKIE,
-        maxAge: DEFAULT_FARM_I18N_COOKIE_MAX_AGE,
-        path: "/",
-        sameSite: "lax",
-        secure: options.mode === "production"
-      },
-      direction: {}
-    };
-  }
-  if (!Array.isArray(input.locales) || input.locales.length === 0) {
-    throw new Error("i18n.locales must contain at least one locale.");
-  }
-  const locales = input.locales.map(canonicalizeLocale);
-  if (new Set(locales).size !== locales.length) {
-    throw new Error("i18n.locales must not contain duplicate locales.");
-  }
-  const defaultLocale = canonicalizeLocale(input.defaultLocale);
-  if (!locales.includes(defaultLocale)) {
-    throw new Error(`i18n.defaultLocale "${defaultLocale}" must be included in i18n.locales.`);
-  }
-  const fallbackLocale = canonicalizeLocale(input.fallbackLocale || defaultLocale);
-  if (!locales.includes(fallbackLocale)) {
-    throw new Error(`i18n.fallbackLocale "${fallbackLocale}" must be included in i18n.locales.`);
-  }
-  const detection = resolveDetection(input);
-  const sameSite = input.cookie?.sameSite ?? "lax";
-  if (sameSite !== "lax" && sameSite !== "strict" && sameSite !== "none") {
-    throw new Error('i18n.cookie.sameSite must be "lax", "strict", or "none".');
-  }
-  if (sameSite === "none" && input.cookie?.secure === false) {
-    throw new Error('i18n.cookie.secure cannot be false when i18n.cookie.sameSite is "none".');
-  }
-  const direction = {};
-  for (const [rawLocale, value] of Object.entries(input.direction || {})) {
-    const locale = canonicalizeLocale(rawLocale);
-    if (!locales.includes(locale)) {
-      throw new Error(`i18n.direction contains unknown locale "${rawLocale}".`);
-    }
-    if (value !== "ltr" && value !== "rtl") {
-      throw new Error(`i18n.direction.${rawLocale} must be "ltr" or "rtl".`);
-    }
-    direction[locale] = value;
-  }
-  return {
-    enabled: true,
-    basePath,
-    locales,
-    defaultLocale,
-    messages: path.resolve(root, input.messages || "src/messages"),
-    routing: input.routing || "prefix-except-default",
-    detection,
-    fallbackLocale,
-    strict: input.strict ?? strictByDefault,
-    cookie: {
-      name: input.cookie?.name?.trim() || DEFAULT_FARM_I18N_COOKIE,
-      maxAge: normalizePositiveInteger(
-        input.cookie?.maxAge,
-        DEFAULT_FARM_I18N_COOKIE_MAX_AGE,
-        "i18n.cookie.maxAge"
-      ),
-      path: normalizeCookiePath(input.cookie?.path),
-      sameSite,
-      secure: input.cookie?.secure ?? (sameSite === "none" || options.mode === "production")
-    },
-    direction
-  };
-}
-function resolveFarmI18nMessagePath(config, locale) {
-  return config.messages.includes("{locale}") ? config.messages.split("{locale}").join(locale) : path.join(config.messages, `${locale}.json`);
-}
-function isFarmI18nCatalogFile(config, file) {
-  if (!config.enabled) return false;
-  const normalizedFile = file.replace(/\\/g, "/");
-  return config.locales.some(
-    (locale) => resolveFarmI18nMessagePath(config, locale).replace(/\\/g, "/") === normalizedFile
-  );
-}
-function canonicalizeLocale(locale) {
-  if (!locale || typeof locale !== "string") {
-    throw new Error("Farm i18n locales must be non-empty strings.");
-  }
-  try {
-    return Intl.getCanonicalLocales(locale)[0];
-  } catch {
-    throw new Error(`Invalid i18n locale "${locale}".`);
-  }
-}
-function resolveDetection(input) {
-  if (input.detection === false || input.localeDetection === false) {
-    return ["url"];
-  }
-  const detection = input.detection || DEFAULT_DETECTION;
-  const allowed = /* @__PURE__ */ new Set(["url", "cookie", "accept-language"]);
-  const unique = [];
-  for (const signal of detection) {
-    if (!allowed.has(signal)) {
-      throw new Error(`Unsupported i18n detection signal "${signal}".`);
-    }
-    if (!unique.includes(signal)) unique.push(signal);
-  }
-  return unique;
-}
-function normalizePositiveInteger(value, fallback, name) {
-  if (value === void 0) return fallback;
-  if (!Number.isInteger(value) || value < 0) {
-    throw new Error(`${name} must be a positive integer.`);
-  }
-  return value;
-}
-function normalizeCookiePath(value) {
-  if (value === void 0) return "/";
-  if (typeof value !== "string") {
-    throw new Error("i18n.cookie.path must be a root-relative pathname.");
-  }
-  const hasUnstableCharacters = (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
-    const code = character.charCodeAt(0);
-    return code <= 31 || code >= 127 && code <= 159;
-  });
-  if (hasUnstableCharacters(value)) {
-    throw new Error("i18n.cookie.path cannot contain backslashes or control characters.");
-  }
-  const pathname = value.trim();
-  if (!pathname || !pathname.startsWith("/") || pathname.startsWith("//") || pathname.includes(";") || pathname.includes("?") || pathname.includes("#")) {
-    throw new Error(
-      "i18n.cookie.path must be a root-relative pathname without attributes, a query, or a hash."
-    );
-  }
-  for (const segment of pathname.split("/")) {
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (hasUnstableCharacters(decoded)) {
-      throw new Error("i18n.cookie.path cannot contain backslashes or control characters.");
-    }
-    if (decoded.includes("/")) {
-      throw new Error("i18n.cookie.path cannot contain percent-encoded path separators.");
-    }
-    if (decoded === "." || decoded === "..") {
-      throw new Error('i18n.cookie.path cannot contain "." or ".." path segments.');
-    }
-  }
-  return pathname;
-}
-
-export {
-  resolveFarmI18nConfig,
-  resolveFarmI18nMessagePath,
-  isFarmI18nCatalogFile
-};

package/dist/chunk-N33DLJBC.mjs

@@ -1,272 +0,0 @@
-import {
-  readFarmEnvironmentValue
-} from "./chunk-WXFY5JIY.mjs";
-
-// src/env.ts
-var FARM_ENV_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env");
-var FARM_ENV_RUNTIME_SYMBOL = /* @__PURE__ */ Symbol.for("farm.env.runtime");
-var farmEnvGlobal = globalThis;
-var currentEnv = getInitialEnv();
-function resolveEnv(config, source = getProcessEnv()) {
-  const resolved = {
-    server: resolveEnvScope(config?.server, source, "server"),
-    public: resolveEnvScope(config?.public, source, "public")
-  };
-  return resolved;
-}
-function createBundledEnv(env2, source = getProcessEnv()) {
-  const resolved = normalizeResolvedEnv(env2 ?? {});
-  const server = {};
-  const runtime = {};
-  for (const [key, value] of Object.entries(resolved.server)) {
-    const raw = source[key];
-    const type = getRuntimeEnvType(value);
-    if (raw !== void 0 && isSameEnvValue(coerceRuntimeEnvValue(raw, type), value)) {
-      runtime[key] = type;
-    } else {
-      server[key] = value;
-    }
-  }
-  return {
-    server,
-    public: resolved.public,
-    ...Object.keys(runtime).length > 0 ? { runtime: { server: runtime } } : {}
-  };
-}
-function setEnv(env2) {
-  currentEnv = prepareEnv(env2);
-  if (typeof window === "undefined") {
-    farmEnvGlobal[FARM_ENV_SYMBOL] = currentEnv;
-  }
-}
-function getResolvedEnv() {
-  const env2 = getCurrentEnv();
-  if (typeof window === "undefined") readRuntimeServerEnv(env2);
-  return env2;
-}
-function getEnv(key) {
-  const server = getEnvScope("server");
-  if (key === void 0) {
-    return server;
-  }
-  return readServerEnvKey(server, key);
-}
-function getPublicEnv(key) {
-  if (key === void 0) {
-    return getCurrentEnv().public;
-  }
-  return getCurrentEnv().public[key];
-}
-var env = createEnvProxy("server");
-var serverEnv = env;
-var publicEnv = createEnvProxy("public");
-function resolveEnvScope(shape, source, scope) {
-  if (!shape) {
-    return {};
-  }
-  const resolved = {};
-  for (const [key, parser] of Object.entries(shape)) {
-    try {
-      resolved[key] = parseEnvValue(parser, source[key], key, scope);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Invalid ${scope} env "${key}": ${message}`);
-    }
-  }
-  return resolved;
-}
-function parseEnvValue(parser, value, key, scope) {
-  if (typeof parser === "function") {
-    return parser(value, { key, scope });
-  }
-  if (parser && typeof parser.parse === "function") {
-    return parser.parse(value);
-  }
-  throw new Error("expected a parser function or schema with parse()");
-}
-function createEnvProxy(scope) {
-  return new Proxy(
-    {},
-    {
-      get(_target, property) {
-        if (typeof property === "symbol") {
-          return void 0;
-        }
-        const env2 = getEnvScope(scope);
-        return scope === "server" ? readServerEnvKey(env2, property) : env2[property];
-      },
-      ownKeys() {
-        return Reflect.ownKeys(getEnvScope(scope));
-      },
-      getOwnPropertyDescriptor(_target, property) {
-        const env2 = getEnvScope(scope);
-        if (!(property in env2)) {
-          return void 0;
-        }
-        return {
-          enumerable: true,
-          configurable: true,
-          value: env2[property]
-        };
-      },
-      has(_target, property) {
-        return property in getEnvScope(scope);
-      }
-    }
-  );
-}
-function getEnvScope(scope) {
-  const env2 = getCurrentEnv();
-  if (scope === "server") {
-    assertServerEnvAccess();
-    readRuntimeServerEnv(env2);
-  }
-  return env2[scope] || {};
-}
-function readServerEnvKey(server, key) {
-  const value = server[key];
-  if (value === void 0) {
-    const state = getCurrentEnv()[FARM_ENV_RUNTIME_SYMBOL];
-    if (state && key in state.pending && !state.warned.has(key)) {
-      state.warned.add(key);
-      console.warn(
-        `[Farm] Server env "${key}" was set when this app was built but is not set where the server runs, so it reads as undefined. Farm reads server env at runtime and does not store it in the build output; set "${key}" in the server's environment.`
-      );
-    }
-  }
-  return value;
-}
-function readRuntimeServerEnv(env2) {
-  const state = env2[FARM_ENV_RUNTIME_SYMBOL];
-  if (!state) return;
-  for (const [key, type] of Object.entries(state.pending)) {
-    const raw = readFarmEnvironmentValue(key);
-    if (raw === void 0) continue;
-    env2.server[key] = coerceRuntimeEnvValue(raw, type);
-    delete state.pending[key];
-  }
-}
-function getRuntimeEnvType(value) {
-  if (typeof value === "number") return "number";
-  if (typeof value === "boolean") return "boolean";
-  if (value !== null && typeof value === "object" && !(value instanceof Date)) return "json";
-  return "string";
-}
-function coerceRuntimeEnvValue(raw, type) {
-  if (type === "number") {
-    const value = Number(raw);
-    return raw.trim() !== "" && Number.isFinite(value) ? value : raw;
-  }
-  if (type === "boolean") {
-    if (/^(true|1)$/i.test(raw.trim())) return true;
-    if (/^(false|0|)$/i.test(raw.trim())) return false;
-    return raw;
-  }
-  if (type === "json") {
-    try {
-      return JSON.parse(raw);
-    } catch {
-      return raw;
-    }
-  }
-  return raw;
-}
-function isSameEnvValue(left, right) {
-  if (Object.is(left, right)) return true;
-  if (Array.isArray(left) || Array.isArray(right)) {
-    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((item, index) => isSameEnvValue(item, right[index]));
-  }
-  if (!isPlainObject(left) || !isPlainObject(right)) return false;
-  const keys = Object.keys(left);
-  return keys.length === Object.keys(right).length && keys.every(
-    (key) => Object.prototype.hasOwnProperty.call(right, key) && isSameEnvValue(left[key], right[key])
-  );
-}
-function isPlainObject(value) {
-  if (!value || typeof value !== "object") return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-}
-function prepareEnv(env2) {
-  const normalized = normalizeResolvedEnv(env2);
-  const runtime = env2.runtime?.server;
-  if (!isRecord(runtime) || Object.keys(runtime).length === 0) return normalized;
-  const prepared = { server: { ...normalized.server }, public: normalized.public };
-  Object.defineProperty(prepared, FARM_ENV_RUNTIME_SYMBOL, {
-    value: {
-      pending: { ...runtime },
-      warned: /* @__PURE__ */ new Set()
-    },
-    enumerable: false
-  });
-  return prepared;
-}
-function assertServerEnvAccess() {
-  if (typeof window !== "undefined") {
-    throw new Error("Farm server env is not available in the browser. Use publicEnv.");
-  }
-}
-function getInitialEnv() {
-  const injectedEnv = getInjectedEnv();
-  if (injectedEnv) {
-    return injectedEnv;
-  }
-  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
-    return normalizeResolvedEnv(farmEnvGlobal[FARM_ENV_SYMBOL]);
-  }
-  return {
-    server: {},
-    public: getInjectedPublicEnv()
-  };
-}
-function getCurrentEnv() {
-  if (typeof window === "undefined" && farmEnvGlobal[FARM_ENV_SYMBOL]) {
-    return farmEnvGlobal[FARM_ENV_SYMBOL];
-  }
-  return currentEnv;
-}
-function getInjectedEnv() {
-  try {
-    if (typeof __FARM_ENV__ !== "undefined" && __FARM_ENV__) {
-      return prepareEnv(__FARM_ENV__);
-    }
-  } catch {
-  }
-  return null;
-}
-function getInjectedPublicEnv() {
-  try {
-    if (typeof __FARM_PUBLIC_ENV__ !== "undefined" && __FARM_PUBLIC_ENV__) {
-      return __FARM_PUBLIC_ENV__;
-    }
-  } catch {
-  }
-  return {};
-}
-function normalizeResolvedEnv(env2) {
-  return {
-    server: isRecord(env2.server) ? env2.server : {},
-    public: isRecord(env2.public) ? env2.public : {}
-  };
-}
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function getProcessEnv() {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env;
-  }
-  return {};
-}
-
-export {
-  resolveEnv,
-  createBundledEnv,
-  setEnv,
-  getResolvedEnv,
-  getEnv,
-  getPublicEnv,
-  env,
-  serverEnv,
-  publicEnv
-};

package/dist/chunk-N35YPV4N.mjs

@@ -1,48 +0,0 @@
-import {
-  bundleNodeModule
-} from "./chunk-VFXE6NWR.mjs";
-
-// src/instrumentation.ts
-import fs from "fs";
-import path from "path";
-import { pathToFileURL } from "url";
-var INSTRUMENTATION_EXTENSIONS = ["ts", "mts", "js", "mjs"];
-function resolveFarmInstrumentationFile(root, srcDir = "src") {
-  const candidates = [
-    ...INSTRUMENTATION_EXTENSIONS.map(
-      (extension) => path.join(root, srcDir, `instrumentation.${extension}`)
-    ),
-    ...INSTRUMENTATION_EXTENSIONS.map(
-      (extension) => path.join(root, `instrumentation.${extension}`)
-    )
-  ].filter((candidate) => fs.existsSync(candidate));
-  if (candidates.length > 1) {
-    throw new Error(
-      `Farm.js found multiple instrumentation files:
-${candidates.map((candidate) => `- ${path.relative(root, candidate)}`).join("\n")}
-Keep only one instrumentation file in the project root or ${srcDir}/.`
-    );
-  }
-  return candidates[0] ?? null;
-}
-async function loadFarmInstrumentation(filePath, root) {
-  if (!filePath) return null;
-  const outputDirectory = path.join(root, ".farm", ".instrumentation-loader");
-  const outputFile = path.join(outputDirectory, "instrumentation.mjs");
-  await fs.promises.mkdir(outputDirectory, { recursive: true });
-  await bundleNodeModule({
-    root,
-    entry: filePath,
-    outfile: outputFile,
-    target: "node20",
-    externalPackages: true
-  });
-  const url = pathToFileURL(outputFile);
-  url.searchParams.set("t", String(Date.now()));
-  return await import(url.href);
-}
-
-export {
-  resolveFarmInstrumentationFile,
-  loadFarmInstrumentation
-};

package/dist/chunk-N4AQNEXR.cjs

@@ -1,17 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/client-revalidation.ts
-function attachRevalidationListeners(refresh, options = {}) {
-  if (typeof window === "undefined") return () => {
-  };
-  const onFocus = options.refetchOnWindowFocus === false ? void 0 : refresh;
-  const onOnline = options.refetchOnReconnect === false ? void 0 : refresh;
-  if (onFocus) window.addEventListener("focus", onFocus);
-  if (onOnline) window.addEventListener("online", onOnline);
-  return () => {
-    if (onFocus) window.removeEventListener("focus", onFocus);
-    if (onOnline) window.removeEventListener("online", onOnline);
-  };
-}
-
-
-
-exports.attachRevalidationListeners = attachRevalidationListeners;

package/dist/chunk-N7XWC6BN.mjs

@@ -1,21 +0,0 @@
-// src/server-query-protocol.ts
-var FARM_SERVER_QUERY_RESULT_VERSION = 1;
-function createFarmServerQueryResult(data, metadata) {
-  return {
-    __farmServerQuery: {
-      version: FARM_SERVER_QUERY_RESULT_VERSION,
-      ...metadata
-    },
-    data
-  };
-}
-function isFarmServerQueryResult(value) {
-  if (!value || typeof value !== "object") return false;
-  const metadata = value.__farmServerQuery;
-  return metadata?.version === FARM_SERVER_QUERY_RESULT_VERSION && typeof metadata.key === "string" && (metadata.staleTime === false || typeof metadata.staleTime === "number") && typeof metadata.updatedAt === "number" && "data" in value;
-}
-
-export {
-  createFarmServerQueryResult,
-  isFarmServerQueryResult
-};

package/dist/chunk-NBIVGHAT.mjs

@@ -1,50 +0,0 @@
-// src/client/island-value-protocol.ts
-var FARM_ISLAND_ELEMENT = "f-island";
-var FARM_PROPS_SCRIPT_TYPE = "f/props";
-var FARM_VALUE_SCRIPT_TYPE = "f/value";
-var FARM_SLOT_ELEMENT = "f-slot";
-var FARM_TAG = "$";
-var FARM_TAG_VALUE = "v";
-var FARM_REFERENCE_TAG = "r";
-var FARM_SLOT_TAG = "s";
-var FARM_ACTION_TAG = "a";
-var FARM_OBJECT_TAG = "o";
-var FARM_VALUES_HEADER = "F-Values";
-function getFarmTag(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const tag = value[FARM_TAG];
-  if (typeof tag !== "string") return void 0;
-  const keys = Object.keys(value);
-  return keys.length === 1 || keys.length === 2 && FARM_TAG_VALUE in value ? tag : void 0;
-}
-var FARM_VALUE_KEY_PATTERN = /^[0-9a-z]{14}$/;
-var FARM_MAX_HELD_VALUES = 128;
-var FARM_ISLAND_VALUE_STORE_KEY = /* @__PURE__ */ Symbol.for("islx.values");
-var ISLAND_VALUES_SERVER_KEY = /* @__PURE__ */ Symbol.for("farm.island-values.server");
-function getFarmIslandValuesServer() {
-  return globalThis[ISLAND_VALUES_SERVER_KEY];
-}
-function getFarmIslandValueHeaders() {
-  const scope = globalThis;
-  const held = scope[FARM_ISLAND_VALUE_STORE_KEY]?.heldHeader();
-  return held ? { [FARM_VALUES_HEADER]: held } : {};
-}
-
-export {
-  FARM_ISLAND_ELEMENT,
-  FARM_PROPS_SCRIPT_TYPE,
-  FARM_VALUE_SCRIPT_TYPE,
-  FARM_SLOT_ELEMENT,
-  FARM_TAG,
-  FARM_TAG_VALUE,
-  FARM_REFERENCE_TAG,
-  FARM_SLOT_TAG,
-  FARM_ACTION_TAG,
-  FARM_OBJECT_TAG,
-  FARM_VALUES_HEADER,
-  getFarmTag,
-  FARM_VALUE_KEY_PATTERN,
-  FARM_MAX_HELD_VALUES,
-  getFarmIslandValuesServer,
-  getFarmIslandValueHeaders
-};

package/dist/chunk-NCIAP562.mjs

@@ -1,27 +0,0 @@
-// src/client/navigation-url.ts
-var FARM_NAVIGATION_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:", "tel:"]);
-function isFarmBlockedNavigationURL(url) {
-  if (FARM_NAVIGATION_PROTOCOLS.has(url.protocol)) return false;
-  console.error(`[Farm.js] Blocked navigation to a ${url.protocol} URL as a security precaution.`);
-  return true;
-}
-function isFarmScriptURL(href) {
-  try {
-    return new URL(href, "http://farm.invalid").protocol === "javascript:";
-  } catch {
-    return false;
-  }
-}
-function isFarmExternalNavigationURL(url, currentOrigin) {
-  return url.protocol !== "http:" && url.protocol !== "https:" || url.origin !== currentOrigin;
-}
-function resolveFarmNavigationURL(href, documentUrl) {
-  return new URL(href, documentUrl);
-}
-
-export {
-  isFarmBlockedNavigationURL,
-  isFarmScriptURL,
-  isFarmExternalNavigationURL,
-  resolveFarmNavigationURL
-};