a11yanalyze/dist/scanner/error-resilience.d.ts

A command-line tool for developers and QA engineers to test web pages and websites for WCAG 2.2 AA accessibility compliance

import { ScanError } from '../types';
/**
 * Configuration for error resilience and timeout handling
 */
export interface ResilienceConfig {
    maxRetries: number;
    baseRetryDelay: number;
    maxRetryDelay: number;
    backoffMultiplier: number;
    circuitBreakerThreshold: number;
    circuitBreakerTimeout: number;
    operationTimeouts: {
        navigation: number;
        pageReady: number;
        ruleExecution: number;
        metadataExtraction: number;
        screenshot: number;
    };
    adaptiveTimeouts: boolean;
    maxConcurrentOperations: number;
}
/**
 * Circuit breaker states
 */
export declare enum CircuitBreakerState {
    CLOSED = "CLOSED",
    OPEN = "OPEN",
    HALF_OPEN = "HALF_OPEN"
}
/**
 * Operation result tracking for adaptive behavior
 */
export interface OperationMetrics {
    successCount: number;
    failureCount: number;
    averageExecutionTime: number;
    lastExecutionTime: number;
    timeouts: number;
}
/**
 * Retry strategy configuration
 */
export interface RetryStrategy {
    maxAttempts: number;
    delay: number;
    backoffType: 'linear' | 'exponential' | 'fixed';
    jitter: boolean;
    retryableErrors: string[];
}
/**
 * Circuit breaker for preventing cascading failures
 */
export declare class CircuitBreaker {
    private threshold;
    private timeout;
    private name;
    private state;
    private failureCount;
    private lastFailureTime;
    private nextAttemptTime;
    constructor(threshold: number, timeout: number, name: string);
    execute<T>(operation: () => Promise<T>): Promise<T>;
    private onSuccess;
    private onFailure;
    getState(): CircuitBreakerState;
    getFailureCount(): number;
    reset(): void;
}
/**
 * Adaptive timeout manager
 */
export declare class TimeoutManager {
    private metrics;
    private config;
    constructor(config: ResilienceConfig);
    /**
     * Get timeout for operation with adaptive adjustment
     */
    getTimeout(operationType: keyof ResilienceConfig['operationTimeouts'] | string): number;
    /**
     * Record operation execution metrics
     */
    recordExecution(operationType: string, executionTime: number, success: boolean, timedOut?: boolean): void;
    /**
     * Calculate adaptive factor based on metrics
     */
    private calculateAdaptiveFactor;
    getMetrics(): Map<string, OperationMetrics>;
    reset(): void;
}
/**
 * Retry manager with configurable strategies
 */
export declare class RetryManager {
    private config;
    constructor(config: ResilienceConfig);
    /**
     * Execute operation with retry logic
     */
    executeWithRetry<T>(operation: () => Promise<T>, strategy: Partial<RetryStrategy> | undefined, operationType: string): Promise<T>;
    /**
     * Check if error is retryable
     */
    private isRetryableError;
    /**
     * Calculate delay for retry attempt
     */
    private calculateDelay;
    /**
     * Sleep for specified duration
     */
    private sleep;
}
/**
 * Comprehensive error resilience manager
 */
export declare class ErrorResilienceManager {
    private circuitBreakers;
    private timeoutManager;
    private retryManager;
    private config;
    private activeOperations;
    constructor(config?: Partial<ResilienceConfig>);
    /**
     * Execute operation with full resilience features
     */
    executeResilient<T>(operation: () => Promise<T>, operationType: string, options?: {
        useCircuitBreaker?: boolean;
        useRetry?: boolean;
        useTimeout?: boolean;
        retryStrategy?: Partial<RetryStrategy>;
    }): Promise<T>;
    /**
     * Create timeout promise
     */
    private createTimeoutPromise;
    /**
     * Get or create circuit breaker for operation type
     */
    private getOrCreateCircuitBreaker;
    /**
     * Get resilience status and metrics
     */
    getStatus(): {
        config: ResilienceConfig;
        activeOperations: number;
        circuitBreakers: {
            name: string;
            state: CircuitBreakerState;
            failureCount: number;
        }[];
        operationMetrics: {
            [k: string]: OperationMetrics;
        };
    };
    /**
     * Reset all resilience components
     */
    reset(): void;
    /**
     * Update configuration
     */
    updateConfig(newConfig: Partial<ResilienceConfig>): void;
    /**
     * Categorize and enrich error information
     */
    categorizeError(error: Error, context: string): ScanError;
    /**
     * Create error with retry information
     */
    createRetryableError(originalError: Error, attempt: number, maxAttempts: number): Error;
}
//# sourceMappingURL=error-resilience.d.ts.map