locon 1.4.6 → 1.5.0

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,38 +15,468 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var locon_exports = {};
-__export(locon_exports, {
-  LText: () => import_LText.default,
+
+// src/locon/index.tsx
+var index_exports = {};
+__export(index_exports, {
+  LText: () => LText_default,
   LoconContext: () => LoconContext,
-  default: () => locon_default,
-  useLocon: () => import_useLocon.default
+  RTL_LANGUAGES: () => RTL_LANGUAGES,
+  RTL_SCRIPTS: () => RTL_SCRIPTS,
+  applyRTL: () => applyRTL,
+  createTranslator: () => createTranslator_default,
+  default: () => index_default,
+  getSystemLanguage: () => getSystemLanguage_default,
+  intlLocale: () => intlLocale_default,
+  isRtlLocale: () => isRtlLocale,
+  resolveLocale: () => resolveLocale_default,
+  useLocon: () => useLocon_default
 });
-module.exports = __toCommonJS(locon_exports);
-var import_jsx_runtime = require("react/jsx-runtime");
+module.exports = __toCommonJS(index_exports);
+var import_react2 = require("react");
+
+// 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 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) => {
+    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/getSystemLanguage.ts
+function isModuleNotFound(error) {
+  const candidate = error;
+  if (candidate?.code === "MODULE_NOT_FOUND") {
+    return true;
+  }
+  return /cannot find module|requiring unknown module|could not be found|unable to resolve/i.test(
+    candidate?.message ?? ""
+  );
+}
+function matchLocale(deviceTags, availableLocales) {
+  const parse = (locale) => {
+    const normalized = locale.toLowerCase().replace(/_/g, "-");
+    const subtags = normalized.split("-");
+    const extensionIndex = subtags.findIndex((subtag, index) => index > 0 && subtag.length === 1);
+    const coreSubtags = subtags.slice(1, extensionIndex < 0 ? void 0 : extensionIndex);
+    const explicitScript = coreSubtags.find((subtag) => /^[a-z]{4}$/.test(subtag));
+    const region = coreSubtags.find((subtag) => /^[a-z]{2}$|^\d{3}$/.test(subtag));
+    const chineseRegionScript = subtags[0] === "zh" && region ? ["tw", "hk", "mo"].includes(region) ? "hant" : ["cn", "sg", "my"].includes(region) ? "hans" : void 0 : void 0;
+    let script = explicitScript ?? chineseRegionScript;
+    if (!script) {
+      try {
+        script = new Intl.Locale(normalized).maximize().script?.toLowerCase();
+      } catch {
+      }
+    }
+    return {
+      normalized,
+      language: subtags[0],
+      // Script is normally the second subtag. Looking until the first
+      // extension also handles legacy extlang-shaped tags without confusing a
+      // four-character variant beginning with a digit for a script. Likely
+      // subtags distinguish region-only tags such as zh-TW and zh-CN.
+      explicitScript,
+      script
+    };
+  };
+  const available = availableLocales.map((locale) => ({ locale, ...parse(locale) }));
+  for (const tag of deviceTags) {
+    if (!tag) {
+      continue;
+    }
+    const requested = parse(tag);
+    const exact = available.find((entry) => entry.normalized === requested.normalized);
+    if (exact) {
+      return exact.locale;
+    }
+    const languageEntries = available.filter((entry) => entry.language === requested.language);
+    const availableScripts = new Set(languageEntries.map((entry) => entry.script).filter(Boolean));
+    const scriptMatters = Boolean(requested.explicitScript || availableScripts.size > 1);
+    const sameScript = scriptMatters && requested.script ? available.find((entry) => entry.language === requested.language && entry.script === requested.script) : void 0;
+    if (sameScript) {
+      return sameScript.locale;
+    }
+    const language = available.find((entry) => entry.normalized === requested.language);
+    if (language) {
+      return language.locale;
+    }
+    const sameLanguage = available.find((entry) => entry.language === requested.language);
+    if (sameLanguage) {
+      return sameLanguage.locale;
+    }
+  }
+  return null;
+}
+function tagsFromReactNativeLocalize() {
+  try {
+    const RNLocalize = require("react-native-localize");
+    if (typeof RNLocalize?.getLocales === "function") {
+      return RNLocalize.getLocales().flatMap(
+        (locale) => [locale.languageTag, locale.languageCode].filter(Boolean)
+      );
+    }
+  } catch (error) {
+    if (!isModuleNotFound(error)) {
+      console.warn("[locon] react-native-localize failed:", error);
+    }
+  }
+  return [];
+}
+function tagsFromExpoLocalization() {
+  try {
+    const Localization = require("expo-localization");
+    if (typeof Localization?.getLocales === "function") {
+      return Localization.getLocales().flatMap(
+        (locale) => [locale.languageTag, locale.languageCode].filter(Boolean)
+      );
+    }
+  } catch (error) {
+    if (!isModuleNotFound(error)) {
+      console.warn("[locon] expo-localization failed:", error);
+    }
+  }
+  return [];
+}
+function tagsFromNativeModules() {
+  try {
+    const { NativeModules, Platform } = require("react-native");
+    const tags = [];
+    if (Platform?.OS === "ios") {
+      const appleLanguages = NativeModules?.SettingsManager?.settings?.AppleLanguages;
+      if (Array.isArray(appleLanguages)) {
+        tags.push(...appleLanguages);
+      }
+    }
+    const localeIdentifier = NativeModules?.I18nManager?.localeIdentifier;
+    if (typeof localeIdentifier === "string") {
+      tags.push(localeIdentifier);
+    }
+    return tags;
+  } catch {
+    return [];
+  }
+}
+function tagsFromIntl() {
+  try {
+    const systemLocale = Intl.DateTimeFormat().resolvedOptions().locale;
+    return systemLocale ? [systemLocale] : [];
+  } catch {
+    return [];
+  }
+}
+function getSystemLanguage(availableLocales) {
+  if (!availableLocales?.length) {
+    return null;
+  }
+  const sources = [tagsFromExpoLocalization, tagsFromReactNativeLocalize, tagsFromNativeModules, tagsFromIntl];
+  for (const source of sources) {
+    const match = matchLocale(source(), availableLocales);
+    if (match) {
+      return match;
+    }
+  }
+  return null;
+}
+var getSystemLanguage_default = getSystemLanguage;
+
+// src/locon/utils/resolveLocale.ts
+function resolveLocale({
+  assets,
+  currentLocale,
+  defaultLocale = "en",
+  autodetect = true,
+  systemLocale
+}) {
+  if (currentLocale) {
+    return currentLocale;
+  }
+  if (!autodetect) {
+    return defaultLocale;
+  }
+  const detected = systemLocale === void 0 ? getSystemLanguage_default(Object.keys(assets)) : systemLocale;
+  return detected ?? defaultLocale;
+}
+var resolveLocale_default = resolveLocale;
+
+// src/locon/utils/rtl.ts
+var RTL_LANGUAGES = /* @__PURE__ */ new Set([
+  "ar",
+  // Arabic
+  "arc",
+  // Aramaic
+  "ckb",
+  // Central Kurdish (Sorani)
+  "dv",
+  // Divehi
+  "fa",
+  // Persian
+  "glk",
+  // Gilaki
+  "he",
+  // Hebrew
+  "khw",
+  // Khowar
+  "ks",
+  // Kashmiri (Perso-Arabic)
+  "lrc",
+  // Northern Luri
+  "mzn",
+  // Mazanderani
+  "nqo",
+  // N'Ko
+  "pnb",
+  // Western Punjabi
+  "ps",
+  // Pashto
+  "sd",
+  // Sindhi (Perso-Arabic)
+  "syr",
+  // Syriac
+  "ug",
+  // Uyghur
+  "ur",
+  // Urdu
+  "yi"
+  // Yiddish
+]);
+var RTL_SCRIPTS = /* @__PURE__ */ new Set([
+  "adlm",
+  "arab",
+  "aran",
+  "armi",
+  "avst",
+  "chrs",
+  "cprt",
+  "elym",
+  "hatr",
+  "hebr",
+  "hung",
+  "khar",
+  "lydi",
+  "mand",
+  "mani",
+  "mend",
+  "merc",
+  "mero",
+  "narb",
+  "nbat",
+  "nkoo",
+  "orkh",
+  "ougr",
+  "palm",
+  "phli",
+  "phlp",
+  "phnx",
+  "prti",
+  "rohg",
+  "samr",
+  "sarb",
+  "sogd",
+  "sogo",
+  "syrc",
+  "thaa",
+  "yezi"
+]);
+var lastRequestedRTL;
+function rtlFromIntl(locale) {
+  try {
+    const likelyLocale = new Intl.Locale(locale.replace(/_/g, "-")).maximize();
+    const localeWithDirection = likelyLocale;
+    const direction = localeWithDirection.getTextInfo?.().direction ?? localeWithDirection.textInfo?.direction;
+    if (direction === "rtl") {
+      return true;
+    }
+    if (direction === "ltr") {
+      return false;
+    }
+    const likelyScript = likelyLocale.script?.toLowerCase();
+    return likelyScript && RTL_SCRIPTS.has(likelyScript) ? true : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isRtlLocale(locale) {
+  if (!locale) {
+    return false;
+  }
+  const subtags = locale.split(/[-_]/);
+  const languageCode = subtags[0]?.toLowerCase();
+  const extensionIndex = subtags.findIndex((subtag, index) => index > 0 && subtag.length === 1);
+  const coreSubtags = subtags.slice(1, extensionIndex < 0 ? void 0 : extensionIndex);
+  const scriptCode = coreSubtags.find((subtag) => /^[a-z]{4}$/i.test(subtag))?.toLowerCase();
+  if (scriptCode) {
+    return RTL_SCRIPTS.has(scriptCode) || rtlFromIntl(locale) === true;
+  }
+  const runtimeDirection = rtlFromIntl(locale);
+  if (runtimeDirection !== void 0) {
+    return runtimeDirection;
+  }
+  return Boolean(languageCode && RTL_LANGUAGES.has(languageCode));
+}
+function applyRTL(locale) {
+  const shouldBeRTL = isRtlLocale(locale);
+  try {
+    const { I18nManager } = require("react-native");
+    if (!I18nManager || typeof I18nManager.forceRTL !== "function") {
+      return false;
+    }
+    I18nManager.allowRTL?.(true);
+    const renderedRTL = Boolean(I18nManager.isRTL);
+    const effectiveRequestedRTL = lastRequestedRTL ?? renderedRTL;
+    if (effectiveRequestedRTL !== shouldBeRTL) {
+      I18nManager.forceRTL(shouldBeRTL);
+    }
+    lastRequestedRTL = shouldBeRTL;
+    return renderedRTL !== shouldBeRTL;
+  } catch {
+    return false;
+  }
+}
+
+// src/locon/components/LText.tsx
+var import_react_native = require("react-native");
+
+// src/locon/hooks/useLocon.ts
 var import_react = require("react");
-var import_getSystemLanguage = __toESM(require("./utils/getSystemLanguage"));
-var import_LText = __toESM(require("./components/LText"));
-var import_useLocon = __toESM(require("./hooks/useLocon"));
-const LoconContext = (0, import_react.createContext)({
+function useLocon() {
+  const locon = (0, import_react.useContext)(LoconContext);
+  return locon;
+}
+var useLocon_default = useLocon;
+
+// src/locon/components/LText.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function LText({ children, assetKey, params, count, locale, ...props }) {
+  const { l } = useLocon_default();
+  const value = l(assetKey || children, { params, count, locale, fallback: assetKey ? children : void 0 });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native.Text, { ...props, children: value });
+}
+var LText_default = LText;
+
+// 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/locon/index.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var fallbackTranslator = createTranslator_default({ assets: {}, locale: "en" });
+var LoconContext = (0, import_react2.createContext)({
   assets: {},
+  locales: [],
   currentLocale: "en",
   defaultLocale: "en",
+  projectLocale: "en",
+  systemLocale: null,
+  isRTL: false,
   autodetect: true,
   setLocale: () => {
   },
-  // Default implementation
-  l: (assetKey) => assetKey
-  // Default implementation
+  l: fallbackTranslator,
+  lIn: (locale, assetKey, options) => fallbackTranslator(assetKey, { ...options, locale })
 });
 function Locon({
   children,
@@ -59,82 +487,89 @@ function Locon({
   autodetect = true
 }) {
   const resolvedProjectLocale = projectLocale || defaultLocale;
-  const [currentLocale, setCurrentLocale] = (0, import_react.useState)(() => {
-    if (currentLocaleProps) {
-      return currentLocaleProps;
-    }
-    if (autodetect) {
-      const systemLocale = (0, import_getSystemLanguage.default)(Object.keys(assets));
-      if (systemLocale && assets[systemLocale]) {
-        return systemLocale;
-      }
-    }
-    return defaultLocale;
-  });
-  const getAssets = (0, import_react.useCallback)(() => {
-    const currentAssets = assets[currentLocale] ?? assets[defaultLocale];
-    return currentAssets ?? {};
-  }, [assets, currentLocale, defaultLocale]);
-  const getAsset = (0, import_react.useCallback)(
-    (assetKey) => {
-      const assetsObj = getAssets();
-      return assetsObj[assetKey] ?? "";
-    },
-    [getAssets]
+  const locales = (0, import_react2.useMemo)(() => Object.keys(assets), [assets]);
+  const systemLocale = (0, import_react2.useMemo)(() => autodetect ? getSystemLanguage_default(locales) : null, [autodetect, locales]);
+  const [currentLocale, setCurrentLocale] = (0, import_react2.useState)(
+    () => resolveLocale_default({ assets, currentLocale: currentLocaleProps, defaultLocale, autodetect, systemLocale })
   );
-  const setCurrentLocaleHandler = (0, import_react.useCallback)(
+  const setCurrentLocaleHandler = (0, import_react2.useCallback)(
     (locale) => {
+      if (locale === null) {
+        setCurrentLocale(resolveLocale_default({ assets, defaultLocale, autodetect, systemLocale }));
+        return;
+      }
       if (assets[locale]) {
         setCurrentLocale(locale);
       } else {
         console.warn(`[locon] Locale "${locale}" not found in assets.`);
       }
     },
-    [assets]
+    [assets, systemLocale, defaultLocale, autodetect]
   );
-  const getAssetByValue = (0, import_react.useCallback)(
-    (assetValue, locale = resolvedProjectLocale) => {
-      const currentAssets = assets[locale];
-      if (!currentAssets) {
-        return void 0;
-      }
-      const assetKey = Object.keys(currentAssets).find((key) => currentAssets[key] === assetValue);
-      return assetKey ? getAsset(assetKey) : void 0;
-    },
-    [assets, getAsset, resolvedProjectLocale]
+  const l = (0, import_react2.useMemo)(
+    () => createTranslator_default({
+      assets,
+      locale: currentLocale,
+      defaultLocale,
+      projectLocale: resolvedProjectLocale
+    }),
+    [assets, currentLocale, defaultLocale, resolvedProjectLocale]
   );
-  const l = (0, import_react.useCallback)(
-    (assetKey) => {
-      if (!assetKey) {
-        return "";
-      }
-      const asset = getAsset(assetKey) || getAssetByValue(assetKey) || getAssetByValue(assetKey, defaultLocale);
-      return asset ?? assetKey;
-    },
-    [getAsset, getAssetByValue, defaultLocale]
+  const lIn = (0, import_react2.useCallback)(
+    (locale, assetKey, options) => l(assetKey, { ...options, locale }),
+    [l]
   );
-  (0, import_react.useEffect)(() => {
-    if (currentLocaleProps) {
-      setCurrentLocale((locale) => locale === currentLocaleProps ? locale : currentLocaleProps);
+  (0, import_react2.useEffect)(() => {
+    if (currentLocaleProps === void 0) {
+      return;
+    }
+    if (currentLocaleProps === null) {
+      setCurrentLocale(resolveLocale_default({ assets, defaultLocale, autodetect, systemLocale }));
+      return;
     }
-  }, [currentLocaleProps]);
-  const value = (0, import_react.useMemo)(
+    setCurrentLocale((locale) => locale === currentLocaleProps ? locale : currentLocaleProps);
+  }, [assets, currentLocaleProps, systemLocale, defaultLocale, autodetect]);
+  const value = (0, import_react2.useMemo)(
     () => ({
       assets,
+      locales,
       currentLocale,
       defaultLocale,
+      projectLocale: resolvedProjectLocale,
+      systemLocale,
+      isRTL: isRtlLocale(currentLocale),
       autodetect,
       l,
+      lIn,
       setLocale: setCurrentLocaleHandler
     }),
-    [assets, currentLocale, defaultLocale, autodetect, l, setCurrentLocaleHandler]
+    [
+      assets,
+      locales,
+      currentLocale,
+      defaultLocale,
+      resolvedProjectLocale,
+      systemLocale,
+      autodetect,
+      l,
+      lIn,
+      setCurrentLocaleHandler
+    ]
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(LoconContext, { value, children });
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(LoconContext, { value, children });
 }
-var locon_default = Locon;
+var index_default = Locon;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LText,
   LoconContext,
+  RTL_LANGUAGES,
+  RTL_SCRIPTS,
+  applyRTL,
+  createTranslator,
+  getSystemLanguage,
+  intlLocale,
+  isRtlLocale,
+  resolveLocale,
   useLocon
 });