@vlian/infrastructure 0.9.10

package/dist/esm/managers/AuthManager/modules/core/EncryptionService.js

@@ -0,0 +1,163 @@
+/**
+ * 加密/解密服务模块
+ */ 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 { AuthError, AuthErrorCode } from "../../types";
+/**
+ * 加密服务
+ */ export class EncryptionService {
+    /**
+   * 生成默认加密密钥
+   * 基于时间戳和随机数生成简单密钥（仅用于开发环境）
+   */ generateDefaultKey() {
+        // 使用时间戳和随机数生成密钥
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2, 15);
+        return `${timestamp}_${random}`;
+    }
+    /**
+   * 默认加密实现（简单 XOR 加密，仅提供基本保护）
+   * 注意：这不是强加密，仅用于开发环境或基本场景
+   * 生产环境应使用更强的加密方案（如 AES）
+   */ defaultEncrypt(data) {
+        if (!this.defaultEncryptionKey) {
+            return data;
+        }
+        // 简单的 XOR 加密
+        let encrypted = '';
+        const key = this.defaultEncryptionKey;
+        for(let i = 0; i < data.length; i++){
+            const charCode = data.charCodeAt(i);
+            const keyCharCode = key.charCodeAt(i % key.length);
+            encrypted += String.fromCharCode(charCode ^ keyCharCode);
+        }
+        // Base64 编码
+        try {
+            if (typeof btoa !== 'undefined') {
+                return btoa(encrypted);
+            }
+            // Node.js 环境
+            if (typeof Buffer !== 'undefined') {
+                return Buffer.from(encrypted, 'binary').toString('base64');
+            }
+        } catch  {
+            // 如果编码失败，返回原始数据
+            return data;
+        }
+        return encrypted;
+    }
+    /**
+   * 默认解密实现
+   */ defaultDecrypt(encryptedData) {
+        if (!this.defaultEncryptionKey) {
+            return encryptedData;
+        }
+        // Base64 解码
+        let decoded;
+        try {
+            if (typeof atob !== 'undefined') {
+                decoded = atob(encryptedData);
+            } else if (typeof Buffer !== 'undefined') {
+                decoded = Buffer.from(encryptedData, 'base64').toString('binary');
+            } else {
+                decoded = encryptedData;
+            }
+        } catch  {
+            // 如果解码失败，返回原始数据
+            return encryptedData;
+        }
+        // XOR 解密
+        let decrypted = '';
+        const key = this.defaultEncryptionKey;
+        for(let i = 0; i < decoded.length; i++){
+            const charCode = decoded.charCodeAt(i);
+            const keyCharCode = key.charCodeAt(i % key.length);
+            decrypted += String.fromCharCode(charCode ^ keyCharCode);
+        }
+        return decrypted;
+    }
+    /**
+   * 加密数据（如果配置了加密函数）
+   */ async encryptData(data) {
+        // 如果提供了自定义加密函数，优先使用
+        if (this.customEncrypt) {
+            try {
+                const result = this.customEncrypt(data);
+                return result instanceof Promise ? await result : result;
+            } catch (error) {
+                this.logger?.error('Failed to encrypt data:', error);
+                throw new AuthError('Failed to encrypt auth data', AuthErrorCode.STORAGE_ERROR, undefined, error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+        // 如果启用了默认加密，使用默认加密
+        if (this.useDefaultEncryption && this.defaultEncryptionKey) {
+            try {
+                return this.defaultEncrypt(data);
+            } catch (error) {
+                this.logger?.error('Failed to encrypt data with default encryption:', error);
+                throw new AuthError('Failed to encrypt auth data with default encryption', AuthErrorCode.STORAGE_ERROR, undefined, error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+        // 不加密，直接返回
+        return data;
+    }
+    /**
+   * 解密数据（如果配置了解密函数）
+   */ async decryptData(encryptedData) {
+        // 如果提供了自定义解密函数，优先使用
+        if (this.customDecrypt) {
+            try {
+                const result = this.customDecrypt(encryptedData);
+                return result instanceof Promise ? await result : result;
+            } catch (error) {
+                this.logger?.error('Failed to decrypt data:', error);
+                throw new AuthError('Failed to decrypt auth data', AuthErrorCode.STORAGE_ERROR, undefined, error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+        // 如果启用了默认加密，使用默认解密
+        if (this.useDefaultEncryption && this.defaultEncryptionKey) {
+            try {
+                return this.defaultDecrypt(encryptedData);
+            } catch (error) {
+                this.logger?.error('Failed to decrypt data with default decryption:', error);
+                throw new AuthError('Failed to decrypt auth data with default decryption', AuthErrorCode.STORAGE_ERROR, undefined, error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+        // 不解密，直接返回
+        return encryptedData;
+    }
+    constructor(options){
+        _define_property(this, "defaultEncryptionKey", null);
+        _define_property(this, "customEncrypt", void 0);
+        _define_property(this, "customDecrypt", void 0);
+        _define_property(this, "useDefaultEncryption", false);
+        _define_property(this, "isProduction", false);
+        _define_property(this, "logger", void 0);
+        this.customEncrypt = options.encryptToken;
+        this.customDecrypt = options.decryptToken;
+        this.useDefaultEncryption = options.useDefaultEncryption ?? false;
+        this.isProduction = options.isProduction ?? false;
+        this.logger = options.logger;
+        // 初始化默认加密（如果需要，但生产环境会禁用）
+        if (this.useDefaultEncryption && !this.customEncrypt && !this.isProduction) {
+            this.defaultEncryptionKey = options.defaultEncryptionKey || this.generateDefaultKey();
+            this.logger?.warn('Using default encryption. This provides basic protection only. ' + 'For production use, please provide custom encryptToken/decryptToken functions.');
+        } else if (this.useDefaultEncryption && this.isProduction) {
+            this.logger?.error('Default encryption is disabled in production environment. ' + 'Please provide custom encryptToken/decryptToken functions.');
+            this.useDefaultEncryption = false;
+        }
+    }
+}
+
+//# sourceMappingURL=EncryptionService.js.map

package/dist/esm/managers/AuthManager/modules/core/EncryptionService.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/managers/AuthManager/modules/core/EncryptionService.ts"],"sourcesContent":["/**\n * 加密/解密服务模块\n */\n\nimport type { EncryptFunction, DecryptFunction } from '../../types';\nimport { AuthError, AuthErrorCode } from '../../types';\n\n/**\n * 加密服务\n */\nexport class EncryptionService {\n  private defaultEncryptionKey: string | null = null;\n  private customEncrypt?: EncryptFunction;\n  private customDecrypt?: DecryptFunction;\n  private useDefaultEncryption: boolean = false;\n  private isProduction: boolean = false;\n  private logger?: { error: (message: string, ...args: unknown[]) => void; warn: (message: string, ...args: unknown[]) => void };\n\n  constructor(\n    options: {\n      encryptToken?: EncryptFunction;\n      decryptToken?: DecryptFunction;\n      useDefaultEncryption?: boolean;\n      defaultEncryptionKey?: string;\n      isProduction?: boolean;\n      logger?: { error: (message: string, ...args: unknown[]) => void; warn: (message: string, ...args: unknown[]) => void };\n    }\n  ) {\n    this.customEncrypt = options.encryptToken;\n    this.customDecrypt = options.decryptToken;\n    this.useDefaultEncryption = options.useDefaultEncryption ?? false;\n    this.isProduction = options.isProduction ?? false;\n    this.logger = options.logger;\n\n    // 初始化默认加密（如果需要，但生产环境会禁用）\n    if (this.useDefaultEncryption && !this.customEncrypt && !this.isProduction) {\n      this.defaultEncryptionKey = options.defaultEncryptionKey || this.generateDefaultKey();\n      this.logger?.warn(\n        'Using default encryption. This provides basic protection only. ' +\n        'For production use, please provide custom encryptToken/decryptToken functions.'\n      );\n    } else if (this.useDefaultEncryption && this.isProduction) {\n      this.logger?.error(\n        'Default encryption is disabled in production environment. ' +\n        'Please provide custom encryptToken/decryptToken functions.'\n      );\n      this.useDefaultEncryption = false;\n    }\n  }\n\n  /**\n   * 生成默认加密密钥\n   * 基于时间戳和随机数生成简单密钥（仅用于开发环境）\n   */\n  private generateDefaultKey(): string {\n    // 使用时间戳和随机数生成密钥\n    const timestamp = Date.now().toString(36);\n    const random = Math.random().toString(36).substring(2, 15);\n    return `${timestamp}_${random}`;\n  }\n\n  /**\n   * 默认加密实现（简单 XOR 加密，仅提供基本保护）\n   * 注意：这不是强加密，仅用于开发环境或基本场景\n   * 生产环境应使用更强的加密方案（如 AES）\n   */\n  private defaultEncrypt(data: string): string {\n    if (!this.defaultEncryptionKey) {\n      return data;\n    }\n    \n    // 简单的 XOR 加密\n    let encrypted = '';\n    const key = this.defaultEncryptionKey;\n    for (let i = 0; i < data.length; i++) {\n      const charCode = data.charCodeAt(i);\n      const keyCharCode = key.charCodeAt(i % key.length);\n      encrypted += String.fromCharCode(charCode ^ keyCharCode);\n    }\n    \n    // Base64 编码\n    try {\n      if (typeof btoa !== 'undefined') {\n        return btoa(encrypted);\n      }\n      // Node.js 环境\n      if (typeof Buffer !== 'undefined') {\n        return Buffer.from(encrypted, 'binary').toString('base64');\n      }\n    } catch {\n      // 如果编码失败，返回原始数据\n      return data;\n    }\n    \n    return encrypted;\n  }\n\n  /**\n   * 默认解密实现\n   */\n  private defaultDecrypt(encryptedData: string): string {\n    if (!this.defaultEncryptionKey) {\n      return encryptedData;\n    }\n    \n    // Base64 解码\n    let decoded: string;\n    try {\n      if (typeof atob !== 'undefined') {\n        decoded = atob(encryptedData);\n      } else if (typeof Buffer !== 'undefined') {\n        decoded = Buffer.from(encryptedData, 'base64').toString('binary');\n      } else {\n        decoded = encryptedData;\n      }\n    } catch {\n      // 如果解码失败，返回原始数据\n      return encryptedData;\n    }\n    \n    // XOR 解密\n    let decrypted = '';\n    const key = this.defaultEncryptionKey;\n    for (let i = 0; i < decoded.length; i++) {\n      const charCode = decoded.charCodeAt(i);\n      const keyCharCode = key.charCodeAt(i % key.length);\n      decrypted += String.fromCharCode(charCode ^ keyCharCode);\n    }\n    \n    return decrypted;\n  }\n\n  /**\n   * 加密数据（如果配置了加密函数）\n   */\n  async encryptData(data: string): Promise<string> {\n    // 如果提供了自定义加密函数，优先使用\n    if (this.customEncrypt) {\n      try {\n        const result = this.customEncrypt(data);\n        return result instanceof Promise ? await result : result;\n      } catch (error) {\n        this.logger?.error('Failed to encrypt data:', error);\n        throw new AuthError(\n          'Failed to encrypt auth data',\n          AuthErrorCode.STORAGE_ERROR,\n          undefined,\n          error instanceof Error ? error : new Error(String(error))\n        );\n      }\n    }\n    \n    // 如果启用了默认加密，使用默认加密\n    if (this.useDefaultEncryption && this.defaultEncryptionKey) {\n      try {\n        return this.defaultEncrypt(data);\n      } catch (error) {\n        this.logger?.error('Failed to encrypt data with default encryption:', error);\n        throw new AuthError(\n          'Failed to encrypt auth data with default encryption',\n          AuthErrorCode.STORAGE_ERROR,\n          undefined,\n          error instanceof Error ? error : new Error(String(error))\n        );\n      }\n    }\n    \n    // 不加密，直接返回\n    return data;\n  }\n\n  /**\n   * 解密数据（如果配置了解密函数）\n   */\n  async decryptData(encryptedData: string): Promise<string> {\n    // 如果提供了自定义解密函数，优先使用\n    if (this.customDecrypt) {\n      try {\n        const result = this.customDecrypt(encryptedData);\n        return result instanceof Promise ? await result : result;\n      } catch (error) {\n        this.logger?.error('Failed to decrypt data:', error);\n        throw new AuthError(\n          'Failed to decrypt auth data',\n          AuthErrorCode.STORAGE_ERROR,\n          undefined,\n          error instanceof Error ? error : new Error(String(error))\n        );\n      }\n    }\n    \n    // 如果启用了默认加密，使用默认解密\n    if (this.useDefaultEncryption && this.defaultEncryptionKey) {\n      try {\n        return this.defaultDecrypt(encryptedData);\n      } catch (error) {\n        this.logger?.error('Failed to decrypt data with default decryption:', error);\n        throw new AuthError(\n          'Failed to decrypt auth data with default decryption',\n          AuthErrorCode.STORAGE_ERROR,\n          undefined,\n          error instanceof Error ? error : new Error(String(error))\n        );\n      }\n    }\n    \n    // 不解密，直接返回\n    return encryptedData;\n  }\n}\n"],"names":["AuthError","AuthErrorCode","EncryptionService","generateDefaultKey","timestamp","Date","now","toString","random","Math","substring","defaultEncrypt","data","defaultEncryptionKey","encrypted","key","i","length","charCode","charCodeAt","keyCharCode","String","fromCharCode","btoa","Buffer","from","defaultDecrypt","encryptedData","decoded","atob","decrypted","encryptData","customEncrypt","result","Promise","error","logger","STORAGE_ERROR","undefined","Error","useDefaultEncryption","decryptData","customDecrypt","options","isProduction","encryptToken","decryptToken","warn"],"mappings":"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"}

package/dist/esm/managers/AuthManager/modules/core/EnvironmentDetector.js

@@ -0,0 +1,192 @@
+/**
+ * 环境检测和配置验证模块
+ */ /**
+ * 环境检测器
+ */ export class EnvironmentDetector {
+    /**
+   * 检测运行环境
+   */ static detectEnvironment() {
+        // SSR 环境检测
+        const globalWindow = typeof globalThis !== 'undefined' && 'window' in globalThis ? globalThis.window : undefined;
+        if (globalWindow === undefined && typeof global !== 'undefined') {
+            // 检查是否在 SSR 渲染过程中
+            if (typeof process !== 'undefined' && process.env?.SSR === 'true') {
+                return 'ssr';
+            }
+            return 'node';
+        }
+        // Worker 环境检测
+        const globalSelf = typeof globalThis !== 'undefined' ? globalThis : undefined;
+        if (globalSelf && typeof globalSelf.WorkerGlobalScope !== 'undefined') {
+            const WorkerGlobalScope = globalSelf.WorkerGlobalScope;
+            if (globalSelf instanceof WorkerGlobalScope) {
+                return 'worker';
+            }
+        }
+        // 浏览器环境
+        if (globalWindow !== undefined) {
+            return 'browser';
+        }
+        return 'unknown';
+    }
+    /**
+   * 检查是否为生产环境
+   */ static checkIsProduction() {
+        if (typeof process !== 'undefined' && process.env) {
+            return process.env.NODE_ENV === 'production';
+        }
+        // 浏览器环境：检查 hostname
+        if (typeof globalThis !== 'undefined' && 'location' in globalThis) {
+            const location = globalThis.location;
+            if (location?.hostname) {
+                return ![
+                    'localhost',
+                    '127.0.0.1',
+                    '0.0.0.0'
+                ].includes(location.hostname);
+            }
+        }
+        return false;
+    }
+    /**
+   * 从环境变量加载配置
+   */ static loadEnvConfig(prefix) {
+        if (!prefix || typeof process === 'undefined' || !process.env) {
+            return {};
+        }
+        const config = {};
+        const env = process.env;
+        // 读取布尔值配置
+        const boolKeys = [
+            'autoRefresh',
+            'enableEvents',
+            'sanitizeErrors',
+            'useDefaultEncryption',
+            'pauseRefreshOnHidden',
+            'useSmartScheduling',
+            'devMode',
+            'validateConfig',
+            'listenNetworkStatus',
+            'enableDetailedMetrics',
+            'enableTracing'
+        ];
+        boolKeys.forEach((key)=>{
+            const envKey = `${prefix}${key.toUpperCase()}`;
+            if (env[envKey] !== undefined) {
+                config[key] = env[envKey] === 'true' || env[envKey] === '1';
+            }
+        });
+        // 读取数字配置
+        const numberKeys = [
+            'refreshThreshold',
+            'refreshInterval',
+            'refreshTimeout',
+            'batchWriteDelay',
+            'maxQueueSize',
+            'operationTimeout'
+        ];
+        numberKeys.forEach((key)=>{
+            const envKey = `${prefix}${key.toUpperCase()}`;
+            if (env[envKey] !== undefined) {
+                const value = Number(env[envKey]);
+                if (!isNaN(value)) {
+                    config[key] = value;
+                }
+            }
+        });
+        // 读取字符串配置
+        const stringKeys = [
+            'authDataKey',
+            'tokenKey',
+            'eventNamespace',
+            'instanceId',
+            'envPrefix',
+            'concurrencyStrategy'
+        ];
+        stringKeys.forEach((key)=>{
+            const envKey = `${prefix}${key.toUpperCase()}`;
+            if (env[envKey] !== undefined) {
+                config[key] = env[envKey];
+            }
+        });
+        return config;
+    }
+    /**
+   * 验证配置
+   */ static validateConfig(options, isProduction) {
+        const errors = [];
+        const warnings = [];
+        // 验证存储配置
+        if (!options.storage) {
+            errors.push('storage is required');
+        } else if (!options.storage.instance && !options.storage.strategy) {
+            errors.push('storage.instance or storage.strategy must be provided');
+        }
+        // 验证加密配置
+        if (options.useDefaultEncryption && isProduction) {
+            errors.push('useDefaultEncryption cannot be enabled in production');
+        }
+        // 验证刷新配置
+        if (options.autoRefresh && !options.refreshTokenFunction) {
+            warnings.push('autoRefresh is enabled but refreshTokenFunction is not provided');
+        }
+        if (options.refreshThreshold && options.refreshThreshold < 0) {
+            errors.push('refreshThreshold must be non-negative');
+        }
+        if (options.refreshInterval && options.refreshInterval < 1000) {
+            warnings.push('refreshInterval is less than 1000ms, which may cause performance issues');
+        }
+        if (options.refreshTimeout && options.refreshTimeout < 1000) {
+            warnings.push('refreshTimeout is less than 1000ms, which may be too short');
+        }
+        // 验证批量写入配置
+        if (options.batchWriteDelay && options.batchWriteDelay < 0) {
+            errors.push('batchWriteDelay must be non-negative');
+        }
+        // 验证并发控制配置
+        if (options.concurrencyStrategy && ![
+            'queue',
+            'version',
+            'none'
+        ].includes(options.concurrencyStrategy)) {
+            errors.push('concurrencyStrategy must be one of: queue, version, none');
+        }
+        if (options.maxQueueSize && options.maxQueueSize < 1) {
+            errors.push('maxQueueSize must be at least 1');
+        }
+        if (options.operationTimeout && options.operationTimeout < 0) {
+            errors.push('operationTimeout must be non-negative');
+        }
+        // 验证事件命名空间
+        if (options.eventNamespace && !options.eventNamespace.endsWith(':')) {
+            warnings.push('eventNamespace should end with ":" for better isolation');
+        }
+        // 验证实例 ID
+        if (options.instanceId && !/^[a-zA-Z0-9_-]+$/.test(options.instanceId)) {
+            errors.push('instanceId must contain only alphanumeric characters, hyphens, and underscores');
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    /**
+   * 脱敏配置用于日志输出
+   */ static sanitizeConfigForLog(options) {
+        const sanitized = {
+            ...options
+        };
+        // 移除敏感信息
+        delete sanitized.defaultEncryptionKey;
+        if (sanitized.encryptToken) {
+            sanitized.encryptToken = '[Function]';
+        }
+        if (sanitized.decryptToken) {
+            sanitized.decryptToken = '[Function]';
+        }
+        return sanitized;
+    }
+}
+
+//# sourceMappingURL=EnvironmentDetector.js.map

package/dist/esm/managers/AuthManager/modules/core/EnvironmentDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/managers/AuthManager/modules/core/EnvironmentDetector.ts"],"sourcesContent":["/**\n * 环境检测和配置验证模块\n */\n\nimport type { Environment, AuthOptions, ConfigValidationResult } from '../../types';\n\n/**\n * 环境检测器\n */\nexport class EnvironmentDetector {\n  /**\n   * 检测运行环境\n   */\n  static detectEnvironment(): Environment {\n    // SSR 环境检测\n    const globalWindow = typeof globalThis !== 'undefined' && 'window' in globalThis \n      ? (globalThis as { window?: unknown }).window \n      : undefined;\n    \n    if (globalWindow === undefined && typeof global !== 'undefined') {\n      // 检查是否在 SSR 渲染过程中\n      if (typeof process !== 'undefined' && process.env?.SSR === 'true') {\n        return 'ssr';\n      }\n      return 'node';\n    }\n\n    // Worker 环境检测\n    const globalSelf = typeof globalThis !== 'undefined' ? globalThis : undefined;\n    if (globalSelf && typeof (globalSelf as any).WorkerGlobalScope !== 'undefined') {\n      const WorkerGlobalScope = (globalSelf as any).WorkerGlobalScope;\n      if (globalSelf instanceof WorkerGlobalScope) {\n        return 'worker';\n      }\n    }\n\n    // 浏览器环境\n    if (globalWindow !== undefined) {\n      return 'browser';\n    }\n\n    return 'unknown';\n  }\n\n  /**\n   * 检查是否为生产环境\n   */\n  static checkIsProduction(): boolean {\n    if (typeof process !== 'undefined' && process.env) {\n      return process.env.NODE_ENV === 'production';\n    }\n    // 浏览器环境：检查 hostname\n    if (typeof globalThis !== 'undefined' && 'location' in globalThis) {\n      const location = (globalThis as { location?: { hostname?: string } }).location;\n      if (location?.hostname) {\n        return !['localhost', '127.0.0.1', '0.0.0.0'].includes(location.hostname);\n      }\n    }\n    return false;\n  }\n\n  /**\n   * 从环境变量加载配置\n   */\n  static loadEnvConfig(prefix?: string): Partial<AuthOptions> {\n    if (!prefix || typeof process === 'undefined' || !process.env) {\n      return {};\n    }\n\n    const config: Partial<AuthOptions> = {};\n    const env = process.env;\n\n    // 读取布尔值配置\n    const boolKeys = ['autoRefresh', 'enableEvents', 'sanitizeErrors', 'useDefaultEncryption', \n      'pauseRefreshOnHidden', 'useSmartScheduling', 'devMode', 'validateConfig', \n      'listenNetworkStatus', 'enableDetailedMetrics', 'enableTracing'];\n    \n    boolKeys.forEach(key => {\n      const envKey = `${prefix}${key.toUpperCase()}`;\n      if (env[envKey] !== undefined) {\n        (config as any)[key] = env[envKey] === 'true' || env[envKey] === '1';\n      }\n    });\n\n    // 读取数字配置\n    const numberKeys = ['refreshThreshold', 'refreshInterval', 'refreshTimeout', 'batchWriteDelay', \n      'maxQueueSize', 'operationTimeout'];\n    numberKeys.forEach(key => {\n      const envKey = `${prefix}${key.toUpperCase()}`;\n      if (env[envKey] !== undefined) {\n        const value = Number(env[envKey]);\n        if (!isNaN(value)) {\n          (config as any)[key] = value;\n        }\n      }\n    });\n\n    // 读取字符串配置\n    const stringKeys = ['authDataKey', 'tokenKey', 'eventNamespace', 'instanceId', 'envPrefix', 'concurrencyStrategy'];\n    stringKeys.forEach(key => {\n      const envKey = `${prefix}${key.toUpperCase()}`;\n      if (env[envKey] !== undefined) {\n        (config as any)[key] = env[envKey];\n      }\n    });\n\n    return config;\n  }\n\n  /**\n   * 验证配置\n   */\n  static validateConfig(options: AuthOptions, isProduction: boolean): ConfigValidationResult {\n    const errors: string[] = [];\n    const warnings: string[] = [];\n\n    // 验证存储配置\n    if (!options.storage) {\n      errors.push('storage is required');\n    } else if (!options.storage.instance && !options.storage.strategy) {\n      errors.push('storage.instance or storage.strategy must be provided');\n    }\n\n    // 验证加密配置\n    if (options.useDefaultEncryption && isProduction) {\n      errors.push('useDefaultEncryption cannot be enabled in production');\n    }\n\n    // 验证刷新配置\n    if (options.autoRefresh && !options.refreshTokenFunction) {\n      warnings.push('autoRefresh is enabled but refreshTokenFunction is not provided');\n    }\n\n    if (options.refreshThreshold && options.refreshThreshold < 0) {\n      errors.push('refreshThreshold must be non-negative');\n    }\n\n    if (options.refreshInterval && options.refreshInterval < 1000) {\n      warnings.push('refreshInterval is less than 1000ms, which may cause performance issues');\n    }\n\n    if (options.refreshTimeout && options.refreshTimeout < 1000) {\n      warnings.push('refreshTimeout is less than 1000ms, which may be too short');\n    }\n\n    // 验证批量写入配置\n    if (options.batchWriteDelay && options.batchWriteDelay < 0) {\n      errors.push('batchWriteDelay must be non-negative');\n    }\n\n    // 验证并发控制配置\n    if (options.concurrencyStrategy && !['queue', 'version', 'none'].includes(options.concurrencyStrategy)) {\n      errors.push('concurrencyStrategy must be one of: queue, version, none');\n    }\n\n    if (options.maxQueueSize && options.maxQueueSize < 1) {\n      errors.push('maxQueueSize must be at least 1');\n    }\n\n    if (options.operationTimeout && options.operationTimeout < 0) {\n      errors.push('operationTimeout must be non-negative');\n    }\n\n    // 验证事件命名空间\n    if (options.eventNamespace && !options.eventNamespace.endsWith(':')) {\n      warnings.push('eventNamespace should end with \":\" for better isolation');\n    }\n\n    // 验证实例 ID\n    if (options.instanceId && !/^[a-zA-Z0-9_-]+$/.test(options.instanceId)) {\n      errors.push('instanceId must contain only alphanumeric characters, hyphens, and underscores');\n    }\n\n    return {\n      valid: errors.length === 0,\n      errors,\n      warnings,\n    };\n  }\n\n  /**\n   * 脱敏配置用于日志输出\n   */\n  static sanitizeConfigForLog(options: Partial<AuthOptions>): Record<string, unknown> {\n    const sanitized: Record<string, unknown> = { ...options };\n    // 移除敏感信息\n    delete sanitized.defaultEncryptionKey;\n    if (sanitized.encryptToken) {\n      sanitized.encryptToken = '[Function]';\n    }\n    if (sanitized.decryptToken) {\n      sanitized.decryptToken = '[Function]';\n    }\n    return sanitized;\n  }\n}\n"],"names":["EnvironmentDetector","detectEnvironment","globalWindow","globalThis","window","undefined","global","process","env","SSR","globalSelf","WorkerGlobalScope","checkIsProduction","NODE_ENV","location","hostname","includes","loadEnvConfig","prefix","config","boolKeys","forEach","key","envKey","toUpperCase","numberKeys","value","Number","isNaN","stringKeys","validateConfig","options","isProduction","errors","warnings","storage","push","instance","strategy","useDefaultEncryption","autoRefresh","refreshTokenFunction","refreshThreshold","refreshInterval","refreshTimeout","batchWriteDelay","concurrencyStrategy","maxQueueSize","operationTimeout","eventNamespace","endsWith","instanceId","test","valid","length","sanitizeConfigForLog","sanitized","defaultEncryptionKey","encryptToken","decryptToken"],"mappings":"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"}

package/dist/esm/managers/AuthManager/modules/core/StorageManager.js

@@ -0,0 +1,253 @@
+/**
+ * 存储管理模块
+ * 负责存储的初始化、数据的保存和恢复
+ */ 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 { AuthError, AuthErrorCode } from "../../types";
+/**
+ * 存储管理器
+ */ export class StorageManager {
+    /**
+   * 初始化存储实例（带缓存优化）
+   */ initStorage(storageConfig) {
+        // 如果直接提供了实例，直接使用（最快路径）
+        if (storageConfig.instance) {
+            return storageConfig.instance;
+        }
+        // 如果没有提供实例，尝试从 @vlian/framework 获取
+        const strategy = storageConfig.strategy || 'local';
+        const cacheKey = `${strategy}_${this.environment}`;
+        // 检查缓存
+        if (StorageManager.storageCache.has(cacheKey)) {
+            return StorageManager.storageCache.get(cacheKey);
+        }
+        try {
+            // SSR 环境特殊处理
+            if (this.environment === 'ssr') {
+                // SSR 环境应该使用内存存储或服务端存储
+                const data = new Map();
+                const memoryStorage = {
+                    async get (key) {
+                        return data.get(key) || null;
+                    },
+                    async set (key, value) {
+                        data.set(key, value);
+                    },
+                    async remove (key) {
+                        data.delete(key);
+                    }
+                };
+                StorageManager.storageCache.set(cacheKey, memoryStorage);
+                return memoryStorage;
+            }
+            // Worker 环境特殊处理
+            if (this.environment === 'worker') {
+                // Worker 环境不支持 localStorage，使用 IndexedDB 或内存存储
+                if (strategy === 'local' || strategy === 'session') {
+                    this.logger?.warn(`${strategy} storage is not available in Worker environment, falling back to memory storage`);
+                    const data = new Map();
+                    const memoryStorage = {
+                        async get (key) {
+                            return data.get(key) || null;
+                        },
+                        async set (key, value) {
+                            data.set(key, value);
+                        },
+                        async remove (key) {
+                            data.delete(key);
+                        }
+                    };
+                    StorageManager.storageCache.set(cacheKey, memoryStorage);
+                    return memoryStorage;
+                }
+            }
+            // 优化的获取逻辑：按优先级检查
+            let storageModule;
+            // 1. 检查全局变量（最快，无需动态导入）
+            if (typeof globalThis !== 'undefined') {
+                const global = globalThis;
+                storageModule = global.window?.vlianFramework || global.vlianFramework;
+            }
+            // 2. 如果全局变量不存在，尝试使用 require（仅 Node.js/CommonJS 环境）
+            if (!storageModule && typeof require !== 'undefined') {
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-require-imports
+                    storageModule = require('@vlian/framework');
+                } catch  {
+                // require 失败，继续抛出错误
+                }
+            }
+            // 如果仍然没有找到，抛出错误
+            if (!storageModule) {
+                throw new AuthError('@vlian/framework is not available. ' + 'Please provide storage.instance or ensure @vlian/framework is installed and accessible.', AuthErrorCode.ENVIRONMENT_ERROR);
+            }
+            // 获取 storage 对象（优化：减少属性访问）
+            const storage = storageModule.storage || storageModule.default?.storage;
+            if (!storage) {
+                throw new AuthError('Storage not found in @vlian/framework', AuthErrorCode.ENVIRONMENT_ERROR);
+            }
+            // 根据策略返回对应的存储实例（优化：使用映射表）
+            const strategyMap = {
+                local: storage.local,
+                session: storage.session,
+                indexedDB: storage.indexedDB
+            };
+            const storageInstance = strategyMap[strategy] || storage.local || storage;
+            // 缓存存储实例
+            StorageManager.storageCache.set(cacheKey, storageInstance);
+            return storageInstance;
+        } catch (error) {
+            throw new AuthError(`Failed to initialize storage: ${error instanceof Error ? error.message : String(error)}. ` + 'Please provide storage.instance or ensure @vlian/framework is installed and provides storage API.', AuthErrorCode.ENVIRONMENT_ERROR, undefined, error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+   * 从存储中恢复认证状态
+   */ async restoreAuthState() {
+        try {
+            const encryptedData = await this.storage.get(this.authDataKey);
+            if (encryptedData) {
+                // 解密数据（如果配置了加密）
+                const data = await this.encryptionService.decryptData(encryptedData);
+                return JSON.parse(data);
+            }
+            return null;
+        } catch (error) {
+            this.logger?.error('Failed to restore auth state:', error);
+            return null;
+        }
+    }
+    /**
+   * 保存认证状态到存储（内部实现，支持批量写入）
+   */ async saveAuthStateImmediate(authData) {
+        try {
+            if (authData) {
+                const data = JSON.stringify(authData);
+                // 加密数据（如果配置了加密）
+                const encryptedData = await this.encryptionService.encryptData(data);
+                await this.storage.set(this.authDataKey, encryptedData);
+            } else {
+                await this.storage.remove(this.authDataKey);
+            }
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger?.error('Failed to save auth state:', errorMessage);
+            throw new AuthError(errorMessage, AuthErrorCode.STORAGE_ERROR, undefined, error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    /**
+   * 保存认证状态到存储（支持批量写入优化）
+   */ async saveAuthState(authData) {
+        // 如果禁用了批量写入或延迟为0，立即写入
+        if (this.batchWriteDelay === 0) {
+            return this.saveAuthStateImmediate(authData);
+        }
+        // 清除之前的定时器
+        if (this.batchWriteTimer) {
+            clearTimeout(this.batchWriteTimer);
+            this.batchWriteTimer = null;
+        }
+        // 创建待写入任务
+        this.pendingWrite = ()=>{
+            this.isWriting = true;
+            const currentAuthData = authData;
+            this.pendingWrite = null;
+            return this.saveAuthStateImmediate(currentAuthData).finally(()=>{
+                this.isWriting = false;
+            });
+        };
+        // 设置延迟写入
+        this.batchWriteTimer = setTimeout(()=>{
+            this.batchWriteTimer = null;
+            if (this.pendingWrite) {
+                this.pendingWrite().catch((error)=>{
+                    this.logger?.error('Batch write failed:', error);
+                });
+            }
+        }, this.batchWriteDelay);
+        // 如果当前没有正在进行的写入，立即执行（首次写入）
+        if (!this.isWriting) {
+            // 使用微任务确保在当前同步操作完成后执行
+            Promise.resolve().then(()=>{
+                if (this.pendingWrite && !this.isWriting) {
+                    if (this.batchWriteTimer) {
+                        clearTimeout(this.batchWriteTimer);
+                        this.batchWriteTimer = null;
+                    }
+                    this.pendingWrite?.().catch((error)=>{
+                        this.logger?.error('Immediate write failed:', error);
+                    });
+                }
+            });
+        }
+    }
+    /**
+   * 强制立即保存认证状态（用于关键操作，如登出）
+   */ async saveAuthStateForce(authData) {
+        // 清除批量写入定时器
+        if (this.batchWriteTimer) {
+            clearTimeout(this.batchWriteTimer);
+            this.batchWriteTimer = null;
+        }
+        // 等待当前写入完成
+        if (this.isWriting && this.pendingWrite) {
+            await this.pendingWrite();
+        }
+        // 执行立即写入
+        return this.saveAuthStateImmediate(authData);
+    }
+    /**
+   * 获取存储实例（用于健康检查等）
+   */ getStorage() {
+        return this.storage;
+    }
+    /**
+   * 清理资源
+   */ destroy() {
+        // 清理批量写入定时器
+        if (this.batchWriteTimer) {
+            clearTimeout(this.batchWriteTimer);
+            this.batchWriteTimer = null;
+        }
+        // 等待待处理的写入完成（如果正在写入）
+        if (this.isWriting && this.pendingWrite) {
+            // 注意：这里不等待 Promise 完成，因为 destroy 是同步方法
+            // 但我们会标记为不再处理新的写入
+            this.pendingWrite = null;
+        }
+        this.isWriting = false;
+        this.pendingWrite = null;
+    }
+    constructor(options){
+        _define_property(this, "storage", void 0);
+        _define_property(this, "encryptionService", void 0);
+        _define_property(this, "authDataKey", void 0);
+        _define_property(this, "environment", void 0);
+        _define_property(this, "logger", void 0);
+        // 批量写入相关
+        _define_property(this, "batchWriteTimer", null);
+        _define_property(this, "pendingWrite", null);
+        _define_property(this, "isWriting", false);
+        _define_property(this, "batchWriteDelay", void 0);
+        this.encryptionService = options.encryptionService;
+        this.authDataKey = options.authDataKey;
+        this.environment = options.environment;
+        this.batchWriteDelay = options.batchWriteDelay;
+        this.logger = options.logger;
+        this.storage = this.initStorage(options.storage);
+    }
+}
+// 存储初始化缓存（优化性能）
+_define_property(StorageManager, "storageCache", new Map());
+
+//# sourceMappingURL=StorageManager.js.map