@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-PENBZAHJ.cjs

@@ -0,0 +1,88 @@
+"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/client-cancellation.ts
+function createClientCancellation(signal, timeoutMs = 0, parent) {
+  let timer;
+  let invalid;
+  let timeoutReason;
+  const signals = [signal, parent].filter((value) => !!value);
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > 2147483647) {
+    invalid = new RangeError(
+      "timeoutMs must be an integer between 0 and 2147483647 (0 disables the deadline)."
+    );
+  } else if (timeoutMs > 0) {
+    const controller = new AbortController();
+    signals.push(controller.signal);
+    timer = setTimeout(() => {
+      timeoutReason = new DOMException("Client request timed out", "TimeoutError");
+      controller.abort(timeoutReason);
+    }, timeoutMs);
+  }
+  const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+  let active = 0;
+  let closed = false;
+  const cleanup = () => {
+    if (closed && active === 0 && timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+  const check = () => {
+    if (invalid) throw invalid;
+    _optionalChain([combined, 'optionalAccess', _ => _.throwIfAborted, 'call', _2 => _2()]);
+  };
+  return {
+    signal: combined,
+    get timedOut() {
+      return timeoutReason !== void 0 && _optionalChain([combined, 'optionalAccess', _3 => _3.reason]) === timeoutReason;
+    },
+    check,
+    hold() {
+      active++;
+      return () => {
+        active--;
+        cleanup();
+      };
+    },
+    // A race also bounds cooperative local dispatch and custom HTTP implementations.
+    // Late completion is consumed, but cannot turn a cancelled result into success.
+    async run(work) {
+      check();
+      active++;
+      let abort;
+      try {
+        if (!combined) return await work();
+        return await new Promise((resolve, reject) => {
+          abort = () => reject(combined.reason);
+          combined.addEventListener("abort", abort, { once: true });
+          Promise.resolve().then(() => {
+            check();
+            return work();
+          }).then(resolve, reject);
+        });
+      } finally {
+        if (abort) _optionalChain([combined, 'optionalAccess', _4 => _4.removeEventListener, 'call', _5 => _5("abort", abort)]);
+        active--;
+        cleanup();
+      }
+    },
+    async delay(ms) {
+      let retryTimer;
+      try {
+        await this.run(
+          () => new Promise((resolve) => {
+            retryTimer = setTimeout(resolve, ms);
+          })
+        );
+      } finally {
+        if (retryTimer !== void 0) clearTimeout(retryTimer);
+      }
+    },
+    dispose() {
+      closed = true;
+      cleanup();
+    }
+  };
+}
+
+
+
+exports.createClientCancellation = createClientCancellation;

package/dist/chunk-PIUTGRDI.cjs

@@ -0,0 +1,358 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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/server-fn-transform.ts
+var SERVER_FUNCTION_FACTORY_IMPORT_RE = /\bimport\s+(?:type\s+)?(?:[A-Za-z_$][\w$]*\s*,\s*)?(\{[^}]*\})\s+from\s*["']@farm.js\/core(?:\/(?:server-fn|server-query))?["']\s*;?/g;
+var EXPORT_SERVER_FUNCTION_FACTORY_RE = /\bexport\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*([A-Za-z_$][\w$]*)\s*(?:<[^<>]*(?:<[^<>]*>[^<>]*)*>)?\s*\(/g;
+var EXPORT_DEFAULT_SERVER_FUNCTION_FACTORY_RE = /\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*(?:<[^<>]*(?:<[^<>]*>[^<>]*)*>)?\s*\(/g;
+var SERVER_FUNCTION_DECLARATION_RE = /(?<![.\w$])([A-Za-z_$][\w$]*)\s*=\s*([A-Za-z_$][\w$]*)\s*(?:<[^<>]*(?:<[^<>]*>[^<>]*)*>)?\s*\(/g;
+var LOCAL_EXPORT_CLAUSE_RE = /\bexport\s*\{([^}]*)\}/g;
+var EXPORT_DEFAULT_ALIAS_RE = /\bexport\s+default\s+([A-Za-z_$][\w$]*)\s*(?:;|(?=[\r\n])|$)/g;
+var EXPORT_BINDING_ALIAS_RE = /\bexport\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*([A-Za-z_$][\w$]*)\s*(?:;|(?=[,\r\n])|$)/g;
+var MODULE_EXT_RE = /\.[cm]?[jt]sx?$/;
+var DECLARATION_RE = /(^|\n)\s*["']([^"']+)["']\s*;?/g;
+var FARM_SERVER_FN_BOUNDARY_QUERY = "?farm-server-fns";
+function transformFarmServerFns(code, id, options = {}) {
+  const analysis = analyzeServerFnModule(code, id);
+  if (!analysis) return null;
+  const { replacements } = analysis;
+  const exports = replacements.map((replacement) => replacement.exportName);
+  if (hasModuleDirective(code, "use server")) {
+    return { code: applyReplacements(code, replacements, "wrapper"), exports };
+  }
+  const boundaryId = JSON.stringify(serverFnBoundaryId(id));
+  if (options.environment !== void 0 && options.environment !== "rsc") {
+    return {
+      code: `export { ${exports.join(", ")} } from ${boundaryId};
+`,
+      exports
+    };
+  }
+  const imports = replacements.map(
+    (replacement) => replacement.exportName === "default" ? "default as $$farm_server_fn_boundary_default" : replacement.exportName
+  );
+  const reExports = replacements.map(
+    (replacement) => replacement.exportName === "default" ? "$$farm_server_fn_boundary_default as default" : replacement.exportName
+  );
+  const privateNames = replacements.map((replacement) => replacement.privateName);
+  return {
+    code: applyReplacements(code, replacements, "private") + `
+import { ${imports.join(", ")} } from ${boundaryId};
+export { ${[...reExports, ...privateNames].join(", ")} };
+`,
+    exports
+  };
+}
+function createFarmServerFnBoundaryModule(code, id) {
+  if (hasModuleDirective(code, "use server")) return null;
+  const analysis = analyzeServerFnModule(code, id);
+  if (!analysis) return null;
+  const sourceId = JSON.stringify(id.split("?", 1)[0].replace(/\\/g, "/"));
+  const privateNames = analysis.replacements.map((replacement) => replacement.privateName);
+  let output = `"use server";
+import { ${privateNames.join(", ")} } from ${sourceId};
+`;
+  for (const replacement of analysis.replacements) {
+    const declaration = replacement.exportName === "default" ? "export default async function" : "export async function";
+    output += `${declaration} ${replacement.wrapperName}(input) {
+  return ${replacement.privateName}(input);
+}
+${copyServerFunctionDescriptor(replacement.wrapperName, replacement.privateName, true)}
+`;
+  }
+  return output;
+}
+function isFarmServerFnBoundaryId(id) {
+  return /[?&]farm-server-fns(?:&|$)/.test(id);
+}
+function serverFnBoundaryId(id) {
+  return `${id.split("?", 1)[0].replace(/\\/g, "/")}${FARM_SERVER_FN_BOUNDARY_QUERY}`;
+}
+function applyReplacements(code, replacements, mode) {
+  let output = code;
+  for (const replacement of [...replacements].sort((a, b) => b.start - a.start)) {
+    const declaration = `const ${replacement.privateName} = ${replacement.callExpression};
+`;
+    const wrapper = mode === "private" ? "" : `${replacement.exportName === "default" ? "export default async function" : "export async function"} ${replacement.wrapperName}(input) {
+  return ${replacement.privateName}(input);
+}
+${copyServerFunctionDescriptor(replacement.wrapperName, replacement.privateName, false)}`;
+    output = output.slice(0, replacement.start) + declaration + wrapper + output.slice(replacement.end);
+  }
+  return output;
+}
+function analyzeServerFnModule(code, id) {
+  if (!isTransformableModule(id) || !code.includes("createServerFn") && !code.includes("createServerQuery")) {
+    return null;
+  }
+  const factoryNames = findServerFunctionFactoryImportNames(code);
+  if (factoryNames.size === 0) return null;
+  const reExport = findServerFnReExport(code, factoryNames);
+  if (reExport) {
+    const factoryName = reExport.factory === "fn" ? "createServerFn" : "createServerQuery";
+    const escape = reExport.form === "clause" ? "with an export clause" : reExport.form === "default" ? "as the default export" : "through another exported binding";
+    const inlineForm = reExport.form === "default" ? `export default ${factoryName}(...)` : `export const ${reExport.exportName} = ${factoryName}(...)`;
+    throw new Error(
+      `Server function "${reExport.localName}" cannot be re-exported ${escape}. Export it inline instead: ${inlineForm}.`
+    );
+  }
+  const replacements = findServerFnExportReplacements(code, factoryNames);
+  if (replacements.length === 0) return null;
+  if (hasModuleDirective(code, "use client")) {
+    throw new Error(
+      "createServerFn and createServerQuery exports must live in a server module. Move them out of the 'use client' file."
+    );
+  }
+  return { replacements };
+}
+function isTransformableModule(id) {
+  const cleanId = id.split("?", 1)[0];
+  return MODULE_EXT_RE.test(cleanId) && !/\.d\.[cm]?ts$/.test(cleanId);
+}
+function findServerFunctionFactoryImportNames(code) {
+  const names = /* @__PURE__ */ new Map();
+  for (const match of code.matchAll(SERVER_FUNCTION_FACTORY_IMPORT_RE)) {
+    const importClause = _nullishCoalesce(match[1], () => ( ""));
+    const namedStart = importClause.indexOf("{");
+    const namedEnd = importClause.lastIndexOf("}");
+    if (namedStart === -1 || namedEnd === -1 || namedEnd <= namedStart) continue;
+    const namedImports = importClause.slice(namedStart + 1, namedEnd).split(",");
+    for (const specifier of namedImports) {
+      const normalized = specifier.trim().replace(/^type\s+/, "");
+      const specifierMatch = normalized.match(
+        /^(createServerFn|createServerQuery)(?:\s+as\s+([A-Za-z_$][\w$]*))?$/
+      );
+      if (specifierMatch) {
+        const factory = specifierMatch[1];
+        names.set(_nullishCoalesce(specifierMatch[2], () => ( factory)), factory === "createServerFn" ? "fn" : "query");
+      }
+    }
+  }
+  return names;
+}
+function findServerFnReExport(code, factoryNames) {
+  const scannable = stripCommentsAndStrings(code);
+  const declarations = /* @__PURE__ */ new Map();
+  for (const match of scannable.matchAll(SERVER_FUNCTION_DECLARATION_RE)) {
+    const localName = match[1];
+    const factoryName = match[2];
+    const factory = factoryName ? factoryNames.get(factoryName) : void 0;
+    if (localName && factory) declarations.set(localName, factory);
+  }
+  if (declarations.size === 0) return null;
+  for (const match of scannable.matchAll(LOCAL_EXPORT_CLAUSE_RE)) {
+    const clause = _nullishCoalesce(match[1], () => ( ""));
+    const clauseEnd = (_nullishCoalesce(match.index, () => ( 0))) + match[0].length;
+    if (scannable.slice(clauseEnd).trimStart().startsWith("from")) continue;
+    for (const specifier of clause.split(",")) {
+      const parts = specifier.trim().split(/\s+as\s+/);
+      const localName = _optionalChain([parts, 'access', _ => _[0], 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]);
+      if (!localName || !declarations.has(localName)) continue;
+      return {
+        localName,
+        exportName: _optionalChain([parts, 'access', _4 => _4[1], 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]) || localName,
+        factory: declarations.get(localName),
+        form: "clause"
+      };
+    }
+  }
+  for (const match of scannable.matchAll(EXPORT_DEFAULT_ALIAS_RE)) {
+    const localName = match[1];
+    if (!localName || !declarations.has(localName)) continue;
+    return {
+      localName,
+      exportName: "default",
+      factory: declarations.get(localName),
+      form: "default"
+    };
+  }
+  for (const match of scannable.matchAll(EXPORT_BINDING_ALIAS_RE)) {
+    const exportName = match[1];
+    const localName = match[2];
+    if (!exportName || !localName || !declarations.has(localName)) continue;
+    return {
+      localName,
+      exportName,
+      factory: declarations.get(localName),
+      form: "binding"
+    };
+  }
+  return null;
+}
+function stripCommentsAndStrings(code) {
+  const output = code.split("");
+  let quote = null;
+  let lineComment = false;
+  let blockComment = false;
+  let escaped = false;
+  for (let index = 0; index < code.length; index++) {
+    const char = code[index];
+    const next = code[index + 1];
+    if (lineComment) {
+      if (char === "\n" || char === "\r") lineComment = false;
+      else output[index] = " ";
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        output[index] = " ";
+        output[index + 1] = " ";
+        index++;
+      } else if (char !== "\n") {
+        output[index] = " ";
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+        output[index] = " ";
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        output[index] = " ";
+        continue;
+      }
+      if (char === quote) {
+        quote = null;
+        continue;
+      }
+      if (char !== "\n") output[index] = " ";
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      output[index] = " ";
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      output[index] = " ";
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+    }
+  }
+  return output.join("");
+}
+function findServerFnExportReplacements(code, factoryNames) {
+  const replacements = [];
+  for (const match of code.matchAll(EXPORT_SERVER_FUNCTION_FACTORY_RE)) {
+    const exportName = match[1];
+    const calleeName = match[2];
+    const factory = calleeName ? factoryNames.get(calleeName) : void 0;
+    if (!exportName || !calleeName || !factory) continue;
+    const openParenIndex = (_nullishCoalesce(match.index, () => ( 0))) + match[0].length - 1;
+    const callEnd = findMatchingParen(code, openParenIndex);
+    if (callEnd === -1) continue;
+    let declarationEnd = callEnd + 1;
+    while (/\s/.test(_nullishCoalesce(code[declarationEnd], () => ( "")))) declarationEnd++;
+    if (code[declarationEnd] === ";") declarationEnd++;
+    const calleeIndex = code.indexOf(calleeName, match.index);
+    replacements.push({
+      start: _nullishCoalesce(match.index, () => ( 0)),
+      end: declarationEnd,
+      exportName,
+      privateName: `$$farm_server_${factory}_${exportName}`,
+      wrapperName: exportName,
+      callExpression: code.slice(calleeIndex, callEnd + 1)
+    });
+  }
+  for (const match of code.matchAll(EXPORT_DEFAULT_SERVER_FUNCTION_FACTORY_RE)) {
+    const calleeName = match[1];
+    const factory = calleeName ? factoryNames.get(calleeName) : void 0;
+    if (!calleeName || !factory) continue;
+    const openParenIndex = (_nullishCoalesce(match.index, () => ( 0))) + match[0].length - 1;
+    const callEnd = findMatchingParen(code, openParenIndex);
+    if (callEnd === -1) continue;
+    let declarationEnd = callEnd + 1;
+    while (/\s/.test(_nullishCoalesce(code[declarationEnd], () => ( "")))) declarationEnd++;
+    if (code[declarationEnd] === ";") declarationEnd++;
+    const calleeIndex = code.indexOf(calleeName, match.index);
+    const privateName = `$$farm_server_${factory}_default`;
+    replacements.push({
+      start: _nullishCoalesce(match.index, () => ( 0)),
+      end: declarationEnd,
+      exportName: "default",
+      privateName,
+      wrapperName: `${privateName}_export`,
+      callExpression: code.slice(calleeIndex, callEnd + 1)
+    });
+  }
+  return replacements;
+}
+function copyServerFunctionDescriptor(target, source, lazy) {
+  const key = 'Symbol.for("farm.server-function.descriptor")';
+  return lazy ? `Object.defineProperty(${target}, ${key}, { get: () => ${source}[${key}] });` : `Object.defineProperty(${target}, ${key}, { value: ${source}[${key}] });`;
+}
+function hasModuleDirective(code, directive) {
+  for (const match of code.matchAll(DECLARATION_RE)) {
+    const value = match[2];
+    if (value === directive) return true;
+    if (value !== "use strict" && value !== "use client" && value !== "use server") return false;
+  }
+  return false;
+}
+function findMatchingParen(code, openParenIndex) {
+  let depth = 0;
+  let quote = null;
+  let lineComment = false;
+  let blockComment = false;
+  let escaped = false;
+  for (let index = openParenIndex; index < code.length; index++) {
+    const char = code[index];
+    const next = code[index + 1];
+    if (lineComment) {
+      if (char === "\n" || char === "\r") lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        index++;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      index++;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      index++;
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "(") depth++;
+    if (char === ")") {
+      depth--;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+
+
+
+
+
+exports.FARM_SERVER_FN_BOUNDARY_QUERY = FARM_SERVER_FN_BOUNDARY_QUERY; exports.transformFarmServerFns = transformFarmServerFns; exports.createFarmServerFnBoundaryModule = createFarmServerFnBoundaryModule; exports.isFarmServerFnBoundaryId = isFarmServerFnBoundaryId;

package/dist/chunk-PMJSG4JS.cjs

@@ -0,0 +1,152 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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/config.ts
+var DEFAULT_FARM_API_BASE_PATH = "/api";
+async function resolveFarmAPIConfig(config, context) {
+  const configuredBasePath = await resolveConfigValue(_optionalChain([config, 'optionalAccess', _ => _.basePath]), context, "api.basePath");
+  const basePath = normalizeFarmAPIBasePath(_nullishCoalesce(configuredBasePath, () => ( DEFAULT_FARM_API_BASE_PATH)));
+  const configuredBaseURL = await resolveConfigValue(_optionalChain([config, 'optionalAccess', _2 => _2.baseURL]), context, "api.baseURL");
+  return normalizeFarmAPIConfig({ baseURL: configuredBaseURL, basePath });
+}
+function normalizeFarmAPIConfig(config) {
+  const basePath = normalizeFarmAPIBasePath(_nullishCoalesce(_optionalChain([config, 'optionalAccess', _3 => _3.basePath]), () => ( DEFAULT_FARM_API_BASE_PATH)));
+  const baseURL = _optionalChain([config, 'optionalAccess', _4 => _4.baseURL, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]);
+  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 (e) {
+    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 (e2) {
+    }
+    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 ? window.location.origin : "http://localhost:3000";
+}
+
+
+
+
+
+
+
+
+exports.DEFAULT_FARM_API_BASE_PATH = DEFAULT_FARM_API_BASE_PATH; exports.resolveFarmAPIConfig = resolveFarmAPIConfig; exports.normalizeFarmAPIConfig = normalizeFarmAPIConfig; exports.normalizeFarmAPIBasePath = normalizeFarmAPIBasePath; exports.getFarmAPIBaseURL = getFarmAPIBaseURL; exports.resolveFarmAPIRequestURL = resolveFarmAPIRequestURL;

package/dist/chunk-PO5MXV5X.cjs

@@ -0,0 +1,13 @@
+"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/api/server-client-bridge.ts
+var API_RUNTIME_RESOLVER = /* @__PURE__ */ Symbol.for("farm.apiRequestRuntimeResolver");
+function setAPIRequestRuntimeResolver(resolver) {
+  globalThis[API_RUNTIME_RESOLVER] = resolver;
+}
+function resolveAPIRequestRuntime() {
+  return _optionalChain([globalThis, 'access', _ => _[API_RUNTIME_RESOLVER], 'optionalCall', _2 => _2()]);
+}
+
+
+
+
+exports.setAPIRequestRuntimeResolver = setAPIRequestRuntimeResolver; exports.resolveAPIRequestRuntime = resolveAPIRequestRuntime;