murmuraba/dist/__tests__/utils/factories.d.ts

Real-time audio noise reduction with advanced chunked processing for web applications

import type { ChunkData, ProcessingMetrics } from '../../types';
type ProcessedChunk = ChunkData;
type EngineMetrics = ProcessingMetrics;
/**
 * Test data factories for creating consistent test objects
 * Eliminates duplication of test data creation across test files
 */
export interface VADData {
    time: number;
    vad: number;
}
export declare class VADDataFactory {
    static create(time: number, vad: number): VADData;
    static createSequence(count: number, baseVad?: number): VADData[];
    static createSpeechPattern(): VADData[];
}
export declare class MetricsFactory {
    static create(overrides?: Partial<EngineMetrics>): EngineMetrics;
    static createHighPerformance(): EngineMetrics;
    static createLowPerformance(): EngineMetrics;
}
export declare class ChunkFactory {
    private static idCounter;
    static reset(): void;
    static create(overrides?: Partial<ProcessedChunk>): ProcessedChunk;
    static createWithVAD(averageVad: number, id?: string): ProcessedChunk;
    static createWithSpeech(): ProcessedChunk;
    static createInvalid(): ProcessedChunk;
    static createPlaying(): ProcessedChunk;
    static createExpanded(): ProcessedChunk;
    static createBatch(count: number): ProcessedChunk[];
    static createSequence(options: {
        count: number;
        startTime?: number;
        duration?: number;
    }): ProcessedChunk[];
}
export declare class MediaStreamFactory {
    static create(options?: {
        audio?: boolean;
        video?: boolean;
        id?: string;
    }): {
        id: string;
        active: boolean;
        getTracks: import("vitest").Mock<() => any[]>;
        getAudioTracks: import("vitest").Mock<() => any[]>;
        getVideoTracks: import("vitest").Mock<() => any[]>;
        addTrack: import("vitest").Mock<(...args: any[]) => any>;
        removeTrack: import("vitest").Mock<(...args: any[]) => any>;
        clone: import("vitest").Mock<(...args: any[]) => any>;
        getTrackById: import("vitest").Mock<(...args: any[]) => any>;
        addEventListener: import("vitest").Mock<(...args: any[]) => any>;
        removeEventListener: import("vitest").Mock<(...args: any[]) => any>;
        dispatchEvent: import("vitest").Mock<(...args: any[]) => any>;
        onaddtrack: null;
        onremovetrack: null;
    };
    static createAudioTrack(options?: Partial<MediaStreamTrack>): {
        contentHint?: string | undefined;
        enabled: boolean;
        id: string;
        kind: string;
        label: string;
        muted: boolean;
        onended?: ((this: MediaStreamTrack, ev: Event) => any) | null | undefined;
        onmute?: ((this: MediaStreamTrack, ev: Event) => any) | null | undefined;
        onunmute?: ((this: MediaStreamTrack, ev: Event) => any) | null | undefined;
        readyState: MediaStreamTrackState;
        applyConstraints: import("vitest").Mock<(...args: any[]) => any> | ((constraints?: MediaTrackConstraints) => Promise<void>);
        clone: import("vitest").Mock<(...args: any[]) => any> | (() => MediaStreamTrack);
        getCapabilities: (() => MediaTrackCapabilities) | import("vitest").Mock<() => {
            channelCount: {
                min: number;
                max: number;
            };
            echoCancellation: boolean[];
            noiseSuppression: boolean[];
            sampleRate: {
                min: number;
                max: number;
            };
            sampleSize: {
                min: number;
                max: number;
            };
        }>;
        getConstraints: (() => MediaTrackConstraints) | import("vitest").Mock<() => {}>;
        getSettings: (() => MediaTrackSettings) | import("vitest").Mock<() => {
            deviceId: string;
            groupId: string;
            echoCancellation: boolean;
            noiseSuppression: boolean;
            autoGainControl: boolean;
            channelCount: number;
            sampleRate: number;
            sampleSize: number;
        }>;
        stop: (() => void) | import("vitest").Mock<(...args: any[]) => any>;
        addEventListener: import("vitest").Mock<(...args: any[]) => any> | {
            <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        };
        removeEventListener: import("vitest").Mock<(...args: any[]) => any> | {
            <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
        };
        dispatchEvent: ((event: Event) => boolean) | import("vitest").Mock<(...args: any[]) => any>;
    };
    static createVideoTrack(options?: Partial<MediaStreamTrack>): {
        kind: "video";
        label: string;
        getCapabilities: import("vitest").Mock<() => {
            width: {
                min: number;
                max: number;
            };
            height: {
                min: number;
                max: number;
            };
            frameRate: {
                min: number;
                max: number;
            };
            facingMode: string[];
        }>;
        getSettings: import("vitest").Mock<() => {
            deviceId: string;
            groupId: string;
            width: number;
            height: number;
            frameRate: number;
            facingMode: string;
        }>;
        contentHint?: string | undefined;
        enabled: boolean;
        id: string;
        muted: boolean;
        onended?: ((this: MediaStreamTrack, ev: Event) => any) | null | undefined;
        onmute?: ((this: MediaStreamTrack, ev: Event) => any) | null | undefined;
        onunmute?: ((this: MediaStreamTrack, ev: Event) => any) | null | undefined;
        readyState: MediaStreamTrackState;
        applyConstraints: import("vitest").Mock<(...args: any[]) => any> | ((constraints?: MediaTrackConstraints) => Promise<void>);
        clone: import("vitest").Mock<(...args: any[]) => any> | (() => MediaStreamTrack);
        getConstraints: (() => MediaTrackConstraints) | import("vitest").Mock<() => {}>;
        stop: (() => void) | import("vitest").Mock<(...args: any[]) => any>;
        addEventListener: import("vitest").Mock<(...args: any[]) => any> | {
            <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
        };
        removeEventListener: import("vitest").Mock<(...args: any[]) => any> | {
            <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
        };
        dispatchEvent: ((event: Event) => boolean) | import("vitest").Mock<(...args: any[]) => any>;
    };
    static createInactiveStream(): {
        id: string;
        active: boolean;
        getTracks: import("vitest").Mock<() => any[]>;
        getAudioTracks: import("vitest").Mock<() => any[]>;
        getVideoTracks: import("vitest").Mock<() => any[]>;
        addTrack: import("vitest").Mock<(...args: any[]) => any>;
        removeTrack: import("vitest").Mock<(...args: any[]) => any>;
        clone: import("vitest").Mock<(...args: any[]) => any>;
        getTrackById: import("vitest").Mock<(...args: any[]) => any>;
        addEventListener: import("vitest").Mock<(...args: any[]) => any>;
        removeEventListener: import("vitest").Mock<(...args: any[]) => any>;
        dispatchEvent: import("vitest").Mock<(...args: any[]) => any>;
        onaddtrack: null;
        onremovetrack: null;
    };
}
export declare class AudioBufferFactory {
    static create(options?: {
        numberOfChannels?: number;
        length?: number;
        sampleRate?: number;
        fillWith?: 'silence' | 'sine' | 'noise' | 'custom';
        customData?: Float32Array;
    }): {
        numberOfChannels: number;
        length: number;
        sampleRate: number;
        duration: number;
        getChannelData: import("vitest").Mock<(channel: number) => Float32Array<ArrayBufferLike>>;
        copyFromChannel: import("vitest").Mock<(...args: any[]) => any>;
        copyToChannel: import("vitest").Mock<(...args: any[]) => any>;
    };
    private static generateChannelData;
}
export declare class WASMModuleFactory {
    static create(options?: {
        rnnoiseState?: number;
        vadProbability?: number;
        memorySize?: number;
    }): {
        _rnnoise_create: import("vitest").Mock<(...args: any[]) => any>;
        _rnnoise_destroy: import("vitest").Mock<(...args: any[]) => any>;
        _rnnoise_process_frame: import("vitest").Mock<(...args: any[]) => any>;
        _malloc: import("vitest").Mock<(size: number) => number>;
        _free: import("vitest").Mock<(...args: any[]) => any>;
        HEAPF32: Float32Array<ArrayBuffer>;
        HEAP32: Int32Array<ArrayBuffer>;
        HEAPU8: Uint8Array<ArrayBuffer>;
        HEAPU32: Uint32Array<ArrayBuffer>;
    };
    static createWithError(): {
        _rnnoise_create: import("vitest").Mock<(...args: any[]) => any>;
        _rnnoise_destroy: import("vitest").Mock<(...args: any[]) => any>;
        _rnnoise_process_frame: import("vitest").Mock<(...args: any[]) => any>;
        _malloc: import("vitest").Mock<(...args: any[]) => any>;
        _free: import("vitest").Mock<(...args: any[]) => any>;
        HEAPF32: Float32Array<ArrayBuffer>;
        HEAP32: Int32Array<ArrayBuffer>;
        HEAPU8: Uint8Array<ArrayBuffer>;
        HEAPU32: Uint32Array<ArrayBuffer>;
    };
}
export declare class BlobFactory {
    static createAudioBlob(sizeInKB?: number, mimeType?: string): Blob;
    static createVideoBlob(sizeInKB?: number, mimeType?: string): Blob;
    static createTextBlob(content: string): Blob;
}
export {};
//# sourceMappingURL=factories.d.ts.map