locon 1.5.1 → 1.6.0

package/dist/react.mjs

@@ -0,0 +1,300 @@
+// src/react/index.tsx
+import { createContext, useContext, useSyncExternalStore } from "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) {
+  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/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);
+      };
+    }
+  };
+}
+
+// src/react/index.tsx
+import { jsx } from "react/jsx-runtime";
+var Context = createContext(null);
+function LoconProvider({ instance, children }) {
+  return /* @__PURE__ */ jsx(Context, { value: instance, children });
+}
+function useLocon() {
+  const instance = useContext(Context);
+  if (!instance) throw new Error("[locon/react] useLocon needs LoconProvider");
+  const snapshot = useSyncExternalStore(instance.subscribe, instance.getSnapshot, instance.getSnapshot);
+  return { ...snapshot, locales: instance.locales, l: instance.l, setLocale: instance.setLocale };
+}
+export {
+  LoconProvider,
+  createLocon,
+  matchLocale,
+  useLocon
+};

package/dist/resources-BwFIzg3m.d.mts

@@ -0,0 +1,52 @@
+/**
+ * Per-call options for `l()`, `lIn()` and `<LText>`.
+ *
+ * All four are optional and independent: `params` interpolates, `count`
+ * selects a plural form, and `locale` renders one call in a language other
+ * than the current one (used when an app exports a document in a language
+ * the interface is not currently showing). `fallback` is returned only when
+ * no locale resolves the input.
+ */
+interface TranslateOptions {
+    /** Values for `{token}` placeholders inside the resolved string. */
+    params?: Record<string, string | number>;
+    /** Selects `key_one` / `key_few` / `key_other` … via `Intl.PluralRules`. */
+    count?: number;
+    /** Resolve against this locale instead of the current one. */
+    locale?: string;
+    /** Human-readable fallback when no locale resolves the key/value. */
+    fallback?: string;
+}
+
+type Resource = Record<string, string>;
+type ResourceLoader = () => Promise<Resource | {
+    default: Resource;
+}>;
+interface ResourceOptions {
+    loaders: Record<string, ResourceLoader>;
+    defaultLocale: string;
+    projectLocale?: string;
+    locale?: string | null;
+    /** Ordered browser/device preferences, or an explicit list in Node. */
+    languages?: readonly string[];
+}
+interface LocaleSnapshot {
+    currentLocale: string;
+    loading: boolean;
+    ready: boolean;
+    error: Error | null;
+}
+/** First matching preference wins; regional variants can use a base resource. */
+declare function matchLocale(languages: readonly string[], supported: readonly string[], fallback: string): string;
+/** A per-app/per-request store. Importing it touches neither React nor a platform API. */
+declare function createLocon(options: ResourceOptions): {
+    locales: string[];
+    l: (key: string, translateOptions?: TranslateOptions) => string;
+    loadLocale: (locale: string) => Promise<Resource>;
+    setLocale: (locale: string | null) => Promise<boolean>;
+    getSnapshot: () => LocaleSnapshot;
+    subscribe(listener: () => void): () => void;
+};
+type LoconInstance = ReturnType<typeof createLocon>;
+
+export { type LocaleSnapshot as L, type ResourceLoader as R, type TranslateOptions as T, type LoconInstance as a, type ResourceOptions as b, createLocon as c, matchLocale as m };

package/dist/resources-BwFIzg3m.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Per-call options for `l()`, `lIn()` and `<LText>`.
+ *
+ * All four are optional and independent: `params` interpolates, `count`
+ * selects a plural form, and `locale` renders one call in a language other
+ * than the current one (used when an app exports a document in a language
+ * the interface is not currently showing). `fallback` is returned only when
+ * no locale resolves the input.
+ */
+interface TranslateOptions {
+    /** Values for `{token}` placeholders inside the resolved string. */
+    params?: Record<string, string | number>;
+    /** Selects `key_one` / `key_few` / `key_other` … via `Intl.PluralRules`. */
+    count?: number;
+    /** Resolve against this locale instead of the current one. */
+    locale?: string;
+    /** Human-readable fallback when no locale resolves the key/value. */
+    fallback?: string;
+}
+
+type Resource = Record<string, string>;
+type ResourceLoader = () => Promise<Resource | {
+    default: Resource;
+}>;
+interface ResourceOptions {
+    loaders: Record<string, ResourceLoader>;
+    defaultLocale: string;
+    projectLocale?: string;
+    locale?: string | null;
+    /** Ordered browser/device preferences, or an explicit list in Node. */
+    languages?: readonly string[];
+}
+interface LocaleSnapshot {
+    currentLocale: string;
+    loading: boolean;
+    ready: boolean;
+    error: Error | null;
+}
+/** First matching preference wins; regional variants can use a base resource. */
+declare function matchLocale(languages: readonly string[], supported: readonly string[], fallback: string): string;
+/** A per-app/per-request store. Importing it touches neither React nor a platform API. */
+declare function createLocon(options: ResourceOptions): {
+    locales: string[];
+    l: (key: string, translateOptions?: TranslateOptions) => string;
+    loadLocale: (locale: string) => Promise<Resource>;
+    setLocale: (locale: string | null) => Promise<boolean>;
+    getSnapshot: () => LocaleSnapshot;
+    subscribe(listener: () => void): () => void;
+};
+type LoconInstance = ReturnType<typeof createLocon>;
+
+export { type LocaleSnapshot as L, type ResourceLoader as R, type TranslateOptions as T, type LoconInstance as a, type ResourceOptions as b, createLocon as c, matchLocale as m };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "locon",
-  "version": "1.5.1",
-  "description": "locon is a simple and lightweight library for React Native that provides a simple way to manage translations in your app.",
+  "version": "1.6.0",
+  "description": "Lightweight localization for React Native, React and Node with lazy locale resources.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -10,17 +10,28 @@
       "default": "./dist/index.js"
     },
     "./skills/*": "./skills/*",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./core": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.mjs",
+      "require": "./dist/core.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.mjs",
+      "require": "./dist/react.js"
+    }
   },
   "files": [
     "dist",
-    "skills"
+    "skills",
+    "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && tsup --config tsup.web.config.ts",
     "lint": "eslint src",
-    "prepare": "tsup",
-    "pretest": "tsup",
+    "prepare": "npm run build",
+    "pretest": "npm run build",
     "test": "jest"
   },
   "keywords": [
@@ -59,6 +70,12 @@
     },
     "react-native-localize": {
       "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
     }
   },
   "devDependencies": {