@vlian/infrastructure 0.9.10

package/dist/esm/managers/SystemConfigManager/core/ConsistencyManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/managers/SystemConfigManager/core/ConsistencyManager.ts"],"sourcesContent":["/**\n * 一致性级别管理模块\n * 管理配置的一致性级别（local/synced/eventual）\n */\n\nimport type { ConsistencyLevel } from '../types';\nimport { CacheManager } from './CacheManager';\n\n/**\n * 一致性级别管理器\n */\nexport class ConsistencyManager {\n  private cacheManager: CacheManager<ConsistencyLevel>;\n  private enableConsistencyLevel: boolean;\n\n  constructor(options: {\n    cacheManager: CacheManager<ConsistencyLevel>;\n    enableConsistencyLevel: boolean;\n  }) {\n    this.cacheManager = options.cacheManager;\n    this.enableConsistencyLevel = options.enableConsistencyLevel;\n  }\n\n  /**\n   * 获取配置的一致性级别\n   */\n  getConsistency(key: string): ConsistencyLevel | null {\n    if (!this.enableConsistencyLevel) {\n      return null;\n    }\n    return this.cacheManager.get(key) || null;\n  }\n\n  /**\n   * 设置配置的一致性级别\n   */\n  setConsistency(key: string, level: ConsistencyLevel): void {\n    if (!this.enableConsistencyLevel) {\n      return;\n    }\n    this.cacheManager.set(key, level);\n  }\n\n  /**\n   * 获取所有配置的一致性级别\n   */\n  getAllConsistency(): Record<string, ConsistencyLevel> {\n    if (!this.enableConsistencyLevel) {\n      return {};\n    }\n    \n    const result: Record<string, ConsistencyLevel> = {};\n    const keys = this.cacheManager.keys();\n    \n    for (const key of keys) {\n      const level = this.cacheManager.get(key);\n      if (level) {\n        result[key] = level;\n      }\n    }\n    \n    return result;\n  }\n\n  /**\n   * 按一致性级别过滤配置键名\n   */\n  getConfigsByConsistency(level: ConsistencyLevel): string[] {\n    if (!this.enableConsistencyLevel) {\n      return [];\n    }\n    \n    const result: string[] = [];\n    const keys = this.cacheManager.keys();\n    \n    for (const key of keys) {\n      const configLevel = this.cacheManager.get(key);\n      if (configLevel === level) {\n        result.push(key);\n      }\n    }\n    \n    return result;\n  }\n\n  /**\n   * 删除配置的一致性级别\n   */\n  deleteConsistency(key: string): void {\n    if (!this.enableConsistencyLevel) {\n      return;\n    }\n    this.cacheManager.delete(key);\n  }\n\n  /**\n   * 清除所有一致性级别\n   */\n  clear(): void {\n    if (!this.enableConsistencyLevel) {\n      return;\n    }\n    this.cacheManager.clear();\n  }\n}\n"],"names":["ConsistencyManager","getConsistency","key","enableConsistencyLevel","cacheManager","get","setConsistency","level","set","getAllConsistency","result","keys","getConfigsByConsistency","configLevel","push","deleteConsistency","delete","clear","options"],"mappings":"AAAA;;;CAGC;;;;;;;;;;;;;AAKD;;CAEC,GACD,OAAO,MAAMA;IAYX;;GAEC,GACDC,eAAeC,GAAW,EAA2B;QACnD,IAAI,CAAC,IAAI,CAACC,sBAAsB,EAAE;YAChC,OAAO;QACT;QACA,OAAO,IAAI,CAACC,YAAY,CAACC,GAAG,CAACH,QAAQ;IACvC;IAEA;;GAEC,GACDI,eAAeJ,GAAW,EAAEK,KAAuB,EAAQ;QACzD,IAAI,CAAC,IAAI,CAACJ,sBAAsB,EAAE;YAChC;QACF;QACA,IAAI,CAACC,YAAY,CAACI,GAAG,CAACN,KAAKK;IAC7B;IAEA;;GAEC,GACDE,oBAAsD;QACpD,IAAI,CAAC,IAAI,CAACN,sBAAsB,EAAE;YAChC,OAAO,CAAC;QACV;QAEA,MAAMO,SAA2C,CAAC;QAClD,MAAMC,OAAO,IAAI,CAACP,YAAY,CAACO,IAAI;QAEnC,KAAK,MAAMT,OAAOS,KAAM;YACtB,MAAMJ,QAAQ,IAAI,CAACH,YAAY,CAACC,GAAG,CAACH;YACpC,IAAIK,OAAO;gBACTG,MAAM,CAACR,IAAI,GAAGK;YAChB;QACF;QAEA,OAAOG;IACT;IAEA;;GAEC,GACDE,wBAAwBL,KAAuB,EAAY;QACzD,IAAI,CAAC,IAAI,CAACJ,sBAAsB,EAAE;YAChC,OAAO,EAAE;QACX;QAEA,MAAMO,SAAmB,EAAE;QAC3B,MAAMC,OAAO,IAAI,CAACP,YAAY,CAACO,IAAI;QAEnC,KAAK,MAAMT,OAAOS,KAAM;YACtB,MAAME,cAAc,IAAI,CAACT,YAAY,CAACC,GAAG,CAACH;YAC1C,IAAIW,gBAAgBN,OAAO;gBACzBG,OAAOI,IAAI,CAACZ;YACd;QACF;QAEA,OAAOQ;IACT;IAEA;;GAEC,GACDK,kBAAkBb,GAAW,EAAQ;QACnC,IAAI,CAAC,IAAI,CAACC,sBAAsB,EAAE;YAChC;QACF;QACA,IAAI,CAACC,YAAY,CAACY,MAAM,CAACd;IAC3B;IAEA;;GAEC,GACDe,QAAc;QACZ,IAAI,CAAC,IAAI,CAACd,sBAAsB,EAAE;YAChC;QACF;QACA,IAAI,CAACC,YAAY,CAACa,KAAK;IACzB;IAxFA,YAAYC,OAGX,CAAE;QANH,uBAAQd,gBAAR,KAAA;QACA,uBAAQD,0BAAR,KAAA;QAME,IAAI,CAACC,YAAY,GAAGc,QAAQd,YAAY;QACxC,IAAI,CAACD,sBAAsB,GAAGe,QAAQf,sBAAsB;IAC9D;AAmFF"}

