@hua-labs/i18n-core 2.1.0 → 2.2.1

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { validateI18nConfig, Translator } from './chunk-EZL5TNH5.mjs';
-export { Translator, serverTranslate, ssrTranslate } from './chunk-EZL5TNH5.mjs';
+import { validateI18nConfig, webPlatformAdapter, Translator } from './chunk-4IYWT7MS.mjs';
+export { Translator, headlessPlatformAdapter, serverTranslate, ssrTranslate, webPlatformAdapter } from './chunk-4IYWT7MS.mjs';
 import React, { createContext, useState, useEffect, useMemo, useCallback, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
@@ -208,11 +208,12 @@ function resolveInitialLanguage(config) {
   if (config.defaultLanguage) {
     return config.defaultLanguage;
   }
-  if (typeof window !== "undefined" && navigator?.language) {
-    const browserLang = navigator.language.slice(0, 2).toLowerCase();
+  const adapter = config.platformAdapter ?? webPlatformAdapter;
+  const deviceLang = adapter.getDeviceLanguage();
+  if (deviceLang) {
     const supportedCodes = config.supportedLanguages?.map((l) => l.code) ?? [];
-    if (supportedCodes.includes(browserLang)) {
-      return browserLang;
+    if (supportedCodes.includes(deviceLang)) {
+      return deviceLang;
     }
   }
   return config.supportedLanguages?.[0]?.code ?? "ko";
@@ -221,7 +222,9 @@ function I18nProvider({
   config,
   children
 }) {
-  const [currentLanguage, setCurrentLanguageState] = useState(() => resolveInitialLanguage(config));
+  const [currentLanguage, setCurrentLanguageState] = useState(
+    () => resolveInitialLanguage(config)
+  );
   const [isLoading, setIsLoading] = useState(true);
   const [isInitialized, setIsInitialized] = useState(false);
   const [error, setError] = useState(null);
@@ -242,7 +245,9 @@ function I18nProvider({
       const translatorLang = translator.getCurrentLanguage();
       if (translatorLang !== currentLanguage) {
         if (config.debug) {
-          console.log(`\u{1F504} [USEI18N] Syncing translator language: ${translatorLang} -> ${currentLanguage} (already initialized)`);
+          console.log(
+            `\u{1F504} [USEI18N] Syncing translator language: ${translatorLang} -> ${currentLanguage} (already initialized)`
+          );
         }
         translator.setLanguage(currentLanguage);
       }
@@ -267,13 +272,18 @@ function I18nProvider({
         await translator.initialize();
         setIsInitialized(true);
         if (config.debug) {
-          console.log("\u2705 [USEI18N] Translator initialization completed successfully");
+          console.log(
+            "\u2705 [USEI18N] Translator initialization completed successfully"
+          );
         }
       } catch (err) {
         const initError = err;
         setError(initError);
         if (config.debug) {
-          console.error("\u274C [USEI18N] Failed to initialize translator:", initError);
+          console.error(
+            "\u274C [USEI18N] Failed to initialize translator:",
+            initError
+          );
         }
         setIsInitialized(true);
       } finally {
@@ -301,7 +311,9 @@ function I18nProvider({
     const unsubscribe = translator.onLanguageChanged((newLanguage) => {
       if (newLanguage !== currentLanguage) {
         if (config.debug) {
-          console.log(`\u{1F504} [USEI18N] Language changed event: ${currentLanguage} -> ${newLanguage}`);
+          console.log(
+            `\u{1F504} [USEI18N] Language changed event: ${currentLanguage} -> ${newLanguage}`
+          );
         }
         setCurrentLanguageState(newLanguage);
         setTranslationVersion((prev) => prev + 1);
@@ -310,57 +322,59 @@ function I18nProvider({
     return unsubscribe;
   }, [translator, isInitialized, currentLanguage, config.debug]);
   useEffect(() => {
-    if (!config.autoLanguageSync || typeof window === "undefined") {
+    if (!config.autoLanguageSync) {
       return;
     }
-    const handleLanguageChange = (event) => {
-      const newLanguage = event.detail;
-      if (typeof newLanguage === "string" && newLanguage !== currentLanguage) {
+    const adapter = config.platformAdapter ?? webPlatformAdapter;
+    return adapter.onLanguageChange((newLanguage) => {
+      if (newLanguage !== currentLanguage) {
         if (config.debug) {
           console.log("\u{1F310} Auto language sync:", newLanguage);
         }
         setLanguage(newLanguage);
       }
-    };
-    window.addEventListener("huaI18nLanguageChange", handleLanguageChange);
-    window.addEventListener("i18nLanguageChanged", handleLanguageChange);
-    return () => {
-      window.removeEventListener("huaI18nLanguageChange", handleLanguageChange);
-      window.removeEventListener("i18nLanguageChanged", handleLanguageChange);
-    };
-  }, [config.autoLanguageSync, currentLanguage]);
-  const setLanguage = useCallback(async (language) => {
-    if (!translator) {
-      return;
-    }
-    const currentLang = translator.getCurrentLanguage();
-    if (currentLang === language) {
-      if (config.debug) {
-        console.log(`\u23ED\uFE0F [USEI18N] Language unchanged, skipping: ${language}`);
-      }
-      return;
-    }
-    if (config.debug) {
-      if (config.debug) {
-        console.log(`\u{1F504} [USEI18N] setLanguage called: ${currentLang} -> ${language}`);
+    });
+  }, [config.autoLanguageSync, config.platformAdapter, currentLanguage]);
+  const setLanguage = useCallback(
+    async (language) => {
+      if (!translator) {
+        return;
+      }
+      const currentLang = translator.getCurrentLanguage();
+      if (currentLang === language) {
+        if (config.debug) {
+          console.log(`\u23ED\uFE0F [USEI18N] Language unchanged, skipping: ${language}`);
+        }
+        return;
       }
-    }
-    setIsLoading(true);
-    try {
-      translator.setLanguage(language);
-      setCurrentLanguageState(language);
-      await new Promise((resolve) => setTimeout(resolve, 0));
       if (config.debug) {
-        console.log(`\u2705 [USEI18N] Language changed to ${language}`);
+        if (config.debug) {
+          console.log(
+            `\u{1F504} [USEI18N] setLanguage called: ${currentLang} -> ${language}`
+          );
+        }
       }
-    } catch (error2) {
-      if (config.debug) {
-        console.error(`\u274C [USEI18N] Failed to change language to ${language}:`, error2);
+      setIsLoading(true);
+      try {
+        translator.setLanguage(language);
+        setCurrentLanguageState(language);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        if (config.debug) {
+          console.log(`\u2705 [USEI18N] Language changed to ${language}`);
+        }
+      } catch (error2) {
+        if (config.debug) {
+          console.error(
+            `\u274C [USEI18N] Failed to change language to ${language}:`,
+            error2
+          );
+        }
+      } finally {
+        setIsLoading(false);
       }
-    } finally {
-      setIsLoading(false);
-    }
-  }, [translator, config.debug]);
+    },
+    [translator, config.debug]
+  );
   const parseKey = useCallback((key) => {
     const parts = key.split(":");
     if (parts.length >= 2) {
@@ -368,246 +382,336 @@ function I18nProvider({
     }
     return { namespace: "common", key };
   }, []);
-  const resolveNestedKey = useCallback((obj, key) => {
-    if (key in obj && typeof obj[key] === "string") {
-      return obj[key];
-    }
-    const parts = key.split(".");
-    let current = obj;
-    for (const part of parts) {
-      if (current && typeof current === "object" && current !== null && part in current) {
-        current = current[part];
-      } else {
-        return null;
+  const resolveNestedKey = useCallback(
+    (obj, key) => {
+      if (key in obj && typeof obj[key] === "string") {
+        return obj[key];
+      }
+      const parts = key.split(".");
+      let current = obj;
+      for (const part of parts) {
+        if (current && typeof current === "object" && current !== null && part in current) {
+          current = current[part];
+        } else {
+          return null;
+        }
       }
-    }
-    return typeof current === "string" ? current : null;
-  }, []);
-  const findInSSRTranslations = useCallback((key, targetLang) => {
-    if (!config.initialTranslations) {
-      return null;
-    }
-    const { namespace, key: actualKey } = parseKey(key);
-    const ssrTranslations = config.initialTranslations[targetLang]?.[namespace];
-    if (ssrTranslations) {
-      const value2 = resolveNestedKey(ssrTranslations, actualKey);
-      if (value2 !== null) {
-        return value2;
+      return typeof current === "string" ? current : null;
+    },
+    []
+  );
+  const findInSSRTranslations = useCallback(
+    (key, targetLang) => {
+      if (!config.initialTranslations) {
+        return null;
       }
-    }
-    const fallbackLang = config.fallbackLanguage || "en";
-    if (targetLang !== fallbackLang) {
-      const fallbackTranslations = config.initialTranslations[fallbackLang]?.[namespace];
-      if (fallbackTranslations) {
-        const value2 = resolveNestedKey(fallbackTranslations, actualKey);
+      const { namespace, key: actualKey } = parseKey(key);
+      const ssrTranslations = config.initialTranslations[targetLang]?.[namespace];
+      if (ssrTranslations) {
+        const value2 = resolveNestedKey(
+          ssrTranslations,
+          actualKey
+        );
         if (value2 !== null) {
           return value2;
         }
       }
-    }
-    return null;
-  }, [config.initialTranslations, config.fallbackLanguage, parseKey, resolveNestedKey]);
-  const findInDefaultTranslations = useCallback((key, targetLang) => {
-    const { namespace, key: actualKey } = parseKey(key);
-    const defaultTranslations = getDefaultTranslations(targetLang, namespace);
-    const fallbackTranslations = getDefaultTranslations(config.fallbackLanguage || "en", namespace);
-    return resolveNestedKey(defaultTranslations, actualKey) || resolveNestedKey(fallbackTranslations, actualKey) || null;
-  }, [config.fallbackLanguage, parseKey, resolveNestedKey]);
-  const t = useCallback((key, paramsOrLang, language) => {
-    if (!translator) {
-      return key;
-    }
-    let params;
-    let lang;
-    if (typeof paramsOrLang === "string") {
-      lang = paramsOrLang;
-    } else if (typeof paramsOrLang === "object" && paramsOrLang !== null) {
-      params = paramsOrLang;
-      lang = language;
-    }
-    const targetLang = lang || currentLanguage;
-    try {
-      const result = translator.translate(key, params || lang, params ? lang : void 0);
-      if (result && result !== key && result !== "") {
-        return result;
+      const fallbackLang = config.fallbackLanguage || "en";
+      if (targetLang !== fallbackLang) {
+        const fallbackTranslations = config.initialTranslations[fallbackLang]?.[namespace];
+        if (fallbackTranslations) {
+          const value2 = resolveNestedKey(
+            fallbackTranslations,
+            actualKey
+          );
+          if (value2 !== null) {
+            return value2;
+          }
+        }
       }
-    } catch (error2) {
-    }
-    const interpolate = (text) => {
-      if (!params) return text;
-      return text.replace(/\{\{(\w+)\}\}/g, (match, k) => {
-        const value2 = params[k];
-        return value2 !== void 0 ? String(value2) : match;
-      });
-    };
-    const ssrResult = findInSSRTranslations(key, targetLang);
-    if (ssrResult) {
-      return interpolate(ssrResult);
-    }
-    const defaultResult = findInDefaultTranslations(key, targetLang);
-    if (defaultResult) {
-      return interpolate(defaultResult);
-    }
-    if (config.debug) {
-      return interpolate(key);
-    }
-    return "";
-  }, [translator, config.debug, currentLanguage, config.fallbackLanguage, translationVersion, findInSSRTranslations, findInDefaultTranslations]);
-  const tAsync = useCallback(async (key, params) => {
-    if (!translator) {
-      if (config.debug) {
-        console.warn("Translator not initialized");
+      return null;
+    },
+    [
+      config.initialTranslations,
+      config.fallbackLanguage,
+      parseKey,
+      resolveNestedKey
+    ]
+  );
+  const findInDefaultTranslations = useCallback(
+    (key, targetLang) => {
+      const { namespace, key: actualKey } = parseKey(key);
+      const defaultTranslations = getDefaultTranslations(targetLang, namespace);
+      const fallbackTranslations = getDefaultTranslations(
+        config.fallbackLanguage || "en",
+        namespace
+      );
+      return resolveNestedKey(
+        defaultTranslations,
+        actualKey
+      ) || resolveNestedKey(
+        fallbackTranslations,
+        actualKey
+      ) || null;
+    },
+    [config.fallbackLanguage, parseKey, resolveNestedKey]
+  );
+  const t = useCallback(
+    (key, paramsOrLang, language) => {
+      if (!translator) {
+        return key;
+      }
+      let params;
+      let lang;
+      if (typeof paramsOrLang === "string") {
+        lang = paramsOrLang;
+      } else if (typeof paramsOrLang === "object" && paramsOrLang !== null) {
+        params = paramsOrLang;
+        lang = language;
+      }
+      const targetLang = lang || currentLanguage;
+      try {
+        const result = translator.translate(
+          key,
+          params || lang,
+          params ? lang : void 0
+        );
+        if (result && result !== key && result !== "") {
+          return result;
+        }
+      } catch (error2) {
       }
-      return key;
-    }
-    setIsLoading(true);
-    try {
-      const result = await translator.translateAsync(key, params);
-      return result;
-    } catch (error2) {
-      if (config.debug) {
-        console.error("Translation error:", error2);
+      const interpolate = (text) => {
+        if (!params) return text;
+        return text.replace(/\{\{(\w+)\}\}/g, (match, k) => {
+          const value2 = params[k];
+          return value2 !== void 0 ? String(value2) : match;
+        });
+      };
+      const ssrResult = findInSSRTranslations(key, targetLang);
+      if (ssrResult) {
+        return interpolate(ssrResult);
       }
-      return key;
-    } finally {
-      setIsLoading(false);
-    }
-  }, [translator, config.debug]);
-  const tSync = useCallback((key, namespace, params) => {
-    if (!translator) {
-      if (config.debug) {
-        console.warn("Translator not initialized");
+      const defaultResult = findInDefaultTranslations(key, targetLang);
+      if (defaultResult) {
+        return interpolate(defaultResult);
       }
-      return key;
-    }
-    return translator.translateSync(key, params);
-  }, [translator, config.debug]);
-  const getRawValue = useCallback((key, language) => {
-    if (!translator || !isInitialized) {
-      return void 0;
-    }
-    return translator.getRawValue(key, language);
-  }, [translator, isInitialized]);
-  const tArray = useCallback((key, language) => {
-    if (!translator || !isInitialized) {
-      return [];
-    }
-    return translator.tArray(key, language);
-  }, [translator, isInitialized, translationVersion, currentLanguage]);
-  const tPlural = useCallback((key, count, params, language) => {
-    if (!translator || !isInitialized) {
-      return key;
-    }
-    return translator.tPlural(key, count, params, language);
-  }, [translator, isInitialized, translationVersion, currentLanguage]);
-  const debug = useMemo(() => ({
-    getCurrentLanguage: () => {
-      try {
-        return translator?.getCurrentLanguage() || currentLanguage;
-      } catch {
-        return currentLanguage;
+      if (typeof paramsOrLang === "object" && paramsOrLang !== null && "defaultValue" in paramsOrLang && typeof paramsOrLang.defaultValue === "string") {
+        return interpolate(paramsOrLang.defaultValue);
       }
-    },
-    getSupportedLanguages: () => {
-      try {
-        return translator?.getSupportedLanguages() || config.supportedLanguages?.map((l) => l.code) || [];
-      } catch {
-        return config.supportedLanguages?.map((l) => l.code) || [];
+      if (config.debug) {
+        return interpolate(key);
       }
+      return "";
     },
-    getLoadedNamespaces: () => {
-      try {
-        const debugInfo = translator?.debug();
-        if (debugInfo && debugInfo.loadedNamespaces) {
-          return Array.from(debugInfo.loadedNamespaces);
-        }
-        if (debugInfo && debugInfo.allTranslations) {
-          const namespaces = /* @__PURE__ */ new Set();
-          Object.values(debugInfo.allTranslations).forEach((langData) => {
-            if (langData && typeof langData === "object") {
-              Object.keys(langData).forEach((namespace) => {
-                namespaces.add(namespace);
-              });
-            }
-          });
-          return Array.from(namespaces);
+    [
+      translator,
+      config.debug,
+      currentLanguage,
+      config.fallbackLanguage,
+      translationVersion,
+      findInSSRTranslations,
+      findInDefaultTranslations
+    ]
+  );
+  const tAsync = useCallback(
+    async (key, params) => {
+      if (!translator) {
+        if (config.debug) {
+          console.warn("Translator not initialized");
         }
-        return [];
-      } catch (error2) {
-        return [];
+        return key;
       }
-    },
-    getAllTranslations: () => {
+      setIsLoading(true);
       try {
-        return translator?.debug()?.allTranslations || {};
+        const result = await translator.translateAsync(key, params);
+        return result;
       } catch (error2) {
-        return {};
+        if (config.debug) {
+          console.error("Translation error:", error2);
+        }
+        return key;
+      } finally {
+        setIsLoading(false);
       }
     },
-    isReady: () => {
-      try {
-        return translator?.isReady() || isInitialized;
-      } catch {
-        return isInitialized;
+    [translator, config.debug]
+  );
+  const tSync = useCallback(
+    (key, namespace, params) => {
+      if (!translator) {
+        if (config.debug) {
+          console.warn("Translator not initialized");
+        }
+        return key;
       }
+      return translator.translateSync(key, params);
     },
-    getInitializationError: () => {
-      try {
-        return translator?.getInitializationError() || error;
-      } catch {
-        return error;
-      }
+    [translator, config.debug]
+  );
+  const getRawValue = useCallback(
+    (key, language) => {
+      if (!translator || !isInitialized) {
+        return void 0;
+      }
+      return translator.getRawValue(key, language);
     },
-    clearCache: () => {
-      try {
-        translator?.clearCache();
-      } catch {
+    [translator, isInitialized]
+  );
+  const tArray = useCallback(
+    (key, language) => {
+      if (!translator || !isInitialized) {
+        return [];
       }
+      return translator.tArray(key, language);
     },
-    getCacheStats: () => {
-      try {
-        const debugInfo = translator?.debug();
-        if (debugInfo && debugInfo.cacheStats) {
-          return {
-            size: debugInfo.cacheSize || 0,
-            hits: debugInfo.cacheStats.hits || 0,
-            misses: debugInfo.cacheStats.misses || 0
-          };
-        }
-        return { size: 0, hits: 0, misses: 0 };
-      } catch (error2) {
-        return { size: 0, hits: 0, misses: 0 };
-      }
+    [translator, isInitialized, translationVersion, currentLanguage]
+  );
+  const tPlural = useCallback(
+    (key, count, params, language) => {
+      if (!translator || !isInitialized) {
+        return key;
+      }
+      return translator.tPlural(key, count, params, language);
     },
-    reloadTranslations: async () => {
-      if (translator) {
-        setIsLoading(true);
-        setError(null);
+    [translator, isInitialized, translationVersion, currentLanguage]
+  );
+  const debug = useMemo(
+    () => ({
+      getCurrentLanguage: () => {
+        try {
+          return translator?.getCurrentLanguage() || currentLanguage;
+        } catch {
+          return currentLanguage;
+        }
+      },
+      getSupportedLanguages: () => {
         try {
-          await translator.initialize();
-        } catch (err) {
-          setError(err);
-        } finally {
-          setIsLoading(false);
+          return translator?.getSupportedLanguages() || config.supportedLanguages?.map((l) => l.code) || [];
+        } catch {
+          return config.supportedLanguages?.map((l) => l.code) || [];
+        }
+      },
+      getLoadedNamespaces: () => {
+        try {
+          const debugInfo = translator?.debug();
+          if (debugInfo && debugInfo.loadedNamespaces) {
+            return Array.from(debugInfo.loadedNamespaces);
+          }
+          if (debugInfo && debugInfo.allTranslations) {
+            const namespaces = /* @__PURE__ */ new Set();
+            Object.values(debugInfo.allTranslations).forEach(
+              (langData) => {
+                if (langData && typeof langData === "object") {
+                  Object.keys(langData).forEach((namespace) => {
+                    namespaces.add(namespace);
+                  });
+                }
+              }
+            );
+            return Array.from(namespaces);
+          }
+          return [];
+        } catch (error2) {
+          return [];
+        }
+      },
+      getAllTranslations: () => {
+        try {
+          return translator?.debug()?.allTranslations || {};
+        } catch (error2) {
+          return {};
+        }
+      },
+      isReady: () => {
+        try {
+          return translator?.isReady() || isInitialized;
+        } catch {
+          return isInitialized;
+        }
+      },
+      getInitializationError: () => {
+        try {
+          return translator?.getInitializationError() || error;
+        } catch {
+          return error;
+        }
+      },
+      clearCache: () => {
+        try {
+          translator?.clearCache();
+        } catch {
+        }
+      },
+      getCacheStats: () => {
+        try {
+          const debugInfo = translator?.debug();
+          if (debugInfo && debugInfo.cacheStats) {
+            return {
+              size: debugInfo.cacheSize || 0,
+              hits: debugInfo.cacheStats.hits || 0,
+              misses: debugInfo.cacheStats.misses || 0
+            };
+          }
+          return { size: 0, hits: 0, misses: 0 };
+        } catch (error2) {
+          return { size: 0, hits: 0, misses: 0 };
+        }
+      },
+      reloadTranslations: async () => {
+        if (translator) {
+          setIsLoading(true);
+          setError(null);
+          try {
+            await translator.initialize();
+          } catch (err) {
+            setError(err);
+          } finally {
+            setIsLoading(false);
+          }
         }
       }
-    }
-  }), [translator, currentLanguage, error, isInitialized, config.supportedLanguages]);
-  const value = useMemo(() => ({
-    currentLanguage,
-    setLanguage,
-    t,
-    tPlural,
-    tArray,
-    tAsync,
-    tSync,
-    getRawValue,
-    isLoading,
-    error,
-    supportedLanguages: config.supportedLanguages,
-    debug,
-    isInitialized
-  }), [currentLanguage, setLanguage, t, tPlural, tArray, tAsync, tSync, getRawValue, isLoading, error, config.supportedLanguages, debug, isInitialized]);
+    }),
+    [
+      translator,
+      currentLanguage,
+      error,
+      isInitialized,
+      config.supportedLanguages
+    ]
+  );
+  const value = useMemo(
+    () => ({
+      currentLanguage,
+      setLanguage,
+      t,
+      tPlural,
+      tArray,
+      tAsync,
+      tSync,
+      getRawValue,
+      isLoading,
+      error,
+      supportedLanguages: config.supportedLanguages,
+      debug,
+      isInitialized
+    }),
+    [
+      currentLanguage,
+      setLanguage,
+      t,
+      tPlural,
+      tArray,
+      tAsync,
+      tSync,
+      getRawValue,
+      isLoading,
+      error,
+      config.supportedLanguages,
+      debug,
+      isInitialized
+    ]
+  );
   return /* @__PURE__ */ jsx(I18nContext.Provider, { value, children });
 }
 function useI18n() {
@@ -617,7 +721,12 @@ function useI18n() {
       currentLanguage: "ko",
       setLanguage: () => {
       },
-      t: (key) => key,
+      t: (key, paramsOrLang) => {
+        if (typeof paramsOrLang === "object" && paramsOrLang !== null && "defaultValue" in paramsOrLang && typeof paramsOrLang.defaultValue === "string") {
+          return paramsOrLang.defaultValue;
+        }
+        return key;
+      },
       tPlural: (key) => key,
       tAsync: async (key) => key,
       tSync: (key) => key,