@farm.js/core 0.1.61 → 0.1.62

package/dist/chunk-K5EW7GUU.mjs

@@ -0,0 +1,417 @@
+// src/deferred.ts
+var FARM_DEFERRED_CONTENT_TYPE = "application/x-farm-deferred+json";
+var FARM_DEFERRED_ERROR_CODE = "FARM_DEFERRED_DATA_ERROR";
+var FARM_DEFERRED_BRAND = /* @__PURE__ */ Symbol.for(
+  "farm.deferred"
+);
+var FARM_DEFERRED_MARKER = "$farmDeferred";
+var DeferredDataError = class extends Error {
+  constructor(message = "Deferred route data failed to load") {
+    super(message);
+    this.name = "DeferredDataError";
+    this.code = FARM_DEFERRED_ERROR_CODE;
+  }
+};
+var deferredStates = /* @__PURE__ */ new WeakMap();
+function defer(value) {
+  if (isDeferred(value)) {
+    return value;
+  }
+  const promise = Promise.resolve(value);
+  Object.defineProperty(promise, FARM_DEFERRED_BRAND, {
+    configurable: false,
+    enumerable: false,
+    value: true,
+    writable: false
+  });
+  deferredStates.set(promise, { status: "pending" });
+  promise.then(
+    (resolved) => deferredStates.set(promise, { status: "fulfilled", value: resolved }),
+    (reason) => deferredStates.set(promise, { status: "rejected", reason })
+  );
+  return promise;
+}
+function isDeferred(value) {
+  return Boolean(
+    value && (typeof value === "object" || typeof value === "function") && value[FARM_DEFERRED_BRAND] === true
+  );
+}
+function prepareDeferredData(value) {
+  const context = createEncodingContext();
+  return {
+    data: encodeDeferredValue(value, context, /* @__PURE__ */ new WeakSet()),
+    records: context.records
+  };
+}
+function snapshotDeferredData(records) {
+  const context = createEncodingContext(records);
+  const settlements = {};
+  for (let index = 0; index < context.records.length; index++) {
+    const record = context.records[index];
+    const state = readDeferredState(record.promise);
+    if (state.status === "fulfilled") {
+      try {
+        settlements[record.id] = {
+          status: "fulfilled",
+          value: encodeDeferredValue(state.value, context, /* @__PURE__ */ new WeakSet())
+        };
+      } catch {
+        settlements[record.id] = createRejectedSettlement();
+      }
+    } else {
+      settlements[record.id] = createRejectedSettlement();
+    }
+  }
+  return settlements;
+}
+function reviveDeferredData(value, settlements) {
+  return reviveDeferredValue(value, /* @__PURE__ */ new Map(), settlements);
+}
+function createDeferredDataResponse(value, init = {}, options = {}) {
+  const context = createEncodingContext();
+  const data = encodeDeferredValue(value, context, /* @__PURE__ */ new WeakSet());
+  const headers = new Headers(init.headers);
+  if (context.records.length === 0) {
+    headers.set("Content-Type", "application/json; charset=utf-8");
+    return new Response(JSON.stringify(data), { ...init, headers });
+  }
+  headers.set("Content-Type", `${FARM_DEFERRED_CONTENT_TYPE}; charset=utf-8`);
+  headers.set("Cache-Control", headers.get("Cache-Control") || "private, max-age=0");
+  const initialLine = encodeDeferredMessage({ type: "data", data });
+  const encoder = new TextEncoder();
+  let cancelled = false;
+  const stream = new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(initialLine));
+      let pending = context.records.length;
+      const finishRecord = () => {
+        pending--;
+        if (!cancelled && pending === 0) controller.close();
+      };
+      const schedule = (record) => {
+        record.promise.then(
+          (resolved) => {
+            if (cancelled) return;
+            try {
+              const previousLength = context.records.length;
+              const encoded = encodeDeferredValue(resolved, context, /* @__PURE__ */ new WeakSet());
+              const nestedRecords = context.records.slice(previousLength);
+              pending += nestedRecords.length;
+              controller.enqueue(
+                encoder.encode(
+                  encodeDeferredMessage({ type: "resolve", id: record.id, data: encoded })
+                )
+              );
+              for (const nestedRecord of nestedRecords) schedule(nestedRecord);
+            } catch (error) {
+              reportDeferredError(options, error, record.id);
+              controller.enqueue(
+                encoder.encode(
+                  encodeDeferredMessage({
+                    type: "reject",
+                    id: record.id,
+                    error: createDeferredPublicError()
+                  })
+                )
+              );
+            }
+          },
+          (error) => {
+            if (cancelled) return;
+            reportDeferredError(options, error, record.id);
+            controller.enqueue(
+              encoder.encode(
+                encodeDeferredMessage({
+                  type: "reject",
+                  id: record.id,
+                  error: createDeferredPublicError()
+                })
+              )
+            );
+          }
+        ).finally(finishRecord);
+      };
+      const initialRecords = context.records.slice();
+      for (const record of initialRecords) schedule(record);
+    },
+    cancel() {
+      cancelled = true;
+    }
+  });
+  return new Response(stream, { ...init, headers });
+}
+async function readDeferredDataResponse(response, options = {}) {
+  const contentType = response.headers.get("Content-Type") || "";
+  if (!contentType.toLowerCase().startsWith(FARM_DEFERRED_CONTENT_TYPE)) {
+    const data2 = await response.json();
+    notifyDeferredComplete(options);
+    return data2;
+  }
+  if (!response.body) {
+    throw new DeferredDataError("Deferred route data response has no body");
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const controllers = /* @__PURE__ */ new Map();
+  let buffer = "";
+  let complete = false;
+  const readLine = async () => {
+    while (true) {
+      const newline = buffer.indexOf("\n");
+      if (newline >= 0) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        return line;
+      }
+      if (complete) {
+        if (!buffer) return void 0;
+        const line = buffer;
+        buffer = "";
+        return line;
+      }
+      const chunk = await reader.read();
+      complete = chunk.done;
+      if (chunk.value) buffer += decoder.decode(chunk.value, { stream: !chunk.done });
+      if (chunk.done) buffer += decoder.decode();
+    }
+  };
+  const firstLine = await readLine();
+  if (!firstLine) {
+    reader.releaseLock();
+    throw new DeferredDataError("Deferred route data response is empty");
+  }
+  const initial = parseDeferredMessage(firstLine);
+  if (initial.type !== "data") {
+    reader.releaseLock();
+    throw new DeferredDataError("Deferred route data response is invalid");
+  }
+  const data = reviveDeferredValue(initial.data, controllers);
+  void (async () => {
+    try {
+      for (let line = await readLine(); line !== void 0; line = await readLine()) {
+        if (!line) continue;
+        const message = parseDeferredMessage(line);
+        if (message.type === "resolve") {
+          const controller = getControlledDeferred(message.id, controllers);
+          controller.resolve(reviveDeferredValue(message.data, controllers));
+        } else if (message.type === "reject") {
+          getControlledDeferred(message.id, controllers).reject(
+            new DeferredDataError(message.error?.message)
+          );
+        }
+      }
+      const outstanding = rejectPendingDeferred(
+        controllers,
+        "Deferred route data stream ended before completion"
+      );
+      if (outstanding === 0) notifyDeferredComplete(options);
+    } catch {
+      rejectPendingDeferred(controllers, "Deferred route data stream could not be read");
+    } finally {
+      reader.releaseLock();
+    }
+  })();
+  return data;
+}
+function notifyDeferredComplete(options) {
+  try {
+    options.onComplete?.();
+  } catch {
+  }
+}
+function createEncodingContext(records = []) {
+  return {
+    records: [...records],
+    ids: new Map(records.map((record) => [record.promise, record.id])),
+    nextId: records.reduce((highest, record) => {
+      const value = Number(record.id.replace(/^d/, ""));
+      return Number.isFinite(value) ? Math.max(highest, value + 1) : highest;
+    }, records.length)
+  };
+}
+function encodeDeferredValue(value, context, ancestors) {
+  if (isDeferred(value)) {
+    let id = context.ids.get(value);
+    if (!id) {
+      id = `d${context.nextId++}`;
+      context.ids.set(value, id);
+      context.records.push({ id, promise: value });
+    }
+    return { [FARM_DEFERRED_MARKER]: id };
+  }
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    assertNotCircular(value, ancestors);
+    const output2 = value.map((item) => encodeDeferredValue(item, context, ancestors));
+    ancestors.delete(value);
+    return output2;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  assertNotCircular(value, ancestors);
+  const output = {};
+  for (const [key, item] of Object.entries(value)) {
+    defineDataProperty(output, key, encodeDeferredValue(item, context, ancestors));
+  }
+  ancestors.delete(value);
+  if (isDeferredMarker(output)) {
+    return { [FARM_DEFERRED_MARKER]: `!${output[FARM_DEFERRED_MARKER]}` };
+  }
+  return output;
+}
+function reviveDeferredValue(value, controllers, settlements, applyingSettlements = /* @__PURE__ */ new Set()) {
+  if (isDeferredMarker(value)) {
+    const id = value[FARM_DEFERRED_MARKER];
+    if (id.startsWith("!")) {
+      return { [FARM_DEFERRED_MARKER]: id.slice(1) };
+    }
+    const controller = getControlledDeferred(id, controllers);
+    const settlement = settlements?.[id];
+    if (settlement && controller.promise.status === "pending") {
+      if (applyingSettlements.has(id)) return controller.promise;
+      applyingSettlements.add(id);
+      if (settlement.status === "fulfilled") {
+        controller.resolve(
+          reviveDeferredValue(settlement.value, controllers, settlements, applyingSettlements)
+        );
+      } else {
+        controller.reject(new DeferredDataError(settlement.error.message));
+      }
+      applyingSettlements.delete(id);
+    } else if (settlements && controller.promise.status === "pending") {
+      controller.reject(new DeferredDataError("Deferred route data was not resolved"));
+    }
+    return controller.promise;
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (item) => reviveDeferredValue(item, controllers, settlements, applyingSettlements)
+    );
+  }
+  if (!value || typeof value !== "object") return value;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return value;
+  const output = {};
+  for (const [key, item] of Object.entries(value)) {
+    defineDataProperty(
+      output,
+      key,
+      reviveDeferredValue(item, controllers, settlements, applyingSettlements)
+    );
+  }
+  return output;
+}
+function defineDataProperty(output, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(output, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  } else {
+    output[key] = value;
+  }
+}
+function getControlledDeferred(id, controllers) {
+  const existing = controllers.get(id);
+  if (existing) return existing;
+  let nativeResolve;
+  let nativeReject;
+  const promise = new Promise((resolve, reject) => {
+    nativeResolve = resolve;
+    nativeReject = reject;
+  });
+  promise.status = "pending";
+  promise.catch(() => void 0);
+  const controlled = {
+    promise,
+    resolve(value) {
+      if (promise.status !== "pending") return;
+      promise.status = "fulfilled";
+      promise.value = value;
+      nativeResolve(value);
+    },
+    reject(error) {
+      if (promise.status !== "pending") return;
+      promise.status = "rejected";
+      promise.reason = error;
+      nativeReject(error);
+    }
+  };
+  controllers.set(id, controlled);
+  return controlled;
+}
+function readDeferredState(promise) {
+  const tracked = deferredStates.get(promise);
+  if (tracked && tracked.status !== "pending") return tracked;
+  const reactState = promise;
+  if (reactState.status === "fulfilled") {
+    return { status: "fulfilled", value: reactState.value };
+  }
+  if (reactState.status === "rejected") {
+    return { status: "rejected", reason: reactState.reason };
+  }
+  return tracked || { status: "pending" };
+}
+function isDeferredMarker(value) {
+  return Boolean(
+    value && typeof value === "object" && Object.keys(value).length === 1 && typeof value[FARM_DEFERRED_MARKER] === "string"
+  );
+}
+function assertNotCircular(value, ancestors) {
+  if (ancestors.has(value)) {
+    throw new TypeError("Deferred route data must be JSON-serializable and cannot be circular");
+  }
+  ancestors.add(value);
+}
+function createDeferredPublicError() {
+  return {
+    code: FARM_DEFERRED_ERROR_CODE,
+    message: "Deferred route data failed to load"
+  };
+}
+function createRejectedSettlement() {
+  return { status: "rejected", error: createDeferredPublicError() };
+}
+function reportDeferredError(options, error, id) {
+  try {
+    options.onError?.(error, id);
+  } catch {
+  }
+}
+function encodeDeferredMessage(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+function parseDeferredMessage(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    throw new DeferredDataError("Deferred route data response contains invalid JSON");
+  }
+}
+function rejectPendingDeferred(controllers, message) {
+  let rejected = 0;
+  for (const controller of controllers.values()) {
+    if (controller.promise.status === "pending") {
+      controller.reject(new DeferredDataError(message));
+      rejected += 1;
+    }
+  }
+  return rejected;
+}
+
+export {
+  FARM_DEFERRED_CONTENT_TYPE,
+  FARM_DEFERRED_ERROR_CODE,
+  FARM_DEFERRED_BRAND,
+  DeferredDataError,
+  defer,
+  isDeferred,
+  prepareDeferredData,
+  snapshotDeferredData,
+  reviveDeferredData,
+  createDeferredDataResponse,
+  readDeferredDataResponse
+};