package/dist/esm/managers/SystemConfigManager/core/StateManagerWrapper.js

@@ -0,0 +1,138 @@
+/**
+ * 状态管理封装模块
+ * 封装 @vlian/framework StateManager，负责状态管理实例初始化
+ */ 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 StateManagerWrapper {
+    /**
+   * 初始化状态管理实例
+   */ initStateManager(instance) {
+        if (instance) {
+            return instance;
+        }
+        // 如果没有提供实例，尝试从 @vlian/framework 获取
+        try {
+            let stateManagerModule;
+            // 1. 检查全局变量
+            if (typeof globalThis !== 'undefined') {
+                const global = globalThis;
+                stateManagerModule = global.window?.vlianFramework || global.vlianFramework;
+            }
+            // 2. 如果全局变量不存在，尝试使用 require
+            if (!stateManagerModule && typeof require !== 'undefined') {
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-require-imports
+                    stateManagerModule = require('@vlian/framework');
+                } catch  {
+                // require 失败，使用内存存储
+                }
+            }
+            if (stateManagerModule) {
+                const stateManager = stateManagerModule.stateManager || stateManagerModule.default?.stateManager;
+                if (stateManager) {
+                    return stateManager;
+                }
+            }
+        } catch (error) {
+            this.logger?.warn('Failed to initialize StateManager, using memory storage:', error);
+        }
+        // 如果没有找到，返回 null，使用内存存储
+        return null;
+    }
+    /**
+   * 获取键名（带命名空间）
+   */ getKey(key) {
+        return `${this.namespace}:${key}`;
+    }
+    /**
+   * 获取值
+   */ get(key) {
+        const fullKey = this.getKey(key);
+        if (this.stateManager) {
+            return this.stateManager.get(fullKey);
+        }
+        // 使用内存存储
+        const value = this.memoryStore.get(fullKey);
+        return value;
+    }
+    /**
+   * 设置值
+   */ set(key, value) {
+        const fullKey = this.getKey(key);
+        if (this.stateManager) {
+            this.stateManager.set(fullKey, value);
+        } else {
+            // 使用内存存储
+            this.memoryStore.set(fullKey, value);
+            // 通知订阅者
+            const callbacks = this.subscribers.get(fullKey);
+            if (callbacks) {
+                callbacks.forEach((callback)=>{
+                    try {
+                        callback(value);
+                    } catch (error) {
+                        this.logger?.error('Error in state subscriber callback', error);
+                    }
+                });
+            }
+        }
+    }
+    /**
+   * 删除值
+   */ remove(key) {
+        const fullKey = this.getKey(key);
+        if (this.stateManager) {
+            this.stateManager.remove(fullKey);
+        } else {
+            this.memoryStore.delete(fullKey);
+        }
+    }
+    /**
+   * 订阅值变化
+   */ subscribe(key, callback) {
+        const fullKey = this.getKey(key);
+        if (this.stateManager) {
+            return this.stateManager.subscribe(fullKey, callback);
+        }
+        // 使用内存存储的订阅机制
+        const callbacks = this.subscribers.get(fullKey) || new Set();
+        callbacks.add(callback);
+        this.subscribers.set(fullKey, callbacks);
+        // 返回取消订阅函数
+        return ()=>{
+            const currentCallbacks = this.subscribers.get(fullKey);
+            if (currentCallbacks) {
+                currentCallbacks.delete(callback);
+                if (currentCallbacks.size === 0) {
+                    this.subscribers.delete(fullKey);
+                }
+            }
+        };
+    }
+    constructor(options){
+        _define_property(this, "stateManager", null);
+        _define_property(this, "namespace", void 0);
+        _define_property(this, "logger", void 0);
+        // 内存存储（当没有提供 StateManager 时使用）
+        _define_property(this, "memoryStore", new Map());
+        _define_property(this, "subscribers", new Map());
+        this.logger = options.logger;
+        this.namespace = options.stateManager?.namespace || 'system_config';
+        this.stateManager = this.initStateManager(options.stateManager?.instance);
+    }
+}
+
+//# sourceMappingURL=StateManagerWrapper.js.map

