@vlian/framework 1.1.0 → 1.2.1

package/dist/core/error/ErrorHandler.d.ts

@@ -0,0 +1,172 @@
+/**
+ * 统一错误处理器
+ *
+ * 优化：
+ * 1. 统一错误处理策略：记录、上报、恢复、降级
+ * 2. 错误分类：致命、可恢复、警告
+ * 3. 错误恢复机制：自动重试、降级方案
+ */
+import { ErrorSeverity, ErrorType, FrameworkError } from '../../utils/errors';
+import type { MonitoringService } from '../../utils/monitoring';
+/**
+ * 错误处理策略
+ */
+export declare enum ErrorHandlingStrategy {
+    /**
+     * 记录错误（日志）
+     */
+    LOG = "LOG",
+    /**
+     * 上报错误（监控服务）
+     */
+    REPORT = "REPORT",
+    /**
+     * 尝试恢复错误
+     */
+    RECOVER = "RECOVER",
+    /**
+     * 降级处理
+     */
+    FALLBACK = "FALLBACK",
+    /**
+     * 忽略错误
+     */
+    IGNORE = "IGNORE"
+}
+/**
+ * 错误恢复选项
+ */
+export interface ErrorRecoveryOptions {
+    /**
+     * 最大重试次数
+     * @default 3
+     */
+    maxRetries?: number;
+    /**
+     * 重试延迟（毫秒）
+     * @default 1000
+     */
+    retryDelay?: number;
+    /**
+     * 是否启用指数退避
+     * @default true
+     */
+    exponentialBackoff?: boolean;
+    /**
+     * 重试条件函数
+     */
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+    /**
+     * 降级方案函数
+     */
+    fallback?: () => Promise<unknown> | unknown;
+}
+/**
+ * 错误处理配置
+ */
+export interface ErrorHandlerConfig {
+    /**
+     * 监控服务实例（可选）
+     */
+    monitoring?: MonitoringService;
+    /**
+     * 默认错误处理策略
+     * @default [ErrorHandlingStrategy.LOG, ErrorHandlingStrategy.REPORT]
+     */
+    defaultStrategies?: ErrorHandlingStrategy[];
+    /**
+     * 错误严重程度对应的处理策略
+     */
+    severityStrategies?: Partial<Record<ErrorSeverity, ErrorHandlingStrategy[]>>;
+    /**
+     * 错误类型对应的处理策略
+     */
+    typeStrategies?: Partial<Record<ErrorType, ErrorHandlingStrategy[]>>;
+    /**
+     * 错误恢复选项
+     */
+    recoveryOptions?: ErrorRecoveryOptions;
+    /**
+     * 是否在开发环境显示详细错误信息
+     * @default true
+     */
+    showDetailedErrorsInDev?: boolean;
+}
+/**
+ * 错误处理结果
+ */
+export interface ErrorHandleResult {
+    /**
+     * 是否已处理
+     */
+    handled: boolean;
+    /**
+     * 是否可恢复
+     */
+    recoverable: boolean;
+    /**
+     * 恢复后的结果（如果已恢复）
+     */
+    recoveredValue?: unknown;
+    /**
+     * 使用的处理策略
+     */
+    strategies: ErrorHandlingStrategy[];
+    /**
+     * 错误信息
+     */
+    error: FrameworkError;
+}
+/**
+ * 统一错误处理器
+ */
+export declare class ErrorHandler {
+    private config;
+    private monitoring?;
+    constructor(config?: ErrorHandlerConfig);
+    /**
+     * 设置监控服务
+     */
+    setMonitoring(monitoring: MonitoringService): void;
+    /**
+     * 处理错误
+     *
+     * @param error - 错误对象
+     * @param context - 错误上下文
+     * @returns 错误处理结果
+     */
+    handleError(error: unknown, context?: Record<string, unknown>): Promise<ErrorHandleResult>;
+    /**
+     * 确定错误处理策略
+     */
+    private determineStrategies;
+    /**
+     * 执行处理策略
+     */
+    private executeStrategies;
+    /**
+     * 记录错误
+     */
+    private logError;
+    /**
+     * 上报错误
+     */
+    private reportError;
+    /**
+     * 尝试恢复错误
+     */
+    private attemptRecovery;
+    /**
+     * 创建错误处理器的便捷方法
+     */
+    static create(config?: ErrorHandlerConfig): ErrorHandler;
+}
+/**
+ * 获取默认错误处理器
+ */
+export declare function getDefaultErrorHandler(): ErrorHandler;
+/**
+ * 设置默认错误处理器
+ */
+export declare function setDefaultErrorHandler(handler: ErrorHandler): void;
+//# sourceMappingURL=ErrorHandler.d.ts.map

