@vlian/infrastructure 0.9.10

package/dist/esm/managers/DictionaryManager/core/DictionaryDataManager.js

@@ -0,0 +1,275 @@
+/**
+ * 字典数据管理模块（Core 层）
+ * 负责字典数据的获取、更新、缓存管理
+ */ 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;
+}
+import { DictionaryError, DictionaryErrorCode } from "../types";
+/**
+ * 字典数据管理器
+ */ export class DictionaryDataManager {
+    /**
+   * 获取字典数据（异步）
+   */ async getDictionary(code, options) {
+        const force = options?.force ?? false;
+        const usePersistentCache = options?.usePersistentCache ?? this.enablePersistentCache;
+        // 如果不强制刷新，先尝试从缓存获取
+        if (!force) {
+            const cached = this.getDictionaryFromCache(code, usePersistentCache);
+            if (cached) {
+                return cached;
+            }
+        }
+        // 从配置获取（静态配置）
+        if (this.dictionaryConfig && this.dictionaryConfig[code]) {
+            const items = this.dictionaryConfig[code];
+            await this.setDictionary(code, items, false);
+            return items;
+        }
+        // 从 API 获取
+        if (this.dictionaryFetcher) {
+            const items = await this.dictionaryFetcher(code);
+            await this.setDictionary(code, items, usePersistentCache);
+            return items;
+        }
+        // 如果都没有，返回空数组
+        return [];
+    }
+    /**
+   * 获取字典数据（同步，仅读取缓存）
+   */ getDictionarySync(code) {
+        return this.getDictionaryFromCache(code, false);
+    }
+    /**
+   * 从缓存获取字典数据
+   */ getDictionaryFromCache(code, usePersistentCache) {
+        const cacheKey = this.getCacheKey(code);
+        // 从内存缓存获取
+        if (this.enableCache) {
+            const cached = this.cacheManager.get(cacheKey);
+            if (cached) {
+                return cached.items;
+            }
+        }
+        // 从状态管理获取
+        if (this.stateManager) {
+            const cached = this.stateManager.get(cacheKey);
+            if (cached) {
+                // 同步到内存缓存
+                if (this.enableCache) {
+                    this.cacheManager.set(cacheKey, cached, this.cacheExpiry);
+                }
+                return cached.items;
+            }
+        }
+        // 从持久化存储获取
+        if (usePersistentCache && this.storageManager) {
+            // 注意：持久化存储是异步的，同步方法无法使用
+            // 这里返回 null，由调用方决定是否等待异步加载
+            return null;
+        }
+        return null;
+    }
+    /**
+   * 设置字典数据
+   * @returns 返回旧数据和新数据，用于 Diff 计算
+   */ async setDictionary(code, items, usePersistentCache) {
+        // 验证数据
+        const validation = this.validator.validate(items);
+        if (!validation.valid) {
+            throw new DictionaryError(validation.error || 'Dictionary data validation failed', DictionaryErrorCode.VALIDATION_ERROR);
+        }
+        // 获取旧数据（用于 Diff 计算）
+        const oldData = this.getDictionaryData(code);
+        const oldItems = oldData?.items || [];
+        // 构建索引
+        const index = this.indexManager.buildIndex(items);
+        // 创建字典数据
+        const dictionaryData = {
+            code,
+            items,
+            index,
+            updatedAt: Date.now(),
+            expiresAt: this.cacheExpiry ? Date.now() + this.cacheExpiry : undefined
+        };
+        const cacheKey = this.getCacheKey(code);
+        // 更新内存缓存
+        if (this.enableCache) {
+            this.cacheManager.set(cacheKey, dictionaryData, this.cacheExpiry);
+        }
+        // 更新状态管理
+        if (this.stateManager) {
+            this.stateManager.set(cacheKey, dictionaryData);
+        }
+        // 更新持久化存储
+        if (usePersistentCache && this.storageManager) {
+            try {
+                await this.storageManager.set(cacheKey, JSON.stringify(dictionaryData));
+            } catch (error) {
+                // 持久化失败不影响内存缓存
+                console.warn('Failed to persist dictionary data:', error);
+            }
+        }
+        return {
+            oldItems,
+            newItems: items
+        };
+    }
+    /**
+   * 获取字典数据对象（包含索引）
+   */ getDictionaryData(code) {
+        const cacheKey = this.getCacheKey(code);
+        // 从内存缓存获取
+        if (this.enableCache) {
+            const cached = this.cacheManager.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+        }
+        // 从状态管理获取
+        if (this.stateManager) {
+            const cached = this.stateManager.get(cacheKey);
+            if (cached) {
+                // 同步到内存缓存
+                if (this.enableCache) {
+                    this.cacheManager.set(cacheKey, cached, this.cacheExpiry);
+                }
+                return cached;
+            }
+        }
+        return null;
+    }
+    /**
+   * 批量获取字典数据（异步）
+   */ async getDictionaries(codes, options) {
+        const result = {};
+        // 如果提供了批量获取函数，使用它
+        if (this.dictionariesFetcher) {
+            const dictionaries = await this.dictionariesFetcher(codes);
+            // 保存到缓存
+            for (const [code, items] of Object.entries(dictionaries)){
+                await this.setDictionary(code, items, options?.usePersistentCache ?? this.enablePersistentCache);
+                result[code] = items;
+            }
+            return result;
+        }
+        // 否则逐个获取
+        const promises = codes.map(async (code)=>{
+            const items = await this.getDictionary(code, options);
+            return {
+                code,
+                items
+            };
+        });
+        const results = await Promise.all(promises);
+        for (const { code, items } of results){
+            result[code] = items;
+        }
+        return result;
+    }
+    /**
+   * 批量获取字典数据（同步，仅读取缓存）
+   */ getDictionariesSync(codes) {
+        const result = {};
+        for (const code of codes){
+            const items = this.getDictionarySync(code);
+            if (items) {
+                result[code] = items;
+            }
+        }
+        return result;
+    }
+    /**
+   * 清除字典缓存
+   */ async clearCache(code) {
+        if (code) {
+            const cacheKey = this.getCacheKey(code);
+            // 清除内存缓存
+            if (this.enableCache) {
+                this.cacheManager.delete(cacheKey);
+            }
+            // 清除状态管理
+            if (this.stateManager) {
+                this.stateManager.remove(cacheKey);
+            }
+            // 清除持久化存储
+            if (this.storageManager) {
+                await this.storageManager.remove(cacheKey);
+            }
+        } else {
+            // 清除所有缓存
+            if (this.enableCache) {
+                this.cacheManager.clear();
+            }
+        // 清除状态管理（需要知道所有键，这里简化处理）
+        // 注意：StateManager 可能没有 clear 方法，需要遍历删除
+        // 清除持久化存储（需要知道所有键）
+        }
+    }
+    /**
+   * 获取缓存键
+   */ getCacheKey(code) {
+        return `${this.dictionaryKeyPrefix}${code}`;
+    }
+    /**
+   * 获取可用字典列表（从缓存）
+   */ getAvailableDictionariesSync() {
+        const codes = [];
+        // 从内存缓存获取
+        if (this.enableCache) {
+            const keys = this.cacheManager.keys();
+            for (const key of keys){
+                if (key.startsWith(this.dictionaryKeyPrefix)) {
+                    codes.push(key.substring(this.dictionaryKeyPrefix.length));
+                }
+            }
+        }
+        // 从配置获取
+        if (this.dictionaryConfig) {
+            for (const code of Object.keys(this.dictionaryConfig)){
+                if (!codes.includes(code)) {
+                    codes.push(code);
+                }
+            }
+        }
+        return codes;
+    }
+    constructor(options){
+        _define_property(this, "cacheManager", void 0);
+        _define_property(this, "stateManager", void 0);
+        _define_property(this, "storageManager", void 0);
+        _define_property(this, "indexManager", void 0);
+        _define_property(this, "validator", void 0);
+        _define_property(this, "dictionaryFetcher", void 0);
+        _define_property(this, "dictionariesFetcher", void 0);
+        _define_property(this, "dictionaryConfig", void 0);
+        _define_property(this, "enableCache", void 0);
+        _define_property(this, "enablePersistentCache", void 0);
+        _define_property(this, "cacheExpiry", void 0);
+        _define_property(this, "dictionaryKeyPrefix", void 0);
+        this.cacheManager = options.cacheManager;
+        this.stateManager = options.stateManager;
+        this.storageManager = options.storageManager;
+        this.indexManager = options.indexManager;
+        this.validator = options.validator;
+        this.dictionaryFetcher = options.dictionaryFetcher;
+        this.dictionariesFetcher = options.dictionariesFetcher;
+        this.dictionaryConfig = options.dictionaryConfig;
+        this.enableCache = options.enableCache;
+        this.enablePersistentCache = options.enablePersistentCache;
+        this.cacheExpiry = options.cacheExpiry;
+        this.dictionaryKeyPrefix = options.dictionaryKeyPrefix;
+    }
+}
+
+//# sourceMappingURL=DictionaryDataManager.js.map

