@xiaonoodles/meetfun-i18n 1.2.14

package/dist/index.js

@@ -0,0 +1,1173 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vueI18n = require('vue-i18n');
+var lodash = require('lodash');
+
+/**
+ * 缓存管理类
+ */
+class CacheManager {
+    constructor(localeCacheKey, langDictCacheKey, cacheMaxAge, baseMessages) {
+        this.localeCacheKey = localeCacheKey;
+        this.langDictCacheKey = langDictCacheKey;
+        this.cacheMaxAge = cacheMaxAge;
+        this.baseMessages = baseMessages;
+    }
+    /**
+     * 保存语言包数据到本地缓存
+     * @param langDictData 语言包数据
+     * @param version 版本号（可选）
+     */
+    saveLangDictToCache(langDictData, version = "1.0.0") {
+        try {
+            const cacheData = {
+                timestamp: Date.now(),
+                version,
+                data: langDictData,
+            };
+            uni.setStorageSync(this.langDictCacheKey, JSON.stringify(cacheData));
+        }
+        catch (error) {
+            console.error("国际化 保存语言包到缓存失败:", error);
+        }
+    }
+    /**
+     * 保存语言设置到缓存
+     * @param locale 语言代码
+     */
+    saveLocaleToCache(locale) {
+        try {
+            uni.setStorageSync(this.localeCacheKey, locale);
+        }
+        catch (error) {
+            console.error("国际化 保存语言到缓存失败:", error);
+        }
+    }
+    /**
+     * 获取缓存的语言设置
+     */
+    getCachedLocale() {
+        try {
+            const cachedLocale = uni.getStorageSync(this.localeCacheKey);
+            return cachedLocale || null;
+        }
+        catch (error) {
+            console.error("国际化 获取缓存语言失败:", error);
+            return null;
+        }
+    }
+    /**
+     * 从本地缓存获取语言包数据
+     * @returns 缓存的语言包数据或null
+     */
+    getLangDictFromCache() {
+        try {
+            const cachedDataStr = uni.getStorageSync(this.langDictCacheKey);
+            if (!cachedDataStr) {
+                return null;
+            }
+            const cachedData = JSON.parse(cachedDataStr);
+            const now = Date.now();
+            // 检查缓存是否过期
+            if (now - cachedData.timestamp > this.cacheMaxAge) {
+                uni.removeStorageSync(this.langDictCacheKey);
+                return null;
+            }
+            return cachedData.data;
+        }
+        catch (error) {
+            console.error("国际化 从缓存获取语言包失败:", error);
+            // 清除损坏的缓存数据
+            try {
+                uni.removeStorageSync(this.langDictCacheKey);
+            }
+            catch (e) {
+                console.error("国际化 清除损坏的缓存失败:", e);
+            }
+            return null;
+        }
+    }
+    /**
+     * 清除语言包缓存
+     */
+    clearLangDictCache() {
+        try {
+            uni.removeStorageSync(this.langDictCacheKey);
+        }
+        catch (error) {
+            console.error("国际化 清除语言包缓存失败:", error);
+        }
+    }
+    /**
+     * 获取初始化时的合并语言包（包含本地缓存）
+     * @returns 合并后的语言包数据
+     */
+    getInitialMergedMessages() {
+        try {
+            console.log("国际化 开始获取初始化合并语言包");
+            // 从缓存获取语言包数据
+            const cachedLangDict = this.getLangDictFromCache();
+            // 如果没有缓存数据，直接返回基础语言包
+            if (!cachedLangDict) {
+                console.log("国际化 没有缓存数据，使用基础语言包");
+                return this.baseMessages;
+            }
+            console.log("国际化 找到缓存的语言包数据，开始合并");
+            // 转换缓存数据格式
+            const { zh_cn: zhHans, zh_hk: zhHant, ...other } = cachedLangDict;
+            const correctDictionaryData = {
+                "zh-Hans": zhHans,
+                "zh-Hant": zhHant,
+                ...other,
+            };
+            // 合并基础语言包和缓存的语言包
+            const mergedMessages = lodash.merge({}, this.baseMessages, correctDictionaryData);
+            console.log("国际化 初始化合并完成，最终语言包:", Object.keys(mergedMessages));
+            return mergedMessages;
+        }
+        catch (error) {
+            console.error("国际化 获取初始化合并语言包失败:", error);
+            // 发生错误时返回基础语言包
+            return this.baseMessages;
+        }
+    }
+}
+
+/**
+ * 语言配置枚举
+ */
+exports.LANGUAGE_OPTIONS_CONFIGURATION = void 0;
+(function (LANGUAGE_OPTIONS_CONFIGURATION) {
+    LANGUAGE_OPTIONS_CONFIGURATION["FOLLOW_SYSTEM"] = "followSystem";
+    LANGUAGE_OPTIONS_CONFIGURATION["EN"] = "en";
+    LANGUAGE_OPTIONS_CONFIGURATION["ZH_HANS"] = "zh-Hans";
+    LANGUAGE_OPTIONS_CONFIGURATION["ZH_HANT"] = "zh-Hant";
+})(exports.LANGUAGE_OPTIONS_CONFIGURATION || (exports.LANGUAGE_OPTIONS_CONFIGURATION = {}));
+
+/**
+ * 翻译管理类
+ */
+class TranslateManager {
+    constructor(i18n, cacheManager, apiConfig, defaultLocale, defaultLangDictDomainCode, reportDelay, onLocaleChanged, debug = false, maxReportedKeysCache = 10000) {
+        this.missingKeyCache = {};
+        this.usedKeyCache = {};
+        this.reportedKeyCache = {}; // 已上报过的键缓存
+        this.reportedKeysOrder = new Map(); // LRU缓存顺序跟踪，key为 "domainCode:keyCode"，value为时间戳
+        this.reportTimer = null;
+        this.i18n = i18n;
+        this.cacheManager = cacheManager;
+        this.apiConfig = apiConfig;
+        this.defaultLocale = defaultLocale;
+        this.defaultLangDictDomainCode = defaultLangDictDomainCode;
+        this.reportDelay = reportDelay;
+        this.onLocaleChanged = onLocaleChanged;
+        this.debug = debug;
+        this.maxReportedKeysCache = maxReportedKeysCache;
+    }
+    /**
+     * 调试日志输出方法
+     * 只有在 debug 模式下才会输出日志
+     */
+    log(...args) {
+        if (this.debug) {
+            console.log('[国际化 Debug]', ...args);
+        }
+    }
+    /**
+     * 获取已上报缓存的总键数量
+     */
+    getTotalReportedKeysCount() {
+        let count = 0;
+        for (const keySet of Object.values(this.reportedKeyCache)) {
+            count += keySet.size;
+        }
+        return count;
+    }
+    /**
+     * LRU 缓存清理机制 - 当缓存达到上限时，清理最旧的 20% 条目
+     */
+    evictOldestReportedKeys() {
+        if (this.maxReportedKeysCache === 0) {
+            // 0 表示不限制
+            return;
+        }
+        const totalCount = this.getTotalReportedKeysCount();
+        if (totalCount <= this.maxReportedKeysCache) {
+            return; // 未达到上限，无需清理
+        }
+        // 计算需要删除的数量（清理 20%）
+        const evictCount = Math.floor(this.maxReportedKeysCache * 0.2);
+        this.log(`缓存达到上限 (${totalCount}/${this.maxReportedKeysCache})，开始清理最旧的 ${evictCount} 条记录`);
+        // 按时间戳排序，找出最旧的条目
+        const sortedEntries = Array.from(this.reportedKeysOrder.entries())
+            .sort((a, b) => a[1] - b[1]) // 按时间戳升序排序
+            .slice(0, evictCount); // 取最旧的 evictCount 条
+        // 删除这些条目
+        let deletedCount = 0;
+        for (const [fullKey] of sortedEntries) {
+            const [domainCode, keyCode] = fullKey.split(':');
+            if (this.reportedKeyCache[domainCode]) {
+                this.reportedKeyCache[domainCode].delete(keyCode);
+                deletedCount++;
+                // 如果该域的 Set 为空，删除整个域
+                if (this.reportedKeyCache[domainCode].size === 0) {
+                    delete this.reportedKeyCache[domainCode];
+                }
+            }
+            // 从顺序跟踪中删除
+            this.reportedKeysOrder.delete(fullKey);
+        }
+        this.log(`LRU 清理完成，已删除 ${deletedCount} 条记录，当前缓存数量: ${this.getTotalReportedKeysCount()}`);
+    }
+    /**
+     * 统一的变量替换方法 - 支持嵌套对象路径和复杂变量替换
+     * @param template 模板字符串，支持 {key} 或 {key.subkey} 格式的变量
+     * @param params 参数对象，支持嵌套对象
+     * @param options 可选配置
+     * @returns 替换后的字符串
+     */
+    interpolateVariables(template, params, options) {
+        // 默认配置
+        const config = {
+            fallbackToOriginal: true,
+            logWarnings: true,
+            escapeHtml: false,
+            ...options,
+        };
+        // 输入验证
+        if (!template || typeof template !== 'string') {
+            return template || '';
+        }
+        if (!params || typeof params !== 'object') {
+            return template;
+        }
+        try {
+            // 正则匹配 {key} 或 {key.subkey} 格式的变量
+            const result = template.replace(/\{([^}]+)\}/g, (match, keyPath) => {
+                try {
+                    // 按点号分割路径，支持嵌套访问
+                    const keys = keyPath.trim().split('.');
+                    let value = params;
+                    // 逐层取值
+                    for (const key of keys) {
+                        if (value && typeof value === 'object' && key in value) {
+                            value = value[key];
+                        }
+                        else {
+                            // 如果路径不存在
+                            if (config.logWarnings) {
+                                console.warn(`国际化 变量替换失败: 路径 "${keyPath}" 不存在于参数中`, params);
+                            }
+                            return config.fallbackToOriginal ? match : '';
+                        }
+                    }
+                    // 处理不同类型的值
+                    let finalValue;
+                    if (value === null || value === undefined) {
+                        finalValue = '';
+                    }
+                    else if (typeof value === 'object') {
+                        // 对象类型转为JSON字符串
+                        finalValue = JSON.stringify(value);
+                    }
+                    else {
+                        // 其他类型转为字符串
+                        finalValue = String(value);
+                    }
+                    // HTML转义（如果需要）
+                    if (config.escapeHtml) {
+                        finalValue = finalValue
+                            .replace(/&/g, '&amp;')
+                            .replace(/</g, '&lt;')
+                            .replace(/>/g, '&gt;')
+                            .replace(/"/g, '&quot;')
+                            .replace(/'/g, '&#x27;');
+                    }
+                    return finalValue;
+                }
+                catch (error) {
+                    if (config.logWarnings) {
+                        console.error(`国际化 变量替换错误: 路径 "${keyPath}"`, error);
+                    }
+                    return config.fallbackToOriginal ? match : '';
+                }
+            });
+            return result;
+        }
+        catch (error) {
+            console.error('国际化 变量替换方法执行失败:', error);
+            return template;
+        }
+    }
+    /**
+     * 获取国际化热数据
+     */
+    async fetchLangDictHotData(systemCode) {
+        this.log('开始获取热数据, systemCode:', systemCode);
+        try {
+            const params = {
+                systemCode,
+            };
+            const res = await this.apiConfig.queryLangDictHotData(params);
+            this.log('热数据获取成功:', res.data);
+            // 使用工具类处理接口返回的国际化数据
+            await this.updateI18nMessages(res.data);
+        }
+        catch (error) {
+            console.error('[国际化] 获取国际化数据失败:', error);
+            this.log('尝试从缓存加载语言包');
+            // 从缓存获取语言包
+            const cachedLangDict = this.cacheManager.getLangDictFromCache();
+            if (cachedLangDict) {
+                this.log('找到缓存的语言包，使用缓存数据');
+                try {
+                    // 使用缓存的语言包，但不再次保存到缓存
+                    await this.updateI18nMessages(cachedLangDict, false);
+                    this.log('缓存语言包加载成功');
+                }
+                catch (cacheError) {
+                    console.error('[国际化] 加载缓存语言包失败:', cacheError);
+                }
+            }
+            else {
+                this.log('没有找到可用的缓存语言包');
+            }
+        }
+    }
+    /**
+     * 批量冷数据&缺失数据上报
+     */
+    async batchReportMissingKeys() {
+        if (Object.keys(this.missingKeyCache).length === 0 && Object.keys(this.usedKeyCache).length === 0) {
+            this.log('没有需要上报的缺失键或已用键');
+            return;
+        }
+        // 获取所有涉及的域代码
+        const allDomainCodes = new Set([
+            ...Object.keys(this.missingKeyCache),
+            ...Object.keys(this.usedKeyCache),
+        ]);
+        // 构建所有域的数据列表
+        const langDictColdDataCmdList = [];
+        for (const domainCode of allDomainCodes) {
+            // 过滤掉已上报过的键
+            const missingKeysSet = this.missingKeyCache[domainCode] || new Set();
+            const reportedKeysSet = this.reportedKeyCache[domainCode] || new Set();
+            // 只上报未上报过的缺失键
+            const missingKeys = Array.from(missingKeysSet).filter(key => !reportedKeysSet.has(key));
+            const usedKeys = Array.from(this.usedKeyCache[domainCode] || []);
+            if (missingKeys.length === 0 && usedKeys.length === 0)
+                continue;
+            langDictColdDataCmdList.push({
+                missingDictKeyList: missingKeys,
+                usedDictKeyList: usedKeys,
+                domainCode,
+            });
+        }
+        // 统一一次上报所有域的数据
+        if (langDictColdDataCmdList.length > 0) {
+            const params = {
+                langDictColdDataCmdList,
+            };
+            const totalMissingKeys = langDictColdDataCmdList.reduce((sum, item) => sum + item.missingDictKeyList.length, 0);
+            const totalUsedKeys = langDictColdDataCmdList.reduce((sum, item) => sum + item.usedDictKeyList.length, 0);
+            this.log(`开始批量上报翻译数据: 域数量=${langDictColdDataCmdList.length}, 总缺失键=${totalMissingKeys}, 总已用键=${totalUsedKeys}`, params);
+            try {
+                const res = await this.apiConfig.queryLangDictColdData(params);
+                this.log('冷数据上报成功，返回数据:', res.data);
+                // 上报成功后，将这些键添加到已上报缓存中
+                for (const item of langDictColdDataCmdList) {
+                    const { domainCode, missingDictKeyList } = item;
+                    // 初始化已上报缓存
+                    if (!this.reportedKeyCache[domainCode]) {
+                        this.reportedKeyCache[domainCode] = new Set();
+                    }
+                    // 将成功上报的缺失键添加到已上报缓存
+                    const timestamp = Date.now();
+                    missingDictKeyList.forEach(key => {
+                        this.reportedKeyCache[domainCode].add(key);
+                        // 记录到 LRU 顺序跟踪中
+                        const fullKey = `${domainCode}:${key}`;
+                        this.reportedKeysOrder.set(fullKey, timestamp);
+                    });
+                    this.log(`域 ${domainCode} 的 ${missingDictKeyList.length} 个缺失键已标记为已上报`);
+                }
+                // 检查并执行 LRU 清理
+                this.evictOldestReportedKeys();
+                // 处理返回的冷数据，合并到当前国际化语言包中
+                if (res.data) {
+                    await this.updateI18nMessages(res.data);
+                }
+            }
+            catch (error) {
+                console.error(`国际化 统一上报翻译数据失败: 域数量=${langDictColdDataCmdList.length}, 总缺失键数量=${totalMissingKeys}, 总已用键数量=${totalUsedKeys}`, error);
+                // 上报失败时不添加到已上报缓存，下次继续尝试上报
+            }
+        }
+        // 清空缓存
+        Object.keys(this.missingKeyCache).forEach((domainCode) => {
+            this.missingKeyCache[domainCode].clear();
+        });
+        Object.keys(this.usedKeyCache).forEach((domainCode) => {
+            this.usedKeyCache[domainCode].clear();
+        });
+    }
+    /**
+     * 自定义翻译查找函数，直接从语言包中查找翻译并完成变量替换
+     * @param key 翻译键
+     * @param domainCode 域代码
+     * @param locale 目标语言
+     * @param params 变量替换参数
+     * @returns 翻译结果或null
+     */
+    findTranslation(key, domainCode, locale, params) {
+        try {
+            // 获取当前语言的语言包
+            const messages = this.getI18nMessages();
+            const localeMessages = messages[locale];
+            if (!localeMessages) {
+                console.warn(`国际化 语言包不存在: ${locale}`);
+                return null;
+            }
+            // 查找域下的翻译
+            const domainMessages = localeMessages[domainCode];
+            if (!domainMessages) {
+                console.warn(`国际化 域代码不存在: ${domainCode} in ${locale}`);
+                return null;
+            }
+            // 获取翻译模板
+            const template = domainMessages[key];
+            if (typeof template !== 'string') {
+                console.warn(`国际化 翻译键不存在: ${key} in ${domainCode}.${locale}`);
+                return null;
+            }
+            // 使用统一的变量替换方法
+            const result = this.interpolateVariables(template, params, {
+                fallbackToOriginal: true,
+                logWarnings: true,
+                escapeHtml: false,
+            });
+            return result;
+        }
+        catch (error) {
+            console.error(`国际化 查找翻译出错: key=${key}, domain=${domainCode}, locale=${locale}`, error);
+            return null;
+        }
+    }
+    /**
+     * 自定义翻译函数，支持缺失翻译的处理和手动变量替换
+     * @param key 翻译键
+     * @param params 翻译参数
+     * @returns 翻译结果
+     */
+    safeTranslate(key, params, domainCode) {
+        this.log('开始翻译:', { key, params, domainCode });
+        try {
+            let result = null;
+            // 获取当前语言
+            const currentLocale = typeof this.i18n.global.locale === 'string'
+                ? this.i18n.global.locale
+                : this.i18n.global.locale.value;
+            this.log('当前语言:', currentLocale);
+            // 使用传入的域代码，如果没有传入则使用默认域代码
+            const finalDomainCode = domainCode || this.defaultLangDictDomainCode;
+            this.log('使用域代码:', finalDomainCode);
+            // 首先尝试在当前语言中查找（包含变量替换）
+            result = this.findTranslation(key, finalDomainCode, currentLocale, params);
+            // 如果找到了翻译
+            if (result !== null) {
+                this.log('翻译成功:', { key, result });
+                // 记录成功翻译的键到已使用键缓存
+                if (!this.usedKeyCache[finalDomainCode]) {
+                    this.usedKeyCache[finalDomainCode] = new Set();
+                    this.log('初始化已使用键缓存:', finalDomainCode);
+                }
+                this.usedKeyCache[finalDomainCode].add(key);
+                this.log('添加到已使用键缓存:', { domainCode: finalDomainCode, key, 当前缓存数量: this.usedKeyCache[finalDomainCode].size });
+                return result;
+            }
+            else {
+                this.log('翻译未找到，将作为缺失键处理:', key);
+                // 调用缺失翻译处理
+                const domainKey = `${finalDomainCode}.${key}`;
+                this.handleMissing(currentLocale, domainKey);
+                // 返回原始键名，但仍需要进行变量替换
+                result = this.interpolateVariables(key, params, {
+                    fallbackToOriginal: true,
+                    logWarnings: false, // 对原始键不记录警告
+                    escapeHtml: false,
+                });
+                this.log('返回原始键名（已替换变量）:', result);
+                return result;
+            }
+        }
+        catch (error) {
+            console.error(`国际化 翻译错误: 键=${key}, 错误=${error}`);
+            this.log('翻译发生错误，返回原始键名:', key);
+            return key; // 返回键名作为fallback
+        }
+    }
+    /**
+     * 处理缺失翻译
+     */
+    handleMissing(locale, domainKey) {
+        this.log('检测到缺失翻译键:', { locale, domainKey });
+        // 只分割第一个点号，避免key中包含...等多个点的情况
+        const dotIndex = domainKey.indexOf('.');
+        const domainCode = dotIndex !== -1 ? domainKey.substring(0, dotIndex) : this.defaultLangDictDomainCode;
+        const keyCode = dotIndex !== -1 ? domainKey.substring(dotIndex + 1) : domainKey;
+        this.log('解析缺失翻译键:', { domainCode, keyCode });
+        // 初始化已上报缓存
+        if (!this.reportedKeyCache[domainCode]) {
+            this.reportedKeyCache[domainCode] = new Set();
+        }
+        // 检查是否已经上报过，如果已上报则直接返回，不再添加到缓存
+        if (this.reportedKeyCache[domainCode].has(keyCode)) {
+            this.log('该键已上报过，跳过:', { domainCode, keyCode });
+            return this.defaultLocale;
+        }
+        // 初始化域代码对应的缓存集合
+        if (!this.missingKeyCache[domainCode]) {
+            this.missingKeyCache[domainCode] = new Set();
+            this.log('初始化缺失键缓存:', domainCode);
+        }
+        // 检查是否已经缓存过此键，避免重复添加
+        if (!this.missingKeyCache[domainCode].has(keyCode)) {
+            this.missingKeyCache[domainCode].add(keyCode);
+            this.log('添加缺失键到缓存:', { domainCode, keyCode, 当前缓存数量: this.missingKeyCache[domainCode].size });
+        }
+        else {
+            this.log('缺失键已存在于缓存中，跳过:', { domainCode, keyCode });
+        }
+        // 重置定时器，使用防抖机制
+        if (this.reportTimer) {
+            clearTimeout(this.reportTimer);
+            this.log('重置上报定时器');
+        }
+        this.reportTimer = setTimeout(() => {
+            this.log(`防抖延迟 ${this.reportDelay}ms 后触发批量上报`);
+            this.batchReportMissingKeys();
+            this.reportTimer = null;
+        }, this.reportDelay);
+        return this.defaultLocale;
+    }
+    /**
+     * 立即上报所有缓存的缺失翻译键
+     * 用于页面卸载或其他需要立即上报的场景
+     */
+    async flushMissingKeys() {
+        if (this.reportTimer) {
+            clearTimeout(this.reportTimer);
+            this.reportTimer = null;
+        }
+        return this.batchReportMissingKeys();
+    }
+    /**
+     * 获取当前缓存的翻译键统计信息
+     */
+    getTranslationKeysStats() {
+        const missingStats = {};
+        const usedStats = {};
+        const reportedStats = {};
+        for (const [domainCode, keySet] of Object.entries(this.missingKeyCache)) {
+            missingStats[domainCode] = keySet.size;
+        }
+        for (const [domainCode, keySet] of Object.entries(this.usedKeyCache)) {
+            usedStats[domainCode] = keySet.size;
+        }
+        for (const [domainCode, keySet] of Object.entries(this.reportedKeyCache)) {
+            reportedStats[domainCode] = keySet.size;
+        }
+        return {
+            missingKeys: missingStats,
+            usedKeys: usedStats,
+            reportedKeys: reportedStats,
+        };
+    }
+    /**
+     * 清空已上报键缓存（可选，用于需要重新上报的场景）
+     */
+    clearReportedKeysCache() {
+        this.reportedKeyCache = {};
+        this.reportedKeysOrder.clear();
+        this.log('已上报键缓存已清空');
+    }
+    /**
+     * 获取缓存内存使用情况（用于监控和调试）
+     */
+    getCacheMemoryInfo() {
+        const reportedKeysCount = this.getTotalReportedKeysCount();
+        const usagePercentage = this.maxReportedKeysCache > 0
+            ? Math.round((reportedKeysCount / this.maxReportedKeysCache) * 100)
+            : 0;
+        let missingKeysCount = 0;
+        for (const keySet of Object.values(this.missingKeyCache)) {
+            missingKeysCount += keySet.size;
+        }
+        let usedKeysCount = 0;
+        for (const keySet of Object.values(this.usedKeyCache)) {
+            usedKeysCount += keySet.size;
+        }
+        return {
+            reportedKeysCount,
+            maxReportedKeysCache: this.maxReportedKeysCache,
+            usagePercentage,
+            missingKeysCount,
+            usedKeysCount,
+        };
+    }
+    isVue2I18n() {
+        return typeof this.i18n.global === 'undefined';
+    }
+    /**
+     * 更新国际化语言包
+     * @param langDictData 接口返回的语言包数据
+     * @param saveToCache 是否保存到本地缓存，默认true
+     */
+    async updateI18nMessages(langDictData, saveToCache = true) {
+        try {
+            this.log('开始更新国际化语言包, saveToCache:', saveToCache);
+            this.log('接收到的语言包数据:', langDictData);
+            const { zh_cn: zhHans, zh_hk: zhHant, ...other } = langDictData;
+            const correctDictionaryData = {
+                'zh-Hans': zhHans,
+                'zh-Hant': zhHant,
+                ...other,
+            };
+            // 获取 i18n.global 中现有的语言包
+            const currentMessages = this.getI18nMessages();
+            // 使用 Lodash merge 深度合并
+            const allMessage = lodash.merge({}, currentMessages, correctDictionaryData);
+            this.log('合并后的语言包:', allMessage);
+            let isVue2 = this.isVue2I18n();
+            // 更新 i18n 实例的语言包
+            Object.keys(allMessage).forEach((langCode) => {
+                const item = allMessage[langCode];
+                if (isVue2) {
+                    this.i18n.mergeLocaleMessage(langCode, item);
+                }
+                else {
+                    this.i18n.global.setLocaleMessage(langCode, item);
+                }
+            });
+            // 保存语言包到本地缓存
+            if (saveToCache) {
+                const version = `v${Date.now()}`; // 使用时间戳作为版本号
+                this.log(`保存语言包到缓存, version: ${version}`, allMessage);
+                this.cacheManager.saveLangDictToCache(allMessage, version);
+            }
+            // 强制触发响应式更新 - 通过重新设置 locale 来触发所有依赖更新
+            const currentLocale = typeof this.i18n.global.locale === 'string'
+                ? this.i18n.global.locale
+                : this.i18n.global.locale.value;
+            if (typeof this.i18n.global.locale === 'string') {
+                this.i18n.global.locale = currentLocale;
+                setTimeout(() => {
+                    this.i18n.global.locale = currentLocale;
+                }, 0);
+            }
+            else if ('value' in this.i18n.global.locale) {
+                this.i18n.global.locale.value = currentLocale;
+                setTimeout(() => {
+                    this.i18n.global.locale.value = currentLocale;
+                }, 0);
+            }
+            // 发送全局事件通知所有组件语言包已更新
+            if (typeof uni !== 'undefined') {
+                uni.$emit('i18n:updated', {
+                    locale: currentLocale,
+                    messages: allMessage[currentLocale],
+                });
+            }
+        }
+        catch (error) {
+            console.error('[国际化] 更新国际化语言包失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 切换语言
+     * @param setLanguageIdentifier 语言标识符
+     */
+    switchLocale(setLanguageIdentifier) {
+        let targetLocale = 'zh-Hans';
+        if (setLanguageIdentifier === exports.LANGUAGE_OPTIONS_CONFIGURATION.FOLLOW_SYSTEM) {
+            // 跟随系统语言
+            targetLocale = uni.getLocale();
+            this.log(`跟随系统语言: ${targetLocale}`);
+        }
+        else {
+            targetLocale = setLanguageIdentifier;
+            this.log(`切换到指定语言: ${targetLocale}`);
+        }
+        try {
+            // 检查语言包是否存在
+            if (!this.hasLocale(targetLocale)) {
+                console.warn(`[国际化] 语言包不存在: ${targetLocale}`);
+                return;
+            }
+            // 设置新的语言 - 根据 i18n 配置使用正确的方式
+            if (typeof this.i18n.global.locale === 'string') {
+                // Legacy 模式
+                this.i18n.global.locale = targetLocale;
+                this.log('使用 Legacy 模式设置语言');
+            }
+            else {
+                // Composition API 模式
+                this.i18n.global.locale.value = targetLocale;
+                this.log('使用 Composition API 模式设置语言');
+            }
+            // 保存新语言到缓存
+            this.cacheManager.saveLocaleToCache(setLanguageIdentifier);
+            this.log('语言设置已保存到缓存');
+            // 调用钩子函数通知语言已切换
+            if (this.onLocaleChanged) {
+                const messages = this.getI18nMessages();
+                this.log('调用 onLocaleChanged 钩子');
+                this.onLocaleChanged({
+                    targetLocale,
+                    messages: messages[targetLocale],
+                });
+            }
+            this.log(`语言切换完成: ${targetLocale}`);
+        }
+        catch (error) {
+            console.error('[国际化] 语言切换失败:', error);
+            throw error;
+        }
+    }
+    /**
+     * 获取当前语言 (Vue3 版本)
+     */
+    getCurrentLocale() {
+        if (typeof this.i18n?.global?.locale === 'string') {
+            return this.i18n.global.locale;
+        }
+        else {
+            if (typeof this.i18n.global !== 'undefined') {
+                return this.i18n?.global.locale?.value;
+            }
+            else {
+                return this.getCurrentLocaleVue2();
+            }
+        }
+    }
+    /**
+     * 获取当前语言 (Vue2 版本 - vue-i18n@8)
+     * Vue2 的 VueI18n 实例直接通过 i18n.locale 访问，而不是 i18n.global.locale
+     */
+    getCurrentLocaleVue2() {
+        // Vue2 i18n@8 的方式：直接访问 this.i18n.locale
+        const i18nAny = this.i18n;
+        if (i18nAny.locale) {
+            return typeof i18nAny.locale === 'string'
+                ? i18nAny.locale
+                : i18nAny.locale;
+        }
+        return this.defaultLocale;
+    }
+    /**
+     * 检查语言包是否存在
+     * @param locale 语言代码
+     */
+    hasLocale(locale) {
+        const messages = this.getI18nMessages();
+        return locale in messages;
+    }
+    /**
+     * 获取当前 i18n 语言标识
+     */
+    getI18nLang() {
+        const currentLocale = typeof this.i18n.global.locale === 'string'
+            ? this.i18n.global.locale
+            : this.i18n.global.locale.value;
+        return currentLocale;
+    }
+    /**
+     * 获取请求头使用的语言标识
+     */
+    getHeaderLang() {
+        const langMap = {
+            'zh-Hans': 'zh_cn',
+            'zh-Hant': 'zh_hk',
+            en: 'en',
+        };
+        const lang = this.getI18nLang();
+        const headerLang = langMap[lang] || 'zh_cn';
+        return headerLang;
+    }
+    /**
+     * 获取 i18n messages 的兼容性方法
+     * 兼容 vue-i18n@8 和 vue-i18n@9+ 版本
+     */
+    getI18nMessages() {
+        try {
+            // vue-i18n@8 版本，messages 是普通对象
+            if (this.isVue2I18n()) {
+                return this.i18n.messages;
+            }
+            // vue-i18n@9+ 版本，messages 是 Ref 对象
+            if (this.i18n.global.messages && typeof this.i18n.global.messages === 'object' && 'value' in this.i18n.global.messages) {
+                return this.i18n.global.messages.value;
+            }
+            // 兜底情况
+            this.log('警告: 无法获取 i18n messages，返回空对象');
+            return {};
+        }
+        catch (error) {
+            console.error('[国际化] 获取 i18n messages 失败:', error);
+            return {};
+        }
+    }
+}
+
+/**
+ * 默认配置
+ */
+const DEFAULT_CONFIG = {
+    /** 默认语言 */
+    defaultLocale: 'zh-Hans',
+    /** 默认领域代码 */
+    defaultLangDictDomainCode: 'TALENTS',
+    /** 语言代码映射 */
+    localeMap: {
+        'zh-CN': 'zh-Hans',
+        'zh-Hans': 'zh-Hans',
+        'zh-Hant': 'zh-Hant',
+        en: 'en',
+    },
+    /** 缓存键名 */
+    localeCacheKey: 'APP_LOCALE_SETTING',
+    /** 语言包缓存键名 */
+    langDictCacheKey: 'APP_LANG_DICT_CACHE',
+    /** 缓存最大有效期（毫秒），默认365天 */
+    cacheMaxAge: 365 * 24 * 60 * 60 * 1000,
+    /** 上报延迟时间（毫秒），默认5000ms */
+    reportDelay: 5000,
+    /** 是否启用调试模式，默认false */
+    debug: false,
+    /** 已上报键缓存最大数量，默认10000，0表示不限制 */
+    maxReportedKeysCache: 10000,
+};
+/**
+ * 语言代码映射函数
+ */
+function getMappedLocale(locale, localeMap) {
+    const map = localeMap || DEFAULT_CONFIG.localeMap;
+    return map[locale] || DEFAULT_CONFIG.defaultLocale;
+}
+
+/**
+ * MeetFun I18n 实例
+ */
+class MeetFunI18n {
+    constructor(baseMessages, apiConfig, userConfig = {}) {
+        /**
+         * 翻译函数
+         */
+        this.$t = (key, params) => {
+            return this.translateManager.safeTranslate(key, params);
+        };
+        /**
+         * 获取语言包热数据
+         */
+        this.fetchLangDictHotData = async () => {
+            if (!this.config.systemCode) {
+                console.warn('[国际化] systemCode 未配置，无法获取热数据');
+                return;
+            }
+            return this.translateManager.fetchLangDictHotData(this.config.systemCode);
+        };
+        /**
+         * 更新国际化语言包
+         */
+        this.updateI18nMessages = async (langDictData, saveToCache = true) => {
+            return this.translateManager.updateI18nMessages(langDictData, saveToCache);
+        };
+        /**
+         * 切换语言
+         */
+        this.switchLocale = (locale) => {
+            return this.translateManager.switchLocale(locale);
+        };
+        /**
+         * 获取当前语言
+         */
+        this.getCurrentLocale = () => {
+            return this.translateManager.getCurrentLocale();
+        };
+        /**
+         * 获取 i18n 语言标识
+         */
+        this.getI18nLang = () => {
+            return this.translateManager.getI18nLang();
+        };
+        /**
+         * 获取请求头语言标识
+         */
+        this.getHeaderLang = () => {
+            return this.translateManager.getHeaderLang();
+        };
+        /**
+         * 立即上报缺失键
+         */
+        this.flushMissingKeys = () => {
+            return this.translateManager.flushMissingKeys();
+        };
+        /**
+         * 获取翻译键统计信息
+         */
+        this.getTranslationKeysStats = () => {
+            return this.translateManager.getTranslationKeysStats();
+        };
+        /**
+         * 检查语言包是否存在
+         */
+        this.hasLocale = (locale) => {
+            return this.translateManager.hasLocale(locale);
+        };
+        /**
+         * 变量替换
+         */
+        this.interpolateVariables = (template, params, options) => {
+            return this.translateManager.interpolateVariables(template, params, options);
+        };
+        /**
+         * 获取缓存的语言设置
+         */
+        this.getCachedLocale = () => {
+            return this.cacheManager.getCachedLocale();
+        };
+        /**
+         * 保存语言设置到缓存
+         */
+        this.saveLocaleToCache = (locale) => {
+            return this.cacheManager.saveLocaleToCache(locale);
+        };
+        /**
+         * 清除语言包缓存
+         */
+        this.clearLangDictCache = () => {
+            return this.cacheManager.clearLangDictCache();
+        };
+        /**
+         * 清空已上报键缓存
+         */
+        this.clearReportedKeysCache = () => {
+            return this.translateManager.clearReportedKeysCache();
+        };
+        /**
+         * 获取缓存内存使用情况（用于监控和调试）
+         */
+        this.getCacheMemoryInfo = () => {
+            return this.translateManager.getCacheMemoryInfo();
+        };
+        /**
+         * 创建国际化代理对象
+         * 用于创建一个对象，当访问属性时自动通过翻译函数进行国际化转换
+         *
+         * @param data 原始数据对象
+         * @param config 配置选项
+         * @returns 代理对象
+         *
+         * @example
+         * ```typescript
+         * const roleNames = i18nInstance.createI18nProxy({
+         *   PRODUCING_AREA: 'role.PRODUCING_AREA',
+         *   PRESENTATION_AREA: 'role.PRESENTATION_AREA'
+         * })
+         *
+         * // 访问时会自动调用翻译函数
+         * console.log(roleNames.PRODUCING_AREA)
+         * console.log(roleNames['PRODUCING_AREA'])
+         * ```
+         */
+        this.createI18nProxy = (data, config = {}) => {
+            const proxyConfig = {
+                fallbackToKey: true,
+                debug: false,
+                ...config,
+            };
+            // 创建 Proxy 来拦截属性访问
+            return new Proxy(data, {
+                get: (target, prop) => {
+                    if (typeof prop === 'symbol') {
+                        return target[prop];
+                    }
+                    const originalValue = target[prop];
+                    if (originalValue === undefined) {
+                        if (proxyConfig.debug) {
+                            console.warn(`I18nProxy: 键 "${String(prop)}" 不存在于源数据中`);
+                        }
+                        return String(prop);
+                    }
+                    // 使用原始值作为翻译键
+                    const translationKey = originalValue;
+                    if (proxyConfig.debug) {
+                        console.log(`I18nProxy: 翻译键 "${String(prop)}" -> "${translationKey}"`);
+                    }
+                    try {
+                        // 调用翻译函数
+                        const translatedValue = this.$t(translationKey);
+                        if (proxyConfig.debug) {
+                            console.log(`I18nProxy: 翻译结果 "${translationKey}" -> "${translatedValue}"`);
+                        }
+                        // 如果翻译结果和翻译键相同，说明没有找到翻译
+                        if (translatedValue === translationKey && proxyConfig.fallbackToKey) {
+                            return originalValue; // 返回原始值
+                        }
+                        return translatedValue;
+                    }
+                    catch (error) {
+                        if (proxyConfig.debug) {
+                            console.error(`I18nProxy: 翻译错误 "${translationKey}":`, error);
+                        }
+                        return proxyConfig.fallbackToKey ? originalValue : String(prop);
+                    }
+                },
+                // 支持 Object.keys() 等操作
+                ownKeys: (target) => {
+                    return Reflect.ownKeys(target);
+                },
+                // 支持 hasOwnProperty 检查
+                has: (target, prop) => {
+                    return Reflect.has(target, prop);
+                },
+                // 支持 getOwnPropertyDescriptor
+                getOwnPropertyDescriptor: (target, prop) => {
+                    return Reflect.getOwnPropertyDescriptor(target, prop);
+                },
+            });
+        };
+        /**
+         * 创建枚举类型的国际化代理
+         * 专门用于处理枚举值到翻译键的映射
+         *
+         * @param enumObject 枚举对象
+         * @param config 额外配置
+         * @returns 代理对象
+         *
+         * @example
+         * ```typescript
+         * const statusEnum = i18nInstance.createEnumI18nProxy({
+         *   ACTIVE: 'status.active',
+         *   INACTIVE: 'status.inactive'
+         * })
+         * ```
+         */
+        this.createEnumI18nProxy = (enumObject, config) => {
+            return this.createI18nProxy(enumObject, config);
+        };
+        // 合并配置
+        this.config = {
+            ...DEFAULT_CONFIG,
+            ...userConfig,
+            systemCode: userConfig.systemCode || '',
+        };
+        // 初始化缓存管理器
+        this.cacheManager = new CacheManager(this.config.localeCacheKey, this.config.langDictCacheKey, this.config.cacheMaxAge, baseMessages);
+        // 获取初始语言设置
+        const currentLocale = this.getInitialLocale();
+        // 获取合并了缓存的初始语言包
+        const initialMessages = this.cacheManager.getInitialMergedMessages();
+        // 创建 i18n 实例
+        this.i18n = vueI18n.createI18n({
+            locale: currentLocale,
+            messages: initialMessages,
+            allowComposition: true,
+            globalInjection: false,
+            fallbackLocale: this.config.defaultLocale,
+            missingWarn: true,
+            fallbackWarn: true,
+            legacy: false,
+        });
+        // 初始化翻译管理器
+        this.translateManager = new TranslateManager(this.i18n, this.cacheManager, apiConfig, this.config.defaultLocale, this.config.defaultLangDictDomainCode, this.config.reportDelay, this.config.onLocaleChanged, this.config.debug, this.config.maxReportedKeysCache);
+        // 设置 missing handler
+        if ('missing' in this.i18n.global) {
+            this.i18n.global.missing = (locale, key) => {
+                return this.translateManager.handleMissing(locale, key);
+            };
+        }
+    }
+    /**
+     * 获取初始语言设置
+     */
+    getInitialLocale() {
+        const systemLocale = uni.getLocale();
+        const setLanguageIdentifier = this.cacheManager.getCachedLocale();
+        // 优先使用缓存的语言，如果没有缓存则使用系统语言
+        // 如果缓存的是 followSystem，则使用系统语言
+        let currentLocale;
+        if (setLanguageIdentifier === exports.LANGUAGE_OPTIONS_CONFIGURATION.FOLLOW_SYSTEM ||
+            !setLanguageIdentifier) {
+            currentLocale = getMappedLocale(systemLocale, this.config.localeMap) || this.config.defaultLocale;
+        }
+        else {
+            currentLocale =
+                getMappedLocale(setLanguageIdentifier, this.config.localeMap) || this.config.defaultLocale;
+        }
+        return currentLocale;
+    }
+    /**
+     * 获取 i18n 实例
+     */
+    getI18n() {
+        return this.i18n;
+    }
+}
+/**
+ * 创建 MeetFun I18n 实例的工厂函数
+ *
+ * @param baseMessages 基础语言包
+ * @param apiConfig API 配置
+ * @param userConfig 用户配置
+ * @returns MeetFunI18n 实例
+ *
+ * @example
+ * ```typescript
+ * import { createMeetFunI18n } from '@meetfun/i18n'
+ * import zhHans from './locales/zh-Hans.json'
+ * import zhHant from './locales/zh-Hant.json'
+ * import en from './locales/en.json'
+ * import { queryLangDictHotData, queryLangDictColdData } from './api/translate'
+ *
+ * const baseMessages = {
+ *   'zh-Hans': zhHans,
+ *   'zh-Hant': zhHant,
+ *   en: en,
+ * }
+ *
+ * const apiConfig = {
+ *   queryLangDictHotData,
+ *   queryLangDictColdData,
+ * }
+ *
+ * const i18nInstance = createMeetFunI18n(baseMessages, apiConfig, {
+ *   defaultLocale: 'zh-Hans',
+ *   defaultLangDictDomainCode: 'TALENTS',
+ *   systemCode: 'TALENTS_STUDENT',
+ *   debug: true, // 启用调试模式，会输出详细日志
+ *   onLocaleChanged: (payload) => {
+ *     console.log('语言已切换:', payload.targetLocale)
+ *     // 可以在这里执行其他需要的操作
+ *   }
+ * })
+ *
+ * // 在 main.ts 中安装
+ * app.use(i18nInstance.getI18n())
+ *
+ * // 使用翻译函数
+ * const text = i18nInstance.$t('welcomeMessage')
+ * ```
+ */
+function createMeetFunI18n(baseMessages, apiConfig, userConfig) {
+    return new MeetFunI18n(baseMessages, apiConfig, userConfig);
+}
+
+exports.MeetFunI18n = MeetFunI18n;
+exports.createMeetFunI18n = createMeetFunI18n;
+exports.default = createMeetFunI18n;
+//# sourceMappingURL=index.js.map