package/dist/core/error/ErrorHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorHandler.d.ts","sourceRoot":"","sources":["../../../src/core/error/ErrorHandler.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAc,aAAa,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC1F,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE;;GAEG;AACH,oBAAY,qBAAqB;IAC/B;;OAEG;IACH,GAAG,QAAQ;IACX;;OAEG;IACH,MAAM,WAAW;IACjB;;OAEG;IACH,OAAO,YAAY;IACnB;;OAEG;IACH,QAAQ,aAAa;IACrB;;OAEG;IACH,MAAM,WAAW;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;OAEG;IACH,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAC3D;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,qBAAqB,EAAE,CAAC;IAC5C;;OAEG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,qBAAqB,EAAE,CAAC,CAAC,CAAC;IAC7E;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,qBAAqB,EAAE,CAAC,CAAC,CAAC;IACrE;;OAEG;IACH,eAAe,CAAC,EAAE,oBAAoB,CAAC;IACvC;;;OAGG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;OAEG;IACH,UAAU,EAAE,qBAAqB,EAAE,CAAC;IACpC;;OAEG;IACH,KAAK,EAAE,cAAc,CAAC;CACvB;AAED;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAmD;IACjE,OAAO,CAAC,UAAU,CAAC,CAAoB;gBAE3B,MAAM,GAAE,kBAAuB;IAc3C;;OAEG;IACH,aAAa,CAAC,UAAU,EAAE,iBAAiB,GAAG,IAAI;IAIlD;;;;;;OAMG;IACG,WAAW,CACf,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,iBAAiB,CAAC;IA8C7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAe3B;;OAEG;YACW,iBAAiB;IA0C/B;;OAEG;IACH,OAAO,CAAC,QAAQ;IAwBhB;;OAEG;YACW,WAAW;IAkBzB;;OAEG;YACW,eAAe;IAgD7B;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,kBAAkB,GAAG,YAAY;CAGzD;AAOD;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,YAAY,CAKrD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAElE"}

package/dist/core/error/ErrorHandler.js

