@hua-labs/i18n-core 2.0.0 → 2.0.4

package/dist/index.mjs

@@ -0,0 +1,845 @@
+import { validateI18nConfig, Translator } from './chunk-F4PDBJLO.mjs';
+export { Translator, serverTranslate, ssrTranslate } from './chunk-F4PDBJLO.mjs';
+import React, { createContext, useState, useEffect, useMemo, useCallback, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/core/translator-factory.ts
+var TranslatorFactory = class {
+  // 최대 인스턴스 수 제한
+  /**
+   * Config를 기반으로 고유 키 생성
+   */
+  static generateConfigKey(config) {
+    const keyParts = [
+      config.defaultLanguage,
+      config.fallbackLanguage || "en",
+      config.namespaces?.join(",") || "common",
+      config.debug ? "debug" : "prod"
+    ];
+    return keyParts.join("|");
+  }
+  /**
+   * Config가 변경되었는지 확인
+   */
+  static isConfigChanged(configKey, newConfig) {
+    const cachedConfig = this.configCache.get(configKey);
+    if (!cachedConfig) return true;
+    return cachedConfig.defaultLanguage !== newConfig.defaultLanguage || cachedConfig.fallbackLanguage !== newConfig.fallbackLanguage || JSON.stringify(cachedConfig.namespaces) !== JSON.stringify(newConfig.namespaces) || cachedConfig.debug !== newConfig.debug;
+  }
+  /**
+   * Translator 인스턴스 생성 또는 반환
+   */
+  static create(config) {
+    const configKey = this.generateConfigKey(config);
+    if (!this.instances.has(configKey) || this.isConfigChanged(configKey, config)) {
+      if (this.instances.size >= this.MAX_INSTANCES && !this.instances.has(configKey)) {
+        const oldestKey = this.instances.keys().next().value;
+        if (oldestKey) {
+          const oldInstance = this.instances.get(oldestKey);
+          if (oldInstance) {
+            oldInstance.clearCache();
+          }
+          this.instances.delete(oldestKey);
+          this.configCache.delete(oldestKey);
+        }
+      }
+      if (this.instances.has(configKey)) {
+        const oldInstance = this.instances.get(configKey);
+        oldInstance.clearCache();
+      }
+      const newInstance = new Translator(config);
+      this.instances.set(configKey, newInstance);
+      this.configCache.set(configKey, { ...config });
+    }
+    return this.instances.get(configKey);
+  }
+  /**
+   * 특정 Config 키의 Translator 인스턴스 반환
+   */
+  static get(config) {
+    const configKey = this.generateConfigKey(config);
+    return this.instances.get(configKey) || null;
+  }
+  /**
+   * 모든 Translator 인스턴스 정리 (테스트용)
+   */
+  static clear() {
+    for (const instance of this.instances.values()) {
+      instance.clearCache();
+    }
+    this.instances.clear();
+    this.configCache.clear();
+  }
+  /**
+   * 특정 Config 키의 인스턴스만 정리
+   */
+  static clearConfig(config) {
+    const configKey = this.generateConfigKey(config);
+    const instance = this.instances.get(configKey);
+    if (instance) {
+      instance.clearCache();
+      this.instances.delete(configKey);
+      this.configCache.delete(configKey);
+    }
+  }
+  /**
+   * 현재 관리 중인 인스턴스 수 반환
+   */
+  static getInstanceCount() {
+    return this.instances.size;
+  }
+  /**
+   * 디버깅용: 모든 인스턴스 정보 반환
+   */
+  static debug() {
+    return {
+      instanceCount: this.instances.size,
+      configKeys: Array.from(this.instances.keys()),
+      instances: this.instances
+    };
+  }
+};
+TranslatorFactory.instances = /* @__PURE__ */ new Map();
+TranslatorFactory.configCache = /* @__PURE__ */ new Map();
+TranslatorFactory.MAX_INSTANCES = 10;
+
+// src/utils/default-translations.ts
+var DEFAULT_TRANSLATIONS = {
+  ko: {
+    common: {
+      welcome: "\uD658\uC601\uD569\uB2C8\uB2E4",
+      greeting: "\uC548\uB155\uD558\uC138\uC694",
+      goodbye: "\uC548\uB155\uD788 \uAC00\uC138\uC694",
+      loading: "\uB85C\uB529 \uC911...",
+      error: "\uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4",
+      success: "\uC131\uACF5\uD588\uC2B5\uB2C8\uB2E4",
+      cancel: "\uCDE8\uC18C",
+      confirm: "\uD655\uC778",
+      save: "\uC800\uC7A5",
+      delete: "\uC0AD\uC81C",
+      edit: "\uD3B8\uC9D1",
+      add: "\uCD94\uAC00",
+      search: "\uAC80\uC0C9",
+      filter: "\uD544\uD130",
+      sort: "\uC815\uB82C",
+      refresh: "\uC0C8\uB85C\uACE0\uCE68",
+      back: "\uB4A4\uB85C",
+      next: "\uB2E4\uC74C",
+      previous: "\uC774\uC804",
+      home: "\uD648",
+      about: "\uC18C\uAC1C",
+      contact: "\uC5F0\uB77D\uCC98",
+      settings: "\uC124\uC815",
+      profile: "\uD504\uB85C\uD544",
+      logout: "\uB85C\uADF8\uC544\uC6C3",
+      login: "\uB85C\uADF8\uC778",
+      register: "\uD68C\uC6D0\uAC00\uC785"
+    },
+    auth: {
+      login: "\uB85C\uADF8\uC778",
+      logout: "\uB85C\uADF8\uC544\uC6C3",
+      register: "\uD68C\uC6D0\uAC00\uC785",
+      email: "\uC774\uBA54\uC77C",
+      password: "\uBE44\uBC00\uBC88\uD638",
+      forgot_password: "\uBE44\uBC00\uBC88\uD638 \uCC3E\uAE30",
+      remember_me: "\uB85C\uADF8\uC778 \uC0C1\uD0DC \uC720\uC9C0"
+    },
+    errors: {
+      not_found: "\uD398\uC774\uC9C0\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+      server_error: "\uC11C\uBC84 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4",
+      network_error: "\uB124\uD2B8\uC6CC\uD06C \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4",
+      unauthorized: "\uC778\uC99D\uC774 \uD544\uC694\uD569\uB2C8\uB2E4",
+      forbidden: "\uC811\uADFC\uC774 \uAC70\uBD80\uB418\uC5C8\uC2B5\uB2C8\uB2E4"
+    }
+  },
+  en: {
+    common: {
+      welcome: "Welcome",
+      greeting: "Hello",
+      goodbye: "Goodbye",
+      loading: "Loading...",
+      error: "An error occurred",
+      success: "Success",
+      cancel: "Cancel",
+      confirm: "Confirm",
+      save: "Save",
+      delete: "Delete",
+      edit: "Edit",
+      add: "Add",
+      search: "Search",
+      filter: "Filter",
+      sort: "Sort",
+      refresh: "Refresh",
+      back: "Back",
+      next: "Next",
+      previous: "Previous",
+      home: "Home",
+      about: "About",
+      contact: "Contact",
+      settings: "Settings",
+      profile: "Profile",
+      logout: "Logout",
+      login: "Login",
+      register: "Register"
+    },
+    auth: {
+      login: "Login",
+      logout: "Logout",
+      register: "Register",
+      email: "Email",
+      password: "Password",
+      forgot_password: "Forgot Password",
+      remember_me: "Remember Me"
+    },
+    errors: {
+      not_found: "Page not found",
+      server_error: "Server error occurred",
+      network_error: "Network error occurred",
+      unauthorized: "Authentication required",
+      forbidden: "Access denied"
+    }
+  }
+};
+function getDefaultTranslations(language, namespace) {
+  return DEFAULT_TRANSLATIONS[language]?.[namespace] || {};
+}
+var I18nContext = createContext(null);
+function I18nProvider({
+  config,
+  children
+}) {
+  const [currentLanguage, setCurrentLanguageState] = useState(config.defaultLanguage);
+  const [isLoading, setIsLoading] = useState(true);
+  const [isInitialized, setIsInitialized] = useState(false);
+  const [error, setError] = useState(null);
+  const [translationVersion, setTranslationVersion] = useState(0);
+  useEffect(() => {
+    if (!isInitialized && config.defaultLanguage !== currentLanguage) {
+      setCurrentLanguageState(config.defaultLanguage);
+    }
+  }, [config.defaultLanguage, currentLanguage, isInitialized]);
+  const translator = useMemo(() => {
+    if (!validateI18nConfig(config)) {
+      throw new Error("Invalid I18nConfig provided to I18nProvider");
+    }
+    return TranslatorFactory.create(config);
+  }, [config]);
+  useEffect(() => {
+    if (isInitialized) {
+      const translatorLang = translator.getCurrentLanguage();
+      if (translatorLang !== currentLanguage) {
+        if (config.debug) {
+          console.log(`\u{1F504} [USEI18N] Syncing translator language: ${translatorLang} -> ${currentLanguage} (already initialized)`);
+        }
+        translator.setLanguage(currentLanguage);
+      }
+      return;
+    }
+    if (config.debug) {
+      console.log("\u{1F504} [USEI18N] useEffect triggered:", {
+        hasTranslator: !!translator,
+        currentLanguage,
+        debug: config.debug,
+        isInitialized
+      });
+    }
+    const initializeTranslator = async () => {
+      try {
+        setIsLoading(true);
+        setError(null);
+        if (config.debug) {
+          console.log("\u{1F680} [USEI18N] Starting translator initialization...");
+        }
+        translator.setLanguage(currentLanguage);
+        await translator.initialize();
+        setIsInitialized(true);
+        if (config.debug) {
+          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);
+        }
+        setIsInitialized(true);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    initializeTranslator();
+  }, [translator, currentLanguage, config.debug, isInitialized]);
+  useEffect(() => {
+    if (!translator || !isInitialized) {
+      return;
+    }
+    const unsubscribe = translator.onTranslationLoaded(() => {
+      setTranslationVersion((prev) => prev + 1);
+      if (config.debug) {
+        console.log("\u{1F504} [USEI18N] Translation loaded, triggering re-render");
+      }
+    });
+    return unsubscribe;
+  }, [translator, isInitialized, config.debug]);
+  useEffect(() => {
+    if (!translator || !isInitialized) {
+      return;
+    }
+    const unsubscribe = translator.onLanguageChanged((newLanguage) => {
+      if (newLanguage !== currentLanguage) {
+        if (config.debug) {
+          console.log(`\u{1F504} [USEI18N] Language changed event: ${currentLanguage} -> ${newLanguage}`);
+        }
+        setCurrentLanguageState(newLanguage);
+        setTranslationVersion((prev) => prev + 1);
+      }
+    });
+    return unsubscribe;
+  }, [translator, isInitialized, currentLanguage, config.debug]);
+  useEffect(() => {
+    if (!config.autoLanguageSync || typeof window === "undefined") {
+      return;
+    }
+    const handleLanguageChange = (event) => {
+      const newLanguage = event.detail;
+      if (typeof newLanguage === "string" && 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}`);
+      }
+    }
+    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);
+    }
+  }, [translator, config.debug]);
+  const parseKey = useCallback((key) => {
+    const parts = key.split(":");
+    if (parts.length >= 2) {
+      return { namespace: parts[0], key: parts.slice(1).join(":") };
+    }
+    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;
+      }
+    }
+    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;
+      }
+    }
+    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;
+        }
+      }
+    }
+    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) {
+    }
+    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 key;
+    }
+    setIsLoading(true);
+    try {
+      const result = await translator.translateAsync(key, params);
+      return result;
+    } catch (error2) {
+      if (config.debug) {
+        console.error("Translation error:", error2);
+      }
+      return key;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [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);
+  }, [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;
+      }
+    },
+    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 {
+        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,
+    translationVersion
+  }), [currentLanguage, setLanguage, t, tPlural, tArray, tAsync, tSync, getRawValue, isLoading, error, config.supportedLanguages, debug, isInitialized, translationVersion]);
+  return /* @__PURE__ */ jsx(I18nContext.Provider, { value, children });
+}
+function useI18n() {
+  const context = useContext(I18nContext);
+  if (!context) {
+    return {
+      currentLanguage: "ko",
+      setLanguage: () => {
+      },
+      t: (key) => key,
+      tPlural: (key) => key,
+      tAsync: async (key) => key,
+      tSync: (key) => key,
+      getRawValue: () => void 0,
+      tArray: () => [],
+      isLoading: false,
+      error: null,
+      supportedLanguages: [
+        { code: "ko", name: "Korean", nativeName: "\uD55C\uAD6D\uC5B4" },
+        { code: "en", name: "English", nativeName: "English" }
+      ],
+      isInitialized: false,
+      debug: {
+        getCurrentLanguage: () => "ko",
+        getSupportedLanguages: () => ["ko", "en"],
+        getLoadedNamespaces: () => [],
+        getAllTranslations: () => ({}),
+        isReady: () => false,
+        getInitializationError: () => null,
+        clearCache: () => {
+        },
+        getCacheStats: () => ({ size: 0, hits: 0, misses: 0 }),
+        reloadTranslations: async () => {
+        }
+      }
+    };
+  }
+  return context;
+}
+function useTranslation() {
+  const { t, tPlural, tArray, currentLanguage, setLanguage, getRawValue, isLoading, error, supportedLanguages, debug, isInitialized } = useI18n();
+  return {
+    t,
+    tPlural,
+    tArray,
+    currentLanguage,
+    setLanguage,
+    getRawValue,
+    isLoading,
+    error,
+    supportedLanguages,
+    debug,
+    isInitialized
+  };
+}
+function useLanguageChange() {
+  const { currentLanguage, setLanguage, supportedLanguages } = useI18n();
+  const changeLanguage = useCallback((language) => {
+    const supported = supportedLanguages.find((lang) => lang.code === language);
+    if (supported) {
+      setLanguage(language);
+    } else {
+      if (process.env.NODE_ENV !== "production") console.warn(`Language ${language} is not supported`);
+    }
+  }, [setLanguage, supportedLanguages]);
+  return {
+    currentLanguage,
+    changeLanguage,
+    supportedLanguages
+  };
+}
+
+// src/index.ts
+var defaultLanguages = [
+  { code: "ko", name: "Korean", nativeName: "\uD55C\uAD6D\uC5B4" },
+  { code: "en", name: "English", nativeName: "English" },
+  { code: "en-IN", name: "English (India)", nativeName: "English (India)" },
+  { code: "ja", name: "Japanese", nativeName: "\u65E5\u672C\u8A9E" },
+  { code: "zh", name: "Chinese (Simplified)", nativeName: "\u7B80\u4F53\u4E2D\u6587" },
+  { code: "zh-TW", name: "Chinese (Traditional)", nativeName: "\u7E41\u9AD4\u4E2D\u6587" },
+  { code: "es", name: "Spanish", nativeName: "Espa\xF1ol" },
+  { code: "ru", name: "Russian", nativeName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" },
+  { code: "de", name: "German", nativeName: "Deutsch" },
+  { code: "fr", name: "French", nativeName: "Fran\xE7ais" }
+];
+function createCoreI18n(options) {
+  const {
+    defaultLanguage = "ko",
+    fallbackLanguage = "en",
+    namespaces = ["common"],
+    debug = false,
+    loadTranslations,
+    translationLoader = "api",
+    translationApiPath = "/api/translations",
+    initialTranslations,
+    supportedLanguages: providedSupportedLanguages,
+    autoLanguageSync = false,
+    // 기본값 false (Zustand 어댑터 등 외부에서 직접 처리)
+    baseUrl,
+    localFallbackBaseUrl
+  } = options || {};
+  let supportedLanguagesConfig;
+  if (providedSupportedLanguages) {
+    if (Array.isArray(providedSupportedLanguages) && providedSupportedLanguages.length > 0) {
+      if (typeof providedSupportedLanguages[0] === "string") {
+        const languageMap = {
+          ko: { name: "Korean", nativeName: "\uD55C\uAD6D\uC5B4" },
+          en: { name: "English", nativeName: "English" },
+          ja: { name: "Japanese", nativeName: "\u65E5\u672C\u8A9E" },
+          zh: { name: "Chinese", nativeName: "\u4E2D\u6587" },
+          es: { name: "Spanish", nativeName: "Espa\xF1ol" },
+          fr: { name: "French", nativeName: "Fran\xE7ais" },
+          de: { name: "German", nativeName: "Deutsch" },
+          pt: { name: "Portuguese", nativeName: "Portugu\xEAs" },
+          it: { name: "Italian", nativeName: "Italiano" },
+          ru: { name: "Russian", nativeName: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439" }
+        };
+        supportedLanguagesConfig = providedSupportedLanguages.map((code) => ({
+          code,
+          name: languageMap[code]?.name || code,
+          nativeName: languageMap[code]?.nativeName || code
+        }));
+      } else {
+        supportedLanguagesConfig = providedSupportedLanguages;
+      }
+    } else {
+      supportedLanguagesConfig = defaultLanguages;
+    }
+  } else {
+    supportedLanguagesConfig = defaultLanguages;
+  }
+  const apiRouteLoader = async (language, namespace) => {
+    try {
+      if (typeof window !== "undefined") {
+        const apiUrl = `${translationApiPath}/${language}/${namespace}`;
+        const response = await fetch(apiUrl);
+        if (response.ok) {
+          const data = await response.json();
+          if (debug) {
+            console.log(`\u2705 Loaded translation from API: ${language}/${namespace}`);
+          }
+          return data;
+        } else if (response.status === 404) {
+          if (debug) {
+            console.warn(`\u26A0\uFE0F Translation not found in API: ${language}/${namespace}`);
+          }
+        }
+      }
+      return getDefaultTranslations(language, namespace);
+    } catch (error) {
+      if (debug) {
+        console.warn(`Failed to load translation from API: ${language}/${namespace}`, error);
+      }
+      return getDefaultTranslations(language, namespace);
+    }
+  };
+  const staticFileLoader = async (language, namespace) => {
+    try {
+      let data = null;
+      if (typeof window !== "undefined") {
+        const possiblePaths = [
+          `/translations/${language}/${namespace}.json`,
+          `../translations/${language}/${namespace}.json`,
+          `./translations/${language}/${namespace}.json`,
+          `translations/${language}/${namespace}.json`,
+          `../../translations/${language}/${namespace}.json`
+        ];
+        for (const path of possiblePaths) {
+          try {
+            const response = await fetch(path);
+            if (response.ok) {
+              data = await response.json();
+              if (debug) {
+                console.log(`\u2705 Loaded translation from static path: ${path}`);
+              }
+              break;
+            }
+          } catch (pathError) {
+            continue;
+          }
+        }
+      }
+      if (data) {
+        return data;
+      }
+      return getDefaultTranslations(language, namespace);
+    } catch (error) {
+      if (debug) {
+        console.warn(`Failed to load translation file: ${language}/${namespace}.json`);
+      }
+      return getDefaultTranslations(language, namespace);
+    }
+  };
+  const defaultFileLoader = translationLoader === "api" ? apiRouteLoader : translationLoader === "static" ? staticFileLoader : loadTranslations || apiRouteLoader;
+  const config = {
+    defaultLanguage,
+    fallbackLanguage,
+    supportedLanguages: supportedLanguagesConfig,
+    namespaces,
+    loadTranslations: translationLoader === "custom" && loadTranslations ? loadTranslations : defaultFileLoader,
+    initialTranslations,
+    // SSR 번역 데이터 전달
+    debug,
+    missingKeyHandler: (key, language, namespace) => {
+      if (debug) {
+        console.warn(`Missing translation key: ${key}`);
+        if (typeof window !== "undefined" && window.__I18N_DEBUG_MISSING_KEYS__) {
+          const missingKeys = window.__I18N_DEBUG_MISSING_KEYS__;
+          const keyPath = `${language || "unknown"}:${namespace || "unknown"}`;
+          missingKeys[keyPath] = missingKeys[keyPath] || [];
+          if (!missingKeys[keyPath].includes(key)) {
+            missingKeys[keyPath].push(key);
+          }
+        }
+        return `[MISSING: ${key}]`;
+      }
+      return key.split(".").pop() || key;
+    },
+    errorHandler: (error, language, namespace) => {
+      if (debug) {
+        console.error(`Translation error for ${language}:${namespace}:`, error);
+      }
+    },
+    // autoLanguageSync는 기본적으로 false (Zustand 어댑터 등 외부에서 직접 처리하는 경우)
+    // 필요시 options에서 명시적으로 true로 설정 가능
+    autoLanguageSync: options?.autoLanguageSync ?? false
+  };
+  return function CoreI18nProvider({ children }) {
+    return React.createElement(I18nProvider, { config, children });
+  };
+}
+function CoreProvider({ children }) {
+  return createCoreI18n()({ children });
+}
+function createLanguageProvider(language) {
+  return createCoreI18n({ defaultLanguage: language });
+}
+function createNamespaceProvider(namespaces) {
+  return createCoreI18n({ namespaces });
+}
+function createCustomLoaderProvider(loadTranslations) {
+  return createCoreI18n({ loadTranslations });
+}
+
+export { CoreProvider, I18nProvider, createCoreI18n, createCustomLoaderProvider, createLanguageProvider, createNamespaceProvider, useI18n, useLanguageChange, useTranslation };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map