@hua-labs/i18n-core 2.2.0 → 2.2.1

package/dist/index.cjs

@@ -10,9 +10,17 @@ var React__default = /*#__PURE__*/_interopDefault(React);
 // src/index.ts
 
 // src/types/index.ts
-var PLURAL_CATEGORIES = /* @__PURE__ */ new Set(["zero", "one", "two", "few", "many", "other"]);
+var PLURAL_CATEGORIES = /* @__PURE__ */ new Set([
+  "zero",
+  "one",
+  "two",
+  "few",
+  "many",
+  "other"
+]);
 function isPluralValue(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
   const obj = value;
   const keys = Object.keys(obj);
   return keys.length > 0 && keys.every((k) => PLURAL_CATEGORIES.has(k)) && Object.values(obj).every((v) => typeof v === "string") && typeof obj.other === "string";
@@ -110,7 +118,9 @@ var Translator = class {
     this.currentLang = config.defaultLanguage;
     if (config.initialTranslations) {
       this.allTranslations = config.initialTranslations;
-      for (const [language, namespaces] of Object.entries(config.initialTranslations)) {
+      for (const [language, namespaces] of Object.entries(
+        config.initialTranslations
+      )) {
         for (const namespace of Object.keys(namespaces)) {
           this.loadedNamespaces.add(`${language}:${namespace}`);
         }
@@ -208,9 +218,15 @@ var Translator = class {
         }
       }
       if (this.config.debug) {
-        console.log("\u{1F30D} [TRANSLATOR] Initializing translator with languages:", languages);
+        console.log(
+          "\u{1F30D} [TRANSLATOR] Initializing translator with languages:",
+          languages
+        );
         console.log("\u{1F4CD} [TRANSLATOR] Current language:", this.currentLang);
-        console.log("\u{1F4E6} [TRANSLATOR] Config namespaces:", this.config.namespaces);
+        console.log(
+          "\u{1F4E6} [TRANSLATOR] Config namespaces:",
+          this.config.namespaces
+        );
       }
       for (const language of languages) {
         if (this.config.debug) {
@@ -223,12 +239,23 @@ var Translator = class {
           const cacheKey = `${language}:${namespace}`;
           if (skipNamespaces.has(cacheKey)) {
             if (this.config.debug) {
-              console.log("\u23ED\uFE0F [TRANSLATOR] Skipping", namespace, "for", language, "(already loaded from SSR)");
+              console.log(
+                "\u23ED\uFE0F [TRANSLATOR] Skipping",
+                namespace,
+                "for",
+                language,
+                "(already loaded from SSR)"
+              );
             }
             continue;
           }
           if (this.config.debug) {
-            console.log("Loading namespace:", namespace, "for language:", language);
+            console.log(
+              "Loading namespace:",
+              namespace,
+              "for language:",
+              language
+            );
           }
           try {
             const data = await this.safeLoadTranslations(language, namespace);
@@ -248,7 +275,10 @@ var Translator = class {
             if (isRecoverableError(translationError)) {
               if (language !== this.config.fallbackLanguage) {
                 try {
-                  const fallbackData = await this.safeLoadTranslations(this.config.fallbackLanguage || "en", namespace);
+                  const fallbackData = await this.safeLoadTranslations(
+                    this.config.fallbackLanguage || "en",
+                    namespace
+                  );
                   this.allTranslations[language][namespace] = fallbackData;
                   this.loadedNamespaces.add(`${language}:${namespace}`);
                   if (this.config.debug) {
@@ -286,7 +316,9 @@ var Translator = class {
       this.logError(this.initializationError);
       this.isInitialized = true;
       if (this.config.debug) {
-        console.warn("Translator initialized with errors, using fallback translations");
+        console.warn(
+          "Translator initialized with errors, using fallback translations"
+        );
       }
     }
   }
@@ -301,7 +333,10 @@ var Translator = class {
     const result = this.findInNamespace(namespace, actualKey, targetLang);
     if (result) {
       if (this.config.debug) {
-        console.log(`\u2705 [TRANSLATOR] Found fallback translation from initialTranslations:`, result);
+        console.log(
+          `\u2705 [TRANSLATOR] Found fallback translation from initialTranslations:`,
+          result
+        );
       }
       return result;
     }
@@ -365,10 +400,17 @@ var Translator = class {
     }
     if (!this.isInitialized) {
       const raw = this.translateBeforeInitialized(key, targetLang);
+      if ((!raw || raw === key) && params && typeof params === "object" && "defaultValue" in params && typeof params.defaultValue === "string") {
+        return this.interpolate(params.defaultValue, params);
+      }
       return params ? this.interpolate(raw, params) : raw;
     }
     const { namespace, key: actualKey } = this.parseKey(key);
-    let result = this.findInNamespace(namespace, actualKey, targetLang);
+    let result = this.findInNamespace(
+      namespace,
+      actualKey,
+      targetLang
+    );
     if (result) {
       this.cacheStats.hits++;
       return params ? this.interpolate(result, params) : result;
@@ -382,6 +424,9 @@ var Translator = class {
       return params ? this.interpolate(result, params) : result;
     }
     this.cacheStats.misses++;
+    if (params && typeof params === "object" && "defaultValue" in params && typeof params.defaultValue === "string") {
+      return this.interpolate(params.defaultValue, params);
+    }
     if (this.config.debug) {
       const missing = this.config.missingKeyHandler?.(key, targetLang, namespace) || key;
       return params ? this.interpolate(missing, params) : missing;
@@ -398,11 +443,16 @@ var Translator = class {
       if (!this.loadedNamespaces.has(cacheKey) && !this.loadingPromises.has(cacheKey)) {
         this.loadTranslationData(language, namespace).catch((error) => {
           if (this.config.debug) {
-            console.warn(`\u26A0\uFE0F [TRANSLATOR] Auto-load failed for ${language}/${namespace}:`, error);
+            console.warn(
+              `\u26A0\uFE0F [TRANSLATOR] Auto-load failed for ${language}/${namespace}:`,
+              error
+            );
           }
         });
         if (this.config.debug) {
-          console.warn(`\u274C [TRANSLATOR] No translations found for ${language}/${namespace}, attempting auto-load...`);
+          console.warn(
+            `\u274C [TRANSLATOR] No translations found for ${language}/${namespace}, attempting auto-load...`
+          );
         }
       }
       return "";
@@ -422,7 +472,9 @@ var Translator = class {
       return nestedValue[Math.floor(Math.random() * nestedValue.length)];
     }
     if (this.config.debug) {
-      console.warn(`\u274C [TRANSLATOR] No match found for key: ${key} in ${language}/${namespace}`);
+      console.warn(
+        `\u274C [TRANSLATOR] No match found for key: ${key} in ${language}/${namespace}`
+      );
     }
     return "";
   }
@@ -488,7 +540,10 @@ var Translator = class {
         if (actualKey in fallbackTranslations) {
           return fallbackTranslations[actualKey];
         }
-        const fallbackNestedValue = this.getNestedValue(fallbackTranslations, actualKey);
+        const fallbackNestedValue = this.getNestedValue(
+          fallbackTranslations,
+          actualKey
+        );
         if (fallbackNestedValue !== void 0) {
           return fallbackNestedValue;
         }
@@ -534,7 +589,9 @@ var Translator = class {
     const raw = this.getRawValue(key, targetLang);
     const mergedParams = { count, ...params };
     if (isPluralValue(raw)) {
-      const category = this.getPluralRules(targetLang).select(count);
+      const category = this.getPluralRules(targetLang).select(
+        count
+      );
       const text = raw[category] ?? raw.other;
       return this.interpolate(text, mergedParams);
     }
@@ -577,7 +634,9 @@ var Translator = class {
       });
     }
     if (this.config.debug) {
-      console.log(`\u{1F310} [TRANSLATOR] Language changed: ${previousLanguage} -> ${language}`);
+      console.log(
+        `\u{1F310} [TRANSLATOR] Language changed: ${previousLanguage} -> ${language}`
+      );
     }
   }
   /**
@@ -689,7 +748,11 @@ var Translator = class {
    */
   logError(error) {
     if (this.config.errorHandler) {
-      this.config.errorHandler(error, error.language || "", error.namespace || "");
+      this.config.errorHandler(
+        error,
+        error.language || "",
+        error.namespace || ""
+      );
     }
   }
   /**
@@ -712,7 +775,9 @@ var Translator = class {
         if (attempt === maxRetries) {
           break;
         }
-        await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3));
+        await new Promise(
+          (resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3)
+        );
       }
     }
     throw lastError;
@@ -722,21 +787,29 @@ var Translator = class {
    */
   async safeLoadTranslations(language, namespace) {
     if (this.config.debug) {
-      console.log(`\u{1F4E5} [TRANSLATOR] safeLoadTranslations called:`, { language, namespace });
+      console.log(`\u{1F4E5} [TRANSLATOR] safeLoadTranslations called:`, {
+        language,
+        namespace
+      });
     }
     const loadOperation = async () => {
       if (!this.config.loadTranslations) {
         throw new Error("No translation loader configured");
       }
       if (this.config.debug) {
-        console.log(`\u{1F504} [TRANSLATOR] Calling loadTranslations for:`, { language, namespace });
+        console.log(`\u{1F504} [TRANSLATOR] Calling loadTranslations for:`, {
+          language,
+          namespace
+        });
       }
       const data = await this.config.loadTranslations(language, namespace);
       if (this.config.debug) {
         console.log(`\u{1F4E6} [TRANSLATOR] loadTranslations returned:`, data);
       }
       if (!isTranslationNamespace(data)) {
-        throw new Error(`Invalid translation data for ${language}:${namespace}`);
+        throw new Error(
+          `Invalid translation data for ${language}:${namespace}`
+        );
       }
       return data;
     };
@@ -749,7 +822,10 @@ var Translator = class {
         language,
         namespace
       );
-      return this.retryOperation(loadOperation, translationError, { language, namespace });
+      return this.retryOperation(loadOperation, translationError, {
+        language,
+        namespace
+      });
     }
   }
   /**
@@ -786,35 +862,30 @@ var Translator = class {
     if (!this.isInitialized) {
       await this.initialize();
     }
-    const translated = this.translate(key);
-    if (!params) {
-      return translated;
-    }
-    return this.interpolate(translated, params);
+    return this.translate(key, params);
   }
   /**
    * 동기 번역 (고급 기능)
    */
   translateSync(key, params) {
     if (!this.isInitialized) {
+      if (params && typeof params === "object" && "defaultValue" in params && typeof params.defaultValue === "string") {
+        return this.interpolate(params.defaultValue, params);
+      }
       if (this.config.debug) {
         console.warn("Translator not initialized for sync translation");
       }
       const { namespace } = this.parseKey(key);
       return this.config.missingKeyHandler?.(key, this.currentLang, namespace) || key;
     }
-    const translated = this.translate(key);
-    if (!params) {
-      return translated;
-    }
-    return this.interpolate(translated, params);
+    return this.translate(key, params);
   }
   /**
    * 키 파싱 (네임스페이스:키 형식)
-   * 
+   *
    * - 콜론(:)만 네임스페이스 구분자로 사용
    * - 점(.)은 키 이름의 일부로 취급 (중첩 객체 접근용)
-   * 
+   *
    * @example
    * parseKey("home:hero.badge") → { namespace: "home", key: "hero.badge" }
    * parseKey("hero.badge") → { namespace: "common", key: "hero.badge" }
@@ -823,7 +894,10 @@ var Translator = class {
   parseKey(key) {
     const colonIndex = key.indexOf(":");
     if (colonIndex !== -1) {
-      return { namespace: key.substring(0, colonIndex), key: key.substring(colonIndex + 1) };
+      return {
+        namespace: key.substring(0, colonIndex),
+        key: key.substring(colonIndex + 1)
+      };
     }
     return { namespace: "common", key };
   }
@@ -862,7 +936,9 @@ var Translator = class {
       this.loadedNamespaces.add(cacheKey);
       this.setCacheEntry(cacheKey, data);
       if (this.config.debug) {
-        console.log(`\u2705 [TRANSLATOR] Auto-loaded and saved ${language}/${namespace}`);
+        console.log(
+          `\u2705 [TRANSLATOR] Auto-loaded and saved ${language}/${namespace}`
+        );
       }
       this.notifyTranslationLoaded(language, namespace);
       return data;
@@ -880,7 +956,9 @@ var Translator = class {
     try {
       const data = await this.config.loadTranslations(language, namespace);
       if (!isTranslationNamespace(data)) {
-        throw new Error(`Invalid translation data for ${language}:${namespace}`);
+        throw new Error(
+          `Invalid translation data for ${language}:${namespace}`
+        );
       }
       return data;
     } catch (error) {
@@ -903,12 +981,20 @@ function ssrTranslate({
   missingKeyHandler = (key2) => key2
 }) {
   const { namespace, key: actualKey } = parseKey(key);
-  let result = ssrFindInNamespace(translations, namespace, actualKey, language);
+  let result = ssrFindInNamespace(
+    translations,
+    namespace,
+    actualKey,
+    language);
   if (result) {
     return result;
   }
   if (language !== fallbackLanguage) {
-    result = ssrFindInNamespace(translations, namespace, actualKey, fallbackLanguage);
+    result = ssrFindInNamespace(
+      translations,
+      namespace,
+      actualKey,
+      fallbackLanguage);
     if (result) {
       return result;
     }
@@ -947,7 +1033,10 @@ function isStringValue(value) {
 function parseKey(key) {
   const colonIndex = key.indexOf(":");
   if (colonIndex !== -1) {
-    return { namespace: key.substring(0, colonIndex), key: key.substring(colonIndex + 1) };
+    return {
+      namespace: key.substring(0, colonIndex),
+      key: key.substring(colonIndex + 1)
+    };
   }
   return { namespace: "common", key };
 }
@@ -969,7 +1058,11 @@ function serverTranslate({
       return cached;
     }
   }
-  const result = findInTranslations(translations, key, language, fallbackLanguage);
+  const result = findInTranslations(
+    translations,
+    key,
+    language,
+    fallbackLanguage);
   if (cache && result) {
     const cacheKey = `${language}:${key}`;
     cache.set(cacheKey, result);
@@ -985,7 +1078,12 @@ function findInTranslations(translations, key, language, fallbackLanguage, missi
     return result;
   }
   if (language !== fallbackLanguage) {
-    result = findInNamespace(translations, namespace, actualKey, fallbackLanguage);
+    result = findInNamespace(
+      translations,
+      namespace,
+      actualKey,
+      fallbackLanguage
+    );
     if (result) {
       return result;
     }
@@ -1231,7 +1329,9 @@ function I18nProvider({
   config,
   children
 }) {
-  const [currentLanguage, setCurrentLanguageState] = React.useState(() => resolveInitialLanguage(config));
+  const [currentLanguage, setCurrentLanguageState] = React.useState(
+    () => resolveInitialLanguage(config)
+  );
   const [isLoading, setIsLoading] = React.useState(true);
   const [isInitialized, setIsInitialized] = React.useState(false);
   const [error, setError] = React.useState(null);
@@ -1252,7 +1352,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);
       }
@@ -1277,13 +1379,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 {
@@ -1311,7 +1418,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);
@@ -1333,38 +1442,46 @@ function I18nProvider({
       }
     });
   }, [config.autoLanguageSync, config.platformAdapter, currentLanguage]);
-  const setLanguage = React.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}`);
+  const setLanguage = React.useCallback(
+    async (language) => {
+      if (!translator) {
+        return;
       }
-      return;
-    }
-    if (config.debug) {
-      if (config.debug) {
-        console.log(`\u{1F504} [USEI18N] setLanguage called: ${currentLang} -> ${language}`);
+      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 parseKey2 = React.useCallback((key) => {
     const parts = key.split(":");
     if (parts.length >= 2) {
@@ -1372,246 +1489,336 @@ function I18nProvider({
     }
     return { namespace: "common", key };
   }, []);
-  const resolveNestedKey = React.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 = React.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 = React.useCallback((key, targetLang) => {
-    if (!config.initialTranslations) {
-      return null;
-    }
-    const { namespace, key: actualKey } = parseKey2(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 = React.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 } = parseKey2(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, parseKey2, resolveNestedKey]);
-  const findInDefaultTranslations = React.useCallback((key, targetLang) => {
-    const { namespace, key: actualKey } = parseKey2(key);
-    const defaultTranslations = getDefaultTranslations(targetLang, namespace);
-    const fallbackTranslations = getDefaultTranslations(config.fallbackLanguage || "en", namespace);
-    return resolveNestedKey(defaultTranslations, actualKey) || resolveNestedKey(fallbackTranslations, actualKey) || null;
-  }, [config.fallbackLanguage, parseKey2, resolveNestedKey]);
-  const t = React.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 = React.useCallback(async (key, params) => {
-    if (!translator) {
-      if (config.debug) {
-        console.warn("Translator not initialized");
+      return null;
+    },
+    [
+      config.initialTranslations,
+      config.fallbackLanguage,
+      parseKey2,
+      resolveNestedKey
+    ]
+  );
+  const findInDefaultTranslations = React.useCallback(
+    (key, targetLang) => {
+      const { namespace, key: actualKey } = parseKey2(key);
+      const defaultTranslations = getDefaultTranslations(targetLang, namespace);
+      const fallbackTranslations = getDefaultTranslations(
+        config.fallbackLanguage || "en",
+        namespace
+      );
+      return resolveNestedKey(
+        defaultTranslations,
+        actualKey
+      ) || resolveNestedKey(
+        fallbackTranslations,
+        actualKey
+      ) || null;
+    },
+    [config.fallbackLanguage, parseKey2, resolveNestedKey]
+  );
+  const t = React.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 = React.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 = React.useCallback((key, language) => {
-    if (!translator || !isInitialized) {
-      return void 0;
-    }
-    return translator.getRawValue(key, language);
-  }, [translator, isInitialized]);
-  const tArray = React.useCallback((key, language) => {
-    if (!translator || !isInitialized) {
-      return [];
-    }
-    return translator.tArray(key, language);
-  }, [translator, isInitialized, translationVersion, currentLanguage]);
-  const tPlural = React.useCallback((key, count, params, language) => {
-    if (!translator || !isInitialized) {
-      return key;
-    }
-    return translator.tPlural(key, count, params, language);
-  }, [translator, isInitialized, translationVersion, currentLanguage]);
-  const debug = React.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 = React.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 = React.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 = React.useCallback(
+    (key, language) => {
+      if (!translator || !isInitialized) {
+        return void 0;
+      }
+      return translator.getRawValue(key, language);
     },
-    clearCache: () => {
-      try {
-        translator?.clearCache();
-      } catch {
+    [translator, isInitialized]
+  );
+  const tArray = React.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 = React.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 = React.useMemo(
+    () => ({
+      getCurrentLanguage: () => {
+        try {
+          return translator?.getCurrentLanguage() || currentLanguage;
+        } catch {
+          return currentLanguage;
+        }
+      },
+      getSupportedLanguages: () => {
+        try {
+          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 {
-          await translator.initialize();
-        } catch (err) {
-          setError(err);
-        } finally {
-          setIsLoading(false);
+          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 = React.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 = React.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__ */ jsxRuntime.jsx(I18nContext.Provider, { value, children });
 }
 function useI18n() {
@@ -1621,7 +1828,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,