@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-K5EW7GUU.mjs

@@ -1,417 +0,0 @@
-// 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

@@ -1,157 +0,0 @@
-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

@@ -1,17 +0,0 @@
-"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

@@ -1,64 +0,0 @@
-"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;