@casoon/auditmysite/dist/core/pipeline/parallel-test-manager.d.ts

Professional website analysis suite with robust accessibility testing, Core Web Vitals performance monitoring, SEO analysis, and content optimization insights. Features isolated browser contexts, retry mechanisms, and comprehensive API endpoints for profe

import { EventDrivenQueueOptions, QueueStats } from './event-driven-queue';
import { AccessibilityChecker } from '../accessibility';
import { TestOptions, AccessibilityResult } from '../types';
/**
 * @deprecated ParallelTestManagerOptions is deprecated and will be removed in v3.0.0
 * Use AccessibilityChecker with unified event system instead
 */
export interface ParallelTestManagerOptions extends EventDrivenQueueOptions {
    maxConcurrent?: number;
    maxRetries?: number;
    retryDelay?: number;
    testOptions?: TestOptions;
    accessibilityChecker?: AccessibilityChecker;
    verbose?: boolean;
    enableResourceMonitoring?: boolean;
    maxMemoryUsage?: number;
    maxCpuUsage?: number;
    enablePersistence?: boolean;
    stateAdapter?: any;
    autoSave?: boolean;
    autoSaveInterval?: number;
    stateId?: string;
    resumable?: boolean;
    onTestStart?: (url: string) => void;
    onTestComplete?: (url: string, result: AccessibilityResult) => void;
    onTestError?: (url: string, error: string) => void;
    onProgressUpdate?: (stats: QueueStats) => void;
    onQueueEmpty?: () => void;
}
export interface ParallelTestResult {
    results: AccessibilityResult[];
    stats: QueueStats;
    duration: number;
    errors: Array<{
        url: string;
        error: string;
        attempts: number;
    }>;
}
/**
 * @deprecated ParallelTestManager is deprecated and will be removed in v3.0.0
 *
 * This class is replaced by the unified PageAnalysisEmitter system integrated into AccessibilityChecker.
 * The new system provides better performance, consistent event handling, and integrated resource monitoring.
 *
 * MIGRATION GUIDE:
 * ```typescript
 * // OLD (deprecated)
 * const manager = new ParallelTestManager({
 *   maxConcurrent: 3,
 *   onTestComplete: (url, result) => { ... }
 * });
 * await manager.runTests(urls);
 *
 * // NEW (recommended)
 * const checker = new AccessibilityChecker({
 *   enableUnifiedEvents: true,
 *   enableComprehensiveAnalysis: true
 * });
 * checker.setUnifiedEventCallbacks({ onUrlCompleted: (url, result) => { ... } });
 * await checker.testMultiplePagesParallel(urls, { maxConcurrent: 3 });
 * ```
 */
export declare class ParallelTestManager {
    private queue;
    private accessibilityChecker;
    private options;
    private isRunning;
    private startTime;
    private activeTests;
    constructor(options?: ParallelTestManagerOptions);
    initialize(): Promise<void>;
    /**
     * Resume tests from saved state
     */
    resumeFromState(stateId?: string): Promise<void>;
    /**
     * Get the current state ID
     */
    getStateId(): string;
    /**
     * Save current state
     */
    saveState(): Promise<void>;
    runTests(urls: string[]): Promise<ParallelTestResult>;
    private processQueue;
    private startWorkers;
    private processNextUrl;
    private checkResourceLimits;
    private handleUrlAdded;
    private handleUrlStarted;
    private handleUrlCompleted;
    private handleUrlFailed;
    private handleUrlRetrying;
    private handleQueueEmpty;
    private handleProgressUpdate;
    private handleError;
    private setupEventListeners;
    pause(): void;
    resume(): void;
    stop(): void;
    getStats(): QueueStats;
    getActiveTests(): number;
    getQueueSize(): number;
    setMaxConcurrent(max: number): void;
    getMemoryUsage(): number;
    getCpuUsage(): number;
    cleanup(): Promise<void>;
}
//# sourceMappingURL=parallel-test-manager.d.ts.map