@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-UJ2C4ICS.cjs

@@ -0,0 +1,277 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkIQXFRNY2cjs = require('./chunk-IQXFRNY2.cjs');
+
+
+var _chunk75BRBIFPcjs = require('./chunk-75BRBIFP.cjs');
+
+
+var _chunkLIUGYUX3cjs = require('./chunk-LIUGYUX3.cjs');
+
+
+var _chunkBIDYX3SLcjs = require('./chunk-BIDYX3SL.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/i18n/server.ts
+var _async_hooks = require('async_hooks');
+
+// src/i18n/runtime.ts
+var _intlmessageformat = require('intl-messageformat'); var _intlmessageformat2 = _interopRequireDefault(_intlmessageformat);
+var _FarmI18nRuntime = class _FarmI18nRuntime {
+  constructor(config, catalogs = {}) {
+    this.compiled = /* @__PURE__ */ new Map();
+    this.warnedMissing = /* @__PURE__ */ new Set();
+    this.config = config;
+    this.catalogs = catalogs;
+  }
+  async initialize() {
+    if (!this.config.enabled) return;
+    const bundle = await _chunkIQXFRNY2cjs.readFarmI18nCatalogs.call(void 0, this.config);
+    this.replaceCatalogs(bundle.catalogs);
+  }
+  async reload() {
+    await this.initialize();
+  }
+  replaceCatalogs(catalogs) {
+    this.catalogs = catalogs;
+    this.compiled.clear();
+    this.warnedMissing.clear();
+  }
+  getCatalogs() {
+    return Object.fromEntries(
+      Object.entries(this.catalogs).map(([locale, catalog]) => [locale, { ...catalog }])
+    );
+  }
+  resolveRequest(request, options = {}) {
+    return _chunk75BRBIFPcjs.resolveFarmLocaleRequest.call(void 0, request, this.config, options);
+  }
+  translate(locale, key, values) {
+    const result = this.formatMessage(locale, key, values);
+    if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
+      throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
+    }
+    return Array.isArray(result) ? result.join("") : String(result);
+  }
+  translateRich(locale, key, values) {
+    const result = this.formatMessage(locale, key, values);
+    return Array.isArray(result) && result.length === 1 ? result[0] : result;
+  }
+  getRawMessage(locale, key) {
+    return this.resolveMessage(locale, key);
+  }
+  hasMessage(locale, key) {
+    return this.readOwnMessage(locale, key) !== void 0;
+  }
+  getClientSnapshot(resolution) {
+    return {
+      locale: resolution.locale,
+      source: resolution.source,
+      locales: this.config.locales,
+      defaultLocale: this.config.defaultLocale,
+      routing: this.config.routing,
+      basePath: this.config.basePath,
+      cookie: this.config.cookie,
+      direction: _chunkBIDYX3SLcjs.getFarmLocaleDirection.call(void 0, resolution.locale, this.config.direction),
+      messages: {
+        ...this.catalogs[this.config.fallbackLocale],
+        ...this.catalogs[resolution.locale]
+      }
+    };
+  }
+  formatMessage(locale, key, values) {
+    const message = this.resolveMessage(locale, key);
+    const cacheKey = `${locale}\0${key}\0${message}`;
+    let formatter = this.compiled.get(cacheKey);
+    if (!formatter) {
+      formatter = new (0, _intlmessageformat2.default)(message, locale);
+      this.compiled.set(cacheKey, formatter);
+    }
+    return formatter.format(values);
+  }
+  // Look up a message by own-property only. A key named after an
+  // Object.prototype member (toString, valueOf, constructor, ...) must resolve
+  // to a real catalog entry or undefined, never the inherited prototype value
+  // (mirrors the own-property handling added to catalog.ts in #454).
+  readOwnMessage(locale, key) {
+    const direct = this.catalogs[locale];
+    if (direct && Object.prototype.hasOwnProperty.call(direct, key)) return direct[key];
+    const fallback = this.catalogs[this.config.fallbackLocale];
+    if (fallback && Object.prototype.hasOwnProperty.call(fallback, key)) return fallback[key];
+    return void 0;
+  }
+  resolveMessage(locale, key) {
+    const message = this.readOwnMessage(locale, key);
+    if (message !== void 0) return message;
+    if (this.config.strict) {
+      throw new Error(`Missing Farm i18n message "${key}" for locale "${locale}".`);
+    }
+    const warningKey = `${locale}:${key}`;
+    if (!this.warnedMissing.has(warningKey)) {
+      this.warnedMissing.add(warningKey);
+      console.warn(`[Farm.js] Missing i18n message "${key}" for locale "${locale}".`);
+    }
+    return key;
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _FarmI18nRuntime, "FarmI18nRuntime");
+var FarmI18nRuntime = _FarmI18nRuntime;
+function createFarmI18nRuntime(config, catalogs) {
+  return new FarmI18nRuntime(config, catalogs);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createFarmI18nRuntime, "createFarmI18nRuntime");
+
+// src/i18n/server.ts
+var FARM_I18N_REQUEST_STORE = /* @__PURE__ */ Symbol.for("farm.i18n.requestStore");
+var FARM_I18N_DEFAULT_RUNTIME = /* @__PURE__ */ Symbol.for("farm.i18n.defaultRuntime");
+function getRequestStore() {
+  const state = globalThis;
+  return _nullishCoalesce(state[FARM_I18N_REQUEST_STORE], () => ( (state[FARM_I18N_REQUEST_STORE] = new (0, _async_hooks.AsyncLocalStorage)())));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getRequestStore, "getRequestStore");
+function getState() {
+  const state = getRequestStore().getStore();
+  if (!state) {
+    throw new Error(
+      "No Farm i18n request context is active. Use this API while rendering, inside an API route, or use createTranslator(locale)."
+    );
+  }
+  return state;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getState, "getState");
+function _setDefaultFarmI18nRuntime(runtime) {
+  globalThis[FARM_I18N_DEFAULT_RUNTIME] = runtime;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _setDefaultFarmI18nRuntime, "_setDefaultFarmI18nRuntime");
+async function _runWithFarmI18nRequest(runtime, request, fn, options = {}) {
+  const resolution = runtime.resolveRequest(request, options);
+  const state = {
+    runtime,
+    resolution,
+    snapshot: runtime.getClientSnapshot(resolution)
+  };
+  return getRequestStore().run(state, () => fn(resolution));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _runWithFarmI18nRequest, "_runWithFarmI18nRequest");
+async function runWithLocale(locale, fn) {
+  const runtime = getDefaultRuntime();
+  assertLocale(runtime, locale);
+  const resolution = {
+    locale,
+    source: "explicit",
+    pathname: "/",
+    persist: false
+  };
+  const state = {
+    runtime,
+    resolution,
+    snapshot: runtime.getClientSnapshot(resolution)
+  };
+  return getRequestStore().run(state, fn);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, runWithLocale, "runWithLocale");
+function getLocale() {
+  return getState().resolution.locale;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getLocale, "getLocale");
+function getLocaleSource() {
+  return getState().resolution.source;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getLocaleSource, "getLocaleSource");
+var t = createTranslatorFromState(() => getState());
+function createTranslator(locale) {
+  const runtime = getDefaultRuntime();
+  assertLocale(runtime, locale);
+  return createTranslatorFromState(() => ({
+    runtime,
+    resolution: {
+      locale,
+      source: "explicit",
+      pathname: "/",
+      persist: false
+    },
+    snapshot: runtime.getClientSnapshot({
+      locale,
+      source: "explicit",
+      pathname: "/",
+      persist: false
+    })
+  }));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createTranslator, "createTranslator");
+function getFarmI18nClientSnapshot() {
+  return _optionalChain([getRequestStore, 'call', _ => _(), 'access', _2 => _2.getStore, 'call', _3 => _3(), 'optionalAccess', _4 => _4.snapshot]);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmI18nClientSnapshot, "getFarmI18nClientSnapshot");
+var format = {
+  number(value, options) {
+    return new Intl.NumberFormat(getLocale(), options).format(value);
+  },
+  currency(value, currency, options = {}) {
+    return new Intl.NumberFormat(getLocale(), {
+      ...options,
+      style: "currency",
+      currency
+    }).format(value);
+  },
+  date(value, options) {
+    return new Intl.DateTimeFormat(getLocale(), options).format(value);
+  },
+  relativeTime(value, unit, options) {
+    return new Intl.RelativeTimeFormat(getLocale(), options).format(value, unit);
+  },
+  list(values, options) {
+    const ListFormat = Intl.ListFormat;
+    return new ListFormat(getLocale(), options).format(Array.from(values));
+  }
+};
+function getDefaultRuntime() {
+  const runtime = globalThis[FARM_I18N_DEFAULT_RUNTIME];
+  if (!_optionalChain([runtime, 'optionalAccess', _5 => _5.config, 'access', _6 => _6.enabled])) {
+    throw new Error("Farm i18n is not configured for this application.");
+  }
+  return runtime;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getDefaultRuntime, "getDefaultRuntime");
+function assertLocale(runtime, locale) {
+  if (!runtime.config.locales.includes(locale)) {
+    throw new Error(`Unsupported Farm i18n locale "${locale}".`);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, assertLocale, "assertLocale");
+function createTranslatorFromState(resolveState) {
+  const translator = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, ((key, values) => {
+    const state = resolveState();
+    return state.runtime.translate(state.resolution.locale, key, values);
+  }), "translator");
+  translator.rich = (key, values) => {
+    const state = resolveState();
+    return state.runtime.translateRich(state.resolution.locale, key, values);
+  };
+  translator.raw = (key) => {
+    const state = resolveState();
+    return state.runtime.getRawMessage(state.resolution.locale, key);
+  };
+  translator.has = (key) => {
+    const state = resolveState();
+    return state.runtime.hasMessage(state.resolution.locale, key);
+  };
+  return translator;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createTranslatorFromState, "createTranslatorFromState");
+_chunkLIUGYUX3cjs._setFarmI18nSnapshotResolver.call(void 0, () => getFarmI18nClientSnapshot());
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FarmI18nRuntime = FarmI18nRuntime; exports.createFarmI18nRuntime = createFarmI18nRuntime; exports._setDefaultFarmI18nRuntime = _setDefaultFarmI18nRuntime; exports._runWithFarmI18nRequest = _runWithFarmI18nRequest; exports.runWithLocale = runWithLocale; exports.getLocale = getLocale; exports.getLocaleSource = getLocaleSource; exports.t = t; exports.createTranslator = createTranslator; exports.getFarmI18nClientSnapshot = getFarmI18nClientSnapshot; exports.format = format;

package/dist/chunk-UQZ4AYTH.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; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// 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 = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+      if (settled) return;
+      settled = true;
+      dispose();
+      resolvePromise(value);
+    }, "listener");
+    return { event, listener };
+  });
+  let resolvePromise;
+  const promise = new Promise((resolve) => {
+    resolvePromise = resolve;
+    for (const { event, listener } of listeners) {
+      res.once(event, listener);
+    }
+  });
+  const dispose = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, () => {
+    for (const { event, listener } of listeners) {
+      res.removeListener(event, listener);
+    }
+  }, "dispose");
+  return { promise, dispose };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, watchResponseEvent, "watchResponseEvent");
+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();
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, waitForWritable, "waitForWritable");
+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);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, splitSetCookieHeader, "splitSetCookieHeader");
+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]);
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyWebResponseHeaders, "applyWebResponseHeaders");
+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) {
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, sendWebResponse, "sendWebResponse");
+
+
+
+
+exports.applyWebResponseHeaders = applyWebResponseHeaders; exports.sendWebResponse = sendWebResponse;

