function _array_like_to_array(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
    return arr2;
}
function _array_with_holes(arr) {
    if (Array.isArray(arr)) return arr;
}
function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
function _iterable_to_array_limit(arr, i) {
    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
    if (_i == null) return;
    var _arr = [];
    var _n = true;
    var _d = false;
    var _s, _e;
    try {
        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
            _arr.push(_s.value);
            if (i && _arr.length === i) break;
        }
    } catch (err) {
        _d = true;
        _e = err;
    } finally{
        try {
            if (!_n && _i["return"] != null) _i["return"]();
        } finally{
            if (_d) throw _e;
        }
    }
    return _arr;
}
function _non_iterable_rest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _object_spread(target) {
    for(var i = 1; i < arguments.length; i++){
        var source = arguments[i] != null ? arguments[i] : {};
        var ownKeys = Object.keys(source);
        if (typeof Object.getOwnPropertySymbols === "function") {
            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
            }));
        }
        ownKeys.forEach(function(key) {
            _define_property(target, key, source[key]);
        });
    }
    return target;
}
function _sliced_to_array(arr, i) {
    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
}
function _unsupported_iterable_to_array(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _array_like_to_array(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(n);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
import { ConfigProvider } from "antd";
import React, { useContext, useEffect, useMemo, useState } from "react";
import { useRefFunction } from "../Hooks/useRefFunction";
import { cnLabels, enLabels } from "./locales";
export { cnLabels, enLabels };
/**
 * 语言检测工具函数
 *
 * 检测用户的语言偏好，支持多种检测方式：
 * 1. 浏览器语言设置
 * 2. Ant Design ConfigProvider 的 locale
 * 3. localStorage 中保存的用户选择
 * 4. 默认语言
 */ export function detectUserLanguage() {
    // 1. 优先检查 localStorage 中用户的选择
    if (typeof window !== 'undefined') {
        var savedLanguage = localStorage.getItem('md-editor-language');
        if (savedLanguage === 'zh-CN' || savedLanguage === 'en-US') {
            return savedLanguage;
        }
    }
    // 2. 检查 Ant Design ConfigProvider 的 locale
    try {
        var _document_querySelector;
        var antdLocale = (_document_querySelector = document.querySelector('[data-antd-locale]')) === null || _document_querySelector === void 0 ? void 0 : _document_querySelector.getAttribute('data-antd-locale');
        if (antdLocale) {
            if (antdLocale.toLowerCase().includes('zh')) {
                return 'zh-CN';
            }
            if (antdLocale.toLowerCase().includes('en')) {
                return 'en-US';
            }
        }
    } catch (error) {
    // 忽略错误，继续其他检测方式
    }
    // 3. 检测浏览器语言
    if (typeof navigator !== 'undefined') {
        var browserLanguages = navigator.languages || [
            navigator.language
        ];
        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
        try {
            for(var _iterator = browserLanguages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                var lang = _step.value;
                var langLower = (lang === null || lang === void 0 ? void 0 : lang.toLowerCase()) || 'zh-CN';
                if (langLower.startsWith('zh')) {
                    return 'zh-CN';
                }
                if (langLower.startsWith('en')) {
                    return 'en-US';
                }
            }
        } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
        } finally{
            try {
                if (!_iteratorNormalCompletion && _iterator.return != null) {
                    _iterator.return();
                }
            } finally{
                if (_didIteratorError) {
                    throw _iteratorError;
                }
            }
        }
    }
    // 4. 在测试环境中默认返回英文，其他环境返回中文
    if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
        return 'en-US';
    }
    return 'zh-CN';
}
/**
 * 获取对应的语言标签对象
 */ export function getLocaleByLanguage(language) {
    return language === 'zh-CN' ? cnLabels : enLabels;
}
/**
 * 保存用户语言选择到 localStorage
 */ export function saveUserLanguage(language) {
    if (typeof window !== 'undefined') {
        localStorage.setItem('md-editor-language', language);
    }
}
/**
 * 国际化上下文
 *
 * 提供国际化功能的React Context，包含当前语言环境和设置语言的方法。
 * 所有国际化文案应统一通过 I18nContext 获取，保证单一数据源。
 */ export var I18nContext = /*#__PURE__*/ React.createContext({
    locale: cnLabels,
    language: 'zh-CN'
});
/**
 * 从 I18nContext 获取当前 locale，国际化统一入口
 */ export function useLocale() {
    return useContext(I18nContext).locale;
}
/**
 * 获取合并后的 locale：以 I18nContext 为基准，用 override 覆盖部分 key
 * 用于 Bubble 等支持 config 级文案覆盖的场景，仍以 I18nContext 为主
 */ export function useMergedLocale(override) {
    var locale = useContext(I18nContext).locale;
    return useMemo(function() {
        return override ? _object_spread({}, locale, override) : locale;
    }, [
        locale,
        override
    ]);
}
/**
 * I18nProvide 组件 - 国际化提供者组件
 *
 * 该组件提供国际化功能，支持中英文切换，自动检测用户语言偏好。
 * 集成Ant Design的ConfigProvider，提供完整的国际化支持。
 *
 * @component
 * @description 国际化提供者组件，支持多语言切换
 * @param {Object} props - 组件属性
 * @param {React.ReactNode} props.children - 子组件
 * @param {typeof cnLabels} [props.locale] - 自定义语言环境
 * @param {'zh-CN' | 'en-US'} [props.defaultLanguage] - 默认语言
 * @param {boolean} [props.autoDetect=true] - 是否自动检测语言
 *
 * @example
 * ```tsx
 * <I18nProvide defaultLanguage="en-US" autoDetect={true}>
 *   <App />
 * </I18nProvide>
 * ```
 *
 * @returns {React.ReactElement} 渲染的国际化提供者组件
 *
 * @remarks
 * - 支持中英文语言切换
 * - 自动检测用户浏览器语言
 * - 集成Ant Design国际化
 * - 提供语言环境上下文
 * - 支持自定义语言配置
 * - 响应式语言切换
 * - 提供模板字符串编译功能
 * - 支持 localStorage 持久化语言选择
 * - 支持 Ant Design ConfigProvider 同步
 */ export var I18nProvide = function I18nProvide(props) {
    var _antdContext_locale;
    var _props_autoDetect = props.autoDetect, autoDetect = _props_autoDetect === void 0 ? true : _props_autoDetect, _props_defaultLanguage = props.defaultLanguage, defaultLanguage = _props_defaultLanguage === void 0 ? 'zh-CN' : _props_defaultLanguage;
    var antdContext = useContext(ConfigProvider.ConfigContext);
    // 初始化语言状态
    var _useState = _sliced_to_array(useState(function() {
        if (!autoDetect) {
            return defaultLanguage;
        }
        // 自动检测语言
        return detectUserLanguage();
    }), 2), language = _useState[0], setLanguageState = _useState[1];
    // 根据语言获取对应的标签对象
    var locale = useMemo(function() {
        return getLocaleByLanguage(language);
    }, [
        language
    ]);
    // 监听 Ant Design ConfigProvider 的 locale 变化
    useEffect(function() {
        if (!autoDetect || !(antdContext === null || antdContext === void 0 ? void 0 : antdContext.locale)) {
            return;
        }
        var antdLocale = antdContext.locale.locale;
        if (antdLocale) {
            var newLanguage = antdLocale.toLowerCase().includes('zh') ? 'zh-CN' : 'en-US';
            if (newLanguage !== language) {
                setLanguageState(newLanguage);
                saveUserLanguage(newLanguage);
            }
        }
    }, [
        antdContext === null || antdContext === void 0 ? void 0 : (_antdContext_locale = antdContext.locale) === null || _antdContext_locale === void 0 ? void 0 : _antdContext_locale.locale,
        autoDetect,
        language
    ]);
    // 语言切换处理函数
    var setLanguage = useRefFunction(function(newLanguage) {
        setLanguageState(newLanguage);
        saveUserLanguage(newLanguage);
    });
    // 兼容旧的 setLocale 接口
    var setLocale = useRefFunction(function(newLocale) {
        // 根据传入的 locale 对象判断语言
        var newLanguage = newLocale === cnLabels ? 'zh-CN' : 'en-US';
        setLanguage(newLanguage);
    });
    var contextValue = useMemo(function() {
        return {
            locale: props.locale || locale,
            language: language,
            setLanguage: setLanguage,
            setLocale: setLocale
        };
    }, [
        props.locale,
        locale,
        language,
        setLanguage,
        setLocale
    ]);
    return /*#__PURE__*/ React.createElement(I18nContext.Provider, {
        value: contextValue
    }, props.children);
};
/**
 * 编译模板字符串，将其中的变量占位符替换为对应的值
 *
 * @param template - 包含变量占位符的模板字符串，格式为 ${variableName}
 * @param variables - 变量名和对应值的键值对对象，默认为空对象
 * @returns 替换变量后的字符串。如果变量在variables中不存在，则显示为[variableName]
 *
 * @example
 * // 返回 "你好，世界！"
 * compileTemplate("你好，${name}！", { name: "世界" });
 *
 * // 返回 "你好，[name]！"（当变量未提供时）
 * compileTemplate("你好，${name}！");
 */ export function compileTemplate(template) {
    var variables = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
    return template.replace(/\$\{(\w+)\}/g, function(_, varName) {
        var _variables_varName;
        // 优先使用传入变量，找不到时显示变量名
        return (_variables_varName = variables[varName]) !== null && _variables_varName !== void 0 ? _variables_varName : "[".concat(varName, "]");
    });
}
