claritykit-svelte/dist/components/data-viz/performance/chart-performance.d.ts

A comprehensive Svelte component library focused on accessibility, ADHD-optimized design, developer experience, and full SSR compatibility

export interface PerformanceConfig {
    enableVirtualization: boolean;
    enableDataStreaming: boolean;
    enableWebWorkers: boolean;
    maxDataPoints: number;
    chunkSize: number;
    debounceMs: number;
    throttleMs: number;
    useOffscreenCanvas: boolean;
    enableLevelOfDetail: boolean;
    cacheSize: number;
}
export interface DataChunk {
    id: string;
    startIndex: number;
    endIndex: number;
    data: any[];
    metadata?: Record<string, any>;
}
export interface VirtualizationResult {
    visibleData: any[];
    totalCount: number;
    startIndex: number;
    endIndex: number;
    hasMore: boolean;
}
/**
 * Data virtualization for large datasets
 */
export declare class DataVirtualizer {
    private data;
    private chunkSize;
    private visibleRange;
    private cache;
    private maxCacheSize;
    constructor(chunkSize?: number, maxCacheSize?: number);
    /**
     * Set the complete dataset
     */
    setData(data: any[]): void;
    /**
     * Get virtualized data for current viewport
     */
    getVirtualizedData(startIndex?: number, count?: number): VirtualizationResult;
    /**
     * Update visible range (e.g., when scrolling)
     */
    updateVisibleRange(start: number, end: number): VirtualizationResult;
    /**
     * Preload chunks around current visible range
     */
    preloadAdjacentChunks(): void;
    private setCache;
    /**
     * Clear cache and reset
     */
    clear(): void;
    /**
     * Get memory usage statistics
     */
    getMemoryStats(): {
        cacheSize: number;
        dataSize: number;
        chunks: number;
    };
}
/**
 * Level of Detail (LOD) management for charts
 */
export declare class LevelOfDetailManager {
    private lodLevels;
    private currentLod;
    /**
     * Generate different levels of detail for data
     */
    generateLOD(data: any[], levels?: number): void;
    /**
     * Get data for appropriate LOD based on zoom level
     */
    getDataForZoom(zoomLevel: number, dataCount: number): any[];
    /**
     * Simplify data by reducing point count
     */
    private simplifyData;
    private isTimeSeries;
    private averageChunk;
    getCurrentLOD(): number;
    getLODInfo(): {
        level: number;
        pointCount: number;
        total: number;
    };
}
/**
 * Web Worker manager for offloading computations
 */
export declare class ChartWorkerManager {
    private workers;
    private maxWorkers;
    private workerScript;
    constructor(maxWorkers?: number);
    /**
     * Process data in a web worker
     */
    processData(operation: 'aggregate' | 'filter' | 'sort' | 'calculate', data: any[], options?: Record<string, any>): Promise<any>;
    /**
     * Calculate statistics in worker
     */
    calculateStatistics(data: number[]): Promise<{
        mean: number;
        median: number;
        std: number;
        min: number;
        max: number;
        percentiles: {
            p25: number;
            p75: number;
            p90: number;
            p95: number;
        };
    }>;
    /**
     * Aggregate time series data in worker
     */
    aggregateTimeSeries(data: Array<{
        timestamp: number;
        value: number;
    }>, interval: 'hour' | 'day' | 'week' | 'month'): Promise<Array<{
        timestamp: number;
        value: number;
        count: number;
    }>>;
    private createWorker;
    private destroyWorker;
    private createWorkerScript;
    /**
     * Cleanup all workers
     */
    destroy(): void;
}
/**
 * Efficient data streaming for real-time updates
 */
export declare class DataStreamer {
    private buffer;
    private maxBufferSize;
    private flushCallback;
    private flushInterval;
    private intervalId;
    constructor(maxBufferSize: number | undefined, flushIntervalMs: number | undefined, flushCallback: (data: any[]) => void);
    /**
     * Add data point to stream
     */
    push(dataPoint: any): void;
    /**
     * Add multiple data points
     */
    pushBatch(dataPoints: any[]): void;
    /**
     * Start automatic flushing
     */
    start(): void;
    /**
     * Stop automatic flushing
     */
    stop(): void;
    /**
     * Manually flush buffer
     */
    flush(): void;
    /**
     * Get current buffer size
     */
    getBufferSize(): number;
}
/**
 * Performance monitoring for charts
 */
export declare class ChartPerformanceMonitor {
    private metrics;
    private startTimes;
    /**
     * Start timing an operation
     */
    startTiming(operation: string): void;
    /**
     * End timing and record metric
     */
    endTiming(operation: string): number;
    /**
     * Get performance statistics for an operation
     */
    getStats(operation: string): {
        avg: number;
        min: number;
        max: number;
        count: number;
        p95: number;
    } | null;
    /**
     * Get all performance metrics
     */
    getAllStats(): Record<string, any>;
    /**
     * Clear all metrics
     */
    clear(): void;
    /**
     * Log performance report to console
     */
    logReport(): void;
}
/**
 * Debounce and throttle utilities
 */
export declare function debounce<T extends (...args: any[]) => any>(func: T, waitMs: number): (...args: Parameters<T>) => void;
export declare function throttle<T extends (...args: any[]) => any>(func: T, waitMs: number): (...args: Parameters<T>) => void;
/**
 * Memory usage monitoring
 */
export declare class MemoryMonitor {
    private static instance;
    private observers;
    static getInstance(): MemoryMonitor;
    /**
     * Get current memory usage
     */
    getMemoryUsage(): MemoryInfo | null;
    /**
     * Start monitoring memory usage
     */
    startMonitoring(intervalMs?: number): void;
    /**
     * Subscribe to memory updates
     */
    subscribe(observer: (usage: MemoryInfo) => void): () => void;
    /**
     * Check if memory usage is high
     */
    isMemoryHigh(): boolean;
}
interface MemoryInfo {
    totalJSHeapSize: number;
    usedJSHeapSize: number;
    jsHeapSizeLimit: number;
}
export {};
//# sourceMappingURL=chart-performance.d.ts.map