locon 1.3.0 → 1.4.0

package/dist/components/LText.d.mts

@@ -0,0 +1,10 @@
+import { ReactElement, ComponentProps } from 'react';
+import { Text } from 'react-native';
+
+interface Props extends ComponentProps<typeof Text> {
+    children: string;
+    assetKey?: string;
+}
+declare function LText({ children, assetKey, ...props }: Props): ReactElement;
+
+export { LText as default };

package/dist/components/LText.d.ts

@@ -0,0 +1,10 @@
+import { ReactElement, ComponentProps } from 'react';
+import { Text } from 'react-native';
+
+interface Props extends ComponentProps<typeof Text> {
+    children: string;
+    assetKey?: string;
+}
+declare function LText({ children, assetKey, ...props }: Props): ReactElement;
+
+export { LText as default };

package/dist/components/LText.js

@@ -0,0 +1,41 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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 LText_exports = {};
+__export(LText_exports, {
+  default: () => LText_default
+});
+module.exports = __toCommonJS(LText_exports);
+var import_jsx_runtime = require("react/jsx-runtime");
+var import_react_native = require("react-native");
+var import_useLocon = __toESM(require("../hooks/useLocon"));
+function LText({ children, assetKey, ...props }) {
+  const { l } = (0, import_useLocon.default)();
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native.Text, { ...props, children: l(assetKey || children) });
+}
+var LText_default = LText;

package/dist/components/LText.mjs

@@ -0,0 +1,11 @@
+import { jsx } from "react/jsx-runtime";
+import { Text } from "react-native";
+import useLocon from "../hooks/useLocon";
+function LText({ children, assetKey, ...props }) {
+  const { l } = useLocon();
+  return /* @__PURE__ */ jsx(Text, { ...props, children: l(assetKey || children) });
+}
+var LText_default = LText;
+export {
+  LText_default as default
+};

package/dist/hooks/useLocon.d.mts

@@ -0,0 +1,6 @@
+import LoconContext from '../types/LoconContext.mjs';
+import '../types/Assets.mjs';
+
+declare function useLocon(): LoconContext;
+
+export { useLocon as default };

package/dist/hooks/useLocon.d.ts

@@ -0,0 +1,6 @@
+import LoconContext from '../types/LoconContext.js';
+import '../types/Assets.js';
+
+declare function useLocon(): LoconContext;
+
+export { useLocon as default };

package/dist/hooks/useLocon.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useLocon_exports = {};
+__export(useLocon_exports, {
+  default: () => useLocon_default
+});
+module.exports = __toCommonJS(useLocon_exports);
+var import_react = require("react");
+var import__ = require("../index");
+function useLocon() {
+  const locon = (0, import_react.useContext)(import__.LoconContext);
+  return locon;
+}
+var useLocon_default = useLocon;

package/dist/hooks/useLocon.mjs

@@ -0,0 +1,10 @@
+import { useContext } from "react";
+import { LoconContext } from "../index";
+function useLocon() {
+  const locon = useContext(LoconContext);
+  return locon;
+}
+var useLocon_default = useLocon;
+export {
+  useLocon_default as default
+};

package/dist/index.d.mts

@@ -1,25 +1,10 @@
 import * as react from 'react';