@@ -0,0 +1,261 @@
+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;
+}
+/**
+ * 统一错误处理器
+ * 
+ * 优化：
+ * 1. 统一错误处理策略：记录、上报、恢复、降级
+ * 2. 错误分类：致命、可恢复、警告
+ * 3. 错误恢复机制：自动重试、降级方案
+ */ import { logger } from "../../utils";
+import { errorUtils, ErrorSeverity, FrameworkError } from "../../utils/errors";
+/**
+ * 错误处理策略
+ */ export var ErrorHandlingStrategy = /*#__PURE__*/ function(ErrorHandlingStrategy) {
+    /**
+   * 记录错误（日志）
+   */ ErrorHandlingStrategy["LOG"] = "LOG";
+    /**
+   * 上报错误（监控服务）
+   */ ErrorHandlingStrategy["REPORT"] = "REPORT";
+    /**
+   * 尝试恢复错误
+   */ ErrorHandlingStrategy["RECOVER"] = "RECOVER";
+    /**
+   * 降级处理
+   */ ErrorHandlingStrategy["FALLBACK"] = "FALLBACK";
+    /**
+   * 忽略错误
+   */ ErrorHandlingStrategy["IGNORE"] = "IGNORE";
+    return ErrorHandlingStrategy;
+}({});
+/**
+ * 统一错误处理器
+ */ export class ErrorHandler {
+    /**
+   * 设置监控服务
+   */ setMonitoring(monitoring) {
+        this.monitoring = monitoring;
+    }
+    /**
+   * 处理错误
+   * 
+   * @param error - 错误对象
+   * @param context - 错误上下文
+   * @returns 错误处理结果
+   */ async handleError(error, context) {
+        // 标准化错误对象
+        const normalizedError = errorUtils.normalizeError(error);
+        // 创建包含上下文信息的错误对象（由于 context 是只读的，需要创建新对象）
+        const errorWithContext = context ? new FrameworkError(normalizedError.message, normalizedError.type, normalizedError.severity, {
+            code: normalizedError.code,
+            originalError: normalizedError.originalError,
+            context: {
+                ...normalizedError.context,
+                ...context
+            },
+            recoverable: normalizedError.recoverable
+        }) : normalizedError;
+        // 确定处理策略
+        const strategies = this.determineStrategies(errorWithContext);
+        // 执行处理策略
+        const handled = await this.executeStrategies(errorWithContext, strategies);
+        // 尝试恢复错误
+        let recoveredValue;
+        let recoverable = false;
+        if (handled && errorWithContext.recoverable && this.config.recoveryOptions) {
+            const recoveryResult = await this.attemptRecovery(errorWithContext);
+            recoverable = recoveryResult.recoverable;
+            recoveredValue = recoveryResult.value;
+        }
+        return {
+            handled,
+            recoverable,
+            recoveredValue,
+            strategies,
+            error: errorWithContext
+        };
+    }
+    /**
+   * 确定错误处理策略
+   */ determineStrategies(error) {
+        // 1. 检查错误类型对应的策略
+        if (this.config.typeStrategies[error.type]) {
+            return this.config.typeStrategies[error.type];
+        }
+        // 2. 检查错误严重程度对应的策略
+        if (this.config.severityStrategies[error.severity]) {
+            return this.config.severityStrategies[error.severity];
+        }
+        // 3. 使用默认策略
+        return this.config.defaultStrategies;
+    }
+    /**
+   * 执行处理策略
+   */ async executeStrategies(error, strategies) {
+        let handled = false;
+        for (const strategy of strategies){
+            try {
+                switch(strategy){
+                    case "LOG":
+                        this.logError(error);
+                        handled = true;
+                        break;
+                    case "REPORT":
+                        await this.reportError(error);
+                        handled = true;
+                        break;
+                    case "RECOVER":
+                        // 恢复策略在 handleError 中统一处理
+                        handled = true;
+                        break;
+                    case "FALLBACK":
+                        // 降级策略在 attemptRecovery 中处理
+                        handled = true;
+                        break;
+                    case "IGNORE":
+                        // 忽略错误，不做任何处理
+                        handled = true;
+                        break;
+                }
+            } catch (strategyError) {
+                logger.warn(`错误处理策略 ${strategy} 执行失败:`, strategyError);
+            }
+        }
+        return handled;
+    }
+    /**
+   * 记录错误
+   */ logError(error) {
+        const errorInfo = errorUtils.extractErrorInfo(error);
+        // 根据错误严重程度选择日志级别
+        switch(error.severity){
+            case ErrorSeverity.CRITICAL:
+            case ErrorSeverity.HIGH:
+                logger.error('错误:', errorInfo);
+                break;
+            case ErrorSeverity.MEDIUM:
+                logger.warn('警告:', errorInfo);
+                break;
+            case ErrorSeverity.LOW:
+                logger.info('信息:', errorInfo);
+                break;
+        }
+        // 开发环境显示详细错误信息
+        if (this.config.showDetailedErrorsInDev && process.env.NODE_ENV === 'development') {
+            const detailedError = errorUtils.formatErrorForDev(error);
+            console.error(detailedError);
+        }
+    }
+    /**
+   * 上报错误
+   */ async reportError(error) {
+        if (!this.monitoring) {
+            logger.debug('监控服务未配置，跳过错误上报');
+            return;
+        }
+        try {
+            this.monitoring.captureError(error, {
+                severity: error.severity,
+                type: error.type,
+                code: error.code,
+                context: error.context
+            });
+        } catch (reportError) {
+            logger.warn('错误上报失败:', reportError);
+        }
+    }
+    /**
+   * 尝试恢复错误
+   */ async attemptRecovery(error) {
+        const options = this.config.recoveryOptions;
+        if (!options) {
+            return {
+                recoverable: false
+            };
+        }
+        const maxRetries = options.maxRetries ?? 3;
+        const retryDelay = options.retryDelay ?? 1000;
+        const exponentialBackoff = options.exponentialBackoff ?? true;
+        const shouldRetry = options.shouldRetry ?? (()=>true);
+        // 如果有降级方案，先尝试降级
+        if (options.fallback) {
+            try {
+                const fallbackValue = await Promise.resolve(options.fallback());
+                logger.info('错误已通过降级方案恢复');
+                return {
+                    recoverable: true,
+                    value: fallbackValue
+                };
+            } catch (fallbackError) {
+                logger.warn('降级方案执行失败:', fallbackError);
+            }
+        }
+        // 尝试重试（如果错误可恢复且满足重试条件）
+        if (error.recoverable && shouldRetry(error, 0)) {
+            for(let attempt = 0; attempt < maxRetries; attempt++){
+                if (!shouldRetry(error, attempt)) {
+                    break;
+                }
+                const delay = exponentialBackoff ? retryDelay * Math.pow(2, attempt) : retryDelay;
+                logger.debug(`错误恢复重试 ${attempt + 1}/${maxRetries}，${delay}ms 后重试...`);
+                await new Promise((resolve)=>setTimeout(resolve, delay));
+            // 这里应该调用原始操作的重试逻辑
+            // 由于错误处理器不知道原始操作，这里只返回可恢复状态
+            // 实际的重试应该在调用方实现
+            }
+        }
+        return {
+            recoverable: error.recoverable
+        };
+    }
+    /**
+   * 创建错误处理器的便捷方法
+   */ static create(config) {
+        return new ErrorHandler(config);
+    }
+    constructor(config = {}){
+        _define_property(this, "config", void 0);
+        _define_property(this, "monitoring", void 0);
+        this.monitoring = config.monitoring;
+        this.config = {
+            defaultStrategies: config.defaultStrategies ?? [
+                "LOG",
+                "REPORT"
+            ],
+            severityStrategies: config.severityStrategies ?? {},
+            typeStrategies: config.typeStrategies ?? {},
+            recoveryOptions: config.recoveryOptions ?? {},
+            showDetailedErrorsInDev: config.showDetailedErrorsInDev ?? true
+        };
+    }
+}
+/**
+ * 默认错误处理器实例（单例）
+ */ let defaultErrorHandler = null;
+/**
+ * 获取默认错误处理器
+ */ export function getDefaultErrorHandler() {
+    if (!defaultErrorHandler) {
+        defaultErrorHandler = new ErrorHandler();
+    }
+    return defaultErrorHandler;
+}
+/**
+ * 设置默认错误处理器
+ */ export function setDefaultErrorHandler(handler) {
+    defaultErrorHandler = handler;
+}
+
+//# sourceMappingURL=ErrorHandler.js.map

