@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-BBPDJGCU.cjs

@@ -1,157 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _chunkLNVGXUL3cjs = require('./chunk-LNVGXUL3.cjs');
-
-// src/i18n/catalog.ts
-var _promises = require('fs/promises');
-var _icumessageformatparser = require('@formatjs/icu-messageformat-parser');
-async function readFarmI18nCatalogs(config) {
-  if (!config.enabled) {
-    return { catalogs: {}, signatures: {} };
-  }
-  const catalogs = {};
-  for (const locale of config.locales) {
-    const filePath = _chunkLNVGXUL3cjs.resolveFarmI18nMessagePath.call(void 0, config, locale);
-    let source;
-    try {
-      source = await _promises.readFile.call(void 0, 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 = _icumessageformatparser.parse.call(void 0, 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 _icumessageformatparser.TYPE.argument:
-        addArgument(signature, element.value, "string", label);
-        break;
-      case _icumessageformatparser.TYPE.number:
-      case _icumessageformatparser.TYPE.plural:
-        addArgument(signature, element.value, "number", label);
-        break;
-      case _icumessageformatparser.TYPE.date:
-      case _icumessageformatparser.TYPE.time:
-        addArgument(signature, element.value, "date", label);
-        break;
-      case _icumessageformatparser.TYPE.select:
-        addArgument(signature, element.value, "select", label);
-        break;
-      case _icumessageformatparser.TYPE.tag:
-        addArgument(signature, element.value, "rich", label);
-        collectArguments(element.children, signature, label);
-        break;
-    }
-    if (element.type === _icumessageformatparser.TYPE.plural || element.type === _icumessageformatparser.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);
-}
-
-
-
-exports.readFarmI18nCatalogs = readFarmI18nCatalogs;

package/dist/chunk-BLD5GVCG.mjs

@@ -1,152 +0,0 @@
-// src/api/config.ts
-var DEFAULT_FARM_API_BASE_PATH = "/api";
-async function resolveFarmAPIConfig(config, context) {
-  const configuredBasePath = await resolveConfigValue(config?.basePath, context, "api.basePath");
-  const basePath = normalizeFarmAPIBasePath(configuredBasePath ?? DEFAULT_FARM_API_BASE_PATH);
-  const configuredBaseURL = await resolveConfigValue(config?.baseURL, context, "api.baseURL");
-  return normalizeFarmAPIConfig({ baseURL: configuredBaseURL, basePath });
-}
-function normalizeFarmAPIConfig(config) {
-  const basePath = normalizeFarmAPIBasePath(config?.basePath ?? DEFAULT_FARM_API_BASE_PATH);
-  const baseURL = config?.baseURL?.trim();
-  if (!baseURL) {
-    return { baseURL: basePath, basePath };
-  }
-  if (baseURL.startsWith("//")) {
-    throw new Error(
-      'Farm api.baseURL must be an absolute URL or a root-relative path such as "/api", not a network-path reference.'
-    );
-  }
-  if (baseURL.startsWith("/")) {
-    const url2 = parseRootRelativeBaseURL(baseURL);
-    if (url2.pathname !== "/") {
-      const effectivePath = normalizeFarmAPIBasePath(url2.pathname);
-      return { baseURL: effectivePath, basePath: effectivePath };
-    }
-    return { baseURL: basePath, basePath };
-  }
-  let url;
-  try {
-    url = new URL(baseURL);
-  } catch {
-    throw new Error(
-      'Farm api.baseURL must be an absolute URL or a root-relative path such as "/api".'
-    );
-  }
-  if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new Error("Farm api.baseURL must use http or https.");
-  }
-  if (url.search || url.hash) {
-    throw new Error("Farm api.baseURL cannot contain a query string or hash.");
-  }
-  if (url.pathname !== "/") {
-    const effectivePath = normalizeFarmAPIBasePath(url.pathname);
-    return {
-      baseURL: `${url.origin}${effectivePath}`,
-      basePath: effectivePath
-    };
-  }
-  return {
-    baseURL: basePath === "/" ? url.origin : `${url.origin}${basePath}`,
-    basePath
-  };
-}
-function normalizeFarmAPIBasePath(value) {
-  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("Farm api.basePath cannot contain backslashes or control characters.");
-  }
-  const path = value.trim();
-  if (!path) {
-    throw new Error("Farm api.basePath cannot be empty.");
-  }
-  if (path.includes("?") || path.includes("#")) {
-    throw new Error("Farm api.basePath cannot contain a query string or hash.");
-  }
-  if (path.startsWith("//")) {
-    throw new Error('Farm api.basePath must be a pathname such as "/api", not a URL.');
-  }
-  for (const segment of path.split("/")) {
-    let decoded = segment;
-    try {
-      decoded = decodeURIComponent(segment);
-    } catch {
-    }
-    if (hasUnstableCharacters(decoded)) {
-      throw new Error("Farm api.basePath cannot contain backslashes or control characters.");
-    }
-    if (decoded.includes("/")) {
-      throw new Error("Farm api.basePath cannot contain percent-encoded path separators.");
-    }
-    if (decoded === "." || decoded === "..") {
-      throw new Error('Farm api.basePath cannot contain "." or ".." path segments.');
-    }
-  }
-  const normalized = `/${path.replace(/^\/+|\/+$/g, "")}`;
-  return normalized === "/" ? "/" : normalized;
-}
-function getFarmAPIBaseURL() {
-  if (typeof __FARM_API_BASE_URL__ !== "undefined" && __FARM_API_BASE_URL__) {
-    return __FARM_API_BASE_URL__;
-  }
-  return DEFAULT_FARM_API_BASE_PATH;
-}
-function resolveFarmAPIRequestURL(routePath, baseURL = getFarmAPIBaseURL(), fallbackOrigin = getDefaultOrigin()) {
-  const base = new URL(baseURL, fallbackOrigin);
-  if (base.pathname === "/") {
-    return new URL(routePath, base);
-  }
-  const route = new URL(routePath, fallbackOrigin);
-  const suffix = stripCanonicalAPIBasePath(route.pathname);
-  const joinedPath = joinURLPath(base.pathname, suffix);
-  base.pathname = joinedPath;
-  base.search = route.search;
-  base.hash = route.hash;
-  return base;
-}
-async function resolveConfigValue(value, context, name) {
-  const resolved = typeof value === "function" ? await value(context) : value;
-  if (resolved === void 0) return void 0;
-  if (typeof resolved !== "string") {
-    throw new Error(`Farm ${name} must resolve to a string or undefined.`);
-  }
-  if (!resolved.trim()) {
-    throw new Error(`Farm ${name} cannot be empty.`);
-  }
-  return resolved;
-}
-function parseRootRelativeBaseURL(value) {
-  const url = new URL(value, "http://farm.local");
-  if (url.search || url.hash) {
-    throw new Error("Farm api.baseURL cannot contain a query string or hash.");
-  }
-  return url;
-}
-function stripCanonicalAPIBasePath(pathname) {
-  if (pathname === DEFAULT_FARM_API_BASE_PATH) return "";
-  if (pathname.startsWith(`${DEFAULT_FARM_API_BASE_PATH}/`)) {
-    return pathname.slice(DEFAULT_FARM_API_BASE_PATH.length + 1);
-  }
-  return pathname.replace(/^\/+/, "");
-}
-function joinURLPath(basePath, suffix) {
-  const normalizedBase = basePath === "/" ? "" : basePath.replace(/\/+$/, "");
-  const normalizedSuffix = suffix.replace(/^\/+/, "");
-  if (!normalizedSuffix) return normalizedBase || "/";
-  return `${normalizedBase}/${normalizedSuffix}`;
-}
-function getDefaultOrigin() {
-  return typeof window !== "undefined" ? window.location.origin : "http://localhost:3000";
-}
-
-export {
-  DEFAULT_FARM_API_BASE_PATH,
-  resolveFarmAPIConfig,
-  normalizeFarmAPIConfig,
-  normalizeFarmAPIBasePath,
-  getFarmAPIBaseURL,
-  resolveFarmAPIRequestURL
-};

package/dist/chunk-BMQAPZXD.mjs

@@ -1,31 +0,0 @@
-// src/route-context.ts
-var FARM_ROUTE_CONTEXT_SYMBOL = /* @__PURE__ */ Symbol.for("farm.routeContext");
-async function resolveFarmRouteContext(config, input) {
-  if (typeof config.context !== "function") {
-    return void 0;
-  }
-  return config.context(input);
-}
-function withFarmRouteContext(props, context) {
-  if (context === void 0) {
-    return props;
-  }
-  Object.defineProperty(props, FARM_ROUTE_CONTEXT_SYMBOL, {
-    value: context,
-    enumerable: false,
-    configurable: true
-  });
-  return props;
-}
-function getFarmRouteContext(props) {
-  if (!props || typeof props !== "object") {
-    return void 0;
-  }
-  return props[FARM_ROUTE_CONTEXT_SYMBOL];
-}
-
-export {
-  resolveFarmRouteContext,
-  withFarmRouteContext,
-  getFarmRouteContext
-};

package/dist/chunk-BNH53KOT.cjs

@@ -1,69 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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/api/dev-dispatch.ts
-var _http = require('http'); var _http2 = _interopRequireDefault(_http);
-var _https = require('https'); var _https2 = _interopRequireDefault(_https);
-var _stream = require('stream');
-function createFarmDevServerDispatch(server) {
-  return (request) => new Promise((resolve, reject) => {
-    const address = _optionalChain([server, 'access', _ => _.httpServer, 'optionalAccess', _2 => _2.address, 'call', _3 => _3()]);
-    if (!address || typeof address === "string") {
-      throw new Error(
-        "Farm cannot dispatch an app endpoint request: the Vite dev server has no listening HTTP server."
-      );
-    }
-    const url = new URL(request.url);
-    const headers = {};
-    request.headers.forEach((value, name) => {
-      headers[name] = value;
-    });
-    headers.host = url.host;
-    const secure = Boolean(server.config.server.https);
-    const outgoing = (secure ? _https2.default : _http2.default).request(
-      {
-        host: loopbackAddress(address),
-        port: address.port,
-        method: request.method,
-        path: `${url.pathname}${url.search}`,
-        headers,
-        signal: request.signal,
-        // The listener is this process's own dev server, often with a self-signed certificate.
-        ...secure ? { rejectUnauthorized: false } : {}
-      },
-      (incoming) => {
-        const responseHeaders = new Headers();
-        for (const [name, value] of Object.entries(incoming.headers)) {
-          if (value === void 0) continue;
-          for (const entry of Array.isArray(value) ? value : [value]) {
-            responseHeaders.append(name, entry);
-          }
-        }
-        const status = _nullishCoalesce(incoming.statusCode, () => ( 502));
-        const hasBody = request.method !== "HEAD" && status !== 204 && status !== 205 && status !== 304;
-        if (!hasBody) incoming.resume();
-        try {
-          resolve(
-            new Response(
-              hasBody ? _stream.Readable.toWeb(incoming) : null,
-              { status, statusText: incoming.statusMessage, headers: responseHeaders }
-            )
-          );
-        } catch (error) {
-          incoming.destroy();
-          reject(error);
-        }
-      }
-    );
-    outgoing.on("error", reject);
-    if (request.body) {
-      _stream.Readable.fromWeb(request.body).on("error", (error) => outgoing.destroy(error)).pipe(outgoing);
-    } else {
-      outgoing.end();
-    }
-  });
-}
-function loopbackAddress({ address }) {
-  return address === "0.0.0.0" ? "127.0.0.1" : address === "::" ? "::1" : address;
-}
-
-
-
-exports.createFarmDevServerDispatch = createFarmDevServerDispatch;

package/dist/chunk-BPAXGCKX.mjs

@@ -1,166 +0,0 @@
-import {
-  matchSegmentParts,
-  normalizePathname,
-  normalizeRoutePattern,
-  parseRoutePattern,
-  splitNormalizedPathname,
-  splitPathname
-} from "./chunk-MFQGU5CC.mjs";
-import {
-  AmbiguousRouteError,
-  compareRouteSpecificity,
-  getRoutePatternShape
-} from "./chunk-AYP2YFVN.mjs";
-
-// src/router.ts
-function createFarmRouter(routes) {
-  const normalizedRoutes = routes.map(normalizeRouteInput);
-  const patternsByShape = /* @__PURE__ */ new Map();
-  for (const entry of normalizedRoutes) {
-    const shape = getRoutePatternShape(entry.route.path, "router");
-    const existingPattern = patternsByShape.get(shape);
-    if (existingPattern) {
-      throw new AmbiguousRouteError(
-        `Ambiguous route patterns "${existingPattern}" and "${entry.route.path}" match the same URLs. Keep only one route for this URL shape.`
-      );
-    }
-    patternsByShape.set(shape, entry.route.path);
-  }
-  normalizedRoutes.sort(compareRoutes);
-  const exactRoutes = /* @__PURE__ */ new Map();
-  for (const entry of normalizedRoutes) {
-    if (entry.segments.every((segment) => segment.type === "static")) {
-      const pathname = entry.segments.length ? `/${entry.segments.map((segment) => encodePathSegment(segment.value)).join("/")}` : "/";
-      exactRoutes.set(pathname, entry);
-    }
-  }
-  return {
-    routes: normalizedRoutes.map((entry) => entry.route),
-    match(pathname) {
-      const normalizedPathname = normalizePathname(pathname);
-      const exactRoute = exactRoutes.get(normalizedPathname);
-      if (exactRoute) {
-        return {
-          route: exactRoute.route,
-          pathname: normalizedPathname,
-          params: {}
-        };
-      }
-      const parts = splitNormalizedPathname(normalizedPathname);
-      for (const entry of normalizedRoutes) {
-        const params = matchSegmentParts(entry.segments, parts);
-        if (params) {
-          return {
-            route: entry.route,
-            pathname: normalizedPathname,
-            params
-          };
-        }
-      }
-      return null;
-    },
-    build: buildFarmRoutePath,
-    isActive: isFarmRouteActive
-  };
-}
-function matchFarmRoute(pattern, pathname) {
-  return matchSegments(parseRoutePattern(pattern), normalizePathname(pathname));
-}
-function buildFarmRoutePath(pattern, params = {}, options = {}) {
-  const parts = [];
-  for (const segment of parseRoutePattern(pattern)) {
-    if (segment.type === "static") {
-      parts.push(encodePathSegment(segment.value));
-      continue;
-    }
-    const value = params[segment.name];
-    const values = Array.isArray(value) ? value : value == null ? [] : [value];
-    if (values.length === 0) {
-      if (segment.optional) continue;
-      throw new Error(`Missing route param "${segment.name}" for ${pattern}.`);
-    }
-    if (!segment.catchAll && values.length > 1) {
-      throw new Error(`Route param "${segment.name}" for ${pattern} expects a single value.`);
-    }
-    const encodedValues = values.map((item) => {
-      const value2 = String(item);
-      if (!value2) {
-        throw new Error(
-          `Route param "${segment.name}" for ${pattern} cannot contain an empty path segment.`
-        );
-      }
-      return encodePathSegment(value2);
-    });
-    parts.push(...encodedValues);
-  }
-  let pathname = parts.length ? `/${parts.join("/")}` : "/";
-  if (options.trailingSlash && pathname !== "/") {
-    pathname = `${pathname}/`;
-  }
-  return appendQueryAndHash(pathname, options);
-}
-function isFarmRouteActive(pattern, pathname, options = {}) {
-  const normalizedPathname = normalizePathname(pathname);
-  const segments = parseRoutePattern(pattern);
-  const parts = splitNormalizedPathname(normalizedPathname);
-  if (matchSegmentParts(segments, parts)) return true;
-  if (options.exact !== false) return false;
-  if (segments.length === 0) return normalizedPathname === "/";
-  return matchSegmentParts(segments, parts, true) !== null;
-}
-function normalizeRouteInput(input, index) {
-  const route = typeof input === "string" ? { path: input } : input;
-  const segments = parseRoutePattern(route.path);
-  const path = normalizeRoutePattern(route.path);
-  return {
-    route: {
-      ...route,
-      path
-    },
-    segments,
-    specificity: segments.map(getRouterSegmentSpecificity),
-    index
-  };
-}
-function matchSegments(segments, pathname, allowTrailingSegments = false) {
-  return matchSegmentParts(segments, splitPathname(pathname), allowTrailingSegments);
-}
-function compareRoutes(left, right) {
-  const specificity = compareRouteSpecificity(left.specificity, right.specificity);
-  if (specificity !== 0) return specificity;
-  return left.index - right.index;
-}
-function getRouterSegmentSpecificity(segment) {
-  if (segment.type === "static") return "static";
-  if (!segment.catchAll) return "dynamic";
-  return segment.optional ? "optional-catch-all" : "catch-all";
-}
-function encodePathSegment(value) {
-  return encodeURIComponent(value);
-}
-function appendQueryAndHash(pathname, options) {
-  const search = createSearchParams(options.query);
-  const hash = options.hash ? `#${options.hash.replace(/^#/, "")}` : "";
-  const query = search.toString();
-  return `${pathname}${query ? `?${query}` : ""}${hash}`;
-}
-function createSearchParams(query) {
-  if (query instanceof URLSearchParams) return query;
-  const search = new URLSearchParams();
-  if (!query) return search;
-  for (const [key, value] of Object.entries(query)) {
-    const values = Array.isArray(value) ? value : [value];
-    for (const item of values) {
-      if (item == null) continue;
-      search.append(key, String(item));
-    }
-  }
-  return search;
-}
-
-export {
-  createFarmRouter,
-  matchFarmRoute,
-  buildFarmRoutePath,
-  isFarmRouteActive
-};