package/dist/chunk-K76CBYQM.mjs

@@ -0,0 +1,157 @@
+import {
+  decodeCookieName
+} from "./chunk-AY2YD5ZX.mjs";
+import {
+  localizeFarmPathname,
+  resolveFarmLocalePath
+} from "./chunk-7S7AAK2D.mjs";
+import {
+  stripFarmBasePath
+} from "./chunk-SF3JB56B.mjs";
+
+// src/i18n/resolver.ts
+function getFarmLocaleVaryHeaders(config, resolution) {
+  if (!config.enabled || resolution.source === "url") return [];
+  const headers = [];
+  if (config.detection.includes("cookie")) headers.push("Cookie");
+  if (config.detection.includes("accept-language")) headers.push("Accept-Language");
+  return headers;
+}
+function resolveFarmLocaleRequest(request, config, options = {}) {
+  const url = new URL(request.url);
+  if (!config.enabled) {
+    return {
+      locale: config.defaultLocale,
+      source: "default",
+      pathname: url.pathname,
+      persist: false
+    };
+  }
+  const pathMatch = resolveFarmLocalePath(url.pathname, config);
+  if (pathMatch.explicit && pathMatch.locale) {
+    const canonicalPath = localizeFarmPathname(pathMatch.pathname, pathMatch.locale, config);
+    const differsOnlyByTrailingSlash = canonicalPath !== url.pathname && (url.pathname.length > 1 ? url.pathname.replace(/\/+$/, "") : url.pathname) === canonicalPath;
+    const redirect = options.redirect !== false && canonicalPath !== url.pathname && !differsOnlyByTrailingSlash ? `${canonicalPath}${url.search}${url.hash}` : void 0;
+    return {
+      locale: pathMatch.locale,
+      source: "url",
+      pathname: pathMatch.pathname,
+      redirect,
+      // Locale-prefixed pages are canonical and can be cached publicly. Locale
+      // switchers persist the same choice before navigating in the browser.
+      persist: false
+    };
+  }
+  const detected = detectLocale(request, config);
+  const shouldRedirect = options.redirect !== false && !isInternalOrApiPath(stripFarmBasePath(url.pathname, config.basePath)) && config.routing !== "none" && (config.routing === "prefix-always" || detected.locale !== config.defaultLocale);
+  return {
+    locale: detected.locale,
+    source: detected.source,
+    pathname: pathMatch.pathname,
+    redirect: shouldRedirect ? `${localizeFarmPathname(pathMatch.pathname, detected.locale, config)}${url.search}${url.hash}` : void 0,
+    persist: detected.source !== "default"
+  };
+}
+function createFarmLocaleCookie(locale, config) {
+  const cookie = config.cookie;
+  let value = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(locale)}`;
+  value += `; Max-Age=${cookie.maxAge}`;
+  value += `; Path=${cookie.path}`;
+  value += `; SameSite=${capitalize(cookie.sameSite)}`;
+  if (cookie.secure) value += "; Secure";
+  return value;
+}
+function matchFarmLocale(requested, locales) {
+  if (!requested) return void 0;
+  let canonical;
+  try {
+    canonical = Intl.getCanonicalLocales(requested)[0];
+  } catch {
+    return void 0;
+  }
+  const exact = locales.find((locale) => locale.toLowerCase() === canonical.toLowerCase());
+  if (exact) return exact;
+  const language = canonical.split("-")[0]?.toLowerCase();
+  const base = locales.find((locale) => locale.toLowerCase() === language);
+  if (base) return base;
+  return locales.find((locale) => locale.split("-")[0]?.toLowerCase() === language);
+}
+function detectLocale(request, config) {
+  for (const signal of config.detection) {
+    if (signal === "url") continue;
+    if (signal === "cookie") {
+      const locale = matchFarmLocale(
+        readCookie(request.headers.get("cookie"), config.cookie.name),
+        config.locales
+      );
+      if (locale) return { locale, source: "cookie" };
+    }
+    if (signal === "accept-language") {
+      const locale = resolveAcceptLanguage(request.headers.get("accept-language"), config.locales);
+      if (locale) return { locale, source: "accept-language" };
+    }
+  }
+  return { locale: config.defaultLocale, source: "default" };
+}
+function resolveAcceptLanguage(header, locales) {
+  if (!header) return void 0;
+  const byRange = /* @__PURE__ */ new Map();
+  for (const [index, entry] of header.split(",").entries()) {
+    const [rawLocale = "", ...parameters] = entry.trim().split(";");
+    const locale = rawLocale.trim();
+    if (!locale) continue;
+    let quality = 1;
+    for (const parameter of parameters) {
+      const [rawName, rawValue] = parameter.trim().split("=", 2);
+      if (rawName?.trim().toLowerCase() !== "q") continue;
+      const value = rawValue?.trim() ?? "";
+      quality = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/.test(value) ? Number(value) : 0;
+    }
+    const key = locale.toLowerCase();
+    const previous = byRange.get(key);
+    if (!previous || quality > previous.quality) {
+      byRange.set(key, { locale, quality, index: previous?.index ?? index });
+    }
+  }
+  const candidates = [...byRange.values()].filter((candidate) => candidate.quality > 0).sort((a, b) => b.quality - a.quality || a.index - b.index);
+  const explicitRanges = [...byRange.values()].filter(({ locale }) => locale !== "*");
+  for (const candidate of candidates) {
+    if (candidate.locale === "*") {
+      const wildcardMatch = locales.find(
+        (locale2) => !explicitRanges.some((range) => matchFarmLocale(range.locale, [locale2]) !== void 0)
+      );
+      if (wildcardMatch) return wildcardMatch;
+      continue;
+    }
+    const locale = matchFarmLocale(candidate.locale, locales);
+    if (locale) return locale;
+  }
+  return void 0;
+}
+function readCookie(header, name) {
+  if (!header) return void 0;
+  for (const part of header.split(";")) {
+    const separator = part.indexOf("=");
+    if (separator < 0) continue;
+    if (decodeCookieName(part.slice(0, separator).trim()) !== name) continue;
+    try {
+      return decodeURIComponent(part.slice(separator + 1).trim());
+    } catch {
+      return part.slice(separator + 1).trim();
+    }
+  }
+  return void 0;
+}
+function isInternalOrApiPath(pathname) {
+  return pathname === "/api" || pathname.startsWith("/api/") || pathname.startsWith("/__farm/") || pathname.startsWith("/_farm/");
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+export {
+  getFarmLocaleVaryHeaders,
+  resolveFarmLocaleRequest,
+  createFarmLocaleCookie,
+  matchFarmLocale
+};

package/dist/chunk-KBGZ5FD6.cjs

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkPO5MXV5Xcjs = require('./chunk-PO5MXV5X.cjs');
+
+// src/api/server-context.ts
+var _async_hooks = require('async_hooks');
+var API_RUNTIME_STORAGE = /* @__PURE__ */ Symbol.for("@farm.js/core/api-request-storage");
+var runtimeGlobal = globalThis;
+var storage = _nullishCoalesce(runtimeGlobal[API_RUNTIME_STORAGE], () => ( (runtimeGlobal[API_RUNTIME_STORAGE] = new (0, _async_hooks.AsyncLocalStorage)())));
+_chunkPO5MXV5Xcjs.setAPIRequestRuntimeResolver.call(void 0, () => storage.getStore());
+function _runWithAPIRequestRuntime(runtime, run) {
+  return storage.run(runtime, run);
+}
+
+
+
+exports._runWithAPIRequestRuntime = _runWithAPIRequestRuntime;

package/dist/chunk-KORZ6PRE.cjs

@@ -0,0 +1,64 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/optional-peer.ts
+var _module = require('module');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function isMissingPackageError(error, packageName) {
+  let current = error;
+  for (let depth = 0; depth < 4; depth++) {
+    if (!current || typeof current !== "object") return false;
+    const { code, message, cause } = current;
+    if ((code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") && typeof message === "string") {
+      return message.includes(`'${packageName}'`) || message.includes(`"${packageName}"`);
+    }
+    current = cause;
+  }
+  return false;
+}
+function isOptionalPeerInstalled(root, packageName) {
+  const appRequire = _module.createRequire.call(void 0, _path2.default.join(root, "package.json"));
+  const requires = [appRequire];
+  try {
+    requires.push(_module.createRequire.call(void 0, appRequire.resolve("@farm.js/core")));
+  } catch (e) {
+  }
+  return requires.some((parentRequire) => {
+    try {
+      parentRequire.resolve(`${packageName}/package.json`);
+      return true;
+    } catch (error) {
+      return error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED";
+    }
+  });
+}
+function formatOptionalPeerInstallHint(packageName, purpose, options = {}) {
+  return `Install "${packageName}" to ${purpose}: pnpm add ${options.dev ? "-D " : ""}${packageName}`;
+}
+var VERCEL_OG_INSTALL_HINT = formatOptionalPeerInstallHint(
+  "@vercel/og",
+  "render OG and metadata images"
+);
+var APP_IMPORTED_OPTIONAL_PEERS = [
+  ["@vercel/og", VERCEL_OG_INSTALL_HINT]
+];
+function explainMissingOptionalPeer(error, context) {
+  for (const [packageName, hint] of APP_IMPORTED_OPTIONAL_PEERS) {
+    if (isMissingPackageError(error, packageName)) {
+      return withOptionalPeerCause(
+        new Error(`${context} needs ${packageName}, which is not installed. ${hint}`),
+        error
+      );
+    }
+  }
+  return error;
+}
+function withOptionalPeerCause(error, cause) {
+  return Object.assign(error, { cause });
+}
+
+
+
+
+
+
+
+
+exports.isMissingPackageError = isMissingPackageError; exports.isOptionalPeerInstalled = isOptionalPeerInstalled; exports.formatOptionalPeerInstallHint = formatOptionalPeerInstallHint; exports.VERCEL_OG_INSTALL_HINT = VERCEL_OG_INSTALL_HINT; exports.explainMissingOptionalPeer = explainMissingOptionalPeer; exports.withOptionalPeerCause = withOptionalPeerCause;