@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-YT3SLLZK.mjs

@@ -0,0 +1,242 @@
+// src/api/transport.ts
+function multipart(schema) {
+  if (!Object.isExtensible(schema) && !isMultipartSchema(schema)) {
+    throw new TypeError("multipart() requires an extensible schema object");
+  }
+  if (!isMultipartSchema(schema)) {
+    Object.defineProperty(schema, "__farmMultipartSchema", {
+      value: true,
+      configurable: false,
+      enumerable: false,
+      writable: false
+    });
+  }
+  return schema;
+}
+function isMultipartSchema(value) {
+  return typeof value === "object" && value !== null && value.__farmMultipartSchema === true && typeof value.parse === "function";
+}
+function toFormData(values) {
+  const formData = new FormData();
+  for (const [key, value] of Object.entries(values)) {
+    if (isUnsafeFormKey(key)) continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) appendFormValue(formData, key, entry);
+      continue;
+    }
+    appendFormValue(formData, key, value);
+  }
+  return formData;
+}
+function jsonStream(source, init = {}) {
+  const iterator = toAsyncIterator(source);
+  const encoder = new TextEncoder();
+  let finished = false;
+  let cleanup;
+  const closeSource = (reason) => cleanup ?? (cleanup = Promise.resolve().then(() => iterator.return?.(reason)));
+  const body = new ReadableStream(
+    {
+      async pull(controller) {
+        if (finished) return;
+        try {
+          const next = await iterator.next();
+          if (finished) return;
+          if (next.done) {
+            finished = true;
+            controller.close();
+            return;
+          }
+          const serialized = JSON.stringify(next.value);
+          if (serialized === void 0) {
+            throw new TypeError("Farm JSON stream chunks must be JSON-serializable values");
+          }
+          controller.enqueue(encoder.encode(`${serialized}
+`));
+        } catch (error) {
+          if (finished) return;
+          finished = true;
+          try {
+            await closeSource(error);
+          } catch {
+          }
+          controller.error(error);
+        }
+      },
+      async cancel(reason) {
+        finished = true;
+        await closeSource(reason);
+      }
+    },
+    {
+      // Do not read the next application event until the response consumer
+      // requests another chunk.
+      highWaterMark: 0
+    }
+  );
+  const headers = new Headers(init.headers);
+  if (!headers.has("content-type")) {
+    headers.set("content-type", "application/x-ndjson; charset=utf-8");
+  }
+  headers.set("cache-control", headers.get("cache-control") ?? "no-store");
+  return new Response(body, {
+    ...init,
+    headers
+  });
+}
+function isJSONStreamResponse(response) {
+  const contentType = response.headers?.get?.("content-type")?.toLowerCase() ?? "";
+  return contentType.includes("application/x-ndjson") || contentType.includes("application/ndjson");
+}
+function readJSONStream(response) {
+  if (!response.body) {
+    throw new TypeError("Cannot read a JSON stream response without a body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let completed = false;
+  let cancelled = false;
+  let claimed = false;
+  let released = false;
+  const releaseReader = () => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  };
+  const parseLine = async (line) => {
+    try {
+      return JSON.parse(line);
+    } catch (error) {
+      completed = true;
+      buffer = "";
+      void reader.cancel(error).catch(() => {
+      });
+      releaseReader();
+      throw error;
+    }
+  };
+  const readNext = async () => {
+    while (true) {
+      if (cancelled) return { done: true, value: void 0 };
+      const lineEnd = buffer.indexOf("\n");
+      if (lineEnd >= 0) {
+        const line = buffer.slice(0, lineEnd).trim();
+        buffer = buffer.slice(lineEnd + 1);
+        if (!line) continue;
+        return { done: false, value: await parseLine(line) };
+      }
+      if (completed) {
+        const line = buffer.trim();
+        buffer = "";
+        if (!line) {
+          releaseReader();
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value: await parseLine(line) };
+      }
+      let chunk;
+      try {
+        chunk = await reader.read();
+      } catch (error) {
+        if (cancelled) return { done: true, value: void 0 };
+        completed = true;
+        buffer = "";
+        releaseReader();
+        throw error;
+      }
+      if (cancelled) return { done: true, value: void 0 };
+      completed = chunk.done;
+      buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+    }
+  };
+  let readQueue = Promise.resolve();
+  const iterator = {
+    next() {
+      const result = readQueue.then(readNext);
+      readQueue = result.then(
+        () => {
+        },
+        () => {
+        }
+      );
+      return result;
+    },
+    async return() {
+      cancelled = true;
+      completed = true;
+      buffer = "";
+      if (!released) {
+        try {
+          await reader.cancel();
+        } finally {
+          releaseReader();
+        }
+      }
+      return { done: true, value: void 0 };
+    }
+  };
+  return {
+    response,
+    async cancel(reason) {
+      cancelled = true;
+      completed = true;
+      buffer = "";
+      if (!released) {
+        try {
+          await reader.cancel(reason);
+        } finally {
+          releaseReader();
+        }
+      }
+    },
+    [Symbol.asyncIterator]() {
+      if (claimed) {
+        throw new TypeError("Farm API streams can only be consumed once");
+      }
+      claimed = true;
+      return iterator;
+    }
+  };
+}
+function isFarmAPIStream(value) {
+  return typeof value === "object" && value !== null && "response" in value && typeof value.cancel === "function" && typeof value[Symbol.asyncIterator] === "function";
+}
+function appendFormValue(formData, key, value) {
+  if (value === void 0) return;
+  if (value === null) {
+    formData.append(key, "");
+    return;
+  }
+  if (value instanceof Blob) {
+    formData.append(key, value);
+    return;
+  }
+  if (value instanceof Date) {
+    formData.append(key, value.toISOString());
+    return;
+  }
+  formData.append(key, String(value));
+}
+function isUnsafeFormKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+function toAsyncIterator(source) {
+  if (Symbol.asyncIterator in Object(source)) {
+    return source[Symbol.asyncIterator]();
+  }
+  const iterator = source[Symbol.iterator]();
+  return {
+    next: async () => iterator.next(),
+    return: iterator.return ? async (value) => iterator.return(value) : void 0
+  };
+}
+
+export {
+  multipart,
+  isMultipartSchema,
+  toFormData,
+  jsonStream,
+  isJSONStreamResponse,
+  readJSONStream,
+  isFarmAPIStream
+};

package/dist/chunk-YTVSWXEZ.cjs

@@ -0,0 +1,168 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/routing/specificity.ts
+var AmbiguousRouteError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AmbiguousRouteError";
+  }
+};
+var NonTerminalCatchAllRouteError = class extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "NonTerminalCatchAllRouteError";
+  }
+};
+var DuplicateRouteParameterError = class extends AmbiguousRouteError {
+  constructor(message) {
+    super(message);
+    this.name = "DuplicateRouteParameterError";
+  }
+};
+var ReservedRouteParameterError = class extends AmbiguousRouteError {
+  constructor(message) {
+    super(message);
+    this.name = "ReservedRouteParameterError";
+  }
+};
+var BrowserUnstableRouteError = class extends TypeError {
+  constructor(message) {
+    super(message);
+    this.name = "BrowserUnstableRouteError";
+  }
+};
+var SEGMENT_RANK = {
+  static: 4,
+  dynamic: 3,
+  "catch-all": 1,
+  "optional-catch-all": 0
+};
+var ROUTE_END_RANK = 2;
+function compareRouteSpecificity(left, right) {
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index++) {
+    const leftRank = index < left.length ? SEGMENT_RANK[left[index]] : ROUTE_END_RANK;
+    const rightRank = index < right.length ? SEGMENT_RANK[right[index]] : ROUTE_END_RANK;
+    if (leftRank !== rightRank) return rightRank - leftRank;
+  }
+  return 0;
+}
+function compareRoutePatternSpecificity(left, right, syntax = "page") {
+  return compareRouteSpecificity(
+    getRoutePatternSpecificity(left, syntax),
+    getRoutePatternSpecificity(right, syntax)
+  );
+}
+var ROUTER_PARAMETER_NAME = "[A-Za-z0-9_$-]+";
+var PAGE_PARAMETER_PATTERN = /^(?:\[\[\.\.\.(.+)\]\]|\[\.\.\.(.+)\]|\[(.+)\])$/;
+var ROUTER_PARAMETER_PATTERN = /^(?:\[\[\.\.\.([A-Za-z0-9_$-]+)\]\]|\[\.\.\.([A-Za-z0-9_$-]+)\]|\[([A-Za-z0-9_$-]+)\]|:([A-Za-z0-9_$-]+)|\*([A-Za-z0-9_$-]+)\??)$/;
+var RESERVED_PARAMETER_NAMES = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function assertBrowserStableRoutePath(pattern) {
+  if (pattern.includes("\\") || hasControlCharacter(pattern)) {
+    throw new BrowserUnstableRouteError(
+      `Route path "${pattern}" cannot contain backslashes or control characters.`
+    );
+  }
+  for (const segment of pattern.split("/").filter(Boolean)) {
+    if (segment.startsWith("(") && segment.endsWith(")") || segment.startsWith("[") && segment.endsWith("]")) {
+      continue;
+    }
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch (e) {
+    }
+    if (decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\") || hasControlCharacter(decoded)) {
+      throw new BrowserUnstableRouteError(
+        `Route path "${pattern}" contains browser-unstable segment "${segment}".`
+      );
+    }
+  }
+}
+function hasControlCharacter(value) {
+  return Array.from(value).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  });
+}
+function assertUniqueRouteParameters(pattern, syntax = "page") {
+  const parameterPattern = syntax === "router" ? ROUTER_PARAMETER_PATTERN : PAGE_PARAMETER_PATTERN;
+  const names = /* @__PURE__ */ new Set();
+  for (const segment of splitRoutePattern(pattern, syntax)) {
+    const match = parameterPattern.exec(segment);
+    const name = _optionalChain([match, 'optionalAccess', _ => _.slice, 'call', _2 => _2(1), 'access', _3 => _3.find, 'call', _4 => _4(Boolean)]);
+    if (!name) continue;
+    if (RESERVED_PARAMETER_NAMES.has(name)) {
+      throw new ReservedRouteParameterError(
+        `Route parameter "${name}" in route "${pattern}" is reserved. Use a different parameter name.`
+      );
+    }
+    if (names.has(name)) {
+      throw new DuplicateRouteParameterError(
+        `Duplicate route parameter "${name}" in route "${pattern}". Each dynamic segment must use a unique name.`
+      );
+    }
+    names.add(name);
+  }
+}
+function splitRoutePattern(pattern, syntax) {
+  return pattern.replace(/\\/g, "/").split("/").filter(Boolean).filter(
+    (segment) => syntax === "api" ? true : !(segment.startsWith("(") && segment.endsWith(")"))
+  );
+}
+function assertTerminalCatchAll(pattern, syntax = "page") {
+  const segments = splitRoutePattern(pattern, syntax);
+  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
+  const catchAllPattern = new RegExp(
+    syntax === "router" ? `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\]|\\*${parameterName}\\??)$` : `^(?:\\[\\[\\.\\.\\.${parameterName}\\]\\]|\\[\\.\\.\\.${parameterName}\\])$`
+  );
+  const catchAllIndex = segments.findIndex((segment) => catchAllPattern.test(segment));
+  if (catchAllIndex >= 0 && catchAllIndex !== segments.length - 1) {
+    throw new NonTerminalCatchAllRouteError(
+      `Catch-all segment "${segments[catchAllIndex]}" must be the final segment in route "${pattern}".`
+    );
+  }
+}
+function getRoutePatternShape(pattern, syntax = "page") {
+  assertTerminalCatchAll(pattern, syntax);
+  const segments = splitRoutePattern(pattern, syntax).map((segment) => {
+    const specificity = getPatternSegmentSpecificity(segment, syntax);
+    if (specificity !== "static") return specificity;
+    try {
+      return `static:${decodeURIComponent(segment)}`;
+    } catch (e2) {
+      return `static:${segment}`;
+    }
+  });
+  return segments.length === 0 ? "/" : JSON.stringify(segments);
+}
+function getRoutePatternSpecificity(pattern, syntax = "page") {
+  assertTerminalCatchAll(pattern, syntax);
+  return splitRoutePattern(pattern, syntax).map(
+    (segment) => getPatternSegmentSpecificity(segment, syntax)
+  );
+}
+function getPatternSegmentSpecificity(segment, syntax) {
+  const parameterName = syntax === "router" ? ROUTER_PARAMETER_NAME : ".+";
+  const supportsColonAndStar = syntax === "router";
+  if (new RegExp(`^\\[\\[\\.\\.\\.${parameterName}\\]\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}\\?$`).test(segment)) {
+    return "optional-catch-all";
+  }
+  if (new RegExp(`^\\[\\.\\.\\.${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^\\*${parameterName}$`).test(segment)) {
+    return "catch-all";
+  }
+  if (new RegExp(`^\\[${parameterName}\\]$`).test(segment) || supportsColonAndStar && new RegExp(`^:${parameterName}$`).test(segment)) {
+    return "dynamic";
+  }
+  return "static";
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.AmbiguousRouteError = AmbiguousRouteError; exports.NonTerminalCatchAllRouteError = NonTerminalCatchAllRouteError; exports.compareRouteSpecificity = compareRouteSpecificity; exports.compareRoutePatternSpecificity = compareRoutePatternSpecificity; exports.assertBrowserStableRoutePath = assertBrowserStableRoutePath; exports.assertUniqueRouteParameters = assertUniqueRouteParameters; exports.assertTerminalCatchAll = assertTerminalCatchAll; exports.getRoutePatternShape = getRoutePatternShape; exports.getRoutePatternSpecificity = getRoutePatternSpecificity;

package/dist/chunk-YVJV7Q2X.mjs

@@ -0,0 +1,35 @@
+import {
+  createFarmMarkdownRouteModule
+} from "./chunk-GW4YUIHW.mjs";
+
+// src/app-markdown.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { pathToFileURL } from "url";
+async function createFarmMarkdownRouteModuleFromFile(filePath, options = {}) {
+  const source = await readFile(filePath, "utf8");
+  return createFarmMarkdownRouteModule({
+    source,
+    filePath,
+    components: options.components,
+    config: options.config
+  });
+}
+async function loadFarmMdxComponents(config, options) {
+  const configured = config?.components;
+  if (!configured) {
+    return {};
+  }
+  if (typeof configured !== "string") {
+    return configured;
+  }
+  const modulePath = path.isAbsolute(configured) ? configured : path.join(options.root, configured);
+  const mod = options.loadModule ? await options.loadModule(modulePath) : await import(pathToFileURL(modulePath).href);
+  const maybeModule = mod;
+  return maybeModule.components || maybeModule.default || {};
+}
+
+export {
+  createFarmMarkdownRouteModuleFromFile,
+  loadFarmMdxComponents
+};

package/dist/chunk-YWPNIYUP.mjs

@@ -0,0 +1,41 @@
+// src/theme/config.ts
+var DEFAULT_FARM_THEME_STORAGE_KEY = "farm-theme";
+var STORAGE_KEY_PATTERN = /^[A-Za-z0-9._-]+$/;
+function resolveFarmThemeConfig(config, basePath = "/") {
+  if (config && "enabled" in config) {
+    return config;
+  }
+  if (!config) {
+    return {
+      enabled: false,
+      default: "system",
+      storageKey: DEFAULT_FARM_THEME_STORAGE_KEY,
+      cookiePath: normalizeCookiePath(basePath)
+    };
+  }
+  const storageKey = config.storageKey?.trim() || DEFAULT_FARM_THEME_STORAGE_KEY;
+  if (!STORAGE_KEY_PATTERN.test(storageKey)) {
+    throw new Error(
+      "theme.storageKey may only contain letters, numbers, dots, underscores, and hyphens."
+    );
+  }
+  const defaultTheme = config.default ?? "system";
+  if (defaultTheme !== "light" && defaultTheme !== "dark" && defaultTheme !== "system") {
+    throw new Error('theme.default must be "light", "dark", or "system".');
+  }
+  return {
+    enabled: true,
+    default: defaultTheme,
+    storageKey,
+    cookiePath: normalizeCookiePath(basePath)
+  };
+}
+function normalizeCookiePath(basePath) {
+  const normalized = `/${basePath}`.replace(/\/{2,}/g, "/");
+  if (normalized === "/") return normalized;
+  return normalized.replace(/\/$/, "");
+}
+
+export {
+  resolveFarmThemeConfig
+};

package/dist/chunk-YX6AFPXC.mjs

@@ -0,0 +1,8 @@
+// src/api/route-files.ts
+function isFarmAPIRouteFileName(fileName) {
+  return /^route\.(?:ts|tsx|js|jsx)$/.test(fileName);
+}
+
+export {
+  isFarmAPIRouteFileName
+};

package/dist/chunk-Z5MZDFX4.cjs

@@ -0,0 +1,159 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/server/response.ts
+function watchResponseEvent(res, events) {
+  if (typeof res.once !== "function" || typeof res.removeListener !== "function") {
+    return null;
+  }
+  let settled = false;
+  const listeners = events.map(([event, value]) => {
+    const listener = () => {
+      if (settled) return;
+      settled = true;
+      dispose();
+      resolvePromise(value);
+    };
+    return { event, listener };
+  });
+  let resolvePromise;
+  const promise = new Promise((resolve) => {
+    resolvePromise = resolve;
+    for (const { event, listener } of listeners) {
+      res.once(event, listener);
+    }
+  });
+  const dispose = () => {
+    for (const { event, listener } of listeners) {
+      res.removeListener(event, listener);
+    }
+  };
+  return { promise, dispose };
+}
+async function waitForWritable(res) {
+  if (res.writableEnded || res.destroyed) {
+    return false;
+  }
+  const watcher = watchResponseEvent(res, [
+    ["drain", true],
+    ["close", false],
+    ["error", false]
+  ]);
+  if (!watcher) {
+    return false;
+  }
+  try {
+    return await watcher.promise;
+  } finally {
+    watcher.dispose();
+  }
+}
+function splitSetCookieHeader(value) {
+  const cookies = [];
+  let start = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    if (value[index] !== ",") continue;
+    let next = index + 1;
+    while (value[next] === " " || value[next] === "	") next += 1;
+    const equals = value.indexOf("=", next);
+    if (equals === -1) continue;
+    const separator = value.slice(next, equals);
+    if (separator.length === 0 || /[;,\s]/.test(separator)) continue;
+    cookies.push(value.slice(start, index).trim());
+    start = next;
+    index = next - 1;
+  }
+  cookies.push(value.slice(start).trim());
+  return cookies.filter(Boolean);
+}
+function applyWebResponseHeaders(res, headers, options = {}) {
+  const responseHeaders = headers;
+  const rawSetCookies = _optionalChain([responseHeaders, 'access', _ => _.raw, 'optionalCall', _2 => _2(), 'access', _3 => _3["set-cookie"]]);
+  const setCookies = _optionalChain([responseHeaders, 'access', _4 => _4.getSetCookie, 'optionalCall', _5 => _5()]) || rawSetCookies || [];
+  const existing = options.appendSetCookie && typeof res.getHeader === "function" ? res.getHeader("Set-Cookie") : void 0;
+  const existingCookies = Array.isArray(existing) ? existing.map(String) : existing === void 0 ? [] : [String(existing)];
+  let fallbackSetCookie = "";
+  headers.forEach((value, key) => {
+    if (key.toLowerCase() === "set-cookie") {
+      fallbackSetCookie = value;
+      return;
+    }
+    res.setHeader(key, value);
+  });
+  const cookies = setCookies.length > 0 ? setCookies : fallbackSetCookie ? splitSetCookieHeader(fallbackSetCookie) : [];
+  if (cookies.length > 0) {
+    res.setHeader("Set-Cookie", [...existingCookies, ...cookies]);
+  }
+}
+async function sendWebResponse(res, response) {
+  res.statusCode = response.status;
+  applyWebResponseHeaders(res, response.headers, { appendSetCookie: true });
+  if (!response.body) {
+    res.end();
+    return;
+  }
+  if (typeof res.write !== "function") {
+    const body = await response.arrayBuffer();
+    res.end(Buffer.from(body));
+    return;
+  }
+  const reader = response.body.getReader();
+  const disconnectWatcher = watchResponseEvent(res, [
+    ["close", true],
+    ["error", true]
+  ]);
+  try {
+    while (true) {
+      if (res.destroyed) {
+        void reader.cancel().catch(() => {
+        });
+        return;
+      }
+      const read = reader.read().then((result) => ({ type: "read", result }));
+      const next = disconnectWatcher ? await Promise.race([
+        read,
+        disconnectWatcher.promise.then(() => ({ type: "disconnect" }))
+      ]) : await read;
+      if (next.type === "disconnect") {
+        void reader.cancel().catch(() => {
+        });
+        return;
+      }
+      const { done, value } = next.result;
+      if (done) {
+        break;
+      }
+      if (!value || value.byteLength === 0) {
+        continue;
+      }
+      if (!res.write(value)) {
+        if (!await waitForWritable(res)) {
+          void reader.cancel().catch(() => {
+          });
+          return;
+        }
+      }
+    }
+    res.end();
+  } catch (error) {
+    void reader.cancel(error).catch(() => {
+    });
+    if (!res.writableEnded) {
+      const responseError = error instanceof Error ? error : new Error(String(error));
+      if (typeof res.destroy === "function") {
+        res.destroy(responseError);
+      } else {
+        res.end();
+      }
+    }
+    throw error;
+  } finally {
+    _optionalChain([disconnectWatcher, 'optionalAccess', _6 => _6.dispose, 'call', _7 => _7()]);
+    try {
+      reader.releaseLock();
+    } catch (e) {
+    }
+  }
+}
+
+
+
+
+exports.applyWebResponseHeaders = applyWebResponseHeaders; exports.sendWebResponse = sendWebResponse;