package/dist/core/error/ErrorHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/core/error/ErrorHandler.ts"],"sourcesContent":["/**\n * 统一错误处理器\n * \n * 优化：\n * 1. 统一错误处理策略：记录、上报、恢复、降级\n * 2. 错误分类：致命、可恢复、警告\n * 3. 错误恢复机制：自动重试、降级方案\n */\n\nimport { logger } from '../../utils';\nimport { errorUtils, ErrorSeverity, ErrorType, FrameworkError } from '../../utils/errors';\nimport type { MonitoringService } from '../../utils/monitoring';\n\n/**\n * 错误处理策略\n */\nexport enum ErrorHandlingStrategy {\n  /**\n   * 记录错误（日志）\n   */\n  LOG = 'LOG',\n  /**\n   * 上报错误（监控服务）\n   */\n  REPORT = 'REPORT',\n  /**\n   * 尝试恢复错误\n   */\n  RECOVER = 'RECOVER',\n  /**\n   * 降级处理\n   */\n  FALLBACK = 'FALLBACK',\n  /**\n   * 忽略错误\n   */\n  IGNORE = 'IGNORE',\n}\n\n/**\n * 错误恢复选项\n */\nexport interface ErrorRecoveryOptions {\n  /**\n   * 最大重试次数\n   * @default 3\n   */\n  maxRetries?: number;\n  /**\n   * 重试延迟（毫秒）\n   * @default 1000\n   */\n  retryDelay?: number;\n  /**\n   * 是否启用指数退避\n   * @default true\n   */\n  exponentialBackoff?: boolean;\n  /**\n   * 重试条件函数\n   */\n  shouldRetry?: (error: unknown, attempt: number) => boolean;\n  /**\n   * 降级方案函数\n   */\n  fallback?: () => Promise<unknown> | unknown;\n}\n\n/**\n * 错误处理配置\n */\nexport interface ErrorHandlerConfig {\n  /**\n   * 监控服务实例（可选）\n   */\n  monitoring?: MonitoringService;\n  /**\n   * 默认错误处理策略\n   * @default [ErrorHandlingStrategy.LOG, ErrorHandlingStrategy.REPORT]\n   */\n  defaultStrategies?: ErrorHandlingStrategy[];\n  /**\n   * 错误严重程度对应的处理策略\n   */\n  severityStrategies?: Partial<Record<ErrorSeverity, ErrorHandlingStrategy[]>>;\n  /**\n   * 错误类型对应的处理策略\n   */\n  typeStrategies?: Partial<Record<ErrorType, ErrorHandlingStrategy[]>>;\n  /**\n   * 错误恢复选项\n   */\n  recoveryOptions?: ErrorRecoveryOptions;\n  /**\n   * 是否在开发环境显示详细错误信息\n   * @default true\n   */\n  showDetailedErrorsInDev?: boolean;\n}\n\n/**\n * 错误处理结果\n */\nexport interface ErrorHandleResult {\n  /**\n   * 是否已处理\n   */\n  handled: boolean;\n  /**\n   * 是否可恢复\n   */\n  recoverable: boolean;\n  /**\n   * 恢复后的结果（如果已恢复）\n   */\n  recoveredValue?: unknown;\n  /**\n   * 使用的处理策略\n   */\n  strategies: ErrorHandlingStrategy[];\n  /**\n   * 错误信息\n   */\n  error: FrameworkError;\n}\n\n/**\n * 统一错误处理器\n */\nexport class ErrorHandler {\n  private config: Omit<Required<ErrorHandlerConfig>, 'monitoring'>;\n  private monitoring?: MonitoringService;\n\n  constructor(config: ErrorHandlerConfig = {}) {\n    this.monitoring = config.monitoring;\n    this.config = {\n      defaultStrategies: config.defaultStrategies ?? [\n        ErrorHandlingStrategy.LOG,\n        ErrorHandlingStrategy.REPORT,\n      ],\n      severityStrategies: config.severityStrategies ?? {},\n      typeStrategies: config.typeStrategies ?? {},\n      recoveryOptions: config.recoveryOptions ?? {},\n      showDetailedErrorsInDev: config.showDetailedErrorsInDev ?? true,\n    };\n  }\n\n  /**\n   * 设置监控服务\n   */\n  setMonitoring(monitoring: MonitoringService): void {\n    this.monitoring = monitoring;\n  }\n\n  /**\n   * 处理错误\n   * \n   * @param error - 错误对象\n   * @param context - 错误上下文\n   * @returns 错误处理结果\n   */\n  async handleError(\n    error: unknown,\n    context?: Record<string, unknown>\n  ): Promise<ErrorHandleResult> {\n    // 标准化错误对象\n    const normalizedError = errorUtils.normalizeError(error);\n    \n    // 创建包含上下文信息的错误对象（由于 context 是只读的，需要创建新对象）\n    const errorWithContext: FrameworkError = context\n      ? new FrameworkError(\n          normalizedError.message,\n          normalizedError.type,\n          normalizedError.severity,\n          {\n            code: normalizedError.code,\n            originalError: normalizedError.originalError,\n            context: {\n              ...normalizedError.context,\n              ...context,\n            },\n            recoverable: normalizedError.recoverable,\n          }\n        )\n      : normalizedError;\n\n    // 确定处理策略\n    const strategies = this.determineStrategies(errorWithContext);\n    \n    // 执行处理策略\n    const handled = await this.executeStrategies(errorWithContext, strategies);\n\n    // 尝试恢复错误\n    let recoveredValue: unknown | undefined;\n    let recoverable = false;\n    if (handled && errorWithContext.recoverable && this.config.recoveryOptions) {\n      const recoveryResult = await this.attemptRecovery(errorWithContext);\n      recoverable = recoveryResult.recoverable;\n      recoveredValue = recoveryResult.value;\n    }\n\n    return {\n      handled,\n      recoverable,\n      recoveredValue,\n      strategies,\n      error: errorWithContext,\n    };\n  }\n\n  /**\n   * 确定错误处理策略\n   */\n  private determineStrategies(error: FrameworkError): ErrorHandlingStrategy[] {\n    // 1. 检查错误类型对应的策略\n    if (this.config.typeStrategies[error.type]) {\n      return this.config.typeStrategies[error.type]!;\n    }\n\n    // 2. 检查错误严重程度对应的策略\n    if (this.config.severityStrategies[error.severity]) {\n      return this.config.severityStrategies[error.severity]!;\n    }\n\n    // 3. 使用默认策略\n    return this.config.defaultStrategies;\n  }\n\n  /**\n   * 执行处理策略\n   */\n  private async executeStrategies(\n    error: FrameworkError,\n    strategies: ErrorHandlingStrategy[]\n  ): Promise<boolean> {\n    let handled = false;\n\n    for (const strategy of strategies) {\n      try {\n        switch (strategy) {\n          case ErrorHandlingStrategy.LOG:\n            this.logError(error);\n            handled = true;\n            break;\n\n          case ErrorHandlingStrategy.REPORT:\n            await this.reportError(error);\n            handled = true;\n            break;\n\n          case ErrorHandlingStrategy.RECOVER:\n            // 恢复策略在 handleError 中统一处理\n            handled = true;\n            break;\n\n          case ErrorHandlingStrategy.FALLBACK:\n            // 降级策略在 attemptRecovery 中处理\n            handled = true;\n            break;\n\n          case ErrorHandlingStrategy.IGNORE:\n            // 忽略错误，不做任何处理\n            handled = true;\n            break;\n        }\n      } catch (strategyError) {\n        logger.warn(`错误处理策略 ${strategy} 执行失败:`, strategyError);\n      }\n    }\n\n    return handled;\n  }\n\n  /**\n   * 记录错误\n   */\n  private logError(error: FrameworkError): void {\n    const errorInfo = errorUtils.extractErrorInfo(error);\n    \n    // 根据错误严重程度选择日志级别\n    switch (error.severity) {\n      case ErrorSeverity.CRITICAL:\n      case ErrorSeverity.HIGH:\n        logger.error('错误:', errorInfo);\n        break;\n      case ErrorSeverity.MEDIUM:\n        logger.warn('警告:', errorInfo);\n        break;\n      case ErrorSeverity.LOW:\n        logger.info('信息:', errorInfo);\n        break;\n    }\n\n    // 开发环境显示详细错误信息\n    if (this.config.showDetailedErrorsInDev && process.env.NODE_ENV === 'development') {\n      const detailedError = errorUtils.formatErrorForDev(error);\n      console.error(detailedError);\n    }\n  }\n\n  /**\n   * 上报错误\n   */\n  private async reportError(error: FrameworkError): Promise<void> {\n    if (!this.monitoring) {\n      logger.debug('监控服务未配置，跳过错误上报');\n      return;\n    }\n\n    try {\n      this.monitoring.captureError(error, {\n        severity: error.severity,\n        type: error.type,\n        code: error.code,\n        context: error.context,\n      });\n    } catch (reportError) {\n      logger.warn('错误上报失败:', reportError);\n    }\n  }\n\n  /**\n   * 尝试恢复错误\n   */\n  private async attemptRecovery(\n    error: FrameworkError\n  ): Promise<{ recoverable: boolean; value?: unknown }> {\n    const options = this.config.recoveryOptions;\n    if (!options) {\n      return { recoverable: false };\n    }\n\n    const maxRetries = options.maxRetries ?? 3;\n    const retryDelay = options.retryDelay ?? 1000;\n    const exponentialBackoff = options.exponentialBackoff ?? true;\n    const shouldRetry = options.shouldRetry ?? (() => true);\n\n    // 如果有降级方案，先尝试降级\n    if (options.fallback) {\n      try {\n        const fallbackValue = await Promise.resolve(options.fallback());\n        logger.info('错误已通过降级方案恢复');\n        return { recoverable: true, value: fallbackValue };\n      } catch (fallbackError) {\n        logger.warn('降级方案执行失败:', fallbackError);\n      }\n    }\n\n    // 尝试重试（如果错误可恢复且满足重试条件）\n    if (error.recoverable && shouldRetry(error, 0)) {\n      for (let attempt = 0; attempt < maxRetries; attempt++) {\n        if (!shouldRetry(error, attempt)) {\n          break;\n        }\n\n        const delay = exponentialBackoff\n          ? retryDelay * Math.pow(2, attempt)\n          : retryDelay;\n\n        logger.debug(`错误恢复重试 ${attempt + 1}/${maxRetries}，${delay}ms 后重试...`);\n\n        await new Promise(resolve => setTimeout(resolve, delay));\n\n        // 这里应该调用原始操作的重试逻辑\n        // 由于错误处理器不知道原始操作，这里只返回可恢复状态\n        // 实际的重试应该在调用方实现\n      }\n    }\n\n    return { recoverable: error.recoverable };\n  }\n\n  /**\n   * 创建错误处理器的便捷方法\n   */\n  static create(config?: ErrorHandlerConfig): ErrorHandler {\n    return new ErrorHandler(config);\n  }\n}\n\n/**\n * 默认错误处理器实例（单例）\n */\nlet defaultErrorHandler: ErrorHandler | null = null;\n\n/**\n * 获取默认错误处理器\n */\nexport function getDefaultErrorHandler(): ErrorHandler {\n  if (!defaultErrorHandler) {\n    defaultErrorHandler = new ErrorHandler();\n  }\n  return defaultErrorHandler;\n}\n\n/**\n * 设置默认错误处理器\n */\nexport function setDefaultErrorHandler(handler: ErrorHandler): void {\n  defaultErrorHandler = handler;\n}\n"],"names":["logger","errorUtils","ErrorSeverity","FrameworkError","ErrorHandlingStrategy","ErrorHandler","setMonitoring","monitoring","handleError","error","context","normalizedError","normalizeError","errorWithContext","message","type","severity","code","originalError","recoverable","strategies","determineStrategies","handled","executeStrategies","recoveredValue","config","recoveryOptions","recoveryResult","attemptRecovery","value","typeStrategies","severityStrategies","defaultStrategies","strategy","logError","reportError","strategyError","warn","errorInfo","extractErrorInfo","CRITICAL","HIGH","MEDIUM","LOW","info","showDetailedErrorsInDev","process","env","NODE_ENV","detailedError","formatErrorForDev","console","debug","captureError","options","maxRetries","retryDelay","exponentialBackoff","shouldRetry","fallback","fallbackValue","Promise","resolve","fallbackError","attempt","delay","Math","pow","setTimeout","create","defaultErrorHandler","getDefaultErrorHandler","setDefaultErrorHandler","handler"],"mappings":"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"}

package/dist/core/error/index.cjs

@@ -14,6 +14,15 @@ _export(exports, {
     get ErrorBoundary () {
         return _ErrorBoundary.ErrorBoundary;
     },
+    get ErrorHandler () {
+        return _ErrorHandler.ErrorHandler;
+    },
+    get getDefaultErrorHandler () {
+        return _ErrorHandler.getDefaultErrorHandler;
+    },
+    get setDefaultErrorHandler () {
+        return _ErrorHandler.setDefaultErrorHandler;
+    },
     get useErrorHandler () {
         return _ErrorBoundary.useErrorHandler;
     },
@@ -22,5 +31,6 @@ _export(exports, {
     }
 });
 const _ErrorBoundary = require("./ErrorBoundary");
+const _ErrorHandler = require("./ErrorHandler");
 
 //# sourceMappingURL=index.js.map

package/dist/core/error/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/core/error/index.ts"],"sourcesContent":["/**\n * 错误处理模块统一导出\n */\n\nexport { ErrorBoundary, withErrorBoundary, useErrorHandler } from './ErrorBoundary';\nexport type { ErrorBoundaryProps } from './ErrorBoundary';\n"],"names":["ErrorBoundary","useErrorHandler","withErrorBoundary"],"mappings":"AAAA;;CAEC;;;;;;;;;;;QAEQA;eAAAA,4BAAa;;QAAqBC;eAAAA,8BAAe;;QAAlCC;eAAAA,gCAAiB;;;+BAAyB"}
+{"version":3,"sources":["../../../src/core/error/index.ts"],"sourcesContent":["/**\n * 错误处理模块统一导出\n */\n\nexport { ErrorBoundary, withErrorBoundary, useErrorHandler } from './ErrorBoundary';\nexport type { ErrorBoundaryProps } from './ErrorBoundary';\nexport { ErrorHandler, getDefaultErrorHandler, setDefaultErrorHandler } from './ErrorHandler';\nexport type {\n  ErrorHandlingStrategy,\n  ErrorHandlerConfig,\n  ErrorHandleResult,\n  ErrorRecoveryOptions,\n} from './ErrorHandler';"],"names":["ErrorBoundary","ErrorHandler","getDefaultErrorHandler","setDefaultErrorHandler","useErrorHandler","withErrorBoundary"],"mappings":"AAAA;;CAEC;;;;;;;;;;;QAEQA;eAAAA,4BAAa;;QAEbC;eAAAA,0BAAY;;QAAEC;eAAAA,oCAAsB;;QAAEC;eAAAA,oCAAsB;;QAF1BC;eAAAA,8BAAe;;QAAlCC;eAAAA,gCAAiB;;;+BAAyB;8BAEW"}

package/dist/core/error/index.d.ts

@@ -3,4 +3,6 @@
  */
 export { ErrorBoundary, withErrorBoundary, useErrorHandler } from './ErrorBoundary';
 export type { ErrorBoundaryProps } from './ErrorBoundary';
+export { ErrorHandler, getDefaultErrorHandler, setDefaultErrorHandler } from './ErrorHandler';
+export type { ErrorHandlingStrategy, ErrorHandlerConfig, ErrorHandleResult, ErrorRecoveryOptions, } from './ErrorHandler';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/error/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/error/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACpF,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/error/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACpF,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,sBAAsB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAC;AAC9F,YAAY,EACV,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,GACrB,MAAM,gBAAgB,CAAC"}

package/dist/core/error/index.js

@@ -1,5 +1,6 @@
 /**
  * 错误处理模块统一导出
  */ export { ErrorBoundary, withErrorBoundary, useErrorHandler } from "./ErrorBoundary";
+export { ErrorHandler, getDefaultErrorHandler, setDefaultErrorHandler } from "./ErrorHandler";
 
 //# sourceMappingURL=index.js.map

package/dist/core/error/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/core/error/index.ts"],"sourcesContent":["/**\n * 错误处理模块统一导出\n */\n\nexport { ErrorBoundary, withErrorBoundary, useErrorHandler } from './ErrorBoundary';\nexport type { ErrorBoundaryProps } from './ErrorBoundary';\n"],"names":["ErrorBoundary","withErrorBoundary","useErrorHandler"],"mappings":"AAAA;;CAEC,GAED,SAASA,aAAa,EAAEC,iBAAiB,EAAEC,eAAe,QAAQ,kBAAkB"}
+{"version":3,"sources":["../../../src/core/error/index.ts"],"sourcesContent":["/**\n * 错误处理模块统一导出\n */\n\nexport { ErrorBoundary, withErrorBoundary, useErrorHandler } from './ErrorBoundary';\nexport type { ErrorBoundaryProps } from './ErrorBoundary';\nexport { ErrorHandler, getDefaultErrorHandler, setDefaultErrorHandler } from './ErrorHandler';\nexport type {\n  ErrorHandlingStrategy,\n  ErrorHandlerConfig,\n  ErrorHandleResult,\n  ErrorRecoveryOptions,\n} from './ErrorHandler';"],"names":["ErrorBoundary","withErrorBoundary","useErrorHandler","ErrorHandler","getDefaultErrorHandler","setDefaultErrorHandler"],"mappings":"AAAA;;CAEC,GAED,SAASA,aAAa,EAAEC,iBAAiB,EAAEC,eAAe,QAAQ,kBAAkB;AAEpF,SAASC,YAAY,EAAEC,sBAAsB,EAAEC,sBAAsB,QAAQ,iBAAiB"}