@hua-labs/i18n-core 2.0.0 → 2.0.4

package/dist/chunk-F4PDBJLO.mjs

@@ -0,0 +1,973 @@
+// src/types/index.ts
+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;
+  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";
+}
+function isTranslationNamespace(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isLanguageConfig(value) {
+  return typeof value === "object" && value !== null && typeof value.code === "string" && typeof value.name === "string" && typeof value.nativeName === "string";
+}
+function validateI18nConfig(config) {
+  if (!config || typeof config !== "object") {
+    return false;
+  }
+  const c = config;
+  return typeof c.defaultLanguage === "string" && Array.isArray(c.supportedLanguages) && c.supportedLanguages.every(isLanguageConfig) && typeof c.loadTranslations === "function";
+}
+function isRecoverableError(error) {
+  const recoverableCodes = [
+    "LOAD_FAILED",
+    "NETWORK_ERROR",
+    "CACHE_ERROR"
+  ];
+  return recoverableCodes.includes(error.code) && (error.retryCount || 0) < (error.maxRetries || 3);
+}
+
+// src/core/translator.tsx
+var Translator = class {
+  constructor(config) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.pluralRulesCache = /* @__PURE__ */ new Map();
+    this.loadedNamespaces = /* @__PURE__ */ new Set();
+    this.loadingPromises = /* @__PURE__ */ new Map();
+    this.allTranslations = {};
+    this.isInitialized = false;
+    this.initializationError = null;
+    this.currentLang = "en";
+    this.cacheStats = {
+      hits: 0,
+      misses: 0
+    };
+    // 번역 로드 완료 시 React 리렌더링을 위한 콜백
+    this.onTranslationLoadedCallbacks = /* @__PURE__ */ new Set();
+    // 언어 변경 시 React 리렌더링을 위한 콜백
+    this.onLanguageChangedCallbacks = /* @__PURE__ */ new Set();
+    // 디바운싱을 위한 타이머
+    this.notifyTimer = null;
+    // 최근 알림한 네임스페이스 (중복 알림 방지)
+    this.recentlyNotified = /* @__PURE__ */ new Set();
+    if (!validateI18nConfig(config)) {
+      throw new Error("Invalid I18nConfig provided");
+    }
+    this.config = {
+      fallbackLanguage: "en",
+      namespaces: ["common"],
+      debug: false,
+      missingKeyHandler: (key) => key,
+      errorHandler: (error) => {
+      },
+      ...config
+    };
+    this.currentLang = config.defaultLanguage;
+    if (config.initialTranslations) {
+      this.allTranslations = config.initialTranslations;
+      for (const [language, namespaces] of Object.entries(config.initialTranslations)) {
+        for (const namespace of Object.keys(namespaces)) {
+          this.loadedNamespaces.add(`${language}:${namespace}`);
+        }
+      }
+      this.isInitialized = true;
+    }
+  }
+  /**
+   * 번역 로드 완료 콜백 등록
+   */
+  onTranslationLoaded(callback) {
+    this.onTranslationLoadedCallbacks.add(callback);
+    return () => {
+      this.onTranslationLoadedCallbacks.delete(callback);
+    };
+  }
+  /**
+   * 언어 변경 콜백 등록
+   */
+  onLanguageChanged(callback) {
+    this.onLanguageChangedCallbacks.add(callback);
+    return () => {
+      this.onLanguageChangedCallbacks.delete(callback);
+    };
+  }
+  /**
+   * 언어 변경 이벤트 발생
+   */
+  notifyLanguageChanged(language) {
+    this.onLanguageChangedCallbacks.forEach((callback) => {
+      try {
+        callback(language);
+      } catch (error) {
+        if (this.config.debug) {
+          console.error("Error in language changed callback:", error);
+        }
+      }
+    });
+  }
+  /**
+   * 번역 로드 완료 이벤트 발생 (디바운싱 적용)
+   */
+  notifyTranslationLoaded(language, namespace) {
+    const cacheKey = `${language}:${namespace}`;
+    if (this.recentlyNotified.has(cacheKey)) {
+      return;
+    }
+    this.recentlyNotified.add(cacheKey);
+    if (this.notifyTimer) {
+      clearTimeout(this.notifyTimer);
+    }
+    this.notifyTimer = setTimeout(() => {
+      this.onTranslationLoadedCallbacks.forEach((callback) => {
+        try {
+          callback();
+        } catch (error) {
+          if (this.config.debug) {
+            console.warn("Error in translation loaded callback:", error);
+          }
+        }
+      });
+      setTimeout(() => {
+        this.recentlyNotified.clear();
+      }, 100);
+      this.notifyTimer = null;
+    }, 50);
+  }
+  /**
+   * 모든 번역 데이터를 미리 로드 (hua-api 스타일)
+   */
+  async initialize() {
+    if (this.isInitialized) {
+      if (this.config.debug) {
+        console.log("\u{1F6AB} [TRANSLATOR] Already initialized, skipping");
+      }
+      return;
+    }
+    if (this.config.debug) {
+      console.log("\u{1F680} [TRANSLATOR] Starting initialization...");
+    }
+    try {
+      if (!this.allTranslations) {
+        this.allTranslations = {};
+      }
+      const languages = [this.currentLang];
+      if (this.config.fallbackLanguage && this.config.fallbackLanguage !== this.currentLang) {
+        languages.push(this.config.fallbackLanguage);
+      }
+      const skipNamespaces = /* @__PURE__ */ new Set();
+      for (const language of languages) {
+        if (this.allTranslations[language]) {
+          for (const namespace of Object.keys(this.allTranslations[language])) {
+            skipNamespaces.add(`${language}:${namespace}`);
+          }
+        }
+      }
+      if (this.config.debug) {
+        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);
+      }
+      for (const language of languages) {
+        if (this.config.debug) {
+          console.log("Processing language:", language);
+        }
+        if (!this.allTranslations[language]) {
+          this.allTranslations[language] = {};
+        }
+        for (const namespace of this.config.namespaces || []) {
+          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)");
+            }
+            continue;
+          }
+          if (this.config.debug) {
+            console.log("Loading namespace:", namespace, "for language:", language);
+          }
+          try {
+            const data = await this.safeLoadTranslations(language, namespace);
+            if (this.config.debug) {
+              console.log("Loaded data for", language, namespace, ":", data);
+            }
+            this.allTranslations[language][namespace] = data;
+            this.loadedNamespaces.add(`${language}:${namespace}`);
+          } catch (error) {
+            const translationError = this.createTranslationError(
+              "LOAD_FAILED",
+              error,
+              language,
+              namespace
+            );
+            this.logError(translationError);
+            if (isRecoverableError(translationError)) {
+              if (language !== this.config.fallbackLanguage) {
+                try {
+                  const fallbackData = await this.safeLoadTranslations(this.config.fallbackLanguage || "en", namespace);
+                  this.allTranslations[language][namespace] = fallbackData;
+                  this.loadedNamespaces.add(`${language}:${namespace}`);
+                  if (this.config.debug) {
+                    console.log("Using fallback data for", language, namespace);
+                  }
+                } catch (fallbackError) {
+                  const fallbackTranslationError = this.createTranslationError(
+                    "FALLBACK_LOAD_FAILED",
+                    fallbackError,
+                    this.config.fallbackLanguage,
+                    namespace
+                  );
+                  this.logError(fallbackTranslationError);
+                  this.allTranslations[language][namespace] = {};
+                }
+              } else {
+                this.allTranslations[language][namespace] = {};
+              }
+            } else {
+              this.allTranslations[language][namespace] = {};
+            }
+          }
+        }
+      }
+      this.isInitialized = true;
+      if (this.config.debug) {
+        console.log("Translator initialized successfully");
+        console.log("Loaded translations:", this.allTranslations);
+      }
+    } catch (error) {
+      this.initializationError = this.createTranslationError(
+        "INITIALIZATION_FAILED",
+        error
+      );
+      this.logError(this.initializationError);
+      this.isInitialized = true;
+      if (this.config.debug) {
+        console.warn("Translator initialized with errors, using fallback translations");
+      }
+    }
+  }
+  /**
+   * 초기화되지 않은 상태에서 번역 시도
+   */
+  translateBeforeInitialized(key, targetLang) {
+    if (this.config.debug) {
+      console.warn("Translator not initialized. Call initialize() first.");
+    }
+    const { namespace, key: actualKey } = this.parseKey(key);
+    const result = this.findInNamespace(namespace, actualKey, targetLang);
+    if (result) {
+      if (this.config.debug) {
+        console.log(`\u2705 [TRANSLATOR] Found fallback translation from initialTranslations:`, result);
+      }
+      return result;
+    }
+    if (this.config.debug) {
+      const translations = this.allTranslations[targetLang]?.[namespace];
+      console.log(`\u{1F50D} [TRANSLATOR] Not initialized, fallback failed:`, {
+        namespace,
+        actualKey,
+        hasTranslations: !!translations,
+        translationsKeys: translations ? Object.keys(translations) : []
+      });
+    }
+    return this.config.missingKeyHandler?.(key, targetLang, "default") || key;
+  }
+  /**
+   * 다른 로드된 언어에서 번역 찾기 (언어 변경 중 깜빡임 방지)
+   */
+  findInOtherLanguages(namespace, key, targetLang) {
+    if (!this.allTranslations || Object.keys(this.allTranslations).length === 0) {
+      return null;
+    }
+    const loadedLanguages = Object.keys(this.allTranslations);
+    for (const lang of loadedLanguages) {
+      if (lang !== targetLang) {
+        const result = this.findInNamespace(namespace, key, lang);
+        if (result) {
+          return result;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * 폴백 언어에서 번역 찾기
+   */
+  findInFallbackLanguage(namespace, key, targetLang) {
+    const fallbackLang = this.config.fallbackLanguage || "en";
+    if (targetLang === fallbackLang) {
+      return null;
+    }
+    const result = this.findInNamespace(namespace, key, fallbackLang);
+    if (result) {
+      this.cacheStats.hits++;
+      return result;
+    }
+    return null;
+  }
+  /**
+   * 번역 키를 번역된 텍스트로 변환
+   */
+  translate(key, paramsOrLang, language) {
+    let params;
+    let targetLang;
+    if (typeof paramsOrLang === "string") {
+      targetLang = paramsOrLang;
+    } else if (typeof paramsOrLang === "object" && paramsOrLang !== null) {
+      params = paramsOrLang;
+      targetLang = language || this.currentLang;
+    } else {
+      targetLang = this.currentLang;
+    }
+    if (!this.isInitialized) {
+      const raw = this.translateBeforeInitialized(key, targetLang);
+      return params ? this.interpolate(raw, params) : raw;
+    }
+    const { namespace, key: actualKey } = this.parseKey(key);
+    let result = this.findInNamespace(namespace, actualKey, targetLang);
+    if (result) {
+      this.cacheStats.hits++;
+      return params ? this.interpolate(result, params) : result;
+    }
+    result = this.findInOtherLanguages(namespace, actualKey, targetLang);
+    if (result) {
+      return params ? this.interpolate(result, params) : result;
+    }
+    result = this.findInFallbackLanguage(namespace, actualKey, targetLang);
+    if (result) {
+      return params ? this.interpolate(result, params) : result;
+    }
+    this.cacheStats.misses++;
+    if (this.config.debug) {
+      const missing = this.config.missingKeyHandler?.(key, targetLang, namespace) || key;
+      return params ? this.interpolate(missing, params) : missing;
+    }
+    return "";
+  }
+  /**
+   * 네임스페이스에서 키 찾기
+   */
+  findInNamespace(namespace, key, language) {
+    const translations = this.allTranslations[language]?.[namespace];
+    if (!translations) {
+      const cacheKey = `${language}:${namespace}`;
+      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);
+          }
+        });
+        if (this.config.debug) {
+          console.warn(`\u274C [TRANSLATOR] No translations found for ${language}/${namespace}, attempting auto-load...`);
+        }
+      }
+      return "";
+    }
+    const directValue = translations[key];
+    if (this.isStringValue(directValue)) {
+      return directValue;
+    }
+    if (this.isStringArray(directValue)) {
+      return directValue[Math.floor(Math.random() * directValue.length)];
+    }
+    const nestedValue = this.getNestedValue(translations, key);
+    if (this.isStringValue(nestedValue)) {
+      return nestedValue;
+    }
+    if (this.isStringArray(nestedValue)) {
+      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}`);
+    }
+    return "";
+  }
+  /**
+   * 중첩된 객체에서 값을 가져오기
+   * 배열도 지원: 최종 값이 string[]이면 그대로 반환
+   */
+  getNestedValue(obj, path) {
+    if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+      return void 0;
+    }
+    return path.split(".").reduce((current, key) => {
+      if (current == null) return void 0;
+      if (Array.isArray(current)) {
+        const idx = Number(key);
+        return Number.isInteger(idx) ? current[idx] : void 0;
+      }
+      if (typeof current === "object" && key in current) {
+        return current[key];
+      }
+      return void 0;
+    }, obj);
+  }
+  /**
+   * 문자열 값인지 확인하는 타입 가드
+   */
+  isStringValue(value) {
+    return typeof value === "string" && value.length > 0;
+  }
+  /**
+   * string[] 배열인지 확인하는 타입 가드
+   * 배열 값이 t()에 전달되면 랜덤으로 하나를 선택하여 반환
+   */
+  isStringArray(value) {
+    return Array.isArray(value) && value.length > 0 && value.every((v) => typeof v === "string");
+  }
+  /**
+   * 원시 값 가져오기 (배열, 객체 포함)
+   */
+  getRawValue(key, language) {
+    const targetLang = language || this.currentLang;
+    if (!this.isInitialized) {
+      if (this.config.debug) {
+        console.warn("Translator not initialized. Call initialize() first.");
+      }
+      return void 0;
+    }
+    const { namespace, key: actualKey } = this.parseKey(key);
+    const translations = this.allTranslations[targetLang]?.[namespace];
+    if (!translations) {
+      return void 0;
+    }
+    if (actualKey in translations) {
+      return translations[actualKey];
+    }
+    const nestedValue = this.getNestedValue(translations, actualKey);
+    if (nestedValue !== void 0) {
+      return nestedValue;
+    }
+    if (targetLang !== this.config.fallbackLanguage) {
+      const fallbackTranslations = this.allTranslations[this.config.fallbackLanguage || "en"]?.[namespace];
+      if (fallbackTranslations) {
+        if (actualKey in fallbackTranslations) {
+          return fallbackTranslations[actualKey];
+        }
+        const fallbackNestedValue = this.getNestedValue(fallbackTranslations, actualKey);
+        if (fallbackNestedValue !== void 0) {
+          return fallbackNestedValue;
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * 배열 번역 값 가져오기 (타입 안전)
+   */
+  tArray(key, language) {
+    const raw = this.getRawValue(key, language);
+    if (Array.isArray(raw) && raw.every((v) => typeof v === "string")) {
+      return raw;
+    }
+    if (process.env.NODE_ENV === "development") {
+      console.warn(`tArray: "${key}" is not a string array`);
+    }
+    return [];
+  }
+  /**
+   * Intl.PluralRules 인스턴스 (언어별 캐시)
+   */
+  getPluralRules(language) {
+    let rules = this.pluralRulesCache.get(language);
+    if (!rules) {
+      rules = new Intl.PluralRules(language);
+      this.pluralRulesCache.set(language, rules);
+    }
+    return rules;
+  }
+  /**
+   * 복수형 번역 (ICU / Intl.PluralRules 기반)
+   *
+   * JSON: { "other": "총 {count}개" }  (ko)
+   *       { "one": "{count} item", "other": "{count} items" }  (en)
+   *
+   * tPlural('common:total_count', 1) → en: "1 item" / ko: "총 1개"
+   * tPlural('common:total_count', 5) → en: "5 items" / ko: "총 5개"
+   */
+  tPlural(key, count, params, language) {
+    const targetLang = language || this.currentLang;
+    const raw = this.getRawValue(key, targetLang);
+    const mergedParams = { count, ...params };
+    if (isPluralValue(raw)) {
+      const category = this.getPluralRules(targetLang).select(count);
+      const text = raw[category] ?? raw.other;
+      return this.interpolate(text, mergedParams);
+    }
+    if (typeof raw === "string") {
+      return this.interpolate(raw, mergedParams);
+    }
+    if (this.config.debug) {
+      return this.interpolate(key, mergedParams);
+    }
+    return "";
+  }
+  /**
+   * 매개변수 보간
+   *
+   * 지원 형식:
+   * - {key} - 단일 중괄호 (일반적인 i18n 형식)
+   * - {{key}} - 이중 중괄호 (하위 호환성)
+   */
+  interpolate(text, params) {
+    return text.replace(/\{\{?(\w+)\}?\}/g, (match, key) => {
+      const value = params[key];
+      return value !== void 0 ? String(value) : match;
+    });
+  }
+  /**
+   * 언어 설정
+   */
+  setLanguage(language) {
+    if (this.currentLang === language) {
+      return;
+    }
+    const previousLanguage = this.currentLang;
+    this.currentLang = language;
+    this.notifyLanguageChanged(language);
+    if (!this.allTranslations[language]) {
+      this.loadLanguageData(language).catch((error) => {
+        if (this.config.debug) {
+          console.warn("Failed to load language data:", error);
+        }
+      });
+    }
+    if (this.config.debug) {
+      console.log(`\u{1F310} [TRANSLATOR] Language changed: ${previousLanguage} -> ${language}`);
+    }
+  }
+  /**
+   * 언어 데이터 로드
+   */
+  async loadLanguageData(language) {
+    if (!this.allTranslations[language]) {
+      this.allTranslations[language] = {};
+    }
+    for (const namespace of this.config.namespaces || []) {
+      try {
+        const data = await this.safeLoadTranslations(language, namespace);
+        this.allTranslations[language][namespace] = data;
+        this.loadedNamespaces.add(`${language}:${namespace}`);
+        this.notifyTranslationLoaded(language, namespace);
+      } catch (error) {
+        const translationError = this.createTranslationError(
+          "LOAD_FAILED",
+          error,
+          language,
+          namespace
+        );
+        this.logError(translationError);
+        if (isRecoverableError(translationError)) {
+          this.allTranslations[language][namespace] = {};
+        } else {
+          this.allTranslations[language][namespace] = {};
+        }
+      }
+    }
+  }
+  /**
+   * 현재 언어 가져오기
+   */
+  getCurrentLanguage() {
+    return this.currentLang;
+  }
+  /**
+   * 지원되는 언어 목록 가져오기
+   */
+  getSupportedLanguages() {
+    return this.config.supportedLanguages?.map((lang) => lang.code) || [];
+  }
+  /**
+   * 초기화 완료 여부 확인
+   */
+  isReady() {
+    return this.isInitialized && !this.initializationError;
+  }
+  /**
+   * 초기화 오류 가져오기
+   */
+  getInitializationError() {
+    return this.initializationError;
+  }
+  /**
+   * 캐시 클리어
+   */
+  clearCache() {
+    this.cache.clear();
+    this.cacheStats = { hits: 0, misses: 0 };
+    if (this.config.debug) {
+      console.log("Cache cleared");
+    }
+  }
+  /**
+   * 캐시 엔트리 설정
+   */
+  setCacheEntry(key, data) {
+    this.cache.set(key, {
+      data,
+      timestamp: Date.now(),
+      ttl: 5 * 60 * 1e3
+      // 5분
+    });
+  }
+  /**
+   * 캐시 엔트리 가져오기
+   */
+  getCacheEntry(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.data;
+  }
+  /**
+   * 번역 오류 생성
+   */
+  createTranslationError(code, originalError, language, namespace, key) {
+    return {
+      name: "TranslationError",
+      code,
+      message: originalError.message,
+      originalError,
+      language,
+      namespace,
+      key,
+      timestamp: Date.now(),
+      stack: originalError.stack
+    };
+  }
+  /**
+   * 오류 로깅
+   */
+  logError(error) {
+    if (this.config.errorHandler) {
+      this.config.errorHandler(error, error.language || "", error.namespace || "");
+    }
+  }
+  /**
+   * 재시도 작업
+   */
+  async retryOperation(operation, error, context) {
+    const maxRetries = 3;
+    let lastError = error;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (retryError) {
+        lastError = this.createTranslationError(
+          "RETRY_FAILED",
+          retryError,
+          context.language,
+          context.namespace,
+          context.key
+        );
+        if (attempt === maxRetries) {
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1e3));
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * 안전한 번역 로드
+   */
+  async safeLoadTranslations(language, namespace) {
+    if (this.config.debug) {
+      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 });
+      }
+      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}`);
+      }
+      return data;
+    };
+    try {
+      return await loadOperation();
+    } catch (error) {
+      const translationError = this.createTranslationError(
+        "LOAD_FAILED",
+        error,
+        language,
+        namespace
+      );
+      return this.retryOperation(loadOperation, translationError, { language, namespace });
+    }
+  }
+  /**
+   * 디버그 정보
+   */
+  debug() {
+    return {
+      isInitialized: this.isInitialized,
+      currentLanguage: this.currentLang,
+      loadedNamespaces: Array.from(this.loadedNamespaces),
+      cacheStats: this.cacheStats,
+      cacheSize: this.cache.size,
+      allTranslations: this.allTranslations,
+      initializationError: this.initializationError,
+      config: this.config
+    };
+  }
+  /**
+   * SSR에서 하이드레이션
+   */
+  hydrateFromSSR(translations) {
+    this.allTranslations = translations;
+    this.isInitialized = true;
+    for (const [language, namespaces] of Object.entries(translations)) {
+      for (const namespace of Object.keys(namespaces)) {
+        this.loadedNamespaces.add(`${language}:${namespace}`);
+      }
+    }
+  }
+  /**
+   * 비동기 번역 (고급 기능)
+   */
+  async translateAsync(key, params) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+    const translated = this.translate(key);
+    if (!params) {
+      return translated;
+    }
+    return this.interpolate(translated, params);
+  }
+  /**
+   * 동기 번역 (고급 기능)
+   */
+  translateSync(key, params) {
+    if (!this.isInitialized) {
+      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);
+  }
+  /**
+   * 키 파싱 (네임스페이스:키 형식)
+   * 
+   * - 콜론(:)만 네임스페이스 구분자로 사용
+   * - 점(.)은 키 이름의 일부로 취급 (중첩 객체 접근용)
+   * 
+   * @example
+   * parseKey("home:hero.badge") → { namespace: "home", key: "hero.badge" }
+   * parseKey("hero.badge") → { namespace: "common", key: "hero.badge" }
+   * parseKey("save") → { namespace: "common", key: "save" }
+   */
+  parseKey(key) {
+    const colonIndex = key.indexOf(":");
+    if (colonIndex !== -1) {
+      return { namespace: key.substring(0, colonIndex), key: key.substring(colonIndex + 1) };
+    }
+    return { namespace: "common", key };
+  }
+  /**
+   * 번역 데이터 로드 (고급 기능)
+   */
+  async loadTranslationData(language, namespace) {
+    const cacheKey = `${language}:${namespace}`;
+    if (this.loadedNamespaces.has(cacheKey)) {
+      const existing = this.allTranslations[language]?.[namespace];
+      if (existing) {
+        return existing;
+      }
+    }
+    const cached = this.getCacheEntry(cacheKey);
+    if (cached) {
+      if (!this.allTranslations[language]) {
+        this.allTranslations[language] = {};
+      }
+      this.allTranslations[language][namespace] = cached;
+      this.loadedNamespaces.add(cacheKey);
+      return cached;
+    }
+    const loadingPromise = this.loadingPromises.get(cacheKey);
+    if (loadingPromise) {
+      return loadingPromise;
+    }
+    const loadPromise = this._loadTranslationData(language, namespace);
+    this.loadingPromises.set(cacheKey, loadPromise);
+    try {
+      const data = await loadPromise;
+      if (!this.allTranslations[language]) {
+        this.allTranslations[language] = {};
+      }
+      this.allTranslations[language][namespace] = data;
+      this.loadedNamespaces.add(cacheKey);
+      this.setCacheEntry(cacheKey, data);
+      if (this.config.debug) {
+        console.log(`\u2705 [TRANSLATOR] Auto-loaded and saved ${language}/${namespace}`);
+      }
+      this.notifyTranslationLoaded(language, namespace);
+      return data;
+    } finally {
+      this.loadingPromises.delete(cacheKey);
+    }
+  }
+  /**
+   * 실제 번역 데이터 로드
+   */
+  async _loadTranslationData(language, namespace) {
+    if (!this.config.loadTranslations) {
+      throw new Error("No translation loader configured");
+    }
+    try {
+      const data = await this.config.loadTranslations(language, namespace);
+      if (!isTranslationNamespace(data)) {
+        throw new Error(`Invalid translation data for ${language}:${namespace}`);
+      }
+      return data;
+    } catch (error) {
+      const translationError = this.createTranslationError(
+        "LOAD_FAILED",
+        error,
+        language,
+        namespace
+      );
+      this.logError(translationError);
+      return {};
+    }
+  }
+};
+function ssrTranslate({
+  translations,
+  key,
+  language = "ko",
+  fallbackLanguage = "en",
+  missingKeyHandler = (key2) => key2
+}) {
+  const { namespace, key: actualKey } = parseKey(key);
+  let result = ssrFindInNamespace(translations, namespace, actualKey, language);
+  if (result) {
+    return result;
+  }
+  if (language !== fallbackLanguage) {
+    result = ssrFindInNamespace(translations, namespace, actualKey, fallbackLanguage);
+    if (result) {
+      return result;
+    }
+  }
+  return missingKeyHandler(key);
+}
+function ssrFindInNamespace(translations, namespace, key, language, fallbackLanguage, missingKeyHandler) {
+  const namespaceData = translations[language]?.[namespace];
+  if (!namespaceData) {
+    return "";
+  }
+  const directValue = namespaceData[key];
+  if (isStringValue(directValue)) {
+    return directValue;
+  }
+  const nestedValue = getNestedValue(namespaceData, key);
+  if (isStringValue(nestedValue)) {
+    return nestedValue;
+  }
+  return "";
+}
+function getNestedValue(obj, path) {
+  if (typeof obj !== "object" || obj === null || Array.isArray(obj)) {
+    return void 0;
+  }
+  return path.split(".").reduce((current, key) => {
+    if (current && typeof current === "object" && !Array.isArray(current) && key in current) {
+      return current[key];
+    }
+    return void 0;
+  }, obj);
+}
+function isStringValue(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function parseKey(key) {
+  const colonIndex = key.indexOf(":");
+  if (colonIndex !== -1) {
+    return { namespace: key.substring(0, colonIndex), key: key.substring(colonIndex + 1) };
+  }
+  return { namespace: "common", key };
+}
+function serverTranslate({
+  translations,
+  key,
+  language = "ko",
+  fallbackLanguage = "en",
+  missingKeyHandler = (key2) => key2,
+  options = {}
+}) {
+  const { cache, metrics, debug } = options;
+  if (cache) {
+    const cacheKey = `${language}:${key}`;
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      if (metrics) metrics.hits++;
+      if (debug) console.log(`[CACHE HIT] ${cacheKey}`);
+      return cached;
+    }
+  }
+  const result = findInTranslations(translations, key, language, fallbackLanguage);
+  if (cache && result) {
+    const cacheKey = `${language}:${key}`;
+    cache.set(cacheKey, result);
+  }
+  if (metrics) metrics.misses++;
+  if (debug) console.log(`[TRANSLATE] ${key} -> ${result}`);
+  return result;
+}
+function findInTranslations(translations, key, language, fallbackLanguage, missingKeyHandler) {
+  const { namespace, key: actualKey } = parseKey(key);
+  let result = findInNamespace(translations, namespace, actualKey, language);
+  if (result) {
+    return result;
+  }
+  if (language !== fallbackLanguage) {
+    result = findInNamespace(translations, namespace, actualKey, fallbackLanguage);
+    if (result) {
+      return result;
+    }
+  }
+  return "";
+}
+function findInNamespace(translations, namespace, key, language) {
+  const languageData = translations[language];
+  if (!languageData || typeof languageData !== "object" || Array.isArray(languageData)) {
+    return "";
+  }
+  const namespaceData = languageData[namespace];
+  if (!namespaceData || typeof namespaceData !== "object" || Array.isArray(namespaceData)) {
+    return "";
+  }
+  const data = namespaceData;
+  if (data[key] && typeof data[key] === "string") {
+    return data[key];
+  }
+  const nestedValue = getNestedValue(namespaceData, key);
+  if (typeof nestedValue === "string") {
+    return nestedValue;
+  }
+  return "";
+}
+
+export { Translator, serverTranslate, ssrTranslate, validateI18nConfig };
+//# sourceMappingURL=chunk-F4PDBJLO.mjs.map
+//# sourceMappingURL=chunk-F4PDBJLO.mjs.map