@alauda-fe/common 1.4.29-beta.0 → 1.4.29-beta.2

package/array-form-table/form/component.d.ts

@@ -83,7 +83,7 @@ export declare class ArrayFormTableComponent implements OnDestroy {
     addDisabled: boolean | '';
     actionColumnDivider: boolean | '';
     showZeroState: boolean;
-    get formDirective(): NgForm | FormGroupDirective;
+    get formDirective(): FormGroupDirective | NgForm;
     /**
      * 自定义是否展示错误内容
      * 例如 control 是 FormGroup，只有在内部子 control 错误时才需要展示错误内容

package/chart/common/series/bar-path.component.d.ts

@@ -40,7 +40,7 @@ export declare class BarPathComponent implements OnInit {
     ngOnInit(): void;
     getRectY: (index: number, y: number) => number;
     getStackedRectY: (index: number) => number;
-    handleVisibility: (name: string) => "hidden" | "";
+    handleVisibility: (name: string) => "" | "hidden";
     handleOpacity: (name: string | number | Date, activateLegend: string) => 1 | 0.2;
     static ɵfac: i0.ɵɵFactoryDeclaration<BarPathComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<BarPathComponent, "g[aclBarPath]", never, { "stroke": { "alias": "stroke"; "required": false; }; "data": { "alias": "data"; "required": false; }; "barPadding": { "alias": "barPadding"; "required": false; }; "groupName": { "alias": "groupName"; "required": false; }; "type": { "alias": "type"; "required": false; }; "bandWidth": { "alias": "bandWidth"; "required": false; }; "adaptiveBandWidth": { "alias": "adaptiveBandWidth"; "required": false; }; }, {}, never, never, false, never>;

package/chart/common/tooltip/tooltip.component.d.ts

@@ -55,7 +55,7 @@ export declare class ChartTooltipComponent implements OnInit, OnDestroy {
     activeLegend: string;
     get typeStandard(): boolean;
     get isBand(): boolean;
-    get anchorVisibility(): "hidden" | "";
+    get anchorVisibility(): "" | "hidden";
     get groupPosition(): {
         x1: number;
         x2: number;

package/core/abstract/base-nested-form-control.d.ts

@@ -21,7 +21,7 @@ export declare class BaseNestedFormControl<V, M = V> implements AfterViewInit, O
     protected asyncValidator: boolean;
     protected cdr: ChangeDetectorRef;
     protected destroy$$: Subject<void>;
-    protected hostForm: NgForm | FormGroupDirective;
+    protected hostForm: FormGroupDirective | NgForm;
     constructor();
     ngAfterViewInit(): void;
     ngOnDestroy(): void;

package/core/directives/scroll-to-first-invalid.directive.d.ts

@@ -13,7 +13,7 @@ export declare class ScrollToFirstInvalidDirective {
     private readonly cdkScrollable;
     labelOffset: number;
     aclScrollToFirstInvalid: boolean | '';
-    get containerEl(): (Window & typeof globalThis) | HTMLElement;
+    get containerEl(): HTMLElement | (Window & typeof globalThis);
     onSubmit(): void;
     constructor(elRef: ElementRef<HTMLElement>, controlContainer: ControlContainer, cdkScrollable: CdkScrollable);
     scrollToFirstInvalid(): void;

package/core/services/feature-gate.service.d.ts

@@ -9,7 +9,7 @@ export declare class FeatureGateService {
     private readonly http;
     private readonly cacheStore;
     constructor(http: HttpClient);
-    loadState(cluster?: string): Observable<"loading" | "loaded" | "loadFailed">;
+    loadState(cluster?: string): Observable<"loaded" | "loadFailed" | "loading">;
     /**
      * check gate status
      * @param gate - specified feature gate

package/esm2022/translate/translate.service.mjs

@@ -6,7 +6,7 @@ import { __decorate, __metadata } from "tslib";
 import { HttpClient } from '@angular/common/http';
 import { Inject, Injectable, Optional, isDevMode, } from '@angular/core';
 import { IntlMessageFormat } from 'intl-messageformat';
-import { get, head, isPlainObject } from 'lodash-es';
+import { get, head, isPlainObject, template } from 'lodash-es';
 import { Observable, Subject, forkJoin, throwError, EMPTY, catchError, filter, finalize, map, takeUntil, } from 'rxjs';
 import { ajax } from 'rxjs/ajax';
 import { API_GATEWAY } from '../core/constants/constants';
@@ -72,25 +72,21 @@ export class TranslateService {
     }
     /**
      * 获取翻译文本并进行模板插值
-     * 自动将传统 {{ key }} 语法转换为 ICU {key} 格式进行解析
-     * 同时支持原生 ICU Message Format 语法
+     * 支持两种模板语法：
+     * 1. 传统的 {{ key }} 语法，使用 lodash template 处理
+     * 2. ICU Message Format 语法，使用 IntlMessageFormat 处理
      * @param key - 翻译键或翻译对象
      * @param data - 模板数据（支持基本类型、Date、对象和数组）
      * @returns 翻译后的文本
      *
      * @example
      * ```typescript
-     * // 对象参数（推荐）
-     * translate.get('hello', { name: 'World' }) // 模板: "Hello {name}"
+     * // lodash template 语法
+     * translate.get('hello', { name: 'World' }) // 模板: "Hello {{ name }}"
      *
-     * // 基本类型参数（自动转换为 {value}）
-     * translate.get('welcome', 'John') // 模板: "Welcome {value}"
-     *
-     * // ICU 格式（数字）
-     * translate.get('itemCount', { count: 5 })
-     *
-     * // ICU 格式（日期，默认本地化）
-     * translate.get('createdAt', { date: new Date() })
+     * // ICU Message Format 语法
+     * translate.get('itemCount', { count: 5 }) // 模板: "Items: {count, number}"
+     * translate.get('createdAt', { date: new Date() }) // 模板: "Created: {date, date, short}"
      * ```
      */
     get(key, data) {
@@ -99,11 +95,17 @@ export class TranslateService {
             return translation;
         }
         try {
-            // 将传统的 {{ key }} 语法转换为 ICU {key} 格式
-            const icuMessage = this.convertToIcuFormat(translation);
-            // 将数据转换为 ICU 兼容的格式
-            const icuData = this.normalizeAndConvertToIcuData(data);
-            return this.formatIcuMessage(icuMessage, icuData);
+            // 检测模板类型并使用相应的处理方式
+            if (this.hasLodashTemplateFormat(translation)) {
+                return this.formatLodashTemplate(translation, data);
+            }
+            else if (this.hasIcuMessageFormat(translation)) {
+                return this.formatIcuMessage(translation, data);
+            }
+            else {
+                // 如果没有模板语法，直接返回翻译文本
+                return translation;
+            }
         }
         catch (error) {
             this.handleTemplateError(key, error);
@@ -237,7 +239,7 @@ export class TranslateService {
      * @param data - 模板数据
      * @returns ICU 兼容的数据对象
      */
-    normalizeAndConvertToIcuData(data) {
+    normalizeIcuData(data) {
         if (data == null) {
             return {};
         }
@@ -321,23 +323,71 @@ export class TranslateService {
         }
     }
     /**
-     * 将传统的 {{ key }} 语法转换为 ICU {key} 格式
-     * 同时保持已有的 ICU 格式不变
-     * @param message - 原始消息模板
-     * @returns 转换后的 ICU 格式消息
+     * 检测字符串是否包含 lodash template 格式的模板语法 {{ }}
+     * @param message - 要检测的字符串
+     * @returns 是否包含 lodash template 语法
      */
-    convertToIcuFormat(message) {
-        // 将 {{ key }} 转换为 {key}
-        // 支持空格：{{ key }} -> {key}，但去掉内部的空格
-        return message.replace(/\{\{([^}]+)\}\}/g, (_, content) => {
-            return `{${content.trim()}}`;
-        });
+    hasLodashTemplateFormat(message) {
+        return /\{\{[^}]+\}\}/.test(message);
+    }
+    /**
+     * 检测字符串是否包含 ICU Message Format 语法
+     * ICU 语法包括：{variable}、{variable, type}、{variable, type, style} 等
+     * @param message - 要检测的字符串
+     * @returns 是否包含 ICU Message Format 语法
+     */
+    hasIcuMessageFormat(message) {
+        // 检测 ICU 格式：{variable}、{variable, type}、{variable, type, style}
+        // 但排除 lodash template 格式的 {{variable}}
+        return /\{[^{}]+\}/.test(message) && !this.hasLodashTemplateFormat(message);
+    }
+    /**
+     * 使用 lodash template 格式化文本
+     * @param message - 包含 {{ }} 语法的模板字符串
+     * @param data - 模板数据
+     * @returns 格式化后的字符串
+     */
+    formatLodashTemplate(message, data) {
+        try {
+            // 将数据标准化为对象格式
+            const templateData = this.normalizeTemplateData(data);
+            // 使用 lodash template 处理 {{ }} 语法
+            const compiled = template(message, {
+                interpolate: /\{\{(.+?)\}\}/g, // 自定义插值语法为 {{ }}
+            });
+            return compiled(templateData);
+        }
+        catch (error) {
+            if (isDevMode()) {
+                console.warn(`Lodash template formatting failed for "${message}":`, error);
+            }
+            // 降级处理：返回原始消息
+            return message;
+        }
+    }
+    /**
+     * 标准化模板数据为对象格式
+     * @param data - 原始模板数据
+     * @returns 标准化后的对象或数组（为了向后兼容）
+     */
+    normalizeTemplateData(data) {
+        if (data == null) {
+            return {};
+        }
+        // 如果是纯对象，直接返回
+        if (this.isPlainTemplateObject(data)) {
+            return data;
+        }
+        // 这样模板中可以使用 {{ 0 }} 访问第一个元素
+        return [data];
     }
     /**
      * 使用 ICU message format 格式化文本
      */
-    formatIcuMessage(message, icuData) {
+    formatIcuMessage(message, data) {
         try {
+            // 将数据转换为 ICU 兼容格式
+            const icuData = this.normalizeIcuData(data);
             const messageFormat = new IntlMessageFormat(message, this.locale, undefined, { ignoreTag: true });
             return messageFormat.format(icuData);
         }
@@ -866,4 +916,4 @@ __decorate([
                 type: Inject,
                 args: [TRANSLATIONS]
             }] }], { locale$: [] }); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translate.service.js","sourceRoot":"","sources":["../../../../../libs/common/src/translate/translate.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module translate\n */\n\nimport { HttpClient } from '@angular/common/http';\nimport {\n  Inject,\n  Injectable,\n  OnDestroy,\n  Optional,\n  isDevMode,\n} from '@angular/core';\nimport { IntlMessageFormat } from 'intl-messageformat';\nimport { get, head, isPlainObject } from 'lodash-es';\nimport {\n  Observable,\n  Subject,\n  forkJoin,\n  throwError,\n  EMPTY,\n  catchError,\n  filter,\n  finalize,\n  map,\n  takeUntil,\n} from 'rxjs';\nimport { ajax } from 'rxjs/ajax';\n\nimport { API_GATEWAY } from '../core/constants/constants';\nimport { ObservableInput, TOKEN_BASE_HREF } from '../core/public-api';\nimport { isAbsoluteUrl } from '../core/utils/common';\nimport { parse } from '../core/utils/yaml';\n\nimport {\n  FALLBACK_LANGUAGE,\n  LOCALE_PLACEHOLDER_REGEX,\n  LOCALE_STORAGE,\n} from './constants';\nimport { getUserLanguage } from './i18n-config';\nimport { TRANSLATE_OPTIONS, TRANSLATIONS } from './tokens';\nimport {\n  TranslateKey,\n  TranslateOptions,\n  Translation,\n  TranslationValue,\n  Translations,\n  TemplateData,\n  IcuData,\n} from './types';\n\n/**\n * 国际化翻译服务\n *\n * 特性：\n * - 支持多层级翻译优先级（远程翻译 > 手动添加翻译 > 配置翻译）\n * - 支持动态语言切换\n * - 支持 ICU Message Format 模板插值\n * - 支持宽松模式语言匹配\n * - 支持异步远程翻译加载\n */\n@Injectable({ providedIn: 'root' })\nexport class TranslateService implements OnDestroy {\n  /** 翻译添加通知流 */\n  private readonly translationsAdded$$ = new Subject<void>();\n\n  readonly translationsAdded$ = this.translationsAdded$$.asObservable();\n\n  /** 组件销毁通知流 */\n  private readonly destroy$$ = new Subject<void>();\n\n  /** 本地翻译列表（优先级：后加入的优先级更高） */\n  readonly translationsList: Array<Readonly<Translations>> = [];\n\n  /** 远程翻译列表（优先级最高） */\n  readonly remoteTranslationsList: Array<Readonly<Translations>> = [];\n\n  /** 翻译配置选项 */\n  readonly options: TranslateOptions;\n\n  /** 当前语言环境 */\n  locale: string;\n\n  /** 当前语言环境（响应式） */\n  @ObservableInput()\n  readonly locale$: Observable<string>;\n\n  /** 获取支持的语言列表 */\n  get locales(): string[] {\n    return this.options.locales;\n  }\n\n  /** 获取回退语言 */\n  get fallbackLocale(): string {\n    return this.options.fallbackLocale;\n  }\n\n  constructor(\n    private readonly http: HttpClient,\n    @Inject(TOKEN_BASE_HREF) private readonly baseHref: string,\n    @Optional() @Inject(TRANSLATE_OPTIONS) options: TranslateOptions,\n    @Optional() @Inject(TRANSLATIONS) translationList: Translations[],\n  ) {\n    // 初始化语言环境\n    this.locale = this.getInitialLocale(options);\n\n    // 初始化配置选项\n    this.options = {\n      locales: [this.locale],\n      fallbackLocale: FALLBACK_LANGUAGE,\n      loose: false,\n      ...options,\n    };\n\n    // 初始化翻译列表\n    this.translationsList = this.getInitializeTranslations(\n      options,\n      translationList,\n    );\n\n    // 加载远程翻译\n    this.loadRemoteTranslations(options);\n  }\n\n  /**\n   * 组件销毁清理\n   */\n  ngOnDestroy(): void {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n  }\n\n  /**\n   * 获取翻译文本并进行模板插值\n   * 自动将传统 {{ key }} 语法转换为 ICU {key} 格式进行解析\n   * 同时支持原生 ICU Message Format 语法\n   * @param key - 翻译键或翻译对象\n   * @param data - 模板数据（支持基本类型、Date、对象和数组）\n   * @returns 翻译后的文本\n   *\n   * @example\n   * ```typescript\n   * // 对象参数（推荐）\n   * translate.get('hello', { name: 'World' }) // 模板: \"Hello {name}\"\n   *\n   * // 基本类型参数（自动转换为 {value}）\n   * translate.get('welcome', 'John') // 模板: \"Welcome {value}\"\n   *\n   * // ICU 格式（数字）\n   * translate.get('itemCount', { count: 5 })\n   *\n   * // ICU 格式（日期，默认本地化）\n   * translate.get('createdAt', { date: new Date() })\n   * ```\n   */\n  get(key: TranslateKey, data?: TemplateData): string {\n    const translation = this.getRaw(key);\n\n    if (data == null) {\n      return translation;\n    }\n\n    try {\n      // 将传统的 {{ key }} 语法转换为 ICU {key} 格式\n      const icuMessage = this.convertToIcuFormat(translation);\n      // 将数据转换为 ICU 兼容的格式\n      const icuData = this.normalizeAndConvertToIcuData(data);\n      return this.formatIcuMessage(icuMessage, icuData);\n    } catch (error) {\n      this.handleTemplateError(key, error);\n      return translation;\n    }\n  }\n\n  /**\n   * 获取原始翻译文本模板（不进行插值处理）\n   * @param key - 翻译键或翻译对象\n   * @returns 原始翻译模板文本\n   */\n  getRaw(key: TranslateKey): string {\n    if (typeof key === 'string') {\n      return this.getTranslationByKey(key);\n    }\n\n    // 当key是Translation对象时，获取当前语言的翻译值\n    const value = this.getTranslationByObject(key);\n\n    // 如果找到值则返回字符串形式，否则返回JSON字符串表示\n    if (value !== undefined) {\n      return value === null ? 'null' : String(value);\n    }\n\n    // 如果没有找到翻译，返回JSON字符串形式\n    return JSON.stringify(key);\n  }\n\n  /**\n   * 切换到下一个支持的语言环境\n   */\n  toggleLocale(): void {\n    const currentIndex = this.options.locales.indexOf(this.locale);\n\n    if (currentIndex === -1) {\n      this.handleInvalidLocale();\n      return;\n    }\n\n    const nextIndex = (currentIndex + 1) % this.options.locales.length;\n    const nextLocale = this.options.locales[nextIndex];\n\n    if (nextLocale && nextLocale !== this.locale) {\n      this.setLocale(nextLocale);\n    }\n  }\n\n  /**\n   * 设置当前语言环境\n   * @param locale - 要设置的语言环境\n   */\n  setLocale(locale: string): void {\n    if (!this.isValidLocale(locale)) {\n      if (isDevMode()) {\n        console.warn(\n          `Invalid locale: ${locale}. Supported locales: ${this.options.locales.join(', ')}`,\n        );\n      }\n      return;\n    }\n\n    localStorage.setItem(LOCALE_STORAGE, locale);\n    this.locale = locale;\n  }\n\n  /**\n   * 手动添加翻译包\n   * @param translations - 要添加的翻译包\n   */\n  addTranslations(translations: Translations): void {\n    if (!translations || typeof translations !== 'object') {\n      if (isDevMode()) {\n        console.warn('Invalid translations object provided');\n      }\n      return;\n    }\n\n    // 开发模式下检查重复翻译\n    if (isDevMode() && this.translationsList.length > 0) {\n      this.checkForDuplicateTranslations(translations);\n    }\n\n    this.translationsList.push(translations);\n    this.translationsAdded$$.next();\n  }\n\n  /**\n   * 添加远程翻译包\n   * @param remoteUrl - 远程翻译文件URL\n   */\n  addRemoteTranslations(remoteUrl: string): void {\n    if (!remoteUrl) {\n      return;\n    }\n\n    const normalizedUrl = this.normalizeRemoteUrl(remoteUrl);\n    const request$ = this.createRemoteTranslationRequest(normalizedUrl);\n\n    request$\n      .pipe(\n        takeUntil(this.destroy$$),\n        finalize(() => {\n          this.translationsAdded$$.next();\n        }),\n      )\n      .subscribe({\n        next: remoteTranslations => {\n          if (remoteTranslations) {\n            this.remoteTranslationsList.push(remoteTranslations);\n          }\n        },\n        error: error => {\n          if (isDevMode()) {\n            console.error(\n              `Failed to load remote translations from ${remoteUrl}:`,\n              error,\n            );\n          }\n        },\n      });\n  }\n\n  /**\n   * 从远程URL获取翻译数据\n   * @param remoteUrl - 远程URL\n   * @param locale - 可选的语言环境（用于URL模板替换）\n   * @returns 翻译数据的Observable\n   */\n  fetchTranslation(remoteUrl: string): Observable<Translations>;\n  fetchTranslation(remoteUrl: string, locale: string): Observable<Translation>;\n  fetchTranslation(\n    remoteUrl: string,\n    locale?: string,\n  ): Observable<Translations | Translation> {\n    this.validateFetchTranslationParams(remoteUrl, locale);\n\n    const targetUrl = locale\n      ? remoteUrl.replace(LOCALE_PLACEHOLDER_REGEX, locale)\n      : remoteUrl;\n\n    return this.performTranslationRequest(targetUrl);\n  }\n\n  /**\n   * 获取初始语言环境\n   */\n  private getInitialLocale(options: TranslateOptions): string {\n    return options?.locale || getUserLanguage();\n  }\n\n  /**\n   * 获取初始翻译列表\n   */\n  private getInitializeTranslations(\n    options: TranslateOptions,\n    translationList: Translations[],\n  ): Translations[] {\n    return [options?.translations, ...(translationList || [])].filter(Boolean);\n  }\n\n  /**\n   * 加载远程翻译\n   */\n  private loadRemoteTranslations(options: TranslateOptions): void {\n    if (!options?.remoteUrl) return;\n\n    const urls = Array.isArray(options.remoteUrl)\n      ? options.remoteUrl\n      : [options.remoteUrl];\n\n    urls.forEach(url => this.addRemoteTranslations(url));\n  }\n\n  /**\n   * 转换模板数据为 ICU 兼容格式\n   * @param data - 模板数据\n   * @returns ICU 兼容的数据对象\n   */\n  private normalizeAndConvertToIcuData(data: TemplateData): IcuData {\n    if (data == null) {\n      return {};\n    }\n\n    // 如果是纯对象，直接转换其属性\n    if (this.isPlainTemplateObject(data)) {\n      return this.convertObjectToIcuData(data);\n    }\n\n    // 基本类型、数组、Date等包装为 { value: data }\n    return { value: this.convertValueToIcuValue(data) };\n  }\n\n  /**\n   * 检查是否为纯模板对象（不是数组、Date等特殊对象）\n   */\n  private isPlainTemplateObject(\n    data: TemplateData,\n  ): data is Record<string, TemplateData> {\n    return (\n      typeof data === 'object' &&\n      data !== null &&\n      !Array.isArray(data) &&\n      !(data instanceof Date) &&\n      data.constructor === Object\n    );\n  }\n\n  /**\n   * 转换对象的所有属性为 ICU 兼容值\n   */\n  private convertObjectToIcuData(obj: Record<string, TemplateData>): IcuData {\n    const result: IcuData = {};\n\n    for (const [key, value] of Object.entries(obj)) {\n      if (value != null) {\n        result[key] = this.convertValueToIcuValue(value);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * 将单个值转换为 ICU 兼容类型\n   * 按照 ICU MessageFormat 规范，只支持 string | number | Date\n   */\n  private convertValueToIcuValue(value: TemplateData): string | number | Date {\n    // ICU 原生支持的类型直接返回\n    if (typeof value === 'string' || typeof value === 'number') {\n      return value;\n    }\n\n    if (value instanceof Date) {\n      return value;\n    }\n\n    // 其他类型转为字符串\n    if (typeof value === 'boolean') {\n      return String(value);\n    }\n\n    if (Array.isArray(value)) {\n      // 简单数组转为逗号分隔的字符串\n      return value.map(item => String(item ?? '')).join(', ');\n    }\n\n    if (value === null) {\n      return 'null';\n    }\n\n    if (value === undefined) {\n      return '';\n    }\n\n    // 对象转为 JSON 字符串\n    if (typeof value === 'object') {\n      try {\n        return JSON.stringify(value);\n      } catch {\n        return String(value);\n      }\n    }\n\n    return String(value);\n  }\n\n  /**\n   * 处理模板错误\n   */\n  private handleTemplateError(key: TranslateKey, error: any): void {\n    const keyStr = typeof key === 'string' ? key : '[object]';\n    const message = `The translation key '${keyStr}' is missing the necessary parameters.`;\n    if (isDevMode()) {\n      console.error(message, error);\n    } else {\n      console.warn(message, error);\n    }\n  }\n\n  /**\n   * 将传统的 {{ key }} 语法转换为 ICU {key} 格式\n   * 同时保持已有的 ICU 格式不变\n   * @param message - 原始消息模板\n   * @returns 转换后的 ICU 格式消息\n   */\n  private convertToIcuFormat(message: string): string {\n    // 将 {{ key }} 转换为 {key}\n    // 支持空格：{{ key }} -> {key}，但去掉内部的空格\n    return message.replace(/\\{\\{([^}]+)\\}\\}/g, (_, content) => {\n      return `{${content.trim()}}`;\n    });\n  }\n\n  /**\n   * 使用 ICU message format 格式化文本\n   */\n  private formatIcuMessage(message: string, icuData: IcuData): string {\n    try {\n      const messageFormat = new IntlMessageFormat(\n        message,\n        this.locale,\n        undefined,\n        { ignoreTag: true },\n      );\n      return messageFormat.format(icuData) as string;\n    } catch (error) {\n      if (isDevMode()) {\n        console.warn(`ICU message formatting failed for \"${message}\":`, error);\n      }\n      // 降级处理：返回原始消息\n      return message;\n    }\n  }\n\n  /**\n   * 格式化数字\n   * @param value - 要格式化的数字\n   * @param options - 格式化选项\n   * @returns 格式化后的数字字符串\n   *\n   * @example\n   * formatNumber(1234.56) // \"1,234.56\"\n   * formatNumber(0.85, { style: 'percent' }) // \"85%\"\n   * formatNumber(1234.56, { style: 'currency', currency: 'CNY' }) // \"¥1,234.56\"\n   */\n  formatNumber(value: number, options: Intl.NumberFormatOptions = {}): string {\n    try {\n      return new Intl.NumberFormat(this.locale, options).format(value);\n    } catch (error) {\n      if (isDevMode()) {\n        console.warn(`Number formatting failed for value ${value}:`, error);\n      }\n      return value.toString();\n    }\n  }\n\n  /**\n   * 格式化货币\n   * @param value - 要格式化的金额\n   * @param currency - 货币代码，默认为 CNY\n   * @param options - 其他格式化选项\n   * @returns 格式化后的货币字符串\n   *\n   * @example\n   * formatCurrency(1234.56) // en-US: \"CN¥1,234.56\", zh-CN: \"¥1,234.56\"\n   * formatCurrency(1234.56, 'USD') // en-US: \"$1,234.56\", zh-CN: \"US$1,234.56\"\n   */\n  formatCurrency(\n    value: number,\n    currency: string = 'CNY',\n    options: Omit<Intl.NumberFormatOptions, 'style' | 'currency'> = {},\n  ): string {\n    return this.formatNumber(value, {\n      style: 'currency',\n      currency,\n      ...options,\n    });\n  }\n\n  /**\n   * 格式化百分比\n   * @param value - 要格式化的值（0.85 表示 85%）\n   * @param options - 格式化选项\n   * @returns 格式化后的百分比字符串\n   *\n   * @example\n   * formatPercent(0.85) // \"85%\"\n   * formatPercent(0.8567, { minimumFractionDigits: 2 }) // \"85.67%\"\n   */\n  formatPercent(\n    value: number,\n    options: Omit<Intl.NumberFormatOptions, 'style'> = {},\n  ): string {\n    return this.formatNumber(value, {\n      style: 'percent',\n      ...options,\n    });\n  }\n\n  /**\n   * 格式化日期\n   * @param date - 要格式化的日期\n   * @param options - Intl.DateTimeFormatOptions 格式配置\n   * @returns 格式化后的日期字符串\n   *\n   * @example\n   * formatDate(new Date()) // en-US: \"01/01/2025\", zh-CN: \"2025/01/01\"\n   * formatDate(new Date(), { dateStyle: 'full' }) // \"2024年8月20日星期二\"\n   * formatDate(new Date(), { year: 'numeric', month: '2-digit', day: '2-digit' }) // 根据locale格式化\n   * formatDate(new Date(), { year: 'numeric', month: 'long' }) // \"2024年8月\"\n   */\n  formatDate(\n    date: Date | string | number,\n    options: Intl.DateTimeFormatOptions = {\n      year: 'numeric',\n      month: '2-digit',\n      day: '2-digit',\n    },\n  ): string {\n    try {\n      const dateObj = new Date(date);\n      if (isNaN(dateObj.getTime())) {\n        throw new Error('Invalid date');\n      }\n      return this.formatDateByOptions(dateObj, options);\n    } catch (error) {\n      if (isDevMode()) {\n        console.warn(`Date formatting failed for date ${date}:`, error);\n      }\n      return String(date);\n    }\n  }\n\n  /**\n   * 格式化日期和时间\n   * @param date - 要格式化的日期时间\n   * @param options - Intl.DateTimeFormatOptions 格式配置\n   * @returns 格式化后的日期时间字符串\n   *\n   * @example\n   * formatDateTime(new Date()) // en-US: \"01/01/2025, 14:30:00\", zh-CN: \"2025/01/01 14:30:00\"\n   * formatDateTime(new Date(), { dateStyle: 'medium', timeStyle: 'short' }) // \"2024年8月20日 14:30\"\n   * formatDateTime(new Date(), { year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false }) // 根据locale格式化\n   */\n  formatDateTime(\n    date: Date | string | number,\n    options: Intl.DateTimeFormatOptions = {\n      year: 'numeric',\n      month: '2-digit',\n      day: '2-digit',\n      hour: '2-digit',\n      minute: '2-digit',\n      second: '2-digit',\n      hour12: false,\n    },\n  ): string {\n    return this.formatDate(date, options);\n  }\n\n  /**\n   * 格式化相对时间\n   * @param value - 时间差值（数字）或日期对象\n   * @param unit - 时间单位（当value为数字时必须提供）\n   * @param options - 格式化选项\n   * @returns 格式化后的相对时间字符串\n   *\n   * @example\n   * // 手动指定单位\n   * formatRelativeTime(-1, 'day') // en-US: \"yesterday\", zh-CN: \"昨天\"\n   * formatRelativeTime(2, 'hour') // en-US: \"in 2 hours\", zh-CN: \"2小时后\"\n   * formatRelativeTime(-30, 'minute') // en-US: \"30 minutes ago\", zh-CN: \"30分钟前\"\n   *\n   * // 自动计算单位\n   * formatRelativeTime(new Date(Date.now() - 60000)) // \"1 minute ago\"\n   * formatRelativeTime(new Date(Date.now() + 7200000)) // \"in 2 hours\"\n   * formatRelativeTime(new Date(Date.now() - 86400000)) // \"yesterday\"\n   */\n  formatRelativeTime(\n    value: Date,\n    options?: Intl.RelativeTimeFormatOptions,\n  ): string;\n\n  formatRelativeTime(\n    value: number,\n    unit: Intl.RelativeTimeFormatUnit,\n    options?: Intl.RelativeTimeFormatOptions,\n  ): string;\n\n  formatRelativeTime(\n    value: number | Date,\n    unitOrOptions?:\n      | Intl.RelativeTimeFormatUnit\n      | Intl.RelativeTimeFormatOptions,\n    options: Intl.RelativeTimeFormatOptions = { numeric: 'auto' },\n  ): string {\n    try {\n      let finalValue: number;\n      let finalUnit: Intl.RelativeTimeFormatUnit;\n      let finalOptions: Intl.RelativeTimeFormatOptions;\n\n      if (value instanceof Date) {\n        // 自动计算时间差和单位\n        const { value: calculatedValue, unit: calculatedUnit } =\n          this.calculateRelativeTime(value);\n        finalValue = calculatedValue;\n        finalUnit = calculatedUnit;\n        finalOptions =\n          (unitOrOptions as Intl.RelativeTimeFormatOptions) || options;\n      } else {\n        // 使用提供的数值和单位\n        finalValue = value;\n        finalUnit = unitOrOptions as Intl.RelativeTimeFormatUnit;\n        finalOptions = options;\n      }\n\n      return new Intl.RelativeTimeFormat(this.locale, finalOptions).format(\n        finalValue,\n        finalUnit,\n      );\n    } catch (error) {\n      if (isDevMode()) {\n        console.warn(`Relative time formatting failed for ${value}:`, error);\n      }\n      return value instanceof Date\n        ? value.toLocaleString(this.locale)\n        : `${value}`;\n    }\n  }\n\n  /**\n   * 根据日期计算相对时间差值和最合适的单位\n   * @param date - 目标日期\n   * @returns 包含时间差值和单位的对象\n   */\n  private calculateRelativeTime(date: Date): {\n    value: number;\n    unit: Intl.RelativeTimeFormatUnit;\n  } {\n    const now = new Date();\n    const diffMs = date.getTime() - now.getTime();\n    const absDiffMs = Math.abs(diffMs);\n\n    // 时间单位阈值（毫秒）\n    const MINUTE_MS = 60 * 1000;\n    const HOUR_MS = 60 * MINUTE_MS;\n    const DAY_MS = 24 * HOUR_MS;\n\n    // 根据时间差选择合适的单位，最大单位为day\n    if (absDiffMs >= DAY_MS) {\n      return {\n        value: Math.round(diffMs / DAY_MS),\n        unit: 'day',\n      };\n    }\n    if (absDiffMs >= HOUR_MS) {\n      return {\n        value: Math.round(diffMs / HOUR_MS),\n        unit: 'hour',\n      };\n    }\n    if (absDiffMs >= MINUTE_MS) {\n      return {\n        value: Math.round(diffMs / MINUTE_MS),\n        unit: 'minute',\n      };\n    }\n    return {\n      value: Math.round(diffMs / 1000),\n      unit: 'second',\n    };\n  }\n\n  /**\n   * 根据日期格式配置格式化日期\n   * 使用标准 Intl.DateTimeFormatOptions 确保格式可预测性\n   */\n  private formatDateByOptions(\n    date: Date,\n    options: Intl.DateTimeFormatOptions,\n  ): string {\n    try {\n      return new Intl.DateTimeFormat(this.locale, options).format(date);\n    } catch (error) {\n      if (isDevMode()) {\n        console.warn(`Date formatting failed:`, error);\n      }\n      return date.toISOString();\n    }\n  }\n\n  /**\n   * 通过字符串键获取翻译\n   */\n  private getTranslationByKey(key: string): string {\n    return this.resolveTranslation(key);\n  }\n\n  /**\n   * 通过翻译对象获取翻译值\n   */\n  private getTranslationByObject(\n    translationObj: Translation,\n  ): TranslationValue {\n    return this.getTranslationValue(translationObj, this.locale);\n  }\n\n  /**\n   * 处理无效语言环境\n   */\n  private handleInvalidLocale(): void {\n    if (isDevMode()) {\n      throw new TypeError('`locales` has not been initialized correctly');\n    }\n  }\n\n  /**\n   * 验证语言环境是否有效\n   */\n  private isValidLocale(locale: string): boolean {\n    return this.options.locales.includes(locale);\n  }\n\n  /**\n   * 检查重复翻译（开发模式）\n   */\n  private checkForDuplicateTranslations(newTranslations: Translations): void {\n    for (const existingTranslations of this.translationsList) {\n      Object.keys(newTranslations).forEach(locale => {\n        if (existingTranslations[locale]) {\n          this.compareTranslationKeys(\n            locale,\n            newTranslations[locale],\n            existingTranslations[locale],\n          );\n        }\n      });\n    }\n  }\n\n  /**\n   * 标准化远程URL\n   */\n  private normalizeRemoteUrl(remoteUrl: string): string {\n    remoteUrl = this.cleanUrl(remoteUrl);\n    const isAbsolute = isAbsoluteUrl(remoteUrl);\n    const isApiGateWayRequest = remoteUrl.startsWith(API_GATEWAY);\n\n    // 开发模式下进行URL验证\n    if (isDevMode()) {\n      this.validateRemoteUrl(remoteUrl, isAbsolute);\n    }\n\n    // 相对URL转换为绝对URL\n    if (!isAbsolute && !isApiGateWayRequest) {\n      const baseUrl = this.baseHref.endsWith('/')\n        ? this.baseHref\n        : `${this.baseHref}/`;\n      return `${baseUrl}${remoteUrl}`;\n    }\n\n    return remoteUrl;\n  }\n\n  /**\n   * 清理URL（移除hash片段）\n   */\n  private cleanUrl(url: string): string {\n    return head(url.split(/#/)) || url;\n  }\n\n  /**\n   * 验证远程URL（开发模式）\n   */\n  private validateRemoteUrl(remoteUrl: string, isAbsolute: boolean): void {\n    if (!isAbsolute && (!this.baseHref || !isAbsoluteUrl(this.baseHref))) {\n      throw new TypeError(\n        'absolute base href is required for relative remote url',\n      );\n    }\n\n    if (remoteUrl.split('?')[0].includes('./')) {\n      throw new TypeError(\n        'do not use any dot with slash for relative url which should always base from base href',\n      );\n    }\n  }\n\n  /**\n   * 创建远程翻译请求\n   */\n  private createRemoteTranslationRequest(\n    normalizedUrl: string,\n  ): Observable<Translations> {\n    if (LOCALE_PLACEHOLDER_REGEX.test(normalizedUrl)) {\n      return this.createMultiLocaleRequest(normalizedUrl);\n    }\n    return this.createSingleLocaleRequest(normalizedUrl);\n  }\n\n  /**\n   * 创建多语言请求\n   */\n  private createMultiLocaleRequest(\n    urlTemplate: string,\n  ): Observable<Translations> {\n    const requests = this.options.locales.map(locale =>\n      this.fetchTranslation(urlTemplate, locale).pipe(\n        catchError(error => {\n          if (this.options.loose) {\n            const looseLocale = this.extractLooseLocale(locale);\n            if (\n              locale !== looseLocale &&\n              !this.options.locales.includes(looseLocale)\n            ) {\n              return this.fetchTranslation(urlTemplate, looseLocale);\n            }\n          }\n          return isDevMode() ? throwError(() => error) : EMPTY;\n        }),\n        filter(isPlainObject),\n        map(\n          (translation: Translation) =>\n            ({ [locale]: translation }) as Translations,\n        ),\n      ),\n    );\n\n    return forkJoin(requests).pipe(\n      map(results =>\n        results.reduce((acc, curr) => Object.assign(acc, curr), {}),\n      ),\n    );\n  }\n\n  /**\n   * 创建单语言请求\n   */\n  private createSingleLocaleRequest(url: string): Observable<Translations> {\n    return this.performTranslationRequest(url).pipe(\n      catchError(error => (isDevMode() ? throwError(() => error) : EMPTY)),\n    ) as Observable<Translations>;\n  }\n\n  /**\n   * 执行翻译请求\n   */\n  private performTranslationRequest(url: string): Observable<any> {\n    const isJSON = url.endsWith('.json');\n    const isApiGateWayRequest = url.startsWith(API_GATEWAY);\n    const responseType = isJSON ? 'json' : 'text';\n\n    if (isApiGateWayRequest) {\n      return this.http\n        .request('GET', url, { responseType })\n        .pipe(map(body => (isJSON ? body : parse(body))));\n    }\n\n    return ajax({ url, responseType }).pipe(\n      map(({ response }) => (isJSON ? response : parse(response as string))),\n    );\n  }\n\n  /**\n   * 验证fetchTranslation参数\n   */\n  private validateFetchTranslationParams(\n    remoteUrl: string,\n    locale?: string,\n  ): void {\n    if (isDevMode() && LOCALE_PLACEHOLDER_REGEX.test(remoteUrl) && !locale) {\n      throw new TypeError(\n        '`locale` is required since the provided remote url contains locale placeholder',\n      );\n    }\n  }\n\n  /**\n   * 解析翻译文本\n   */\n  private resolveTranslation(key: string, locale = this.locale): string {\n    // 优先从远程翻译中查找\n    let value = this.searchInTranslationsList(\n      key,\n      locale,\n      this.remoteTranslationsList,\n    );\n\n    // 如果远程翻译中没有找到（undefined），则从本地翻译中查找\n    if (value === undefined) {\n      value = this.searchInTranslationsList(key, locale, this.translationsList);\n    }\n\n    return value ?? key;\n  }\n\n  /**\n   * 在翻译列表中搜索\n   */\n  private searchInTranslationsList(\n    key: string,\n    locale: string,\n    translationsList: Translations[],\n  ): string | undefined {\n    if (!translationsList || translationsList.length === 0) {\n      return undefined;\n    }\n\n    // 从后往前遍历（后加入的优先级更高）\n    for (let i = translationsList.length - 1; i >= 0; i--) {\n      const value = this.searchInTranslations(key, locale, translationsList[i]);\n      if (value !== undefined) {\n        return value;\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * 在单个翻译对象中搜索\n   */\n  private searchInTranslations(\n    key: string,\n    locale: string,\n    translations: Translations,\n  ): string | undefined {\n    const translationValue = this.getTranslationValue(translations, locale);\n\n    // 如果没有获取到翻译值对象（getTranslationValue已经处理了loose和fallback），直接返回\n    if (translationValue === undefined) {\n      return undefined;\n    }\n\n    // 获取翻译值，支持扁平和嵌套两种结构\n    const value = this.getTranslationFromSource(translationValue, key);\n\n    // 如果找到值（包括null值），则处理并返回\n    if (value !== undefined) {\n      this.validateTranslationValue(value, locale, key);\n      // null值转换为字符串'null'，其他值正常转换\n      return value === null ? 'null' : String(value);\n    }\n\n    // 如果在当前语言的翻译值中找不到key，但这不是fallback语言，尝试fallback\n    if (locale !== this.options.fallbackLocale) {\n      const fallbackTranslationValue = this.getTranslationValue(\n        translations,\n        this.options.fallbackLocale,\n      );\n\n      if (fallbackTranslationValue !== undefined) {\n        const fallbackValue = this.getTranslationFromSource(\n          fallbackTranslationValue,\n          key,\n        );\n        if (fallbackValue !== undefined) {\n          this.validateTranslationValue(\n            fallbackValue,\n            this.options.fallbackLocale,\n            key,\n          );\n          return fallbackValue === null ? 'null' : String(fallbackValue);\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * 从翻译源获取翻译值，支持扁平和嵌套两种结构\n   * @param source - 翻译源对象\n   * @param key - 翻译键（如 'a.b.c'）\n   * @returns 翻译值或undefined\n   */\n  private getTranslationFromSource(source: any, key: string): any {\n    if (!source || typeof source !== 'object') {\n      return undefined;\n    }\n\n    // 1. 优先尝试扁平结构：直接查找完整的键 'a.b.c'\n    if (Object.prototype.hasOwnProperty.call(source, key)) {\n      return source[key];\n    }\n\n    // 2. 再尝试嵌套结构：使用lodash.get按路径查找 a.b.c\n    const nestedValue = get(source, key);\n    if (nestedValue !== undefined) {\n      return nestedValue;\n    }\n\n    return undefined;\n  }\n\n  /**\n   * 获取指定语言的翻译值（处理loose模式和fallback逻辑）\n   */\n  private getTranslationValue(\n    source: Translation,\n    locale = this.locale,\n  ): TranslationValue {\n    if (!source) {\n      return undefined;\n    }\n\n    // 1. 首先检查精确匹配的键是否存在\n    if (Object.prototype.hasOwnProperty.call(source, locale)) {\n      return source[locale]; // 返回实际值，可能是null、undefined或其他值\n    }\n\n    // 2. 如果启用了宽松模式，尝试宽松匹配\n    if (this.options.loose) {\n      const looseValue = this.getLooseTranslationValue(source, locale);\n      if (looseValue !== undefined) {\n        return looseValue;\n      }\n    }\n\n    // 3. 如果当前语言不是fallback语言，尝试fallback语言\n    if (locale !== this.options.fallbackLocale) {\n      // 首先检查fallback语言的精确匹配\n      if (\n        Object.prototype.hasOwnProperty.call(\n          source,\n          this.options.fallbackLocale,\n        )\n      ) {\n        return source[this.options.fallbackLocale];\n      }\n\n      // 如果启用了宽松模式，也对fallback语言进行宽松匹配\n      if (this.options.loose) {\n        const fallbackLooseValue = this.getLooseTranslationValue(\n          source,\n          this.options.fallbackLocale,\n        );\n        if (fallbackLooseValue !== undefined) {\n          return fallbackLooseValue;\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * 宽松模式下获取翻译值\n   */\n  private getLooseTranslationValue(\n    source: Translation,\n    locale: string,\n  ): TranslationValue {\n    const looseLocale = this.extractLooseLocale(locale);\n\n    if (locale === looseLocale) {\n      // 寻找匹配的宽松语言\n      const matchedEntry = Object.entries(source).find(\n        ([key]) => looseLocale === this.extractLooseLocale(key),\n      );\n      return matchedEntry?.[1];\n    }\n\n    // 检查宽松语言键是否存在\n    if (Object.prototype.hasOwnProperty.call(source, looseLocale)) {\n      return source[looseLocale];\n    }\n\n    return undefined;\n  }\n\n  /**\n   * 提取宽松语言代码（如：zh-CN -> zh）\n   */\n  private extractLooseLocale(locale: string): string {\n    return head(locale.split(/[_-]/)) || locale;\n  }\n\n  /**\n   * 验证翻译值（开发模式）\n   */\n  private validateTranslationValue(\n    value: any,\n    locale: string,\n    key: string,\n  ): void {\n    if (\n      isDevMode() &&\n      typeof value === 'object' &&\n      typeof get(value, Symbol.toPrimitive) !== 'function'\n    ) {\n      console.warn(\n        `The translation for locale: \\`${locale}\\` and key:\\`${key}\\` is an object, which could be unexpected`,\n      );\n    }\n  }\n\n  /**\n   * 比较翻译键（开发模式下检查重复）\n   */\n  private compareTranslationKeys(\n    locale: string,\n    translation: Translation,\n    prevTranslation: Translation,\n    path: string[] = [],\n  ): void {\n    if (translation == null || prevTranslation == null) {\n      return;\n    }\n\n    Object.entries(translation).forEach(([key, value]) => {\n      if (!Object.prototype.hasOwnProperty.call(prevTranslation, key)) {\n        return;\n      }\n\n      const prevValue = prevTranslation[key];\n      const valueIsPlainObject = isPlainObject(value);\n      const prevValueIsPlainObject = isPlainObject(prevValue);\n\n      if (valueIsPlainObject && prevValueIsPlainObject) {\n        this.compareTranslationKeys(\n          locale,\n          value as Translation,\n          prevValue as Translation,\n          [...path, key],\n        );\n        return;\n      }\n\n      if (!valueIsPlainObject && !prevValueIsPlainObject) {\n        const outputPath = [...path, key].join(' -> ');\n        if (value === prevValue) {\n          console.warn(\n            `The customized translation for locale: \\`${locale}\\` and path: \\`${outputPath}\\` is duplicated with the other translation, please remove it in your translation file.`,\n          );\n        } else {\n          console.warn(\n            `Two keys that the locale is \\`${locale}\\` and the path is \\`${outputPath}\\` are same, but their values are not equal, please remove one of them or change one of the keys.`,\n          );\n        }\n      }\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"translate.service.js","sourceRoot":"","sources":["../../../../../libs/common/src/translate/translate.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module translate\n */\n\nimport { HttpClient } from '@angular/common/http';\nimport {\n  Inject,\n  Injectable,\n  OnDestroy,\n  Optional,\n  isDevMode,\n} from '@angular/core';\nimport { IntlMessageFormat } from 'intl-messageformat';\nimport { get, head, isPlainObject, template } from 'lodash-es';\nimport {\n  Observable,\n  Subject,\n  forkJoin,\n  throwError,\n  EMPTY,\n  catchError,\n  filter,\n  finalize,\n  map,\n  takeUntil,\n} from 'rxjs';\nimport { ajax } from 'rxjs/ajax';\n\nimport { API_GATEWAY } from '../core/constants/constants';\nimport { ObservableInput, TOKEN_BASE_HREF } from '../core/public-api';\nimport { isAbsoluteUrl } from '../core/utils/common';\nimport { parse } from '../core/utils/yaml';\n\nimport {\n  FALLBACK_LANGUAGE,\n  LOCALE_PLACEHOLDER_REGEX,\n  LOCALE_STORAGE,\n} from './constants';\nimport { getUserLanguage } from './i18n-config';\nimport { TRANSLATE_OPTIONS, TRANSLATIONS } from './tokens';\nimport {\n  TranslateKey,\n  TranslateOptions,\n  Translation,\n  TranslationValue,\n  Translations,\n  TemplateData,\n  IcuData,\n} from './types';\n\n/**\n * 国际化翻译服务\n *\n * 特性：\n * - 支持多层级翻译优先级（远程翻译 > 手动添加翻译 > 配置翻译）\n * - 支持动态语言切换\n * - 支持 ICU Message Format 模板插值\n * - 支持宽松模式语言匹配\n * - 支持异步远程翻译加载\n */\n@Injectable({ providedIn: 'root' })\nexport class TranslateService implements OnDestroy {\n  /** 翻译添加通知流 */\n  private readonly translationsAdded$$ = new Subject<void>();\n\n  readonly translationsAdded$ = this.translationsAdded$$.asObservable();\n\n  /** 组件销毁通知流 */\n  private readonly destroy$$ = new Subject<void>();\n\n  /** 本地翻译列表（优先级：后加入的优先级更高） */\n  readonly translationsList: Array<Readonly<Translations>> = [];\n\n  /** 远程翻译列表（优先级最高） */\n  readonly remoteTranslationsList: Array<Readonly<Translations>> = [];\n\n  /** 翻译配置选项 */\n  readonly options: TranslateOptions;\n\n  /** 当前语言环境 */\n  locale: string;\n\n  /** 当前语言环境（响应式） */\n  @ObservableInput()\n  readonly locale$: Observable<string>;\n\n  /** 获取支持的语言列表 */\n  get locales(): string[] {\n    return this.options.locales;\n  }\n\n  /** 获取回退语言 */\n  get fallbackLocale(): string {\n    return this.options.fallbackLocale;\n  }\n\n  constructor(\n    private readonly http: HttpClient,\n    @Inject(TOKEN_BASE_HREF) private readonly baseHref: string,\n    @Optional() @Inject(TRANSLATE_OPTIONS) options: TranslateOptions,\n    @Optional() @Inject(TRANSLATIONS) translationList: Translations[],\n  ) {\n    // 初始化语言环境\n    this.locale = this.getInitialLocale(options);\n\n    // 初始化配置选项\n    this.options = {\n      locales: [this.locale],\n      fallbackLocale: FALLBACK_LANGUAGE,\n      loose: false,\n      ...options,\n    };\n\n    // 初始化翻译列表\n    this.translationsList = this.getInitializeTranslations(\n      options,\n      translationList,\n    );\n\n    // 加载远程翻译\n    this.loadRemoteTranslations(options);\n  }\n\n  /**\n   * 组件销毁清理\n   */\n  ngOnDestroy(): void {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n  }\n\n  /**\n   * 获取翻译文本并进行模板插值\n   * 支持两种模板语法：\n   * 1. 传统的 {{ key }} 语法，使用 lodash template 处理\n   * 2. ICU Message Format 语法，使用 IntlMessageFormat 处理\n   * @param key - 翻译键或翻译对象\n   * @param data - 模板数据（支持基本类型、Date、对象和数组）\n   * @returns 翻译后的文本\n   *\n   * @example\n   * ```typescript\n   * // lodash template 语法\n   * translate.get('hello', { name: 'World' }) // 模板: \"Hello {{ name }}\"\n   *\n   * // ICU Message Format 语法\n   * translate.get('itemCount', { count: 5 }) // 模板: \"Items: {count, number}\"\n   * translate.get('createdAt', { date: new Date() }) // 模板: \"Created: {date, date, short}\"\n   * ```\n   */\n  get(key: TranslateKey, data?: TemplateData): string {\n    const translation = this.getRaw(key);\n\n    if (data == null) {\n      return translation;\n    }\n\n    try {\n      // 检测模板类型并使用相应的处理方式\n      if (this.hasLodashTemplateFormat(translation)) {\n        return this.formatLodashTemplate(translation, data);\n      } else if (this.hasIcuMessageFormat(translation)) {\n        return this.formatIcuMessage(translation, data);\n      } else {\n        // 如果没有模板语法，直接返回翻译文本\n        return translation;\n      }\n    } catch (error) {\n      this.handleTemplateError(key, error);\n      return translation;\n    }\n  }\n\n  /**\n   * 获取原始翻译文本模板（不进行插值处理）\n   * @param key - 翻译键或翻译对象\n   * @returns 原始翻译模板文本\n   */\n  getRaw(key: TranslateKey): string {\n    if (typeof key === 'string') {\n      return this.getTranslationByKey(key);\n    }\n\n    // 当key是Translation对象时，获取当前语言的翻译值\n    const value = this.getTranslationByObject(key);\n\n    // 如果找到值则返回字符串形式，否则返回JSON字符串表示\n    if (value !== undefined) {\n      return value === null ? 'null' : String(value);\n    }\n\n    // 如果没有找到翻译，返回JSON字符串形式\n    return JSON.stringify(key);\n  }\n\n  /**\n   * 切换到下一个支持的语言环境\n   */\n  toggleLocale(): void {\n    const currentIndex = this.options.locales.indexOf(this.locale);\n\n    if (currentIndex === -1) {\n      this.handleInvalidLocale();\n      return;\n    }\n\n    const nextIndex = (currentIndex + 1) % this.options.locales.length;\n    const nextLocale = this.options.locales[nextIndex];\n\n    if (nextLocale && nextLocale !== this.locale) {\n      this.setLocale(nextLocale);\n    }\n  }\n\n  /**\n   * 设置当前语言环境\n   * @param locale - 要设置的语言环境\n   */\n  setLocale(locale: string): void {\n    if (!this.isValidLocale(locale)) {\n      if (isDevMode()) {\n        console.warn(\n          `Invalid locale: ${locale}. Supported locales: ${this.options.locales.join(', ')}`,\n        );\n      }\n      return;\n    }\n\n    localStorage.setItem(LOCALE_STORAGE, locale);\n    this.locale = locale;\n  }\n\n  /**\n   * 手动添加翻译包\n   * @param translations - 要添加的翻译包\n   */\n  addTranslations(translations: Translations): void {\n    if (!translations || typeof translations !== 'object') {\n      if (isDevMode()) {\n        console.warn('Invalid translations object provided');\n      }\n      return;\n    }\n\n    // 开发模式下检查重复翻译\n    if (isDevMode() && this.translationsList.length > 0) {\n      this.checkForDuplicateTranslations(translations);\n    }\n\n    this.translationsList.push(translations);\n    this.translationsAdded$$.next();\n  }\n\n  /**\n   * 添加远程翻译包\n   * @param remoteUrl - 远程翻译文件URL\n   */\n  addRemoteTranslations(remoteUrl: string): void {\n    if (!remoteUrl) {\n      return;\n    }\n\n    const normalizedUrl = this.normalizeRemoteUrl(remoteUrl);\n    const request$ = this.createRemoteTranslationRequest(normalizedUrl);\n\n    request$\n      .pipe(\n        takeUntil(this.destroy$$),\n        finalize(() => {\n          this.translationsAdded$$.next();\n        }),\n      )\n      .subscribe({\n        next: remoteTranslations => {\n          if (remoteTranslations) {\n            this.remoteTranslationsList.push(remoteTranslations);\n          }\n        },\n        error: error => {\n          if (isDevMode()) {\n            console.error(\n              `Failed to load remote translations from ${remoteUrl}:`,\n              error,\n            );\n          }\n        },\n      });\n  }\n\n  /**\n   * 从远程URL获取翻译数据\n   * @param remoteUrl - 远程URL\n   * @param locale - 可选的语言环境（用于URL模板替换）\n   * @returns 翻译数据的Observable\n   */\n  fetchTranslation(remoteUrl: string): Observable<Translations>;\n  fetchTranslation(remoteUrl: string, locale: string): Observable<Translation>;\n  fetchTranslation(\n    remoteUrl: string,\n    locale?: string,\n  ): Observable<Translations | Translation> {\n    this.validateFetchTranslationParams(remoteUrl, locale);\n\n    const targetUrl = locale\n      ? remoteUrl.replace(LOCALE_PLACEHOLDER_REGEX, locale)\n      : remoteUrl;\n\n    return this.performTranslationRequest(targetUrl);\n  }\n\n  /**\n   * 获取初始语言环境\n   */\n  private getInitialLocale(options: TranslateOptions): string {\n    return options?.locale || getUserLanguage();\n  }\n\n  /**\n   * 获取初始翻译列表\n   */\n  private getInitializeTranslations(\n    options: TranslateOptions,\n    translationList: Translations[],\n  ): Translations[] {\n    return [options?.translations, ...(translationList || [])].filter(Boolean);\n  }\n\n  /**\n   * 加载远程翻译\n   */\n  private loadRemoteTranslations(options: TranslateOptions): void {\n    if (!options?.remoteUrl) return;\n\n    const urls = Array.isArray(options.remoteUrl)\n      ? options.remoteUrl\n      : [options.remoteUrl];\n\n    urls.forEach(url => this.addRemoteTranslations(url));\n  }\n\n  /**\n   * 转换模板数据为 ICU 兼容格式\n   * @param data - 模板数据\n   * @returns ICU 兼容的数据对象\n   */\n  private normalizeIcuData(data: TemplateData): IcuData {\n    if (data == null) {\n      return {};\n    }\n\n    // 如果是纯对象，直接转换其属性\n    if (this.isPlainTemplateObject(data)) {\n      return this.convertObjectToIcuData(data);\n    }\n\n    // 基本类型、数组、Date等包装为 { value: data }\n    return { value: this.convertValueToIcuValue(data) };\n  }\n\n  /**\n   * 检查是否为纯模板对象（不是数组、Date等特殊对象）\n   */\n  private isPlainTemplateObject(\n    data: TemplateData,\n  ): data is Record<string, TemplateData> {\n    return (\n      typeof data === 'object' &&\n      data !== null &&\n      !Array.isArray(data) &&\n      !(data instanceof Date) &&\n      data.constructor === Object\n    );\n  }\n\n  /**\n   * 转换对象的所有属性为 ICU 兼容值\n   */\n  private convertObjectToIcuData(obj: Record<string, TemplateData>): IcuData {\n    const result: IcuData = {};\n\n    for (const [key, value] of Object.entries(obj)) {\n      if (value != null) {\n        result[key] = this.convertValueToIcuValue(value);\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * 将单个值转换为 ICU 兼容类型\n   * 按照 ICU MessageFormat 规范，只支持 string | number | Date\n   */\n  private convertValueToIcuValue(value: TemplateData): string | number | Date {\n    // ICU 原生支持的类型直接返回\n    if (typeof value === 'string' || typeof value === 'number') {\n      return value;\n    }\n\n    if (value instanceof Date) {\n      return value;\n    }\n\n    // 其他类型转为字符串\n    if (typeof value === 'boolean') {\n      return String(value);\n    }\n\n    if (Array.isArray(value)) {\n      // 简单数组转为逗号分隔的字符串\n      return value.map(item => String(item ?? '')).join(', ');\n    }\n\n    if (value === null) {\n      return 'null';\n    }\n\n    if (value === undefined) {\n      return '';\n    }\n\n    // 对象转为 JSON 字符串\n    if (typeof value === 'object') {\n      try {\n        return JSON.stringify(value);\n      } catch {\n        return String(value);\n      }\n    }\n\n    return String(value);\n  }\n\n  /**\n   * 处理模板错误\n   */\n  private handleTemplateError(key: TranslateKey, error: any): void {\n    const keyStr = typeof key === 'string' ? key : '[object]';\n    const message = `The translation key '${keyStr}' is missing the necessary parameters.`;\n    if (isDevMode()) {\n      console.error(message, error);\n    } else {\n      console.warn(message, error);\n    }\n  }\n\n  /**\n   * 检测字符串是否包含 lodash template 格式的模板语法 {{ }}\n   * @param message - 要检测的字符串\n   * @returns 是否包含 lodash template 语法\n   */\n  private hasLodashTemplateFormat(message: string): boolean {\n    return /\\{\\{[^}]+\\}\\}/.test(message);\n  }\n\n  /**\n   * 检测字符串是否包含 ICU Message Format 语法\n   * ICU 语法包括：{variable}、{variable, type}、{variable, type, style} 等\n   * @param message - 要检测的字符串\n   * @returns 是否包含 ICU Message Format 语法\n   */\n  private hasIcuMessageFormat(message: string): boolean {\n    // 检测 ICU 格式：{variable}、{variable, type}、{variable, type, style}\n    // 但排除 lodash template 格式的 {{variable}}\n    return /\\{[^{}]+\\}/.test(message) && !this.hasLodashTemplateFormat(message);\n  }\n\n  /**\n   * 使用 lodash template 格式化文本\n   * @param message - 包含 {{ }} 语法的模板字符串\n   * @param data - 模板数据\n   * @returns 格式化后的字符串\n   */\n  private formatLodashTemplate(message: string, data: TemplateData): string {\n    try {\n      // 将数据标准化为对象格式\n      const templateData = this.normalizeTemplateData(data);\n\n      // 使用 lodash template 处理 {{ }} 语法\n      const compiled = template(message, {\n        interpolate: /\\{\\{(.+?)\\}\\}/g, // 自定义插值语法为 {{ }}\n      });\n\n      return compiled(templateData);\n    } catch (error) {\n      if (isDevMode()) {\n        console.warn(\n          `Lodash template formatting failed for \"${message}\":`,\n          error,\n        );\n      }\n      // 降级处理：返回原始消息\n      return message;\n    }\n  }\n\n  /**\n   * 标准化模板数据为对象格式\n   * @param data - 原始模板数据\n   * @returns 标准化后的对象或数组（为了向后兼容）\n   */\n  private normalizeTemplateData(\n    data: TemplateData,\n  ): Record<string, any> | any[] {\n    if (data == null) {\n      return {};\n    }\n\n    // 如果是纯对象，直接返回\n    if (this.isPlainTemplateObject(data)) {\n      return data;\n    }\n\n    // 这样模板中可以使用 {{ 0 }} 访问第一个元素\n    return [data] as any;\n  }\n\n  /**\n   * 使用 ICU message format 格式化文本\n   */\n  private formatIcuMessage(message: string, data: TemplateData): string {\n    try {\n      // 将数据转换为 ICU 兼容格式\n      const icuData = this.normalizeIcuData(data);\n\n      const messageFormat = new IntlMessageFormat(\n        message,\n        this.locale,\n        undefined,\n        { ignoreTag: true },\n      );\n      return messageFormat.format(icuData) as string;\n    } catch (error) {\n      if (isDevMode()) {\n        console.warn(`ICU message formatting failed for \"${message}\":`, error);\n      }\n      // 降级处理：返回原始消息\n      return message;\n    }\n  }\n\n  /**\n   * 格式化数字\n   * @param value - 要格式化的数字\n   * @param options - 格式化选项\n   * @returns 格式化后的数字字符串\n   *\n   * @example\n   * formatNumber(1234.56) // \"1,234.56\"\n   * formatNumber(0.85, { style: 'percent' }) // \"85%\"\n   * formatNumber(1234.56, { style: 'currency', currency: 'CNY' }) // \"¥1,234.56\"\n   */\n  formatNumber(value: number, options: Intl.NumberFormatOptions = {}): string {\n    try {\n      return new Intl.NumberFormat(this.locale, options).format(value);\n    } catch (error) {\n      if (isDevMode()) {\n        console.warn(`Number formatting failed for value ${value}:`, error);\n      }\n      return value.toString();\n    }\n  }\n\n  /**\n   * 格式化货币\n   * @param value - 要格式化的金额\n   * @param currency - 货币代码，默认为 CNY\n   * @param options - 其他格式化选项\n   * @returns 格式化后的货币字符串\n   *\n   * @example\n   * formatCurrency(1234.56) // en-US: \"CN¥1,234.56\", zh-CN: \"¥1,234.56\"\n   * formatCurrency(1234.56, 'USD') // en-US: \"$1,234.56\", zh-CN: \"US$1,234.56\"\n   */\n  formatCurrency(\n    value: number,\n    currency: string = 'CNY',\n    options: Omit<Intl.NumberFormatOptions, 'style' | 'currency'> = {},\n  ): string {\n    return this.formatNumber(value, {\n      style: 'currency',\n      currency,\n      ...options,\n    });\n  }\n\n  /**\n   * 格式化百分比\n   * @param value - 要格式化的值（0.85 表示 85%）\n   * @param options - 格式化选项\n   * @returns 格式化后的百分比字符串\n   *\n   * @example\n   * formatPercent(0.85) // \"85%\"\n   * formatPercent(0.8567, { minimumFractionDigits: 2 }) // \"85.67%\"\n   */\n  formatPercent(\n    value: number,\n    options: Omit<Intl.NumberFormatOptions, 'style'> = {},\n  ): string {\n    return this.formatNumber(value, {\n      style: 'percent',\n      ...options,\n    });\n  }\n\n  /**\n   * 格式化日期\n   * @param date - 要格式化的日期\n   * @param options - Intl.DateTimeFormatOptions 格式配置\n   * @returns 格式化后的日期字符串\n   *\n   * @example\n   * formatDate(new Date()) // en-US: \"01/01/2025\", zh-CN: \"2025/01/01\"\n   * formatDate(new Date(), { dateStyle: 'full' }) // \"2024年8月20日星期二\"\n   * formatDate(new Date(), { year: 'numeric', month: '2-digit', day: '2-digit' }) // 根据locale格式化\n   * formatDate(new Date(), { year: 'numeric', month: 'long' }) // \"2024年8月\"\n   */\n  formatDate(\n    date: Date | string | number,\n    options: Intl.DateTimeFormatOptions = {\n      year: 'numeric',\n      month: '2-digit',\n      day: '2-digit',\n    },\n  ): string {\n    try {\n      const dateObj = new Date(date);\n      if (isNaN(dateObj.getTime())) {\n        throw new Error('Invalid date');\n      }\n      return this.formatDateByOptions(dateObj, options);\n    } catch (error) {\n      if (isDevMode()) {\n        console.warn(`Date formatting failed for date ${date}:`, error);\n      }\n      return String(date);\n    }\n  }\n\n  /**\n   * 格式化日期和时间\n   * @param date - 要格式化的日期时间\n   * @param options - Intl.DateTimeFormatOptions 格式配置\n   * @returns 格式化后的日期时间字符串\n   *\n   * @example\n   * formatDateTime(new Date()) // en-US: \"01/01/2025, 14:30:00\", zh-CN: \"2025/01/01 14:30:00\"\n   * formatDateTime(new Date(), { dateStyle: 'medium', timeStyle: 'short' }) // \"2024年8月20日 14:30\"\n   * formatDateTime(new Date(), { year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit', hour12: false }) // 根据locale格式化\n   */\n  formatDateTime(\n    date: Date | string | number,\n    options: Intl.DateTimeFormatOptions = {\n      year: 'numeric',\n      month: '2-digit',\n      day: '2-digit',\n      hour: '2-digit',\n      minute: '2-digit',\n      second: '2-digit',\n      hour12: false,\n    },\n  ): string {\n    return this.formatDate(date, options);\n  }\n\n  /**\n   * 格式化相对时间\n   * @param value - 时间差值（数字）或日期对象\n   * @param unit - 时间单位（当value为数字时必须提供）\n   * @param options - 格式化选项\n   * @returns 格式化后的相对时间字符串\n   *\n   * @example\n   * // 手动指定单位\n   * formatRelativeTime(-1, 'day') // en-US: \"yesterday\", zh-CN: \"昨天\"\n   * formatRelativeTime(2, 'hour') // en-US: \"in 2 hours\", zh-CN: \"2小时后\"\n   * formatRelativeTime(-30, 'minute') // en-US: \"30 minutes ago\", zh-CN: \"30分钟前\"\n   *\n   * // 自动计算单位\n   * formatRelativeTime(new Date(Date.now() - 60000)) // \"1 minute ago\"\n   * formatRelativeTime(new Date(Date.now() + 7200000)) // \"in 2 hours\"\n   * formatRelativeTime(new Date(Date.now() - 86400000)) // \"yesterday\"\n   */\n  formatRelativeTime(\n    value: Date,\n    options?: Intl.RelativeTimeFormatOptions,\n  ): string;\n\n  formatRelativeTime(\n    value: number,\n    unit: Intl.RelativeTimeFormatUnit,\n    options?: Intl.RelativeTimeFormatOptions,\n  ): string;\n\n  formatRelativeTime(\n    value: number | Date,\n    unitOrOptions?:\n      | Intl.RelativeTimeFormatUnit\n      | Intl.RelativeTimeFormatOptions,\n    options: Intl.RelativeTimeFormatOptions = { numeric: 'auto' },\n  ): string {\n    try {\n      let finalValue: number;\n      let finalUnit: Intl.RelativeTimeFormatUnit;\n      let finalOptions: Intl.RelativeTimeFormatOptions;\n\n      if (value instanceof Date) {\n        // 自动计算时间差和单位\n        const { value: calculatedValue, unit: calculatedUnit } =\n          this.calculateRelativeTime(value);\n        finalValue = calculatedValue;\n        finalUnit = calculatedUnit;\n        finalOptions =\n          (unitOrOptions as Intl.RelativeTimeFormatOptions) || options;\n      } else {\n        // 使用提供的数值和单位\n        finalValue = value;\n        finalUnit = unitOrOptions as Intl.RelativeTimeFormatUnit;\n        finalOptions = options;\n      }\n\n      return new Intl.RelativeTimeFormat(this.locale, finalOptions).format(\n        finalValue,\n        finalUnit,\n      );\n    } catch (error) {\n      if (isDevMode()) {\n        console.warn(`Relative time formatting failed for ${value}:`, error);\n      }\n      return value instanceof Date\n        ? value.toLocaleString(this.locale)\n        : `${value}`;\n    }\n  }\n\n  /**\n   * 根据日期计算相对时间差值和最合适的单位\n   * @param date - 目标日期\n   * @returns 包含时间差值和单位的对象\n   */\n  private calculateRelativeTime(date: Date): {\n    value: number;\n    unit: Intl.RelativeTimeFormatUnit;\n  } {\n    const now = new Date();\n    const diffMs = date.getTime() - now.getTime();\n    const absDiffMs = Math.abs(diffMs);\n\n    // 时间单位阈值（毫秒）\n    const MINUTE_MS = 60 * 1000;\n    const HOUR_MS = 60 * MINUTE_MS;\n    const DAY_MS = 24 * HOUR_MS;\n\n    // 根据时间差选择合适的单位，最大单位为day\n    if (absDiffMs >= DAY_MS) {\n      return {\n        value: Math.round(diffMs / DAY_MS),\n        unit: 'day',\n      };\n    }\n    if (absDiffMs >= HOUR_MS) {\n      return {\n        value: Math.round(diffMs / HOUR_MS),\n        unit: 'hour',\n      };\n    }\n    if (absDiffMs >= MINUTE_MS) {\n      return {\n        value: Math.round(diffMs / MINUTE_MS),\n        unit: 'minute',\n      };\n    }\n    return {\n      value: Math.round(diffMs / 1000),\n      unit: 'second',\n    };\n  }\n\n  /**\n   * 根据日期格式配置格式化日期\n   * 使用标准 Intl.DateTimeFormatOptions 确保格式可预测性\n   */\n  private formatDateByOptions(\n    date: Date,\n    options: Intl.DateTimeFormatOptions,\n  ): string {\n    try {\n      return new Intl.DateTimeFormat(this.locale, options).format(date);\n    } catch (error) {\n      if (isDevMode()) {\n        console.warn(`Date formatting failed:`, error);\n      }\n      return date.toISOString();\n    }\n  }\n\n  /**\n   * 通过字符串键获取翻译\n   */\n  private getTranslationByKey(key: string): string {\n    return this.resolveTranslation(key);\n  }\n\n  /**\n   * 通过翻译对象获取翻译值\n   */\n  private getTranslationByObject(\n    translationObj: Translation,\n  ): TranslationValue {\n    return this.getTranslationValue(translationObj, this.locale);\n  }\n\n  /**\n   * 处理无效语言环境\n   */\n  private handleInvalidLocale(): void {\n    if (isDevMode()) {\n      throw new TypeError('`locales` has not been initialized correctly');\n    }\n  }\n\n  /**\n   * 验证语言环境是否有效\n   */\n  private isValidLocale(locale: string): boolean {\n    return this.options.locales.includes(locale);\n  }\n\n  /**\n   * 检查重复翻译（开发模式）\n   */\n  private checkForDuplicateTranslations(newTranslations: Translations): void {\n    for (const existingTranslations of this.translationsList) {\n      Object.keys(newTranslations).forEach(locale => {\n        if (existingTranslations[locale]) {\n          this.compareTranslationKeys(\n            locale,\n            newTranslations[locale],\n            existingTranslations[locale],\n          );\n        }\n      });\n    }\n  }\n\n  /**\n   * 标准化远程URL\n   */\n  private normalizeRemoteUrl(remoteUrl: string): string {\n    remoteUrl = this.cleanUrl(remoteUrl);\n    const isAbsolute = isAbsoluteUrl(remoteUrl);\n    const isApiGateWayRequest = remoteUrl.startsWith(API_GATEWAY);\n\n    // 开发模式下进行URL验证\n    if (isDevMode()) {\n      this.validateRemoteUrl(remoteUrl, isAbsolute);\n    }\n\n    // 相对URL转换为绝对URL\n    if (!isAbsolute && !isApiGateWayRequest) {\n      const baseUrl = this.baseHref.endsWith('/')\n        ? this.baseHref\n        : `${this.baseHref}/`;\n      return `${baseUrl}${remoteUrl}`;\n    }\n\n    return remoteUrl;\n  }\n\n  /**\n   * 清理URL（移除hash片段）\n   */\n  private cleanUrl(url: string): string {\n    return head(url.split(/#/)) || url;\n  }\n\n  /**\n   * 验证远程URL（开发模式）\n   */\n  private validateRemoteUrl(remoteUrl: string, isAbsolute: boolean): void {\n    if (!isAbsolute && (!this.baseHref || !isAbsoluteUrl(this.baseHref))) {\n      throw new TypeError(\n        'absolute base href is required for relative remote url',\n      );\n    }\n\n    if (remoteUrl.split('?')[0].includes('./')) {\n      throw new TypeError(\n        'do not use any dot with slash for relative url which should always base from base href',\n      );\n    }\n  }\n\n  /**\n   * 创建远程翻译请求\n   */\n  private createRemoteTranslationRequest(\n    normalizedUrl: string,\n  ): Observable<Translations> {\n    if (LOCALE_PLACEHOLDER_REGEX.test(normalizedUrl)) {\n      return this.createMultiLocaleRequest(normalizedUrl);\n    }\n    return this.createSingleLocaleRequest(normalizedUrl);\n  }\n\n  /**\n   * 创建多语言请求\n   */\n  private createMultiLocaleRequest(\n    urlTemplate: string,\n  ): Observable<Translations> {\n    const requests = this.options.locales.map(locale =>\n      this.fetchTranslation(urlTemplate, locale).pipe(\n        catchError(error => {\n          if (this.options.loose) {\n            const looseLocale = this.extractLooseLocale(locale);\n            if (\n              locale !== looseLocale &&\n              !this.options.locales.includes(looseLocale)\n            ) {\n              return this.fetchTranslation(urlTemplate, looseLocale);\n            }\n          }\n          return isDevMode() ? throwError(() => error) : EMPTY;\n        }),\n        filter(isPlainObject),\n        map(\n          (translation: Translation) =>\n            ({ [locale]: translation }) as Translations,\n        ),\n      ),\n    );\n\n    return forkJoin(requests).pipe(\n      map(results =>\n        results.reduce((acc, curr) => Object.assign(acc, curr), {}),\n      ),\n    );\n  }\n\n  /**\n   * 创建单语言请求\n   */\n  private createSingleLocaleRequest(url: string): Observable<Translations> {\n    return this.performTranslationRequest(url).pipe(\n      catchError(error => (isDevMode() ? throwError(() => error) : EMPTY)),\n    ) as Observable<Translations>;\n  }\n\n  /**\n   * 执行翻译请求\n   */\n  private performTranslationRequest(url: string): Observable<any> {\n    const isJSON = url.endsWith('.json');\n    const isApiGateWayRequest = url.startsWith(API_GATEWAY);\n    const responseType = isJSON ? 'json' : 'text';\n\n    if (isApiGateWayRequest) {\n      return this.http\n        .request('GET', url, { responseType })\n        .pipe(map(body => (isJSON ? body : parse(body))));\n    }\n\n    return ajax({ url, responseType }).pipe(\n      map(({ response }) => (isJSON ? response : parse(response as string))),\n    );\n  }\n\n  /**\n   * 验证fetchTranslation参数\n   */\n  private validateFetchTranslationParams(\n    remoteUrl: string,\n    locale?: string,\n  ): void {\n    if (isDevMode() && LOCALE_PLACEHOLDER_REGEX.test(remoteUrl) && !locale) {\n      throw new TypeError(\n        '`locale` is required since the provided remote url contains locale placeholder',\n      );\n    }\n  }\n\n  /**\n   * 解析翻译文本\n   */\n  private resolveTranslation(key: string, locale = this.locale): string {\n    // 优先从远程翻译中查找\n    let value = this.searchInTranslationsList(\n      key,\n      locale,\n      this.remoteTranslationsList,\n    );\n\n    // 如果远程翻译中没有找到（undefined），则从本地翻译中查找\n    if (value === undefined) {\n      value = this.searchInTranslationsList(key, locale, this.translationsList);\n    }\n\n    return value ?? key;\n  }\n\n  /**\n   * 在翻译列表中搜索\n   */\n  private searchInTranslationsList(\n    key: string,\n    locale: string,\n    translationsList: Translations[],\n  ): string | undefined {\n    if (!translationsList || translationsList.length === 0) {\n      return undefined;\n    }\n\n    // 从后往前遍历（后加入的优先级更高）\n    for (let i = translationsList.length - 1; i >= 0; i--) {\n      const value = this.searchInTranslations(key, locale, translationsList[i]);\n      if (value !== undefined) {\n        return value;\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * 在单个翻译对象中搜索\n   */\n  private searchInTranslations(\n    key: string,\n    locale: string,\n    translations: Translations,\n  ): string | undefined {\n    const translationValue = this.getTranslationValue(translations, locale);\n\n    // 如果没有获取到翻译值对象（getTranslationValue已经处理了loose和fallback），直接返回\n    if (translationValue === undefined) {\n      return undefined;\n    }\n\n    // 获取翻译值，支持扁平和嵌套两种结构\n    const value = this.getTranslationFromSource(translationValue, key);\n\n    // 如果找到值（包括null值），则处理并返回\n    if (value !== undefined) {\n      this.validateTranslationValue(value, locale, key);\n      // null值转换为字符串'null'，其他值正常转换\n      return value === null ? 'null' : String(value);\n    }\n\n    // 如果在当前语言的翻译值中找不到key，但这不是fallback语言，尝试fallback\n    if (locale !== this.options.fallbackLocale) {\n      const fallbackTranslationValue = this.getTranslationValue(\n        translations,\n        this.options.fallbackLocale,\n      );\n\n      if (fallbackTranslationValue !== undefined) {\n        const fallbackValue = this.getTranslationFromSource(\n          fallbackTranslationValue,\n          key,\n        );\n        if (fallbackValue !== undefined) {\n          this.validateTranslationValue(\n            fallbackValue,\n            this.options.fallbackLocale,\n            key,\n          );\n          return fallbackValue === null ? 'null' : String(fallbackValue);\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * 从翻译源获取翻译值，支持扁平和嵌套两种结构\n   * @param source - 翻译源对象\n   * @param key - 翻译键（如 'a.b.c'）\n   * @returns 翻译值或undefined\n   */\n  private getTranslationFromSource(source: any, key: string): any {\n    if (!source || typeof source !== 'object') {\n      return undefined;\n    }\n\n    // 1. 优先尝试扁平结构：直接查找完整的键 'a.b.c'\n    if (Object.prototype.hasOwnProperty.call(source, key)) {\n      return source[key];\n    }\n\n    // 2. 再尝试嵌套结构：使用lodash.get按路径查找 a.b.c\n    const nestedValue = get(source, key);\n    if (nestedValue !== undefined) {\n      return nestedValue;\n    }\n\n    return undefined;\n  }\n\n  /**\n   * 获取指定语言的翻译值（处理loose模式和fallback逻辑）\n   */\n  private getTranslationValue(\n    source: Translation,\n    locale = this.locale,\n  ): TranslationValue {\n    if (!source) {\n      return undefined;\n    }\n\n    // 1. 首先检查精确匹配的键是否存在\n    if (Object.prototype.hasOwnProperty.call(source, locale)) {\n      return source[locale]; // 返回实际值，可能是null、undefined或其他值\n    }\n\n    // 2. 如果启用了宽松模式，尝试宽松匹配\n    if (this.options.loose) {\n      const looseValue = this.getLooseTranslationValue(source, locale);\n      if (looseValue !== undefined) {\n        return looseValue;\n      }\n    }\n\n    // 3. 如果当前语言不是fallback语言，尝试fallback语言\n    if (locale !== this.options.fallbackLocale) {\n      // 首先检查fallback语言的精确匹配\n      if (\n        Object.prototype.hasOwnProperty.call(\n          source,\n          this.options.fallbackLocale,\n        )\n      ) {\n        return source[this.options.fallbackLocale];\n      }\n\n      // 如果启用了宽松模式，也对fallback语言进行宽松匹配\n      if (this.options.loose) {\n        const fallbackLooseValue = this.getLooseTranslationValue(\n          source,\n          this.options.fallbackLocale,\n        );\n        if (fallbackLooseValue !== undefined) {\n          return fallbackLooseValue;\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n  /**\n   * 宽松模式下获取翻译值\n   */\n  private getLooseTranslationValue(\n    source: Translation,\n    locale: string,\n  ): TranslationValue {\n    const looseLocale = this.extractLooseLocale(locale);\n\n    if (locale === looseLocale) {\n      // 寻找匹配的宽松语言\n      const matchedEntry = Object.entries(source).find(\n        ([key]) => looseLocale === this.extractLooseLocale(key),\n      );\n      return matchedEntry?.[1];\n    }\n\n    // 检查宽松语言键是否存在\n    if (Object.prototype.hasOwnProperty.call(source, looseLocale)) {\n      return source[looseLocale];\n    }\n\n    return undefined;\n  }\n\n  /**\n   * 提取宽松语言代码（如：zh-CN -> zh）\n   */\n  private extractLooseLocale(locale: string): string {\n    return head(locale.split(/[_-]/)) || locale;\n  }\n\n  /**\n   * 验证翻译值（开发模式）\n   */\n  private validateTranslationValue(\n    value: any,\n    locale: string,\n    key: string,\n  ): void {\n    if (\n      isDevMode() &&\n      typeof value === 'object' &&\n      typeof get(value, Symbol.toPrimitive) !== 'function'\n    ) {\n      console.warn(\n        `The translation for locale: \\`${locale}\\` and key:\\`${key}\\` is an object, which could be unexpected`,\n      );\n    }\n  }\n\n  /**\n   * 比较翻译键（开发模式下检查重复）\n   */\n  private compareTranslationKeys(\n    locale: string,\n    translation: Translation,\n    prevTranslation: Translation,\n    path: string[] = [],\n  ): void {\n    if (translation == null || prevTranslation == null) {\n      return;\n    }\n\n    Object.entries(translation).forEach(([key, value]) => {\n      if (!Object.prototype.hasOwnProperty.call(prevTranslation, key)) {\n        return;\n      }\n\n      const prevValue = prevTranslation[key];\n      const valueIsPlainObject = isPlainObject(value);\n      const prevValueIsPlainObject = isPlainObject(prevValue);\n\n      if (valueIsPlainObject && prevValueIsPlainObject) {\n        this.compareTranslationKeys(\n          locale,\n          value as Translation,\n          prevValue as Translation,\n          [...path, key],\n        );\n        return;\n      }\n\n      if (!valueIsPlainObject && !prevValueIsPlainObject) {\n        const outputPath = [...path, key].join(' -> ');\n        if (value === prevValue) {\n          console.warn(\n            `The customized translation for locale: \\`${locale}\\` and path: \\`${outputPath}\\` is duplicated with the other translation, please remove it in your translation file.`,\n          );\n        } else {\n          console.warn(\n            `Two keys that the locale is \\`${locale}\\` and the path is \\`${outputPath}\\` are same, but their values are not equal, please remove one of them or change one of the keys.`,\n          );\n        }\n      }\n    });\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alauda-fe/common",
-  "version": "1.4.29-beta.0",
+  "version": "1.4.29-beta.2",
   "description": "Alauda frontend team common codes.",
   "author": "Alauda Frontend",
   "license": "MIT",
@@ -13,43 +13,44 @@
   ],
   "peerDependencies": {
     "@alauda-fe/i18n": "1.0.4",
-    "@alauda/chart": "^0.1.11",
-    "@alauda/code-editor": "^5.1.0",
-    "@alauda/ui": "^7.2.0",
-    "@angular/animations": "^16.2.3",
-    "@angular/cdk": "^16.2.2",
-    "@angular/common": "^16.2.3",
-    "@angular/compiler": "^16.2.3",
-    "@angular/core": "^16.2.3",
-    "@angular/forms": "^16.2.3",
-    "@angular/platform-browser": "^16.2.3",
-    "@angular/platform-browser-dynamic": "^16.2.3",
-    "@angular/router": "^16.2.3",
-    "ab64": "^0.1.1",
-    "compare-versions": "^6.1.0",
-    "cron-parser": "^4.9.0",
+    "@alauda/chart": "^0.1.13",
+    "@alauda/code-editor": "^5.3.0",
+    "@alauda/ui": "^9.1.0",
+    "@angular/animations": "^18.1.1",
+    "@angular/cdk": "^18.1.1",
+    "@angular/common": "^18.1.1",
+    "@angular/compiler": "^18.1.1",
+    "@angular/core": "^18.1.1",
+    "@angular/forms": "^18.1.1",
+    "@angular/platform-browser": "^18.1.1",
+    "@angular/platform-browser-dynamic": "^18.1.1",
+    "@angular/router": "^18.1.1",
     "d3": "^7.8.5",
     "dayjs": "^1.11.9",
     "lodash-es": "^4.17.21",
-    "lottie-web": "^5.12.2",
-    "marked": "^7.0.5",
     "monaco-editor": "^0.39.0",
-    "ng-monaco-editor": "^5.1.0",
+    "ng-monaco-editor": "^5.1.1",
     "ng-resource-form-util": "^6.1.0",
     "ramda": "^0.29.0",
     "rxjs": "^7.8.1",
+    "zone.js": "^0.14.8"
+  },
+  "dependencies": {
+    "ab64": "^0.1.1",
+    "compare-versions": "^6.1.0",
+    "cron-parser": "^4.9.0",
+    "intl-messageformat": "^10.7.16",
+    "lottie-web": "^5.12.2",
+    "marked": "^7.0.5",
     "ts-md5": "^1.3.1",
+    "tslib": "^2.6.2",
     "xterm": "^5.2.1",
     "xterm-addon-canvas": "^0.4.0",
     "xterm-addon-fit": "^0.7.0",
     "xterm-addon-search": "^0.12.0",
     "xterm-addon-web-links": "^0.8.0",
     "xterm-addon-webgl": "^0.15.0",
-    "yaml": "^2.3.2",
-    "zone.js": "^0.13.1"
-  },
-  "dependencies": {
-    "tslib": "^2.6.2"
+    "yaml": "^2.3.2"
   },
   "sideEffects": false,
   "module": "esm2022/alauda-fe-common.mjs",

package/translate/translate.service.d.ts

@@ -46,25 +46,21 @@ export declare class TranslateService implements OnDestroy {
     ngOnDestroy(): void;
     /**
      * 获取翻译文本并进行模板插值
-     * 自动将传统 {{ key }} 语法转换为 ICU {key} 格式进行解析
-     * 同时支持原生 ICU Message Format 语法
+     * 支持两种模板语法：
+     * 1. 传统的 {{ key }} 语法，使用 lodash template 处理
+     * 2. ICU Message Format 语法，使用 IntlMessageFormat 处理
      * @param key - 翻译键或翻译对象
      * @param data - 模板数据（支持基本类型、Date、对象和数组）
      * @returns 翻译后的文本
      *
      * @example
      * ```typescript
-     * // 对象参数（推荐）
-     * translate.get('hello', { name: 'World' }) // 模板: "Hello {name}"
+     * // lodash template 语法
+     * translate.get('hello', { name: 'World' }) // 模板: "Hello {{ name }}"
      *
-     * // 基本类型参数（自动转换为 {value}）
-     * translate.get('welcome', 'John') // 模板: "Welcome {value}"
-     *
-     * // ICU 格式（数字）
-     * translate.get('itemCount', { count: 5 })
-     *
-     * // ICU 格式（日期，默认本地化）
-     * translate.get('createdAt', { date: new Date() })
+     * // ICU Message Format 语法
+     * translate.get('itemCount', { count: 5 }) // 模板: "Items: {count, number}"
+     * translate.get('createdAt', { date: new Date() }) // 模板: "Created: {date, date, short}"
      * ```
      */
     get(key: TranslateKey, data?: TemplateData): string;
@@ -118,7 +114,7 @@ export declare class TranslateService implements OnDestroy {
      * @param data - 模板数据
      * @returns ICU 兼容的数据对象
      */
-    private normalizeAndConvertToIcuData;
+    private normalizeIcuData;
     /**
      * 检查是否为纯模板对象（不是数组、Date等特殊对象）
      */
@@ -137,12 +133,31 @@ export declare class TranslateService implements OnDestroy {
      */
     private handleTemplateError;
     /**
-     * 将传统的 {{ key }} 语法转换为 ICU {key} 格式
-     * 同时保持已有的 ICU 格式不变
-     * @param message - 原始消息模板
-     * @returns 转换后的 ICU 格式消息
+     * 检测字符串是否包含 lodash template 格式的模板语法 {{ }}
+     * @param message - 要检测的字符串
+     * @returns 是否包含 lodash template 语法
+     */
+    private hasLodashTemplateFormat;
+    /**
+     * 检测字符串是否包含 ICU Message Format 语法
+     * ICU 语法包括：{variable}、{variable, type}、{variable, type, style} 等
+     * @param message - 要检测的字符串
+     * @returns 是否包含 ICU Message Format 语法
+     */
+    private hasIcuMessageFormat;
+    /**
+     * 使用 lodash template 格式化文本
+     * @param message - 包含 {{ }} 语法的模板字符串
+     * @param data - 模板数据
+     * @returns 格式化后的字符串
+     */
+    private formatLodashTemplate;
+    /**
+     * 标准化模板数据为对象格式
+     * @param data - 原始模板数据
+     * @returns 标准化后的对象或数组（为了向后兼容）
      */
-    private convertToIcuFormat;
+    private normalizeTemplateData;
     /**
      * 使用 ICU message format 格式化文本
      */

package/view-chart/view-chart.component.d.ts

@@ -146,7 +146,7 @@ export declare class ViewChartComponent implements OnChanges, AfterViewInit, OnD
     get scaleType(): ScaleType;
     get isScaleTime(): boolean;
     get options(): ViewOptions;
-    get tooltipTriggerType(): "none" | "item" | "axis";
+    get tooltipTriggerType(): "item" | "none" | "axis";
     getTriggerType(): "none" | "axis" | "item";
     constructor(componentFactoryResolver: ComponentFactoryResolver, injector: Injector, appRef: ApplicationRef, translate: TranslateService, cdr: ChangeDetectorRef, viewContainerRef: ViewContainerRef);
     ngOnChanges({ enableZoom }: SimpleChanges): void;