@farm.js/core 0.1.16 → 0.1.18

package/dist/chunk-IQXFRNY2.cjs

@@ -0,0 +1,169 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkHBTUGXHScjs = require('./chunk-HBTUGXHS.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/i18n/catalog.ts
+var _promises = require('fs/promises');
+var _icumessageformatparser = require('@formatjs/icu-messageformat-parser');
+async function readFarmI18nCatalogs(config) {
+  if (!config.enabled) {
+    return { catalogs: {}, signatures: {} };
+  }
+  const catalogs = {};
+  for (const locale of config.locales) {
+    const filePath = _chunkHBTUGXHScjs.resolveFarmI18nMessagePath.call(void 0, config, locale);
+    let source;
+    try {
+      source = await _promises.readFile.call(void 0, filePath, "utf8");
+    } catch (error) {
+      throw new Error(
+        `Unable to read Farm i18n catalog for "${locale}" at ${filePath}: ${messageOf(error)}`
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(source);
+    } catch (error) {
+      throw new Error(`Invalid JSON in Farm i18n catalog ${filePath}: ${messageOf(error)}`);
+    }
+    catalogs[locale] = flattenFarmI18nCatalog(parsed, filePath);
+  }
+  const reference = catalogs[config.defaultLocale] || {};
+  const signatures = {};
+  for (const [key, message] of Object.entries(reference)) {
+    signatures[key] = analyzeFarmI18nMessage(message, `${config.defaultLocale}:${key}`);
+  }
+  validateFarmI18nCatalogs(config, catalogs, signatures);
+  return { catalogs, signatures };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readFarmI18nCatalogs, "readFarmI18nCatalogs");
+function flattenFarmI18nCatalog(input, source = "i18n catalog") {
+  if (!isPlainObject(input)) {
+    throw new Error(`${source} must contain a JSON object at its root.`);
+  }
+  const output = {};
+  const visit = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (value, segments) => {
+    if (typeof value === "string") {
+      const key = segments.join(".");
+      if (!key) throw new Error(`${source} contains an empty message key.`);
+      if (Object.prototype.hasOwnProperty.call(output, key)) {
+        throw new Error(`${source} contains duplicate message key "${key}".`);
+      }
+      output[key] = value;
+      return;
+    }
+    if (!isPlainObject(value)) {
+      const key = segments.join(".") || "<root>";
+      throw new Error(`${source} message "${key}" must be a string or nested object.`);
+    }
+    for (const [key, nested] of Object.entries(value)) {
+      if (!key.trim()) throw new Error(`${source} contains an empty message key.`);
+      visit(nested, [...segments, key]);
+    }
+  }, "visit");
+  visit(input, []);
+  return output;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, flattenFarmI18nCatalog, "flattenFarmI18nCatalog");
+function analyzeFarmI18nMessage(message, label = "message") {
+  let ast;
+  try {
+    ast = _icumessageformatparser.parse.call(void 0, message, { captureLocation: false });
+  } catch (error) {
+    throw new Error(`Invalid ICU syntax in ${label}: ${messageOf(error)}`);
+  }
+  const signature = {};
+  collectArguments(ast, signature, label);
+  return signature;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, analyzeFarmI18nMessage, "analyzeFarmI18nMessage");
+function validateFarmI18nCatalogs(config, catalogs, signatures) {
+  const referenceKeys = Object.keys(catalogs[config.defaultLocale] || {}).sort();
+  for (const locale of config.locales) {
+    const catalog = catalogs[locale] || {};
+    const localeKeys = Object.keys(catalog).sort();
+    const missing = referenceKeys.filter(
+      (key) => !Object.prototype.hasOwnProperty.call(catalog, key)
+    );
+    const extra = localeKeys.filter(
+      (key) => !Object.prototype.hasOwnProperty.call(signatures, key)
+    );
+    if (config.strict && (missing.length > 0 || extra.length > 0)) {
+      const details = [
+        missing.length ? `missing: ${missing.join(", ")}` : "",
+        extra.length ? `extra: ${extra.join(", ")}` : ""
+      ].filter(Boolean).join("; ");
+      throw new Error(
+        `Farm i18n catalog "${locale}" does not match the default catalog (${details}).`
+      );
+    }
+    for (const [key, message] of Object.entries(catalog)) {
+      const actual = analyzeFarmI18nMessage(message, `${locale}:${key}`);
+      const expected = signatures[key];
+      if (!expected || sameSignature(expected, actual)) continue;
+      throw new Error(
+        `Farm i18n message "${key}" in "${locale}" uses different variables than "${config.defaultLocale}".`
+      );
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, validateFarmI18nCatalogs, "validateFarmI18nCatalogs");
+function collectArguments(elements, signature, label) {
+  for (const element of elements) {
+    switch (element.type) {
+      case _icumessageformatparser.TYPE.argument:
+        addArgument(signature, element.value, "string", label);
+        break;
+      case _icumessageformatparser.TYPE.number:
+      case _icumessageformatparser.TYPE.plural:
+        addArgument(signature, element.value, "number", label);
+        break;
+      case _icumessageformatparser.TYPE.date:
+      case _icumessageformatparser.TYPE.time:
+        addArgument(signature, element.value, "date", label);
+        break;
+      case _icumessageformatparser.TYPE.select:
+        addArgument(signature, element.value, "select", label);
+        break;
+      case _icumessageformatparser.TYPE.tag:
+        addArgument(signature, element.value, "rich", label);
+        collectArguments(element.children, signature, label);
+        break;
+    }
+    if (element.type === _icumessageformatparser.TYPE.plural || element.type === _icumessageformatparser.TYPE.select) {
+      for (const option of Object.values(element.options)) {
+        collectArguments(option.value, signature, label);
+      }
+    }
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, collectArguments, "collectArguments");
+function addArgument(signature, name, kind, label) {
+  const existing = signature[name];
+  if (existing && existing !== kind) {
+    throw new Error(`Farm i18n ${label} uses variable "${name}" as both ${existing} and ${kind}.`);
+  }
+  signature[name] = kind;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, addArgument, "addArgument");
+function sameSignature(expected, actual) {
+  const expectedEntries = Object.entries(expected).sort(([a], [b]) => a.localeCompare(b));
+  const actualEntries = Object.entries(actual).sort(([a], [b]) => a.localeCompare(b));
+  return JSON.stringify(expectedEntries) === JSON.stringify(actualEntries);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, sameSignature, "sameSignature");
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isPlainObject, "isPlainObject");
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, messageOf, "messageOf");
+
+
+
+exports.readFarmI18nCatalogs = readFarmI18nCatalogs;