locon 1.5.0 → 1.6.0

package/dist/core.mjs

@@ -0,0 +1,322 @@
+// src/locon/utils/pluralCategory.ts
+var between = (x, from, to) => x >= from && x <= to;
+var oneIfIntegerOne = ({ i, v }) => i === 1 && v === 0 ? "one" : "other";
+var oneIfOne = ({ n }) => n === 1 ? "one" : "other";
+var oneIfZeroOrOne = ({ i }) => i === 0 || i === 1 ? "one" : "other";
+var onlyOther = () => "other";
+var eastSlavic = ({ i, v }) => {
+  if (v !== 0) return "other";
+  if (i % 10 === 1 && i % 100 !== 11) return "one";
+  if (between(i % 10, 2, 4) && !between(i % 100, 12, 14)) return "few";
+  return "many";
+};
+var southSlavic = ({ i, v }) => {
+  if (v === 0 && i % 10 === 1 && i % 100 !== 11) return "one";
+  if (v === 0 && between(i % 10, 2, 4) && !between(i % 100, 12, 14)) return "few";
+  return "other";
+};
+var westSlavic = ({ i, v }) => {
+  if (i === 1 && v === 0) return "one";
+  if (between(i, 2, 4) && v === 0) return "few";
+  return v !== 0 ? "many" : "other";
+};
+var RULES = {
+  ru: eastSlavic,
+  uk: eastSlavic,
+  be: eastSlavic,
+  pl: ({ i, v }) => {
+    if (v !== 0) return "other";
+    if (i === 1) return "one";
+    if (between(i % 10, 2, 4) && !between(i % 100, 12, 14)) return "few";
+    return "many";
+  },
+  cs: westSlavic,
+  sk: westSlavic,
+  hr: southSlavic,
+  sr: southSlavic,
+  bs: southSlavic,
+  sl: ({ i, v }) => {
+    if (v !== 0) return "few";
+    if (i % 100 === 1) return "one";
+    if (i % 100 === 2) return "two";
+    if (between(i % 100, 3, 4)) return "few";
+    return "other";
+  },
+  lt: ({ n, v }) => {
+    if (v !== 0) return "many";
+    if (n % 10 === 1 && !between(n % 100, 11, 19)) return "one";
+    if (between(n % 10, 2, 9) && !between(n % 100, 11, 19)) return "few";
+    return "other";
+  },
+  lv: ({ n, v }) => {
+    if (v === 0 && (n % 10 === 0 || between(n % 100, 11, 19))) return "zero";
+    if (v === 0 && n % 10 === 1 && n % 100 !== 11) return "one";
+    return "other";
+  },
+  ro: ({ n, i, v }) => {
+    if (i === 1 && v === 0) return "one";
+    if (v !== 0 || n === 0 || n !== 1 && between(n % 100, 1, 19)) return "few";
+    return "other";
+  },
+  ar: ({ n, v }) => {
+    if (v !== 0) return "other";
+    if (n === 0) return "zero";
+    if (n === 1) return "one";
+    if (n === 2) return "two";
+    if (between(n % 100, 3, 10)) return "few";
+    if (between(n % 100, 11, 99)) return "many";
+    return "other";
+  },
+  he: ({ i, v }) => {
+    if (i === 1 && v === 0 || i === 0 && v !== 0) return "one";
+    if (i === 2 && v === 0) return "two";
+    return "other";
+  },
+  ga: ({ n, v }) => {
+    if (v !== 0) return "other";
+    if (n === 1) return "one";
+    if (n === 2) return "two";
+    if (between(n, 3, 6)) return "few";
+    if (between(n, 7, 10)) return "many";
+    return "other";
+  },
+  fr: oneIfZeroOrOne,
+  pt: oneIfZeroOrOne,
+  hi: ({ n, i }) => i === 0 || n === 1 ? "one" : "other",
+  bn: ({ n, i }) => i === 0 || n === 1 ? "one" : "other",
+  fa: ({ n, i }) => i === 0 || n === 1 ? "one" : "other",
+  es: oneIfOne,
+  tr: oneIfOne,
+  el: oneIfOne,
+  hu: oneIfOne,
+  ka: oneIfOne,
+  kk: oneIfOne,
+  az: oneIfOne,
+  uz: oneIfOne,
+  bg: oneIfOne,
+  sq: oneIfOne,
+  ja: onlyOther,
+  zh: onlyOther,
+  ko: onlyOther,
+  vi: onlyOther,
+  th: onlyOther,
+  id: onlyOther,
+  ms: onlyOther,
+  my: onlyOther,
+  km: onlyOther,
+  lo: onlyOther
+};
+function operands(count) {
+  const n = Math.abs(count);
+  const fraction = String(n).split(".")[1] ?? "";
+  return { n, i: Math.floor(n), v: fraction.length };
+}
+function fallbackCategory(count, tag) {
+  const language = tag.split("-")[0]?.toLowerCase() ?? "";
+  const rule = RULES[language] ?? oneIfIntegerOne;
+  return rule(operands(count));
+}
+function pluralCategory(count, locale) {
+  const tag = locale.replace(/_/g, "-");
+  if (typeof Intl !== "undefined" && typeof Intl.PluralRules === "function") {
+    try {
+      return new Intl.PluralRules(tag).select(count);
+    } catch {
+    }
+  }
+  return fallbackCategory(count, tag);
+}
+
+// src/locon/utils/createTranslator.ts
+var reverseIndexCache = /* @__PURE__ */ new WeakMap();
+function getReverseIndex(assets, locale) {
+  let perLocale = reverseIndexCache.get(assets);
+  if (!perLocale) {
+    perLocale = /* @__PURE__ */ new Map();
+    reverseIndexCache.set(assets, perLocale);
+  }
+  const cached = perLocale.get(locale);
+  if (cached) {
+    return cached;
+  }
+  const index = /* @__PURE__ */ new Map();
+  const localeAssets = assets[locale];
+  if (localeAssets) {
+    for (const key of Object.keys(localeAssets)) {
+      const value = localeAssets[key];
+      if (value !== void 0 && !index.has(value)) {
+        index.set(value, key);
+      }
+    }
+  }
+  perLocale.set(locale, index);
+  return index;
+}
+function interpolate(value, params) {
+  if (!params) {
+    return value;
+  }
+  return value.replace(
+    /\{(\w+)\}/g,
+    (match, token) => params[token] === void 0 ? match : String(params[token])
+  );
+}
+var PLURAL_SUFFIX = /_(zero|one|two|few|many|other)$/;
+function createTranslator({ assets, locale, defaultLocale = "en", projectLocale }) {
+  const resolvedProjectLocale = projectLocale || defaultLocale;
+  const read = (fromLocale, key) => {
+    const value = assets[fromLocale]?.[key];
+    return value === void 0 || value === "" ? void 0 : value;
+  };
+  const keyFor = (input, targetLocale) => {
+    if (assets[targetLocale]?.[input] !== void 0 || assets[defaultLocale]?.[input] !== void 0 || assets[resolvedProjectLocale]?.[input] !== void 0) {
+      return input;
+    }
+    return getReverseIndex(assets, resolvedProjectLocale).get(input) ?? getReverseIndex(assets, defaultLocale).get(input) ?? input;
+  };
+  return function l(assetKey, options) {
+    if (!assetKey) {
+      return "";
+    }
+    const targetLocale = options?.locale || locale;
+    const resolvedKey = keyFor(assetKey, targetLocale);
+    const key = options?.count === void 0 ? resolvedKey : resolvedKey.replace(PLURAL_SUFFIX, "");
+    const params = options?.count === void 0 ? options?.params : { ...options.params, count: options.count };
+    for (const candidateLocale of [targetLocale, defaultLocale, resolvedProjectLocale]) {
+      const candidateKeys = options?.count === void 0 ? [key] : [`${key}_${pluralCategory(options.count, candidateLocale)}`, `${key}_other`, key];
+      for (const candidateKey of candidateKeys) {
+        const value = read(candidateLocale, candidateKey);
+        if (value !== void 0) {
+          return interpolate(value, params);
+        }
+      }
+    }
+    return interpolate(options?.fallback ?? assetKey, params);
+  };
+}
+var createTranslator_default = createTranslator;
+
+// src/locon/utils/intlLocale.ts
+function intlLocale(locale, extensions = {}) {
+  const normalizedLocale = locale.replace(/_/g, "-");
+  const requested = [];
+  if (extensions.calendar) {
+    requested.push(["ca", extensions.calendar]);
+  }
+  if (extensions.numbering) {
+    requested.push(["nu", extensions.numbering]);
+  }
+  if (!requested.length) {
+    return normalizedLocale;
+  }
+  const subtags = normalizedLocale.split("-");
+  const isSingleton = (subtag) => subtag.length === 1;
+  const privateUseIndex = subtags.findIndex((subtag, index) => index > 0 && subtag.toLowerCase() === "x");
+  const unicodeIndex = subtags.findIndex(
+    (subtag, index) => index > 0 && (privateUseIndex < 0 || index < privateUseIndex) && subtag.toLowerCase() === "u"
+  );
+  if (unicodeIndex >= 0) {
+    const nextSingleton = subtags.findIndex((subtag, index) => index > unicodeIndex && isSingleton(subtag));
+    const unicodeEnd = nextSingleton < 0 ? subtags.length : nextSingleton;
+    const existingKeys = new Set(
+      subtags.slice(unicodeIndex + 1, unicodeEnd).filter((subtag) => subtag.length === 2).map((subtag) => subtag.toLowerCase())
+    );
+    const additions = requested.flatMap(([key, value]) => existingKeys.has(key) ? [] : [key, value]);
+    if (!additions.length) {
+      return normalizedLocale;
+    }
+    subtags.splice(unicodeEnd, 0, ...additions);
+    return subtags.join("-");
+  }
+  const insertionIndex = privateUseIndex < 0 ? subtags.length : privateUseIndex;
+  subtags.splice(insertionIndex, 0, "u", ...requested.flat());
+  return subtags.join("-");
+}
+var intlLocale_default = intlLocale;
+
+// src/core/resources.ts
+var normalized = (value) => value.replace(/_/g, "-").toLowerCase();
+function matchLocale(languages, supported, fallback) {
+  for (const language of languages) {
+    let candidate = normalized(language);
+    while (candidate) {
+      const exact = supported.find((locale) => normalized(locale) === candidate);
+      if (exact) return exact;
+      const next = candidate.lastIndexOf("-");
+      if (next < 0) break;
+      candidate = candidate.slice(0, next);
+    }
+    const base = normalized(language).split("-")[0];
+    const variant = supported.find((locale) => normalized(locale).split("-")[0] === base);
+    if (variant) return variant;
+  }
+  return fallback;
+}
+function createLocon(options) {
+  const locales = Object.keys(options.loaders);
+  if (!locales.includes(options.defaultLocale)) throw new Error("[locon] defaultLocale needs a loader");
+  const initial = matchLocale(options.locale ? [options.locale] : options.languages ?? [], locales, options.defaultLocale);
+  let snapshot = { currentLocale: initial, loading: false, ready: false, error: null };
+  let assets = {};
+  const pending = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let selection = 0;
+  const notify = (next) => {
+    snapshot = next;
+    listeners.forEach((listener) => listener());
+  };
+  async function loadLocale(locale) {
+    if (!locales.includes(locale)) throw new Error(`[locon] Unsupported locale: ${locale}`);
+    if (assets[locale]) return assets[locale];
+    let request = pending.get(locale);
+    if (!request) {
+      request = Promise.resolve().then(options.loaders[locale]).then((module) => {
+        const resource = typeof module.default === "object" ? module.default : module;
+        if (!resource || typeof resource !== "object" || Array.isArray(resource) || Object.values(resource).some((value) => typeof value !== "string")) {
+          throw new Error(`[locon] Invalid resources: ${locale}`);
+        }
+        assets = { ...assets, [locale]: { ...resource } };
+        return assets[locale];
+      }).finally(() => pending.delete(locale));
+      pending.set(locale, request);
+    }
+    return request;
+  }
+  async function setLocale(locale) {
+    const target = locale === null ? matchLocale(options.languages ?? [], locales, options.defaultLocale) : locale;
+    if (!locales.includes(target)) throw new Error(`[locon] Unsupported locale: ${target}`);
+    const version = ++selection;
+    notify({ ...snapshot, loading: true, error: null });
+    try {
+      await loadLocale(target);
+      if (version !== selection) return false;
+      notify({ currentLocale: target, loading: false, ready: true, error: null });
+      return true;
+    } catch (cause) {
+      if (version === selection) notify({ ...snapshot, loading: false, error: cause instanceof Error ? cause : new Error("[locon] Loading failed") });
+      throw cause;
+    }
+  }
+  function l(key, translateOptions) {
+    return createTranslator_default({ assets, locale: snapshot.currentLocale, defaultLocale: options.defaultLocale, projectLocale: options.projectLocale })(key, translateOptions);
+  }
+  return {
+    locales,
+    l,
+    loadLocale,
+    setLocale,
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+export {
+  createLocon,
+  createTranslator_default as createTranslator,
+  intlLocale_default as intlLocale,
+  matchLocale
+};

package/dist/index.js

@@ -36,6 +36,135 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 var import_react2 = require("react");
 
+// src/locon/utils/pluralCategory.ts
+var between = (x, from, to) => x >= from && x <= to;
+var oneIfIntegerOne = ({ i, v }) => i === 1 && v === 0 ? "one" : "other";
+var oneIfOne = ({ n }) => n === 1 ? "one" : "other";
+var oneIfZeroOrOne = ({ i }) => i === 0 || i === 1 ? "one" : "other";
+var onlyOther = () => "other";
+var eastSlavic = ({ i, v }) => {
+  if (v !== 0) return "other";
+  if (i % 10 === 1 && i % 100 !== 11) return "one";
+  if (between(i % 10, 2, 4) && !between(i % 100, 12, 14)) return "few";
+  return "many";
+};
+var southSlavic = ({ i, v }) => {
+  if (v === 0 && i % 10 === 1 && i % 100 !== 11) return "one";
+  if (v === 0 && between(i % 10, 2, 4) && !between(i % 100, 12, 14)) return "few";
+  return "other";
+};
+var westSlavic = ({ i, v }) => {
+  if (i === 1 && v === 0) return "one";
+  if (between(i, 2, 4) && v === 0) return "few";
+  return v !== 0 ? "many" : "other";
+};
+var RULES = {
+  ru: eastSlavic,
+  uk: eastSlavic,
+  be: eastSlavic,
+  pl: ({ i, v }) => {
+    if (v !== 0) return "other";
+    if (i === 1) return "one";
+    if (between(i % 10, 2, 4) && !between(i % 100, 12, 14)) return "few";
+    return "many";
+  },
+  cs: westSlavic,
+  sk: westSlavic,
+  hr: southSlavic,
+  sr: southSlavic,
+  bs: southSlavic,
+  sl: ({ i, v }) => {
+    if (v !== 0) return "few";
+    if (i % 100 === 1) return "one";
+    if (i % 100 === 2) return "two";
+    if (between(i % 100, 3, 4)) return "few";
+    return "other";
+  },
+  lt: ({ n, v }) => {
+    if (v !== 0) return "many";
+    if (n % 10 === 1 && !between(n % 100, 11, 19)) return "one";
+    if (between(n % 10, 2, 9) && !between(n % 100, 11, 19)) return "few";
+    return "other";
+  },
+  lv: ({ n, v }) => {
+    if (v === 0 && (n % 10 === 0 || between(n % 100, 11, 19))) return "zero";
+    if (v === 0 && n % 10 === 1 && n % 100 !== 11) return "one";
+    return "other";
+  },
+  ro: ({ n, i, v }) => {
+    if (i === 1 && v === 0) return "one";
+    if (v !== 0 || n === 0 || n !== 1 && between(n % 100, 1, 19)) return "few";
+    return "other";
+  },
+  ar: ({ n, v }) => {
+    if (v !== 0) return "other";
+    if (n === 0) return "zero";
+    if (n === 1) return "one";
+    if (n === 2) return "two";
+    if (between(n % 100, 3, 10)) return "few";
+    if (between(n % 100, 11, 99)) return "many";
+    return "other";
+  },
+  he: ({ i, v }) => {
+    if (i === 1 && v === 0 || i === 0 && v !== 0) return "one";
+    if (i === 2 && v === 0) return "two";
+    return "other";
+  },
+  ga: ({ n, v }) => {
+    if (v !== 0) return "other";
+    if (n === 1) return "one";
+    if (n === 2) return "two";
+    if (between(n, 3, 6)) return "few";
+    if (between(n, 7, 10)) return "many";
+    return "other";
+  },
+  fr: oneIfZeroOrOne,
+  pt: oneIfZeroOrOne,
+  hi: ({ n, i }) => i === 0 || n === 1 ? "one" : "other",
+  bn: ({ n, i }) => i === 0 || n === 1 ? "one" : "other",
+  fa: ({ n, i }) => i === 0 || n === 1 ? "one" : "other",
+  es: oneIfOne,
+  tr: oneIfOne,
+  el: oneIfOne,
+  hu: oneIfOne,
+  ka: oneIfOne,
+  kk: oneIfOne,
+  az: oneIfOne,
+  uz: oneIfOne,
+  bg: oneIfOne,
+  sq: oneIfOne,
+  ja: onlyOther,
+  zh: onlyOther,
+  ko: onlyOther,
+  vi: onlyOther,
+  th: onlyOther,
+  id: onlyOther,
+  ms: onlyOther,
+  my: onlyOther,
+  km: onlyOther,
+  lo: onlyOther
+};
+function operands(count) {
+  const n = Math.abs(count);
+  const fraction = String(n).split(".")[1] ?? "";
+  return { n, i: Math.floor(n), v: fraction.length };
+}
+function fallbackCategory(count, tag) {
+  const language = tag.split("-")[0]?.toLowerCase() ?? "";
+  const rule = RULES[language] ?? oneIfIntegerOne;
+  return rule(operands(count));
+}
+function pluralCategory(count, locale) {
+  const tag = locale.replace(/_/g, "-");
+  if (typeof Intl !== "undefined" && typeof Intl.PluralRules === "function") {
+    try {
+      return new Intl.PluralRules(tag).select(count);
+    } catch {
+    }
+  }
+  return fallbackCategory(count, tag);
+}
+
 // src/locon/utils/createTranslator.ts
 var reverseIndexCache = /* @__PURE__ */ new WeakMap();
 function getReverseIndex(assets, locale) {
@@ -71,13 +200,6 @@ function interpolate(value, params) {
   );
 }
 var PLURAL_SUFFIX = /_(zero|one|two|few|many|other)$/;
-function pluralCategory(count, locale) {
-  try {
-    return new Intl.PluralRules(locale.replace(/_/g, "-")).select(count);
-  } catch {
-    return count === 1 ? "one" : "other";
-  }
-}
 function createTranslator({ assets, locale, defaultLocale = "en", projectLocale }) {
   const resolvedProjectLocale = projectLocale || defaultLocale;
   const read = (fromLocale, key) => {

package/dist/react.d.mts

@@ -0,0 +1,19 @@
+import { a as LoconInstance, T as TranslateOptions } from './resources-BwFIzg3m.mjs';
+export { R as ResourceLoader, b as ResourceOptions, c as createLocon, m as matchLocale } from './resources-BwFIzg3m.mjs';
+import * as react from 'react';
+import { PropsWithChildren } from 'react';
+
+declare function LoconProvider({ instance, children }: PropsWithChildren<{
+    instance: LoconInstance;
+}>): react.JSX.Element;
+declare function useLocon(): {
+    locales: string[];
+    l: (key: string, translateOptions?: TranslateOptions) => string;
+    setLocale: (locale: string | null) => Promise<boolean>;
+    currentLocale: string;
+    loading: boolean;
+    ready: boolean;
+    error: Error | null;
+};
+
+export { LoconInstance, LoconProvider, useLocon };

package/dist/react.d.ts

@@ -0,0 +1,19 @@
+import { a as LoconInstance, T as TranslateOptions } from './resources-BwFIzg3m.js';
+export { R as ResourceLoader, b as ResourceOptions, c as createLocon, m as matchLocale } from './resources-BwFIzg3m.js';
+import * as react from 'react';
+import { PropsWithChildren } from 'react';
+
+declare function LoconProvider({ instance, children }: PropsWithChildren<{
+    instance: LoconInstance;
+}>): react.JSX.Element;
+declare function useLocon(): {
+    locales: string[];
+    l: (key: string, translateOptions?: TranslateOptions) => string;
+    setLocale: (locale: string | null) => Promise<boolean>;
+    currentLocale: string;
+    loading: boolean;
+    ready: boolean;
+    error: Error | null;
+};
+
+export { LoconInstance, LoconProvider, useLocon };