-import { ReactElement, ComponentProps, PropsWithChildren } from 'react';
-import { Text } from 'react-native';
-
-type Assets = Record<string, Record<string, string>>;
-
-interface LoconContext$1 {
-    l: (assetKey: string) => string;
-    assets: Assets;
-    currentLocale: string;
-    defaultLocale: string;
-    autodetect: boolean;
-    setLocale: (locale: string) => void;
-}
-
-interface Props$1 extends ComponentProps<typeof Text> {
-    children: string;
-    assetKey?: string;
-}
-declare function LText({ children, assetKey, ...props }: Props$1): ReactElement;
-
-declare function useLocon(): LoconContext$1;
+import { ReactElement, PropsWithChildren } from 'react';
+import LoconContext$1 from './types/LoconContext.mjs';
+export { default as LText } from './components/LText.mjs';
+export { default as useLocon } from './hooks/useLocon.mjs';
+import './types/Assets.mjs';
+import 'react-native';
 
 declare const LoconContext: react.Context<LoconContext$1>;
 interface Props extends PropsWithChildren {
@@ -31,4 +16,4 @@ interface Props extends PropsWithChildren {
 }
 declare function Locon({ children, assets, currentLocale: currentLocaleProps, defaultLocale, projectLocale, autodetect, }: Props): ReactElement;
 
-export { LText, LoconContext, Locon as default, useLocon };
+export { LoconContext, Locon as default };

package/dist/index.d.ts

@@ -1,25 +1,10 @@
 import * as react from 'react';
-import { ReactElement, ComponentProps, PropsWithChildren } from 'react';
-import { Text } from 'react-native';
-
-type Assets = Record<string, Record<string, string>>;
-
-interface LoconContext$1 {
-    l: (assetKey: string) => string;
-    assets: Assets;
-    currentLocale: string;
-    defaultLocale: string;
-    autodetect: boolean;
-    setLocale: (locale: string) => void;
-}
-
-interface Props$1 extends ComponentProps<typeof Text> {
-    children: string;
-    assetKey?: string;
-}
-declare function LText({ children, assetKey, ...props }: Props$1): ReactElement;
-
-declare function useLocon(): LoconContext$1;
+import { ReactElement, PropsWithChildren } from 'react';
+import LoconContext$1 from './types/LoconContext.js';
+export { default as LText } from './components/LText.js';
+export { default as useLocon } from './hooks/useLocon.js';
+import './types/Assets.js';
+import 'react-native';
 
 declare const LoconContext: react.Context<LoconContext$1>;
 interface Props extends PropsWithChildren {
@@ -31,4 +16,4 @@ interface Props extends PropsWithChildren {
 }
 declare function Locon({ children, assets, currentLocale: currentLocaleProps, defaultLocale, projectLocale, autodetect, }: Props): ReactElement;
 
-export { LText, LoconContext, Locon as default, useLocon };
+export { LoconContext, Locon as default };

package/dist/types/Assets.d.mts

@@ -0,0 +1,3 @@
+type Assets = Record<string, Record<string, string>>;
+
+export type { Assets as default };

package/dist/types/Assets.d.ts

@@ -0,0 +1,3 @@
+type Assets = Record<string, Record<string, string>>;
+
+export type { Assets as default };

package/dist/types/Assets.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Assets_exports = {};
+module.exports = __toCommonJS(Assets_exports);

package/dist/types/LoconContext.d.mts

@@ -0,0 +1,12 @@
+import Assets from './Assets.mjs';
+
+interface LoconContext {
+    l: (assetKey: string) => string;
+    assets: Assets;
+    currentLocale: string;
+    defaultLocale: string;
+    autodetect: boolean;
+    setLocale: (locale: string) => void;
+}
+
+export type { LoconContext as default };

package/dist/types/LoconContext.d.ts

@@ -0,0 +1,12 @@
+import Assets from './Assets.js';
+
+interface LoconContext {
+    l: (assetKey: string) => string;
+    assets: Assets;
+    currentLocale: string;
+    defaultLocale: string;
+    autodetect: boolean;
+    setLocale: (locale: string) => void;
+}
+
+export type { LoconContext as default };

package/dist/types/LoconContext.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var LoconContext_exports = {};
+module.exports = __toCommonJS(LoconContext_exports);

package/dist/utils/getSystemLanguage.d.mts

@@ -0,0 +1,7 @@
+/**
+ * Detects the system language and returns the best matching available locale.
+ * Uses react-native-localize if available, otherwise falls back to native APIs.
+ */
+declare function getSystemLanguage(availableLocales?: string[]): string | null;
+
+export { getSystemLanguage as default };

package/dist/utils/getSystemLanguage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Detects the system language and returns the best matching available locale.
+ * Uses react-native-localize if available, otherwise falls back to native APIs.
+ */
+declare function getSystemLanguage(availableLocales?: string[]): string | null;
+
+export { getSystemLanguage as default };

package/dist/utils/getSystemLanguage.js

@@ -0,0 +1,125 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getSystemLanguage_exports = {};
+__export(getSystemLanguage_exports, {
+  default: () => getSystemLanguage_default
+});
+module.exports = __toCommonJS(getSystemLanguage_exports);
+function getSystemLanguage(availableLocales) {
+  if (!availableLocales?.length) return null;
+  try {
+    try {
+      const RNLocalize = require("react-native-localize");
+      if (typeof RNLocalize.findBestLanguageTag === "function") {
+        const best = RNLocalize.findBestLanguageTag(availableLocales);
+        if (best?.languageTag) {
+          const { languageTag } = best;
+          const languageCode = languageTag.split("-")[0]?.toLowerCase();
+          if (availableLocales.includes(languageTag)) {
+            return languageTag;
+          }
+          if (languageCode && availableLocales.includes(languageCode)) {
+            return languageCode;
+          }
+        }
+      }
+      if (typeof RNLocalize.getLocales === "function") {
+        const locales = RNLocalize.getLocales();
+        const matchedLocale = locales.find((locale) => {
+          const languageCode = locale.languageCode.toLowerCase();
+          if (languageCode && availableLocales.includes(languageCode)) {
+            return true;
+          }
+          if (locale.languageTag) {
+            const tagCode = locale.languageTag.split("-")[0]?.toLowerCase();
+            if (tagCode && availableLocales.includes(tagCode)) {
+              return true;
+            }
+          }
+          return false;
+        });
+        if (matchedLocale) {
+          const languageCode = matchedLocale.languageCode.toLowerCase();
+          if (availableLocales.includes(languageCode)) {
+            return languageCode;
+          }
+          if (matchedLocale.languageTag) {
+            const tagCode = matchedLocale.languageTag.split("-")[0]?.toLowerCase();
+            if (tagCode && availableLocales.includes(tagCode)) {
+              return tagCode;
+            }
+          }
+        }
+      }
+    } catch (localizeError) {
+      console.warn("[locon] \u274C react-native-localize error:", localizeError);
+    }
+    try {
+      const { NativeModules, Platform } = require("react-native");
+      if (Platform.OS === "ios") {
+        const { SettingsManager } = NativeModules;
+        if (SettingsManager?.settings?.AppleLanguages) {
+          const appleLanguages = SettingsManager.settings.AppleLanguages;
+          const supportedLanguage = appleLanguages.map((lang) => lang.split("-")[0]?.toLowerCase()).filter((languageCode) => Boolean(languageCode)).find((languageCode) => availableLocales.includes(languageCode));
+          if (supportedLanguage) {
+            return supportedLanguage;
+          }
+        }
+        const { I18nManager } = NativeModules;
+        if (I18nManager?.localeIdentifier) {
+          const languageCode = I18nManager.localeIdentifier.split("-")[0]?.toLowerCase();
+          if (languageCode) {
+            const supportedLanguage = availableLocales.find((locale) => locale === languageCode);
+            if (supportedLanguage) {
+              return supportedLanguage;
+            }
+          }
+        }
+      } else if (Platform.OS === "android") {
+        const { I18nManager } = NativeModules;
+        if (I18nManager?.localeIdentifier) {
+          const languageCode = I18nManager.localeIdentifier.split("-")[0]?.toLowerCase();
+          if (languageCode) {
+            const supportedLanguage = availableLocales.find((locale) => locale === languageCode);
+            if (supportedLanguage) {
+              return supportedLanguage;
+            }
+          }
+        }
+      }
+    } catch (rnError) {
+      console.warn("[locon] \u274C react-native error:", rnError);
+    }
+    const systemLocale = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (systemLocale) {
+      const languageCode = systemLocale.split("-")[0]?.toLowerCase();
+      if (languageCode) {
+        const supportedLanguage = availableLocales.find((locale) => locale === languageCode);
+        if (supportedLanguage) {
+          return supportedLanguage;
+        }
+      }
+    }
+    return null;
+  } catch (error) {
+    console.warn("[locon] \u274C Could not detect system language:", error);
+    return null;
+  }
+}
+var getSystemLanguage_default = getSystemLanguage;

package/dist/utils/getSystemLanguage.mjs

@@ -0,0 +1,105 @@
+function getSystemLanguage(availableLocales) {
+  if (!availableLocales?.length) return null;
+  try {
+    try {
+      const RNLocalize = require("react-native-localize");
+      if (typeof RNLocalize.findBestLanguageTag === "function") {
+        const best = RNLocalize.findBestLanguageTag(availableLocales);
+        if (best?.languageTag) {
+          const { languageTag } = best;
+          const languageCode = languageTag.split("-")[0]?.toLowerCase();
+          if (availableLocales.includes(languageTag)) {
+            return languageTag;
+          }
+          if (languageCode && availableLocales.includes(languageCode)) {
+            return languageCode;
+          }
+        }
+      }
+      if (typeof RNLocalize.getLocales === "function") {
+        const locales = RNLocalize.getLocales();
+        const matchedLocale = locales.find((locale) => {
+          const languageCode = locale.languageCode.toLowerCase();
+          if (languageCode && availableLocales.includes(languageCode)) {
+            return true;
+          }
+          if (locale.languageTag) {
+            const tagCode = locale.languageTag.split("-")[0]?.toLowerCase();
+            if (tagCode && availableLocales.includes(tagCode)) {
+              return true;
+            }
+          }
+          return false;
+        });
+        if (matchedLocale) {
+          const languageCode = matchedLocale.languageCode.toLowerCase();
+          if (availableLocales.includes(languageCode)) {
+            return languageCode;
+          }
+          if (matchedLocale.languageTag) {
+            const tagCode = matchedLocale.languageTag.split("-")[0]?.toLowerCase();
+            if (tagCode && availableLocales.includes(tagCode)) {
+              return tagCode;
+            }
+          }
+        }
+      }
+    } catch (localizeError) {
+      console.warn("[locon] \u274C react-native-localize error:", localizeError);
+    }
+    try {
+      const { NativeModules, Platform } = require("react-native");
+      if (Platform.OS === "ios") {
+        const { SettingsManager } = NativeModules;
+        if (SettingsManager?.settings?.AppleLanguages) {
+          const appleLanguages = SettingsManager.settings.AppleLanguages;
+          const supportedLanguage = appleLanguages.map((lang) => lang.split("-")[0]?.toLowerCase()).filter((languageCode) => Boolean(languageCode)).find((languageCode) => availableLocales.includes(languageCode));
+          if (supportedLanguage) {
+            return supportedLanguage;
+          }
+        }
+        const { I18nManager } = NativeModules;
+        if (I18nManager?.localeIdentifier) {
+          const languageCode = I18nManager.localeIdentifier.split("-")[0]?.toLowerCase();
+          if (languageCode) {
+            const supportedLanguage = availableLocales.find((locale) => locale === languageCode);
+            if (supportedLanguage) {
+              return supportedLanguage;
+            }
+          }
+        }
+      } else if (Platform.OS === "android") {
+        const { I18nManager } = NativeModules;
+        if (I18nManager?.localeIdentifier) {
+          const languageCode = I18nManager.localeIdentifier.split("-")[0]?.toLowerCase();
+          if (languageCode) {
+            const supportedLanguage = availableLocales.find((locale) => locale === languageCode);
+            if (supportedLanguage) {
+              return supportedLanguage;
+            }
+          }
+        }
+      }
+    } catch (rnError) {
+      console.warn("[locon] \u274C react-native error:", rnError);
+    }
+    const systemLocale = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (systemLocale) {
+      const languageCode = systemLocale.split("-")[0]?.toLowerCase();
+      if (languageCode) {
+        const supportedLanguage = availableLocales.find((locale) => locale === languageCode);
+        if (supportedLanguage) {
+          return supportedLanguage;
+        }
+      }
+    }
+    return null;
+  } catch (error) {
+    console.warn("[locon] \u274C Could not detect system language:", error);
+    return null;
+  }
+}
+var getSystemLanguage_default = getSystemLanguage;
+export {
+  getSystemLanguage_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "locon",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "locon is a simple and lightweight library for React Native that provides a simple way to manage translations in your app.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",