@casoon/auditmysite
Version:
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
250 lines âĸ 7.92 kB
TypeScript
import { EventEmitter } from 'events';
import { BackpressureConfig } from '../backpressure-controller';
import { ResourceMonitorConfig } from '../resource-monitor';
import { QueueStateAdapter, ResumeOptions } from '../../types/queue-state';
/**
* @deprecated EventDrivenQueue is deprecated and will be removed in v3.0.0
* Use PageAnalysisEmitter instead for unified event handling across all analyzers
*
* Migration Guide:
* - Replace EventDrivenQueue with PageAnalysisEmitter
* - Use UnifiedEventCallbacks instead of EventDrivenQueueOptions.eventCallbacks
* - Access via AccessibilityChecker.getUnifiedEmitter() for advanced usage
*/
export interface QueuedUrl {
url: string;
priority: number;
status: 'pending' | 'in-progress' | 'completed' | 'failed' | 'retrying';
attempts: number;
result?: any;
error?: string;
startedAt?: Date;
completedAt?: Date;
duration?: number;
}
export interface QueueEvent {
type: 'url-added' | 'url-started' | 'url-completed' | 'url-failed' | 'url-retrying' | 'queue-empty' | 'progress-update' | 'error';
data: any;
timestamp: Date;
}
export interface EventDrivenQueueOptions {
maxRetries?: number;
maxConcurrent?: number;
priorityPatterns?: Array<{
pattern: string;
priority: number;
}>;
retryDelay?: number;
enableEvents?: boolean;
enableShortStatus?: boolean;
statusUpdateInterval?: number;
enableBackpressure?: boolean;
backpressureConfig?: Partial<BackpressureConfig>;
enableResourceMonitoring?: boolean;
resourceMonitorConfig?: Partial<ResourceMonitorConfig>;
hardTimeout?: number;
globalTimeout?: number;
enablePersistence?: boolean;
stateAdapter?: QueueStateAdapter;
autoSave?: boolean;
autoSaveInterval?: number;
stateId?: string;
resumable?: boolean;
eventCallbacks?: {
onUrlAdded?: (url: string, priority: number) => void;
onUrlStarted?: (url: string) => void;
onUrlCompleted?: (url: string, result: any, duration: number) => void;
onUrlFailed?: (url: string, error: string, attempts: number) => void;
onUrlRetrying?: (url: string, attempts: number) => void;
onQueueEmpty?: () => void;
onProgressUpdate?: (stats: QueueStats) => void;
onError?: (error: string) => void;
onShortStatus?: (status: string) => void;
onBackpressureActivated?: (reason: string) => void;
onBackpressureDeactivated?: () => void;
onResourceWarning?: (usage: number, limit: number) => void;
onResourceCritical?: (usage: number, limit: number) => void;
onGarbageCollection?: (beforeMB: number, afterMB?: number) => void;
};
}
export interface QueueStats {
total: number;
pending: number;
inProgress: number;
completed: number;
failed: number;
retrying: number;
progress: number;
averageDuration: number;
estimatedTimeRemaining: number;
activeWorkers: number;
memoryUsage: number;
cpuUsage: number;
}
export interface ProcessOptions {
processor: (url: string) => Promise<any>;
onResult?: (url: string, result: any) => void;
onError?: (url: string, error: string) => void;
onProgress?: (stats: QueueStats) => void;
onShortStatus?: (status: string) => void;
}
/**
* @deprecated EventDrivenQueue class is deprecated and will be removed in v3.0.0
*
* Use PageAnalysisEmitter for unified event handling instead.
* This class is maintained for backward compatibility only.
*
* MIGRATION PATH:
* ```typescript
* // OLD (deprecated)
* const queue = new EventDrivenQueue({ eventCallbacks: { ... } });
*
* // NEW (recommended)
* const emitter = new PageAnalysisEmitter({ callbacks: { ... } });
* // OR via AccessibilityChecker
* const checker = new AccessibilityChecker({ enableUnifiedEvents: true });
* checker.setUnifiedEventCallbacks({ ... });
* ```
*/
export declare class EventDrivenQueue extends EventEmitter {
private queue;
private completed;
private failed;
private activeWorkers;
private options;
private isProcessing;
private startTime;
private lastProgressUpdate;
private progressUpdateInterval;
private statusInterval;
private backpressureController?;
private resourceMonitor?;
private hardTimeoutTracker;
private globalTimeoutTimer;
private stateAdapter?;
private autoSaveTimer;
private stateId;
private currentState;
constructor(options?: EventDrivenQueueOptions);
/**
* Setup backpressure controller
*/
private setupBackpressure;
/**
* Setup persistence functionality
*/
private setupPersistence;
/**
* Generate unique state ID based on timestamp and random string
*/
private generateStateId;
/**
* Setup resource monitoring
*/
private setupResourceMonitoring;
private setupEventListeners;
addUrls(urls: string[]): void;
getNextUrl(): Promise<QueuedUrl | null>;
markCompleted(url: string, result: any): void;
markFailed(url: string, error: string): void;
/**
* Update backpressure controller with current state
*/
private updateBackpressure;
private checkQueueEmpty;
private updateProgress;
getStats(): QueueStats;
private calculatePriority;
/**
* Start auto-save timer
*/
private startAutoSave;
/**
* Stop auto-save timer
*/
private stopAutoSave;
/**
* Create current queue state snapshot
*/
private createStateSnapshot;
/**
* Save current state to adapter
*/
saveState(): Promise<void>;
/**
* Load state from adapter and resume processing
*/
resumeFromState(options?: ResumeOptions): Promise<void>;
/**
* Delete saved state
*/
deleteState(stateId?: string): Promise<void>;
/**
* List all available saved states
*/
listSavedStates(): Promise<string[]>;
/**
* Get state ID
*/
getStateId(): string;
/**
* Check if persistence is enabled
*/
isPersistenceEnabled(): boolean;
/**
* đ Integrated parallel queue processing
* Processes all URLs in parallel with automatic status reporting
*/
processUrls(urls: string[], options: ProcessOptions): Promise<any[]>;
/**
* đ§ Worker function for parallel processing (optimized to prevent timeout accumulation)
*/
private worker;
/**
* đ Starts short status updates
*/
private startStatusUpdates;
/**
* âšī¸ Stops status updates
*/
private stopStatusUpdates;
/**
* đ Generates short status message with improved ETA
*/
private generateShortStatus;
/**
* Create a simple progress bar
*/
private createProgressBar;
onUrlAdded(callback: (event: QueueEvent) => void): this;
onUrlStarted(callback: (event: QueueEvent) => void): this;
onUrlCompleted(callback: (event: QueueEvent) => void): this;
onUrlFailed(callback: (event: QueueEvent) => void): this;
onUrlRetrying(callback: (event: QueueEvent) => void): this;
onQueueEmpty(callback: (event: QueueEvent) => void): this;
onProgressUpdate(callback: (event: QueueEvent) => void): this;
onError(callback: (event: QueueEvent) => void): this;
/**
* Cleanup resources and stop processing
*/
destroy(): void;
/**
* Force garbage collection if available
*/
forceGarbageCollection(): boolean;
getCompletedResults(): any[];
getFailedResults(): any[];
clear(): void;
pause(): void;
resume(): void;
isPaused(): boolean;
/**
* đ§¯ Cleanup method to prevent memory leaks
*/
cleanup(): void;
getQueueSize(): number;
getActiveWorkers(): number;
getMaxConcurrent(): number;
setMaxConcurrent(max: number): void;
}
//# sourceMappingURL=event-driven-queue.d.ts.map