cs-element/dist/workers/plugins/CompressionPlugin.d.ts

Advanced reactive data management library with state machines, blueprints, persistence, compression, networking, and multithreading support

import { CSElementPlugin } from '../types/plugin-interfaces';
import { CSElement } from '../core/CSElement';
export interface PluginContext {
    element: CSElement;
    operation: string;
    [key: string]: any;
}
export interface PluginResult {
    success: boolean;
    data?: any;
    error?: string;
    [key: string]: any;
}
export declare enum CompressionAlgorithm {
    GZIP = "gzip",
    DEFLATE = "deflate",
    BROTLI = "brotli",
    LZ4 = "lz4",
    ZSTD = "zstd",
    SNAPPY = "snappy"
}
export declare enum CompressionLevel {
    FASTEST = 1,
    FAST = 3,
    BALANCED = 6,
    BEST = 9
}
export declare enum CompressionMode {
    AUTOMATIC = "automatic",
    MANUAL = "manual",
    THRESHOLD_BASED = "threshold_based",
    SELECTIVE = "selective"
}
export declare enum DataType {
    JSON = "json",
    TEXT = "text",
    BINARY = "binary",
    IMAGE = "image",
    AUDIO = "audio",
    VIDEO = "video"
}
export interface CompressionResult {
    originalSize: number;
    compressedSize: number;
    compressionRatio: number;
    algorithm: CompressionAlgorithm;
    level: CompressionLevel;
    duration: number;
    checksum: string;
    metadata: Record<string, any>;
}
export interface CompressionOptions {
    algorithm: CompressionAlgorithm;
    level: CompressionLevel;
    dictionary?: Buffer;
    windowSize?: number;
    memoryLevel?: number;
    strategy?: number;
    chunkSize?: number;
    validateChecksum?: boolean;
}
export interface CompressionRule {
    id: string;
    name: string;
    description?: string;
    enabled: boolean;
    priority: number;
    conditions: CompressionCondition[];
    algorithm: CompressionAlgorithm;
    level: CompressionLevel;
    options?: Partial<CompressionOptions>;
    createdAt: Date;
    updatedAt: Date;
}
export interface CompressionCondition {
    type: 'size' | 'dataType' | 'elementType' | 'custom';
    operator: 'greater' | 'less' | 'equals' | 'contains' | 'matches';
    value: any;
    field?: string;
}
export interface CompressionProfile {
    id: string;
    name: string;
    description?: string;
    dataTypes: DataType[];
    algorithm: CompressionAlgorithm;
    level: CompressionLevel;
    options: CompressionOptions;
    isDefault: boolean;
    benchmarkResults?: BenchmarkResult[];
}
export interface BenchmarkResult {
    dataSize: number;
    dataType: DataType;
    algorithm: CompressionAlgorithm;
    level: CompressionLevel;
    compressionRatio: number;
    compressionTime: number;
    decompressionTime: number;
    memoryUsage: number;
    timestamp: Date;
}
export interface CompressionJob {
    id: string;
    elementId: string;
    status: 'pending' | 'processing' | 'completed' | 'failed';
    algorithm: CompressionAlgorithm;
    level: CompressionLevel;
    startTime: Date;
    endTime?: Date;
    originalSize: number;
    compressedSize?: number;
    error?: string;
    result?: CompressionResult;
}
export interface CompressionCache {
    key: string;
    data: Buffer;
    algorithm: CompressionAlgorithm;
    level: CompressionLevel;
    checksum: string;
    createdAt: Date;
    lastAccessed: Date;
    accessCount: number;
    size: number;
}
export interface CompressionPluginConfig {
    enabled?: boolean;
    priority?: number;
    defaultAlgorithm: CompressionAlgorithm;
    defaultLevel: CompressionLevel;
    mode: CompressionMode;
    autoCompress: boolean;
    compressionThreshold: number;
    maxCompressionJobs: number;
    enableCaching: boolean;
    cacheSize: number;
    cacheTTL: number;
    enableBenchmarking: boolean;
    validateChecksums: boolean;
    enableStatistics: boolean;
    blacklistedDataTypes: DataType[];
    whitelistedDataTypes: DataType[];
}
export interface CompressionStats {
    totalCompressions: number;
    totalDecompressions: number;
    totalOriginalSize: number;
    totalCompressedSize: number;
    averageCompressionRatio: number;
    averageCompressionTime: number;
    averageDecompressionTime: number;
    compressionsByAlgorithm: Record<CompressionAlgorithm, number>;
    compressionsByLevel: Record<CompressionLevel, number>;
    cacheHits: number;
    cacheMisses: number;
    cacheHitRatio: number;
    activeJobs: number;
    failedCompressions: number;
    savedSpace: number;
    lastCompressionTime?: Date;
    bestCompressionRatio: number;
    worstCompressionRatio: number;
}
export declare class CompressionPlugin implements CSElementPlugin {
    readonly name = "CompressionPlugin";
    readonly version = "1.0.0";
    readonly description = "\u041F\u043B\u0430\u0433\u0438\u043D \u0434\u043B\u044F \u0441\u0436\u0430\u0442\u0438\u044F \u0434\u0430\u043D\u043D\u044B\u0445 \u0438 \u043E\u043F\u0442\u0438\u043C\u0438\u0437\u0430\u0446\u0438\u0438 \u043F\u0430\u043C\u044F\u0442\u0438";
    private config;
    private rules;
    private profiles;
    private jobs;
    private cache;
    private stats;
    private compressedElements;
    constructor(config?: Partial<CompressionPluginConfig>);
    install(_CSElementClass: typeof CSElement): void;
    initialize(): Promise<void>;
    destroy(): Promise<void>;
    getConfig(): CompressionPluginConfig;
    updateConfig(newConfig: Partial<CompressionPluginConfig>): void;
    afterCreate(element: CSElement, _context: PluginContext): Promise<PluginResult>;
    afterUpdate(element: CSElement, _context: PluginContext): Promise<PluginResult>;
    beforeRead(element: CSElement, _context: PluginContext): Promise<PluginResult>;
    compressData(data: Buffer | string, options?: Partial<CompressionOptions>): Promise<CompressionResult>;
    decompressData(compressedData: Buffer, algorithm: CompressionAlgorithm, expectedChecksum?: string): Promise<Buffer>;
    compressElement(element: CSElement): Promise<CompressionResult | null>;
    decompressElement(element: CSElement): Promise<boolean>;
    createProfile(profileData: Omit<CompressionProfile, 'id'>): CompressionProfile;
    getProfile(id: string): CompressionProfile | undefined;
    updateProfile(id: string, updates: Partial<CompressionProfile>): boolean;
    deleteProfile(id: string): boolean;
    addRule(ruleData: Omit<CompressionRule, 'id' | 'createdAt' | 'updatedAt'>): CompressionRule;
    getRule(id: string): CompressionRule | undefined;
    updateRule(id: string, updates: Partial<CompressionRule>): boolean;
    deleteRule(id: string): boolean;
    runBenchmark(data: Buffer, algorithms?: CompressionAlgorithm[], levels?: CompressionLevel[]): Promise<BenchmarkResult[]>;
    analyzeBestAlgorithm(data: Buffer): Promise<CompressionAlgorithm>;
    getCompressionRecommendations(element: CSElement): {
        algorithm: CompressionAlgorithm;
        level: CompressionLevel;
        expectedRatio: number;
        reason: string;
    };
    /**
     * Сериализация элемента для сжатия с использованием встроенной сериализации
     */
    private serializeElementForCompression;
    private shouldCompress;
    private isElementCompressed;
    private findMatchingRule;
    private evaluateRuleConditions;
    private evaluateCondition;
    private detectElementDataType;
    private detectDataType;
    private performCompression;
    private performDecompression;
    private generateCacheKey;
    private getCachedCompression;
    private cacheCompression;
    private createResultFromCache;
    private cleanupCache;
    private evictLeastRecentlyUsed;
    private getCurrentCacheSize;
    private updateCompressionStats;
    private updateStats;
    private initializeDefaultProfiles;
    private initializeDefaultRules;
    private calculateChecksum;
    private generateId;
    getStats(): CompressionStats;
    getAllProfiles(): CompressionProfile[];
    getAllRules(): CompressionRule[];
    getActiveJobs(): CompressionJob[];
    getCompressedElements(): Map<string, CompressionResult>;
    getCacheInfo(): {
        size: number;
        entries: number;
        hitRatio: number;
        totalSize: number;
    };
}
//# sourceMappingURL=CompressionPlugin.d.ts.map