package/dist/esm/managers/DictionaryManager/core/DictionaryDataManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/managers/DictionaryManager/core/DictionaryDataManager.ts"],"sourcesContent":["/**\n * 字典数据管理模块（Core 层）\n * 负责字典数据的获取、更新、缓存管理\n */\n\nimport type {\n  DictionaryItem,\n  DictionaryData,\n} from '../types';\nimport { DictionaryError, DictionaryErrorCode } from '../types';\nimport { CacheManager } from './CacheManager';\nimport { StateManagerWrapper } from './StateManagerWrapper';\nimport { IndexManager } from './IndexManager';\nimport { DictionaryValidator } from './DictionaryValidator';\nimport { StorageManager } from '../modules/StorageManager';\n\n/**\n * 字典数据管理器\n */\nexport class DictionaryDataManager<TDictionaryItem = DictionaryItem> {\n  private cacheManager: CacheManager<DictionaryData<TDictionaryItem>>;\n  private stateManager?: StateManagerWrapper;\n  private storageManager?: StorageManager;\n  private indexManager: IndexManager<TDictionaryItem>;\n  private validator: DictionaryValidator<TDictionaryItem>;\n  \n  private dictionaryFetcher?: (code: string) => Promise<TDictionaryItem[]>;\n  private dictionariesFetcher?: (codes: string[]) => Promise<Record<string, TDictionaryItem[]>>;\n  private dictionaryConfig?: Record<string, TDictionaryItem[]>;\n  \n  private enableCache: boolean;\n  private enablePersistentCache: boolean;\n  private cacheExpiry?: number;\n  private dictionaryKeyPrefix: string;\n\n  constructor(options: {\n    cacheManager: CacheManager<DictionaryData<TDictionaryItem>>;\n    stateManager?: StateManagerWrapper;\n    storageManager?: StorageManager;\n    indexManager: IndexManager<TDictionaryItem>;\n    validator: DictionaryValidator<TDictionaryItem>;\n    dictionaryFetcher?: (code: string) => Promise<TDictionaryItem[]>;\n    dictionariesFetcher?: (codes: string[]) => Promise<Record<string, TDictionaryItem[]>>;\n    dictionaryConfig?: Record<string, TDictionaryItem[]>;\n    enableCache: boolean;\n    enablePersistentCache: boolean;\n    cacheExpiry?: number;\n    dictionaryKeyPrefix: string;\n  }) {\n    this.cacheManager = options.cacheManager;\n    this.stateManager = options.stateManager;\n    this.storageManager = options.storageManager;\n    this.indexManager = options.indexManager;\n    this.validator = options.validator;\n    this.dictionaryFetcher = options.dictionaryFetcher;\n    this.dictionariesFetcher = options.dictionariesFetcher;\n    this.dictionaryConfig = options.dictionaryConfig;\n    this.enableCache = options.enableCache;\n    this.enablePersistentCache = options.enablePersistentCache;\n    this.cacheExpiry = options.cacheExpiry;\n    this.dictionaryKeyPrefix = options.dictionaryKeyPrefix;\n  }\n\n  /**\n   * 获取字典数据（异步）\n   */\n  async getDictionary(\n    code: string,\n    options?: { force?: boolean; usePersistentCache?: boolean }\n  ): Promise<TDictionaryItem[]> {\n    const force = options?.force ?? false;\n    const usePersistentCache = options?.usePersistentCache ?? this.enablePersistentCache;\n\n    // 如果不强制刷新，先尝试从缓存获取\n    if (!force) {\n      const cached = this.getDictionaryFromCache(code, usePersistentCache);\n      if (cached) {\n        return cached;\n      }\n    }\n\n    // 从配置获取（静态配置）\n    if (this.dictionaryConfig && this.dictionaryConfig[code]) {\n      const items = this.dictionaryConfig[code];\n      await this.setDictionary(code, items, false);\n      return items;\n    }\n\n    // 从 API 获取\n    if (this.dictionaryFetcher) {\n      const items = await this.dictionaryFetcher(code);\n      await this.setDictionary(code, items, usePersistentCache);\n      return items;\n    }\n\n    // 如果都没有，返回空数组\n    return [];\n  }\n\n  /**\n   * 获取字典数据（同步，仅读取缓存）\n   */\n  getDictionarySync(code: string): TDictionaryItem[] | null {\n    return this.getDictionaryFromCache(code, false);\n  }\n\n  /**\n   * 从缓存获取字典数据\n   */\n  private getDictionaryFromCache(\n    code: string,\n    usePersistentCache: boolean\n  ): TDictionaryItem[] | null {\n    const cacheKey = this.getCacheKey(code);\n\n    // 从内存缓存获取\n    if (this.enableCache) {\n      const cached = this.cacheManager.get(cacheKey);\n      if (cached) {\n        return cached.items;\n      }\n    }\n\n    // 从状态管理获取\n    if (this.stateManager) {\n      const cached = this.stateManager.get<DictionaryData<TDictionaryItem>>(cacheKey);\n      if (cached) {\n        // 同步到内存缓存\n        if (this.enableCache) {\n          this.cacheManager.set(cacheKey, cached, this.cacheExpiry);\n        }\n        return cached.items;\n      }\n    }\n\n    // 从持久化存储获取\n    if (usePersistentCache && this.storageManager) {\n      // 注意：持久化存储是异步的，同步方法无法使用\n      // 这里返回 null，由调用方决定是否等待异步加载\n      return null;\n    }\n\n    return null;\n  }\n\n  /**\n   * 设置字典数据\n   * @returns 返回旧数据和新数据，用于 Diff 计算\n   */\n  async setDictionary(\n    code: string,\n    items: TDictionaryItem[],\n    usePersistentCache: boolean\n  ): Promise<{ oldItems: TDictionaryItem[]; newItems: TDictionaryItem[] }> {\n    // 验证数据\n    const validation = this.validator.validate(items);\n    if (!validation.valid) {\n      throw new DictionaryError(\n        validation.error || 'Dictionary data validation failed',\n        DictionaryErrorCode.VALIDATION_ERROR\n      );\n    }\n\n    // 获取旧数据（用于 Diff 计算）\n    const oldData = this.getDictionaryData(code);\n    const oldItems = oldData?.items || [];\n\n    // 构建索引\n    const index = this.indexManager.buildIndex(items);\n\n    // 创建字典数据\n    const dictionaryData: DictionaryData<TDictionaryItem> = {\n      code,\n      items,\n      index,\n      updatedAt: Date.now(),\n      expiresAt: this.cacheExpiry ? Date.now() + this.cacheExpiry : undefined,\n    };\n\n    const cacheKey = this.getCacheKey(code);\n\n    // 更新内存缓存\n    if (this.enableCache) {\n      this.cacheManager.set(cacheKey, dictionaryData, this.cacheExpiry);\n    }\n\n    // 更新状态管理\n    if (this.stateManager) {\n      this.stateManager.set(cacheKey, dictionaryData);\n    }\n\n    // 更新持久化存储\n    if (usePersistentCache && this.storageManager) {\n      try {\n        await this.storageManager.set(\n          cacheKey,\n          JSON.stringify(dictionaryData)\n        );\n      } catch (error) {\n        // 持久化失败不影响内存缓存\n        console.warn('Failed to persist dictionary data:', error);\n      }\n    }\n\n    return { oldItems, newItems: items };\n  }\n\n  /**\n   * 获取字典数据对象（包含索引）\n   */\n  getDictionaryData(code: string): DictionaryData<TDictionaryItem> | null {\n    const cacheKey = this.getCacheKey(code);\n\n    // 从内存缓存获取\n    if (this.enableCache) {\n      const cached = this.cacheManager.get(cacheKey);\n      if (cached) {\n        return cached;\n      }\n    }\n\n    // 从状态管理获取\n    if (this.stateManager) {\n      const cached = this.stateManager.get<DictionaryData<TDictionaryItem>>(cacheKey);\n      if (cached) {\n        // 同步到内存缓存\n        if (this.enableCache) {\n          this.cacheManager.set(cacheKey, cached, this.cacheExpiry);\n        }\n        return cached;\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * 批量获取字典数据（异步）\n   */\n  async getDictionaries(\n    codes: string[],\n    options?: { force?: boolean; usePersistentCache?: boolean }\n  ): Promise<Record<string, TDictionaryItem[]>> {\n    const result: Record<string, TDictionaryItem[]> = {};\n\n    // 如果提供了批量获取函数，使用它\n    if (this.dictionariesFetcher) {\n      const dictionaries = await this.dictionariesFetcher(codes);\n      \n      // 保存到缓存\n      for (const [code, items] of Object.entries(dictionaries)) {\n        await this.setDictionary(code, items, options?.usePersistentCache ?? this.enablePersistentCache);\n        result[code] = items;\n      }\n      \n      return result;\n    }\n\n    // 否则逐个获取\n    const promises = codes.map(async (code) => {\n      const items = await this.getDictionary(code, options);\n      return { code, items };\n    });\n\n    const results = await Promise.all(promises);\n    for (const { code, items } of results) {\n      result[code] = items;\n    }\n\n    return result;\n  }\n\n  /**\n   * 批量获取字典数据（同步，仅读取缓存）\n   */\n  getDictionariesSync(codes: string[]): Record<string, TDictionaryItem[]> {\n    const result: Record<string, TDictionaryItem[]> = {};\n\n    for (const code of codes) {\n      const items = this.getDictionarySync(code);\n      if (items) {\n        result[code] = items;\n      }\n    }\n\n    return result;\n  }\n\n  /**\n   * 清除字典缓存\n   */\n  async clearCache(code?: string): Promise<void> {\n    if (code) {\n      const cacheKey = this.getCacheKey(code);\n      \n      // 清除内存缓存\n      if (this.enableCache) {\n        this.cacheManager.delete(cacheKey);\n      }\n\n      // 清除状态管理\n      if (this.stateManager) {\n        this.stateManager.remove(cacheKey);\n      }\n\n      // 清除持久化存储\n      if (this.storageManager) {\n        await this.storageManager.remove(cacheKey);\n      }\n    } else {\n      // 清除所有缓存\n      if (this.enableCache) {\n        this.cacheManager.clear();\n      }\n\n      // 清除状态管理（需要知道所有键，这里简化处理）\n      // 注意：StateManager 可能没有 clear 方法，需要遍历删除\n\n      // 清除持久化存储（需要知道所有键）\n    }\n  }\n\n  /**\n   * 获取缓存键\n   */\n  private getCacheKey(code: string): string {\n    return `${this.dictionaryKeyPrefix}${code}`;\n  }\n\n  /**\n   * 获取可用字典列表（从缓存）\n   */\n  getAvailableDictionariesSync(): string[] {\n    const codes: string[] = [];\n\n    // 从内存缓存获取\n    if (this.enableCache) {\n      const keys = this.cacheManager.keys();\n      for (const key of keys) {\n        if (key.startsWith(this.dictionaryKeyPrefix)) {\n          codes.push(key.substring(this.dictionaryKeyPrefix.length));\n        }\n      }\n    }\n\n    // 从配置获取\n    if (this.dictionaryConfig) {\n      for (const code of Object.keys(this.dictionaryConfig)) {\n        if (!codes.includes(code)) {\n          codes.push(code);\n        }\n      }\n    }\n\n    return codes;\n  }\n}\n"],"names":["DictionaryError","DictionaryErrorCode","DictionaryDataManager","getDictionary","code","options","force","usePersistentCache","enablePersistentCache","cached","getDictionaryFromCache","dictionaryConfig","items","setDictionary","dictionaryFetcher","getDictionarySync","cacheKey","getCacheKey","enableCache","cacheManager","get","stateManager","set","cacheExpiry","storageManager","validation","validator","validate","valid","error","VALIDATION_ERROR","oldData","getDictionaryData","oldItems","index","indexManager","buildIndex","dictionaryData","updatedAt","Date","now","expiresAt","undefined","JSON","stringify","console","warn","newItems","getDictionaries","codes","result","dictionariesFetcher","dictionaries","Object","entries","promises","map","results","Promise","all","getDictionariesSync","clearCache","delete","remove","clear","dictionaryKeyPrefix","getAvailableDictionariesSync","keys","key","startsWith","push","substring","length","includes"],"mappings":"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"}

package/dist/esm/managers/DictionaryManager/core/DictionaryValidator.js

@@ -0,0 +1,58 @@
+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;
+}
+/**
+ * 字典数据验证模块
+ * 验证字典数据的有效性
+ */ /**
+ * 字典验证器
+ */ export class DictionaryValidator {
+    /**
+   * 验证字典数据
+   */ validate(data) {
+        // 如果没有自定义验证函数，只做基本检查
+        if (!this.validator) {
+            return this.basicValidate(data);
+        }
+        // 使用自定义验证函数
+        const result = this.validator(data);
+        if (result === true) {
+            return {
+                valid: true
+            };
+        }
+        return {
+            valid: false,
+            error: result
+        };
+    }
+    /**
+   * 基本验证
+   */ basicValidate(data) {
+        if (!Array.isArray(data)) {
+            return {
+                valid: false,
+                error: 'Dictionary data must be an array'
+            };
+        }
+        return {
+            valid: true
+        };
+    }
+    constructor(options){
+        _define_property(this, "validator", void 0);
+        this.validator = options?.validator;
+    }
+}
+
+//# sourceMappingURL=DictionaryValidator.js.map

package/dist/esm/managers/DictionaryManager/core/DictionaryValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/managers/DictionaryManager/core/DictionaryValidator.ts"],"sourcesContent":["/**\n * 字典数据验证模块\n * 验证字典数据的有效性\n */\n\n/**\n * 字典验证器\n */\nexport class DictionaryValidator<TDictionaryItem> {\n  private validator?: (data: TDictionaryItem[]) => true | string;\n\n  constructor(options?: {\n    validator?: (data: TDictionaryItem[]) => true | string;\n  }) {\n    this.validator = options?.validator;\n  }\n\n  /**\n   * 验证字典数据\n   */\n  validate(data: TDictionaryItem[]): { valid: boolean; error?: string } {\n    // 如果没有自定义验证函数，只做基本检查\n    if (!this.validator) {\n      return this.basicValidate(data);\n    }\n\n    // 使用自定义验证函数\n    const result = this.validator(data);\n    if (result === true) {\n      return { valid: true };\n    }\n\n    return {\n      valid: false,\n      error: result,\n    };\n  }\n\n  /**\n   * 基本验证\n   */\n  private basicValidate(data: TDictionaryItem[]): { valid: boolean; error?: string } {\n    if (!Array.isArray(data)) {\n      return {\n        valid: false,\n        error: 'Dictionary data must be an array',\n      };\n    }\n\n    return { valid: true };\n  }\n}\n"],"names":["DictionaryValidator","validate","data","validator","basicValidate","result","valid","error","Array","isArray","options"],"mappings":";;;;;;;;;;;;;AAAA;;;CAGC,GAED;;CAEC,GACD,OAAO,MAAMA;IASX;;GAEC,GACDC,SAASC,IAAuB,EAAsC;QACpE,qBAAqB;QACrB,IAAI,CAAC,IAAI,CAACC,SAAS,EAAE;YACnB,OAAO,IAAI,CAACC,aAAa,CAACF;QAC5B;QAEA,YAAY;QACZ,MAAMG,SAAS,IAAI,CAACF,SAAS,CAACD;QAC9B,IAAIG,WAAW,MAAM;YACnB,OAAO;gBAAEC,OAAO;YAAK;QACvB;QAEA,OAAO;YACLA,OAAO;YACPC,OAAOF;QACT;IACF;IAEA;;GAEC,GACD,AAAQD,cAAcF,IAAuB,EAAsC;QACjF,IAAI,CAACM,MAAMC,OAAO,CAACP,OAAO;YACxB,OAAO;gBACLI,OAAO;gBACPC,OAAO;YACT;QACF;QAEA,OAAO;YAAED,OAAO;QAAK;IACvB;IAvCA,YAAYI,OAEX,CAAE;QAJH,uBAAQP,aAAR,KAAA;QAKE,IAAI,CAACA,SAAS,GAAGO,SAASP;IAC5B;AAoCF"}

package/dist/esm/managers/DictionaryManager/core/DiffCalculator.js

@@ -0,0 +1,101 @@
+/**
+ * 差异计算模块
+ * 计算字典数据的差异信息（added、removed、changed）
+ */ /**
+ * 字典差异信息
+ */ 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;
+}
+/**
+ * 差异计算器
+ */ export class DiffCalculator {
+    /**
+   * 计算字典差异
+   */ calculateDiff(newItems, oldItems) {
+        const added = [];
+        const removed = [];
+        const changed = [];
+        // 构建旧项的索引（通过索引键）
+        const oldItemsMap = new Map();
+        for (const item of oldItems){
+            const key = this.getIndexKey(item);
+            if (key) {
+                oldItemsMap.set(key, item);
+            }
+        }
+        // 构建新项的索引
+        const newItemsMap = new Map();
+        for (const item of newItems){
+            const key = this.getIndexKey(item);
+            if (key) {
+                newItemsMap.set(key, item);
+            }
+        }
+        // 找出新增的项（在新数据中存在，在旧数据中不存在）
+        for (const item of newItems){
+            const key = this.getIndexKey(item);
+            if (key && !oldItemsMap.has(key)) {
+                added.push(item);
+            }
+        }
+        // 找出删除的项（在旧数据中存在，在新数据中不存在）
+        for (const item of oldItems){
+            const key = this.getIndexKey(item);
+            if (key && !newItemsMap.has(key)) {
+                removed.push(item);
+            }
+        }
+        // 找出变更的项（在新旧数据中都存在，但内容不同）
+        for (const item of newItems){
+            const key = this.getIndexKey(item);
+            if (key && oldItemsMap.has(key)) {
+                const oldItem = oldItemsMap.get(key);
+                if (this.itemChangeDetector(oldItem, item)) {
+                    changed.push({
+                        before: oldItem,
+                        after: item
+                    });
+                }
+            }
+        }
+        return {
+            added,
+            removed,
+            changed
+        };
+    }
+    /**
+   * 获取索引键
+   */ getIndexKey(item) {
+        if (typeof this.indexKeyField === 'function') {
+            return this.indexKeyField(item);
+        }
+        // 从对象中获取字段值
+        const value = item[this.indexKeyField];
+        if (value === undefined || value === null) {
+            return '';
+        }
+        return String(value);
+    }
+    constructor(options){
+        _define_property(this, "itemChangeDetector", void 0);
+        _define_property(this, "indexKeyField", void 0);
+        this.indexKeyField = options.indexKeyField;
+        // 默认变更检测：深度比较
+        this.itemChangeDetector = options.itemChangeDetector || ((before, after)=>{
+            return JSON.stringify(before) !== JSON.stringify(after);
+        });
+    }
+}
+
+//# sourceMappingURL=DiffCalculator.js.map

package/dist/esm/managers/DictionaryManager/core/DiffCalculator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/managers/DictionaryManager/core/DiffCalculator.ts"],"sourcesContent":["/**\n * 差异计算模块\n * 计算字典数据的差异信息（added、removed、changed）\n */\n\n/**\n * 字典差异信息\n */\nexport interface DictionaryDiff<TDictionaryItem> {\n  added: TDictionaryItem[];\n  removed: TDictionaryItem[];\n  changed: Array<{\n    before: TDictionaryItem;\n    after: TDictionaryItem;\n  }>;\n}\n\n/**\n * 差异计算器\n */\nexport class DiffCalculator<TDictionaryItem> {\n  private itemChangeDetector: (before: TDictionaryItem, after: TDictionaryItem) => boolean;\n  private indexKeyField: string | ((item: TDictionaryItem) => string);\n\n  constructor(options: {\n    itemComparator?: (item1: TDictionaryItem, item2: TDictionaryItem) => boolean;\n    itemChangeDetector?: (before: TDictionaryItem, after: TDictionaryItem) => boolean;\n    indexKeyField: string | ((item: TDictionaryItem) => string);\n  }) {\n    this.indexKeyField = options.indexKeyField;\n    \n    // 默认变更检测：深度比较\n    this.itemChangeDetector = options.itemChangeDetector || ((before, after) => {\n      return JSON.stringify(before) !== JSON.stringify(after);\n    });\n  }\n\n  /**\n   * 计算字典差异\n   */\n  calculateDiff(\n    newItems: TDictionaryItem[],\n    oldItems: TDictionaryItem[]\n  ): DictionaryDiff<TDictionaryItem> {\n    const added: TDictionaryItem[] = [];\n    const removed: TDictionaryItem[] = [];\n    const changed: Array<{ before: TDictionaryItem; after: TDictionaryItem }> = [];\n\n    // 构建旧项的索引（通过索引键）\n    const oldItemsMap = new Map<string, TDictionaryItem>();\n    for (const item of oldItems) {\n      const key = this.getIndexKey(item);\n      if (key) {\n        oldItemsMap.set(key, item);\n      }\n    }\n\n    // 构建新项的索引\n    const newItemsMap = new Map<string, TDictionaryItem>();\n    for (const item of newItems) {\n      const key = this.getIndexKey(item);\n      if (key) {\n        newItemsMap.set(key, item);\n      }\n    }\n\n    // 找出新增的项（在新数据中存在，在旧数据中不存在）\n    for (const item of newItems) {\n      const key = this.getIndexKey(item);\n      if (key && !oldItemsMap.has(key)) {\n        added.push(item);\n      }\n    }\n\n    // 找出删除的项（在旧数据中存在，在新数据中不存在）\n    for (const item of oldItems) {\n      const key = this.getIndexKey(item);\n      if (key && !newItemsMap.has(key)) {\n        removed.push(item);\n      }\n    }\n\n    // 找出变更的项（在新旧数据中都存在，但内容不同）\n    for (const item of newItems) {\n      const key = this.getIndexKey(item);\n      if (key && oldItemsMap.has(key)) {\n        const oldItem = oldItemsMap.get(key)!;\n        if (this.itemChangeDetector(oldItem, item)) {\n          changed.push({\n            before: oldItem,\n            after: item,\n          });\n        }\n      }\n    }\n\n    return {\n      added,\n      removed,\n      changed,\n    };\n  }\n\n  /**\n   * 获取索引键\n   */\n  private getIndexKey(item: TDictionaryItem): string {\n    if (typeof this.indexKeyField === 'function') {\n      return this.indexKeyField(item);\n    }\n\n    // 从对象中获取字段值\n    const value = (item as Record<string, unknown>)[this.indexKeyField];\n    if (value === undefined || value === null) {\n      return '';\n    }\n\n    return String(value);\n  }\n}\n"],"names":["DiffCalculator","calculateDiff","newItems","oldItems","added","removed","changed","oldItemsMap","Map","item","key","getIndexKey","set","newItemsMap","has","push","oldItem","get","itemChangeDetector","before","after","indexKeyField","value","undefined","String","options","JSON","stringify"],"mappings":"AAAA;;;CAGC,GAED;;CAEC;;;;;;;;;;;;;AAUD;;CAEC,GACD,OAAO,MAAMA;IAiBX;;GAEC,GACDC,cACEC,QAA2B,EAC3BC,QAA2B,EACM;QACjC,MAAMC,QAA2B,EAAE;QACnC,MAAMC,UAA6B,EAAE;QACrC,MAAMC,UAAsE,EAAE;QAE9E,iBAAiB;QACjB,MAAMC,cAAc,IAAIC;QACxB,KAAK,MAAMC,QAAQN,SAAU;YAC3B,MAAMO,MAAM,IAAI,CAACC,WAAW,CAACF;YAC7B,IAAIC,KAAK;gBACPH,YAAYK,GAAG,CAACF,KAAKD;YACvB;QACF;QAEA,UAAU;QACV,MAAMI,cAAc,IAAIL;QACxB,KAAK,MAAMC,QAAQP,SAAU;YAC3B,MAAMQ,MAAM,IAAI,CAACC,WAAW,CAACF;YAC7B,IAAIC,KAAK;gBACPG,YAAYD,GAAG,CAACF,KAAKD;YACvB;QACF;QAEA,2BAA2B;QAC3B,KAAK,MAAMA,QAAQP,SAAU;YAC3B,MAAMQ,MAAM,IAAI,CAACC,WAAW,CAACF;YAC7B,IAAIC,OAAO,CAACH,YAAYO,GAAG,CAACJ,MAAM;gBAChCN,MAAMW,IAAI,CAACN;YACb;QACF;QAEA,2BAA2B;QAC3B,KAAK,MAAMA,QAAQN,SAAU;YAC3B,MAAMO,MAAM,IAAI,CAACC,WAAW,CAACF;YAC7B,IAAIC,OAAO,CAACG,YAAYC,GAAG,CAACJ,MAAM;gBAChCL,QAAQU,IAAI,CAACN;YACf;QACF;QAEA,0BAA0B;QAC1B,KAAK,MAAMA,QAAQP,SAAU;YAC3B,MAAMQ,MAAM,IAAI,CAACC,WAAW,CAACF;YAC7B,IAAIC,OAAOH,YAAYO,GAAG,CAACJ,MAAM;gBAC/B,MAAMM,UAAUT,YAAYU,GAAG,CAACP;gBAChC,IAAI,IAAI,CAACQ,kBAAkB,CAACF,SAASP,OAAO;oBAC1CH,QAAQS,IAAI,CAAC;wBACXI,QAAQH;wBACRI,OAAOX;oBACT;gBACF;YACF;QACF;QAEA,OAAO;YACLL;YACAC;YACAC;QACF;IACF;IAEA;;GAEC,GACD,AAAQK,YAAYF,IAAqB,EAAU;QACjD,IAAI,OAAO,IAAI,CAACY,aAAa,KAAK,YAAY;YAC5C,OAAO,IAAI,CAACA,aAAa,CAACZ;QAC5B;QAEA,YAAY;QACZ,MAAMa,QAAQ,AAACb,IAAgC,CAAC,IAAI,CAACY,aAAa,CAAC;QACnE,IAAIC,UAAUC,aAAaD,UAAU,MAAM;YACzC,OAAO;QACT;QAEA,OAAOE,OAAOF;IAChB;IA9FA,YAAYG,OAIX,CAAE;QAPH,uBAAQP,sBAAR,KAAA;QACA,uBAAQG,iBAAR,KAAA;QAOE,IAAI,CAACA,aAAa,GAAGI,QAAQJ,aAAa;QAE1C,cAAc;QACd,IAAI,CAACH,kBAAkB,GAAGO,QAAQP,kBAAkB,IAAK,CAAA,CAACC,QAAQC;YAChE,OAAOM,KAAKC,SAAS,CAACR,YAAYO,KAAKC,SAAS,CAACP;QACnD,CAAA;IACF;AAoFF"}

package/dist/esm/managers/DictionaryManager/core/IndexManager.js

@@ -0,0 +1,106 @@
+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;
+}
+/**
+ * 索引管理模块
+ * 管理字典项的 Map 索引，提升查询性能
+ */ /**
+ * 索引管理器
+ */ export class IndexManager {
+    /**
+   * 构建索引
+   */ buildIndex(items) {
+        if (!this.enableIndex) {
+            return new Map();
+        }
+        const index = new Map();
+        for (const item of items){
+            const indexKey = this.getIndexKey(item);
+            if (indexKey) {
+                index.set(indexKey, item);
+            }
+        }
+        return index;
+    }
+    /**
+   * 更新索引（增量更新）
+   */ updateIndex(index, added, removed, changed) {
+        if (!this.enableIndex) {
+            return;
+        }
+        // 移除删除的项
+        for (const item of removed){
+            const indexKey = this.getIndexKey(item);
+            if (indexKey) {
+                index.delete(indexKey);
+            }
+        }
+        // 更新变更的项
+        if (changed) {
+            for (const { before, after } of changed){
+                const beforeKey = this.getIndexKey(before);
+                const afterKey = this.getIndexKey(after);
+                // 如果索引键发生变化，需要先删除旧的
+                if (beforeKey && beforeKey !== afterKey) {
+                    index.delete(beforeKey);
+                }
+                // 添加新的
+                if (afterKey) {
+                    index.set(afterKey, after);
+                }
+            }
+        }
+        // 添加新增的项
+        for (const item of added){
+            const indexKey = this.getIndexKey(item);
+            if (indexKey) {
+                index.set(indexKey, item);
+            }
+        }
+    }
+    /**
+   * 获取索引键
+   */ getIndexKey(item) {
+        if (typeof this.indexKeyField === 'function') {
+            return this.indexKeyField(item);
+        }
+        // 从对象中获取字段值
+        const value = item[this.indexKeyField];
+        if (value === undefined || value === null) {
+            return '';
+        }
+        return String(value);
+    }
+    /**
+   * 通过索引键获取字典项
+   */ getItemByIndex(index, indexKey) {
+        if (!this.enableIndex) {
+            return null;
+        }
+        return index.get(indexKey) || null;
+    }
+    constructor(options){
+        _define_property(this, "indexKeyField", void 0);
+        _define_property(this, "enableIndex", void 0);
+        this.enableIndex = options.enableIndex;
+        // 确定索引键字段
+        if (options.indexKeyField) {
+            this.indexKeyField = options.indexKeyField;
+        } else {
+            // 默认使用 keyField
+            this.indexKeyField = options.keyField;
+        }
+    }
+}
+
+//# sourceMappingURL=IndexManager.js.map

package/dist/esm/managers/DictionaryManager/core/IndexManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/managers/DictionaryManager/core/IndexManager.ts"],"sourcesContent":["/**\n * 索引管理模块\n * 管理字典项的 Map 索引，提升查询性能\n */\n\n/**\n * 索引管理器\n */\nexport class IndexManager<TDictionaryItem> {\n  private indexKeyField: string | ((item: TDictionaryItem) => string);\n  private enableIndex: boolean;\n\n  constructor(options: {\n    indexKeyField?: string | ((item: TDictionaryItem) => string);\n    keyField: string;\n    enableIndex: boolean;\n  }) {\n    this.enableIndex = options.enableIndex;\n    \n    // 确定索引键字段\n    if (options.indexKeyField) {\n      this.indexKeyField = options.indexKeyField;\n    } else {\n      // 默认使用 keyField\n      this.indexKeyField = options.keyField;\n    }\n  }\n\n  /**\n   * 构建索引\n   */\n  buildIndex(items: TDictionaryItem[]): Map<string, TDictionaryItem> {\n    if (!this.enableIndex) {\n      return new Map();\n    }\n\n    const index = new Map<string, TDictionaryItem>();\n\n    for (const item of items) {\n      const indexKey = this.getIndexKey(item);\n      if (indexKey) {\n        index.set(indexKey, item);\n      }\n    }\n\n    return index;\n  }\n\n  /**\n   * 更新索引（增量更新）\n   */\n  updateIndex(\n    index: Map<string, TDictionaryItem>,\n    added: TDictionaryItem[],\n    removed: TDictionaryItem[],\n    changed?: Array<{ before: TDictionaryItem; after: TDictionaryItem }>\n  ): void {\n    if (!this.enableIndex) {\n      return;\n    }\n\n    // 移除删除的项\n    for (const item of removed) {\n      const indexKey = this.getIndexKey(item);\n      if (indexKey) {\n        index.delete(indexKey);\n      }\n    }\n\n    // 更新变更的项\n    if (changed) {\n      for (const { before, after } of changed) {\n        const beforeKey = this.getIndexKey(before);\n        const afterKey = this.getIndexKey(after);\n        \n        // 如果索引键发生变化，需要先删除旧的\n        if (beforeKey && beforeKey !== afterKey) {\n          index.delete(beforeKey);\n        }\n        \n        // 添加新的\n        if (afterKey) {\n          index.set(afterKey, after);\n        }\n      }\n    }\n\n    // 添加新增的项\n    for (const item of added) {\n      const indexKey = this.getIndexKey(item);\n      if (indexKey) {\n        index.set(indexKey, item);\n      }\n    }\n  }\n\n  /**\n   * 获取索引键\n   */\n  private getIndexKey(item: TDictionaryItem): string {\n    if (typeof this.indexKeyField === 'function') {\n      return this.indexKeyField(item);\n    }\n\n    // 从对象中获取字段值\n    const value = (item as Record<string, unknown>)[this.indexKeyField];\n    if (value === undefined || value === null) {\n      return '';\n    }\n\n    return String(value);\n  }\n\n  /**\n   * 通过索引键获取字典项\n   */\n  getItemByIndex(\n    index: Map<string, TDictionaryItem>,\n    indexKey: string\n  ): TDictionaryItem | null {\n    if (!this.enableIndex) {\n      return null;\n    }\n\n    return index.get(indexKey) || null;\n  }\n}\n"],"names":["IndexManager","buildIndex","items","enableIndex","Map","index","item","indexKey","getIndexKey","set","updateIndex","added","removed","changed","delete","before","after","beforeKey","afterKey","indexKeyField","value","undefined","String","getItemByIndex","get","options","keyField"],"mappings":";;;;;;;;;;;;;AAAA;;;CAGC,GAED;;CAEC,GACD,OAAO,MAAMA;IAoBX;;GAEC,GACDC,WAAWC,KAAwB,EAAgC;QACjE,IAAI,CAAC,IAAI,CAACC,WAAW,EAAE;YACrB,OAAO,IAAIC;QACb;QAEA,MAAMC,QAAQ,IAAID;QAElB,KAAK,MAAME,QAAQJ,MAAO;YACxB,MAAMK,WAAW,IAAI,CAACC,WAAW,CAACF;YAClC,IAAIC,UAAU;gBACZF,MAAMI,GAAG,CAACF,UAAUD;YACtB;QACF;QAEA,OAAOD;IACT;IAEA;;GAEC,GACDK,YACEL,KAAmC,EACnCM,KAAwB,EACxBC,OAA0B,EAC1BC,OAAoE,EAC9D;QACN,IAAI,CAAC,IAAI,CAACV,WAAW,EAAE;YACrB;QACF;QAEA,SAAS;QACT,KAAK,MAAMG,QAAQM,QAAS;YAC1B,MAAML,WAAW,IAAI,CAACC,WAAW,CAACF;YAClC,IAAIC,UAAU;gBACZF,MAAMS,MAAM,CAACP;YACf;QACF;QAEA,SAAS;QACT,IAAIM,SAAS;YACX,KAAK,MAAM,EAAEE,MAAM,EAAEC,KAAK,EAAE,IAAIH,QAAS;gBACvC,MAAMI,YAAY,IAAI,CAACT,WAAW,CAACO;gBACnC,MAAMG,WAAW,IAAI,CAACV,WAAW,CAACQ;gBAElC,oBAAoB;gBACpB,IAAIC,aAAaA,cAAcC,UAAU;oBACvCb,MAAMS,MAAM,CAACG;gBACf;gBAEA,OAAO;gBACP,IAAIC,UAAU;oBACZb,MAAMI,GAAG,CAACS,UAAUF;gBACtB;YACF;QACF;QAEA,SAAS;QACT,KAAK,MAAMV,QAAQK,MAAO;YACxB,MAAMJ,WAAW,IAAI,CAACC,WAAW,CAACF;YAClC,IAAIC,UAAU;gBACZF,MAAMI,GAAG,CAACF,UAAUD;YACtB;QACF;IACF;IAEA;;GAEC,GACD,AAAQE,YAAYF,IAAqB,EAAU;QACjD,IAAI,OAAO,IAAI,CAACa,aAAa,KAAK,YAAY;YAC5C,OAAO,IAAI,CAACA,aAAa,CAACb;QAC5B;QAEA,YAAY;QACZ,MAAMc,QAAQ,AAACd,IAAgC,CAAC,IAAI,CAACa,aAAa,CAAC;QACnE,IAAIC,UAAUC,aAAaD,UAAU,MAAM;YACzC,OAAO;QACT;QAEA,OAAOE,OAAOF;IAChB;IAEA;;GAEC,GACDG,eACElB,KAAmC,EACnCE,QAAgB,EACQ;QACxB,IAAI,CAAC,IAAI,CAACJ,WAAW,EAAE;YACrB,OAAO;QACT;QAEA,OAAOE,MAAMmB,GAAG,CAACjB,aAAa;IAChC;IAjHA,YAAYkB,OAIX,CAAE;QAPH,uBAAQN,iBAAR,KAAA;QACA,uBAAQhB,eAAR,KAAA;QAOE,IAAI,CAACA,WAAW,GAAGsB,QAAQtB,WAAW;QAEtC,UAAU;QACV,IAAIsB,QAAQN,aAAa,EAAE;YACzB,IAAI,CAACA,aAAa,GAAGM,QAAQN,aAAa;QAC5C,OAAO;YACL,gBAAgB;YAChB,IAAI,CAACA,aAAa,GAAGM,QAAQC,QAAQ;QACvC;IACF;AAoGF"}