compresswave/dist/index.d.ts

🌊 Powerful file compression library that runs entirely in the browser. No uploads, no servers, complete privacy.

interface CompressionOptions {
    preset?: 'web' | 'mobile' | 'social' | 'email' | 'custom';
    quality?: number;
    onProgress?: (progress: number) => void;
    onComplete?: (result: CompressionResult) => void;
    onError?: (error: Error) => void;
}
interface VideoCompressionOptions extends CompressionOptions {
    codec?: 'h264' | 'h265' | 'vp8' | 'vp9' | 'av1';
    crf?: number;
    bitrate?: string;
    framerate?: number;
    resolution?: {
        width: number;
        height: number;
    };
    audio?: {
        codec?: 'aac' | 'mp3' | 'opus';
        bitrate?: string;
        sampleRate?: number;
    };
}
interface ImageOptimizationOptions extends CompressionOptions {
    format?: 'auto' | 'jpeg' | 'png' | 'webp' | 'avif';
    maxWidth?: number;
    maxHeight?: number;
    progressive?: boolean;
    preserveExif?: boolean;
}
interface CompressionResult {
    originalSize: number;
    compressedSize: number;
    compressionRatio: number;
    processingTime: number;
    blob: Blob;
    url: string;
}
interface BatchProcessingOptions {
    concurrency?: number;
    onFileStart?: (file: File, index: number) => void;
    onFileComplete?: (file: File, result: CompressionResult, index: number) => void;
    onFileError?: (file: File, error: Error, index: number) => void;
    onAllComplete?: (results: CompressionResult[]) => void;
}
type CompressionPreset = {
    name: string;
    video?: Partial<VideoCompressionOptions>;
    image?: Partial<ImageOptimizationOptions>;
};

declare class VideoCompressor {
    private ffmpeg;
    private options;
    constructor(options?: VideoCompressionOptions);
    private setupFFmpeg;
    compress(file: File): Promise<CompressionResult>;
    private buildFFmpegCommand;
    terminate(): Promise<void>;
}

declare class ImageOptimizer {
    private options;
    constructor(options?: ImageOptimizationOptions);
    process(file: File): Promise<CompressionResult>;
    private getOutputFormat;
    private getMimeType;
    processMultiple(files: File[]): Promise<CompressionResult[]>;
    resize(file: File, width: number, height: number): Promise<CompressionResult>;
    convertFormat(file: File, format: 'jpeg' | 'png' | 'webp' | 'avif'): Promise<CompressionResult>;
}

declare class BatchProcessor {
    private options;
    private videoCompressor?;
    private imageOptimizer?;
    constructor(options?: BatchProcessingOptions);
    compressFiles(files: File[], videoOptions?: VideoCompressionOptions, imageOptions?: ImageOptimizationOptions): Promise<CompressionResult[]>;
    private processFile;
    private createBatches;
    private cleanup;
    compressVideos(files: File[], options?: VideoCompressionOptions): Promise<CompressionResult[]>;
    optimizeImages(files: File[], options?: ImageOptimizationOptions): Promise<CompressionResult[]>;
    static analyzeFiles(files: File[]): {
        totalSize: number;
        videoCount: number;
        imageCount: number;
        otherCount: number;
        types: Record<string, number>;
    };
}

declare const COMPRESSION_PRESETS: Record<string, CompressionPreset>;
declare function getPreset(presetName: string): CompressionPreset | undefined;
declare function listPresets(): string[];

export { BatchProcessor, COMPRESSION_PRESETS, ImageOptimizer, VideoCompressor, getPreset, listPresets };
export type { BatchProcessingOptions, CompressionOptions, CompressionPreset, CompressionResult, ImageOptimizationOptions, VideoCompressionOptions };