package/dist/chunk-US2QVW3E.cjs

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/utils/decode.ts
+function decodeRouteSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch (e) {
+    return segment;
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, decodeRouteSegment, "decodeRouteSegment");
+function canonicalizeRequestPathSegments(pathname) {
+  const segments = pathname.split("/").filter(Boolean);
+  if (!pathname.includes("%")) return segments;
+  return segments.map(decodeRouteSegment);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, canonicalizeRequestPathSegments, "canonicalizeRequestPathSegments");
+function canonicalizeRequestPathname(pathname) {
+  const encoded = pathname.includes("%");
+  if (!encoded && !pathname.includes("//")) return pathname;
+  const collapsed = pathname.replace(/\/{2,}/g, "/");
+  if (!encoded) return collapsed;
+  return collapsed.split("/").map((segment) => {
+    const decoded = decodeRouteSegment(segment);
+    return decoded === segment ? segment : decoded.replace(/\//g, "%2F");
+  }).join("/");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, canonicalizeRequestPathname, "canonicalizeRequestPathname");
+
+
+
+
+
+exports.decodeRouteSegment = decodeRouteSegment; exports.canonicalizeRequestPathSegments = canonicalizeRequestPathSegments; exports.canonicalizeRequestPathname = canonicalizeRequestPathname;

package/dist/{chunk-QGVJVSNX.mjs → chunk-V4AICMQA.mjs}

@@ -28,7 +28,7 @@ import {
   resolveFarmNoindexPreviews,
   resolveFarmPerformanceConfig,
   resolveFarmSecurityConfig
-} from "./chunk-ZCNJKLA2.mjs";
+} from "./chunk-7BC6GAL7.mjs";
 import {
   resolveFarmImageConfig
 } from "./chunk-G2KY33I6.mjs";
@@ -47,7 +47,7 @@ import {
 } from "./chunk-FA2W42OV.mjs";
 import {
   resolveMarkdownConfig
-} from "./chunk-SXHV42UQ.mjs";
+} from "./chunk-OFEY6KHO.mjs";
 import {
   resolveWorkflowsConfig
 } from "./chunk-EGJDUF4Q.mjs";