package/dist/esm/managers/SystemConfigManager/core/StateManagerWrapper.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/managers/SystemConfigManager/core/StateManagerWrapper.ts"],"sourcesContent":["/**\n * 状态管理封装模块\n * 封装 @vlian/framework StateManager，负责状态管理实例初始化\n */\n\nimport type { StateManagerInstance } from '../types';\n\n/**\n * 状态管理器封装\n */\nexport class StateManagerWrapper {\n  private stateManager: StateManagerInstance | null = null;\n  private namespace: string;\n  private logger?: { warn: (message: string, ...args: unknown[]) => void; error: (message: string, ...args: unknown[]) => void };\n  \n  // 内存存储（当没有提供 StateManager 时使用）\n  private memoryStore: Map<string, unknown> = new Map();\n  private subscribers: Map<string, Set<(value: unknown) => void>> = new Map();\n\n  constructor(\n    options: {\n      stateManager?: { instance?: StateManagerInstance; namespace?: string };\n      logger?: { warn: (message: string, ...args: unknown[]) => void; error: (message: string, ...args: unknown[]) => void };\n    }\n  ) {\n    this.logger = options.logger;\n    this.namespace = options.stateManager?.namespace || 'system_config';\n    this.stateManager = this.initStateManager(options.stateManager?.instance);\n  }\n\n  /**\n   * 初始化状态管理实例\n   */\n  private initStateManager(instance?: StateManagerInstance): StateManagerInstance | null {\n    if (instance) {\n      return instance;\n    }\n\n    // 如果没有提供实例，尝试从 @vlian/framework 获取\n    try {\n      let stateManagerModule: any;\n      \n      // 1. 检查全局变量\n      if (typeof globalThis !== 'undefined') {\n        const global = globalThis as any;\n        stateManagerModule = global.window?.vlianFramework || global.vlianFramework;\n      }\n      \n      // 2. 如果全局变量不存在，尝试使用 require\n      if (!stateManagerModule && typeof require !== 'undefined') {\n        try {\n          // eslint-disable-next-line @typescript-eslint/no-require-imports\n          stateManagerModule = require('@vlian/framework');\n        } catch {\n          // require 失败，使用内存存储\n        }\n      }\n      \n      if (stateManagerModule) {\n        const stateManager = stateManagerModule.stateManager || stateManagerModule.default?.stateManager;\n        if (stateManager) {\n          return stateManager;\n        }\n      }\n    } catch (error) {\n      this.logger?.warn('Failed to initialize StateManager, using memory storage:', error);\n    }\n\n    // 如果没有找到，返回 null，使用内存存储\n    return null;\n  }\n\n  /**\n   * 获取键名（带命名空间）\n   */\n  private getKey(key: string): string {\n    return `${this.namespace}:${key}`;\n  }\n\n  /**\n   * 获取值\n   */\n  get<T>(key: string): T | null {\n    const fullKey = this.getKey(key);\n    \n    if (this.stateManager) {\n      return this.stateManager.get<T>(fullKey);\n    }\n    \n    // 使用内存存储\n    const value = this.memoryStore.get(fullKey);\n    return value as T | null;\n  }\n\n  /**\n   * 设置值\n   */\n  set<T>(key: string, value: T): void {\n    const fullKey = this.getKey(key);\n    \n    if (this.stateManager) {\n      this.stateManager.set<T>(fullKey, value);\n    } else {\n      // 使用内存存储\n      this.memoryStore.set(fullKey, value);\n      \n      // 通知订阅者\n      const callbacks = this.subscribers.get(fullKey);\n      if (callbacks) {\n        callbacks.forEach(callback => {\n          try {\n            callback(value);\n          } catch (error) {\n            this.logger?.error('Error in state subscriber callback', error);\n          }\n        });\n      }\n    }\n  }\n\n  /**\n   * 删除值\n   */\n  remove(key: string): void {\n    const fullKey = this.getKey(key);\n    \n    if (this.stateManager) {\n      this.stateManager.remove(fullKey);\n    } else {\n      this.memoryStore.delete(fullKey);\n    }\n  }\n\n  /**\n   * 订阅值变化\n   */\n  subscribe<T>(key: string, callback: (value: T) => void): () => void {\n    const fullKey = this.getKey(key);\n    \n    if (this.stateManager) {\n      return this.stateManager.subscribe<T>(fullKey, callback);\n    }\n    \n    // 使用内存存储的订阅机制\n    const callbacks = this.subscribers.get(fullKey) || new Set();\n    callbacks.add(callback as (value: unknown) => void);\n    this.subscribers.set(fullKey, callbacks);\n    \n    // 返回取消订阅函数\n    return () => {\n      const currentCallbacks = this.subscribers.get(fullKey);\n      if (currentCallbacks) {\n        currentCallbacks.delete(callback as (value: unknown) => void);\n        if (currentCallbacks.size === 0) {\n          this.subscribers.delete(fullKey);\n        }\n      }\n    };\n  }\n}\n"],"names":["StateManagerWrapper","initStateManager","instance","stateManagerModule","globalThis","global","window","vlianFramework","require","stateManager","default","error","logger","warn","getKey","key","namespace","get","fullKey","value","memoryStore","set","callbacks","subscribers","forEach","callback","remove","delete","subscribe","Set","add","currentCallbacks","size","options","Map"],"mappings":"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"}

package/dist/esm/managers/SystemConfigManager/core/SyncManager.js

@@ -0,0 +1,471 @@
+/**
+ * 同步管理模块（Core 层）
+ * 负责配置同步策略（immediate/batch/queue）、重试机制和离线队列
+ */ 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 SyncManager {
+    /**
+   * 同步单个配置
+   */ async syncConfig(key, value, immediateSync) {
+        const actualStrategy = immediateSync ? 'immediate' : this.syncStrategy;
+        if (actualStrategy === 'immediate') {
+            return this.syncImmediate(key, value);
+        } else if (actualStrategy === 'batch') {
+            return this.syncBatch(key, value);
+        } else {
+            return this.enqueueSync(key, value);
+        }
+    }
+    /**
+   * 批量同步配置
+   */ async syncBatchConfigs(configs, immediateSync) {
+        const actualStrategy = immediateSync ? 'immediate' : this.syncStrategy;
+        if (actualStrategy === 'immediate') {
+            return this.syncBatchImmediate(configs);
+        } else if (actualStrategy === 'batch') {
+            return this.syncBatchDelayed(configs);
+        } else {
+            return this.syncBatchQueue(configs);
+        }
+    }
+    /**
+   * 立即同步（immediate 策略）
+   */ async syncImmediate(key, value) {
+        if (!this.configUpdater) {
+            return;
+        }
+        try {
+            await this.executeWithRetry(()=>this.configUpdater(key, value), key);
+            this.consistencyManager.setConsistency(key, 'synced');
+        } catch (error) {
+            // 同步失败，根据是否启用离线队列决定处理方式
+            if (this.enableOfflineQueue) {
+                await this.addToOfflineQueue({
+                    id: `${key}_${Date.now()}`,
+                    type: 'single',
+                    key,
+                    value,
+                    retryCount: 0,
+                    timestamp: Date.now()
+                });
+                this.consistencyManager.setConsistency(key, 'eventual');
+            } else {
+                this.consistencyManager.setConsistency(key, 'local');
+                throw error;
+            }
+        }
+    }
+    /**
+   * 批量立即同步（immediate 策略）
+   */ async syncBatchImmediate(configs) {
+        if (!this.configBatchUpdater) {
+            return;
+        }
+        try {
+            await this.executeWithRetry(()=>this.configBatchUpdater(configs), Object.keys(configs).join(','));
+            // 所有配置同步成功
+            for (const key of Object.keys(configs)){
+                this.consistencyManager.setConsistency(key, 'synced');
+            }
+        } catch (error) {
+            // 同步失败，根据是否启用离线队列决定处理方式
+            if (this.enableOfflineQueue) {
+                await this.addToOfflineQueue({
+                    id: `batch_${Date.now()}`,
+                    type: 'batch',
+                    configs: configs,
+                    retryCount: 0,
+                    timestamp: Date.now()
+                });
+                for (const key of Object.keys(configs)){
+                    this.consistencyManager.setConsistency(key, 'eventual');
+                }
+            } else {
+                for (const key of Object.keys(configs)){
+                    this.consistencyManager.setConsistency(key, 'local');
+                }
+                throw error;
+            }
+        }
+    }
+    /**
+   * 延迟批量同步（batch 策略）
+   */ async syncBatch(key, value) {
+        const task = {
+            id: `${key}_${Date.now()}`,
+            type: 'single',
+            key,
+            value,
+            retryCount: 0,
+            timestamp: Date.now()
+        };
+        this.batchQueue.push(task);
+        // 清除之前的定时器
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+        }
+        // 设置新的定时器
+        this.batchTimer = setTimeout(()=>{
+            this.processBatchQueue().catch(()=>{
+            // 静默失败，会在下次尝试时处理
+            });
+        }, this.batchSyncDelay);
+    }
+    /**
+   * 延迟批量同步配置（batch 策略）
+   */ async syncBatchDelayed(configs) {
+        const task = {
+            id: `batch_${Date.now()}`,
+            type: 'batch',
+            configs: configs,
+            retryCount: 0,
+            timestamp: Date.now()
+        };
+        this.batchQueue.push(task);
+        // 清除之前的定时器
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+        }
+        // 设置新的定时器
+        this.batchTimer = setTimeout(()=>{
+            this.processBatchQueue().catch(()=>{
+            // 静默失败，会在下次尝试时处理
+            });
+        }, this.batchSyncDelay);
+    }
+    /**
+   * 处理批量队列
+   */ async processBatchQueue() {
+        if (this.isProcessingBatch || this.batchQueue.length === 0) {
+            return;
+        }
+        this.isProcessingBatch = true;
+        try {
+            // 合并所有任务
+            const mergedConfigs = {};
+            const keys = [];
+            for (const task of this.batchQueue){
+                if (task.type === 'single' && task.key !== undefined) {
+                    mergedConfigs[task.key] = task.value;
+                    keys.push(task.key);
+                } else if (task.type === 'batch' && task.configs) {
+                    Object.assign(mergedConfigs, task.configs);
+                    keys.push(...Object.keys(task.configs));
+                }
+            }
+            // 清空队列
+            this.batchQueue = [];
+            // 执行批量同步
+            if (this.configBatchUpdater && Object.keys(mergedConfigs).length > 0) {
+                try {
+                    await this.executeWithRetry(()=>this.configBatchUpdater(mergedConfigs), keys.join(','));
+                    // 所有配置同步成功
+                    for (const key of keys){
+                        this.consistencyManager.setConsistency(key, 'synced');
+                    }
+                } catch (error) {
+                    // 同步失败，根据是否启用离线队列决定处理方式
+                    if (this.enableOfflineQueue) {
+                        await this.addToOfflineQueue({
+                            id: `batch_${Date.now()}`,
+                            type: 'batch',
+                            configs: mergedConfigs,
+                            retryCount: 0,
+                            timestamp: Date.now()
+                        });
+                        for (const key of keys){
+                            this.consistencyManager.setConsistency(key, 'eventual');
+                        }
+                    } else {
+                        for (const key of keys){
+                            this.consistencyManager.setConsistency(key, 'local');
+                        }
+                        throw error;
+                    }
+                }
+            }
+        } finally{
+            this.isProcessingBatch = false;
+        }
+    }
+    /**
+   * 队列同步（queue 策略）
+   */ async enqueueSync(key, value) {
+        const task = {
+            id: `${key}_${Date.now()}`,
+            type: 'single',
+            key,
+            value,
+            retryCount: 0,
+            timestamp: Date.now()
+        };
+        this.syncQueue.push(task);
+        this.processSyncQueue().catch(()=>{
+        // 静默失败，会在下次尝试时处理
+        });
+    }
+    /**
+   * 批量队列同步（queue 策略）
+   */ async syncBatchQueue(configs) {
+        const task = {
+            id: `batch_${Date.now()}`,
+            type: 'batch',
+            configs: configs,
+            retryCount: 0,
+            timestamp: Date.now()
+        };
+        this.syncQueue.push(task);
+        this.processSyncQueue().catch(()=>{
+        // 静默失败，会在下次尝试时处理
+        });
+    }
+    /**
+   * 处理同步队列
+   */ async processSyncQueue() {
+        if (this.isProcessingQueue || this.syncQueue.length === 0) {
+            return;
+        }
+        this.isProcessingQueue = true;
+        try {
+            while(this.syncQueue.length > 0){
+                const task = this.syncQueue.shift();
+                if (!task) {
+                    break;
+                }
+                try {
+                    if (task.type === 'single' && task.key !== undefined) {
+                        if (this.configUpdater) {
+                            await this.executeWithRetry(()=>this.configUpdater(task.key, task.value), task.key, task.retryCount);
+                            this.consistencyManager.setConsistency(task.key, 'synced');
+                        }
+                    } else if (task.type === 'batch' && task.configs) {
+                        if (this.configBatchUpdater) {
+                            const keys = Object.keys(task.configs);
+                            await this.executeWithRetry(()=>this.configBatchUpdater(task.configs), keys.join(','), task.retryCount);
+                            for (const key of keys){
+                                this.consistencyManager.setConsistency(key, 'synced');
+                            }
+                        }
+                    }
+                } catch (error) {
+                    // 同步失败，根据是否启用离线队列决定处理方式
+                    if (this.enableOfflineQueue) {
+                        await this.addToOfflineQueue({
+                            ...task,
+                            retryCount: task.retryCount + 1
+                        });
+                        if (task.type === 'single' && task.key) {
+                            this.consistencyManager.setConsistency(task.key, 'eventual');
+                        } else if (task.type === 'batch' && task.configs) {
+                            for (const key of Object.keys(task.configs)){
+                                this.consistencyManager.setConsistency(key, 'eventual');
+                            }
+                        }
+                    } else {
+                        // 不启用离线队列，直接标记为 local
+                        if (task.type === 'single' && task.key) {
+                            this.consistencyManager.setConsistency(task.key, 'local');
+                        } else if (task.type === 'batch' && task.configs) {
+                            for (const key of Object.keys(task.configs)){
+                                this.consistencyManager.setConsistency(key, 'local');
+                            }
+                        }
+                    }
+                }
+            }
+        } finally{
+            this.isProcessingQueue = false;
+        }
+    }
+    /**
+   * 执行带重试的操作
+   */ async executeWithRetry(operation, key, initialRetryCount = 0) {
+        let retryCount = initialRetryCount;
+        let lastError;
+        while(retryCount <= this.syncRetryConfig.maxRetries){
+            try {
+                await operation();
+                return;
+            } catch (error) {
+                lastError = error;
+                retryCount++;
+                if (retryCount <= this.syncRetryConfig.maxRetries) {
+                    // 计算延迟时间（指数退避）
+                    const delay = this.syncRetryConfig.retryDelay * Math.pow(this.syncRetryConfig.backoffMultiplier, retryCount - 1);
+                    await new Promise((resolve)=>setTimeout(resolve, delay));
+                }
+            }
+        }
+        throw lastError || new Error(`Sync failed for key: ${key}`);
+    }
+    /**
+   * 添加到离线队列
+   */ async addToOfflineQueue(task) {
+        this.offlineQueue.push(task);
+        await this.saveOfflineQueue();
+    }
+    /**
+   * 处理离线队列
+   */ async processOfflineQueue() {
+        if (this.offlineQueue.length === 0) {
+            return;
+        }
+        const tasks = [
+            ...this.offlineQueue
+        ];
+        this.offlineQueue = [];
+        for (const task of tasks){
+            try {
+                if (task.type === 'single' && task.key !== undefined) {
+                    if (this.configUpdater) {
+                        await this.executeWithRetry(()=>this.configUpdater(task.key, task.value), task.key, task.retryCount);
+                        this.consistencyManager.setConsistency(task.key, 'synced');
+                    }
+                } else if (task.type === 'batch' && task.configs) {
+                    if (this.configBatchUpdater) {
+                        const keys = Object.keys(task.configs);
+                        await this.executeWithRetry(()=>this.configBatchUpdater(task.configs), keys.join(','), task.retryCount);
+                        for (const key of keys){
+                            this.consistencyManager.setConsistency(key, 'synced');
+                        }
+                    }
+                }
+            } catch (error) {
+                // 同步失败，重新添加到离线队列
+                if (task.retryCount < this.syncRetryConfig.maxRetries) {
+                    this.offlineQueue.push({
+                        ...task,
+                        retryCount: task.retryCount + 1
+                    });
+                }
+            // 超过最大重试次数，放弃该任务
+            }
+        }
+        await this.saveOfflineQueue();
+    }
+    /**
+   * 保存离线队列到存储
+   */ async saveOfflineQueue() {
+        if (!this.storageManager) {
+            return;
+        }
+        try {
+            await this.storageManager.set(this.offlineQueueKey, JSON.stringify(this.offlineQueue));
+        } catch (error) {
+            // 保存失败不影响功能
+            console.warn('Failed to save offline queue:', error);
+        }
+    }
+    /**
+   * 从存储加载离线队列
+   */ async loadOfflineQueue() {
+        if (!this.storageManager) {
+            return;
+        }
+        try {
+            const data = await this.storageManager.get(this.offlineQueueKey);
+            if (data) {
+                this.offlineQueue = JSON.parse(data);
+            }
+        } catch (error) {
+            // 加载失败，使用空队列
+            this.offlineQueue = [];
+        }
+    }
+    /**
+   * 强制处理所有待同步任务
+   */ async flush() {
+        // 处理批量队列
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = undefined;
+        }
+        await this.processBatchQueue();
+        // 处理同步队列
+        await this.processSyncQueue();
+        // 处理离线队列
+        await this.processOfflineQueue();
+    }
+    /**
+   * 清除所有队列
+   */ async clear() {
+        // 清除批量队列
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = undefined;
+        }
+        this.batchQueue = [];
+        // 清除同步队列
+        this.syncQueue = [];
+        // 清除离线队列
+        this.offlineQueue = [];
+        if (this.storageManager) {
+            try {
+                await this.storageManager.remove(this.offlineQueueKey);
+            } catch (error) {
+                console.warn('Failed to clear offline queue:', error);
+            }
+        }
+    }
+    /**
+   * 获取队列统计信息
+   */ getQueueStats() {
+        return {
+            batchQueueLength: this.batchQueue.length,
+            syncQueueLength: this.syncQueue.length,
+            offlineQueueLength: this.offlineQueue.length
+        };
+    }
+    constructor(options){
+        _define_property(this, "consistencyManager", void 0);
+        _define_property(this, "storageManager", void 0);
+        _define_property(this, "configUpdater", void 0);
+        _define_property(this, "configBatchUpdater", void 0);
+        _define_property(this, "syncStrategy", void 0);
+        _define_property(this, "batchSyncDelay", void 0);
+        _define_property(this, "syncRetryConfig", void 0);
+        _define_property(this, "enableOfflineQueue", void 0);
+        _define_property(this, "offlineQueueKey", void 0);
+        // Batch 策略相关
+        _define_property(this, "batchTimer", void 0);
+        _define_property(this, "batchQueue", []);
+        _define_property(this, "isProcessingBatch", false);
+        // Queue 策略相关
+        _define_property(this, "syncQueue", []);
+        _define_property(this, "isProcessingQueue", false);
+        // 离线队列相关
+        _define_property(this, "offlineQueue", []);
+        this.consistencyManager = options.consistencyManager;
+        this.storageManager = options.storageManager;
+        this.configUpdater = options.configUpdater;
+        this.configBatchUpdater = options.configBatchUpdater;
+        this.syncStrategy = options.syncStrategy;
+        this.batchSyncDelay = options.batchSyncDelay;
+        this.syncRetryConfig = options.syncRetryConfig;
+        this.enableOfflineQueue = options.enableOfflineQueue;
+        this.offlineQueueKey = options.offlineQueueKey;
+        // 加载离线队列
+        this.loadOfflineQueue();
+        // 如果启用离线队列，尝试处理离线队列中的任务
+        if (this.enableOfflineQueue && this.offlineQueue.length > 0) {
+            this.processOfflineQueue().catch(()=>{
+            // 静默失败，离线队列会在下次尝试时处理
+            });
+        }
+    }
+}
+
+//# sourceMappingURL=SyncManager.js.map