@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-U4KT7QP3.cjs

@@ -0,0 +1,23 @@
+"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/request-bridge.ts
+var CURRENT_REQUEST_RESOLVER_KEY = /* @__PURE__ */ Symbol.for("farm.currentRequestResolver");
+function getGlobalState() {
+  return globalThis;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getGlobalState, "getGlobalState");
+function _setCurrentRequestResolver(resolver) {
+  getGlobalState()[CURRENT_REQUEST_RESOLVER_KEY] = resolver;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _setCurrentRequestResolver, "_setCurrentRequestResolver");
+function _resolveCurrentRequest() {
+  return _optionalChain([getGlobalState, 'call', _ => _(), 'access', _2 => _2[CURRENT_REQUEST_RESOLVER_KEY], 'optionalCall', _3 => _3()]);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, _resolveCurrentRequest, "_resolveCurrentRequest");
+
+
+
+
+exports._setCurrentRequestResolver = _setCurrentRequestResolver; exports._resolveCurrentRequest = _resolveCurrentRequest;

package/dist/{chunk-LK6FGAQR.mjs → chunk-UDBJCUPA.mjs}

@@ -6,10 +6,10 @@ import {
 } from "./chunk-IOEH4VWN.mjs";
 import {
   APIRouteConflictError
-} from "./chunk-ZHOIQC6U.mjs";
+} from "./chunk-ATERBVHQ.mjs";
 import {
   findProgrammaticRouteFilesInDir
-} from "./chunk-VO5SCWF5.mjs";
+} from "./chunk-BNGS6KJ6.mjs";
 import {
   isFarmAPIRouteFileName
 } from "./chunk-CU625VAY.mjs";
@@ -19,7 +19,7 @@ import {
   invokeAPIRouteEndpoint,
   matchAPIRouteAtBasePath,
   resolveAPIRouteEndpoint
-} from "./chunk-DPZUDPVJ.mjs";
+} from "./chunk-XP777LRD.mjs";
 import {
   isProgrammaticRoutesFileName
 } from "./chunk-EA5K5BKU.mjs";
@@ -38,6 +38,9 @@ import {
 import {
   sendWebResponse
 } from "./chunk-Z2RZJZIZ.mjs";
+import {
+  resolveFarmRequestURL
+} from "./chunk-BSPQVJ4A.mjs";
 import {
   AmbiguousRouteError,
   assertUniqueRouteParameters,
@@ -395,7 +398,7 @@ function farmApiPlugin(options = {}) {
             if (currentPathname !== pathname && !matchAPIRouteAtBasePath(apiRoutesCache, currentPathname, basePath)) {
               return next();
             }
-            const fullUrl = `http://${req.headers.host || "localhost:3000"}${currentUrl}`;
+            const fullUrl = resolveFarmRequestURL(req);
             const headers = new Headers();
             for (const [key, value] of Object.entries(req.headers)) {
               if (value) {

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;