@webrtc2/utils/src/index.ts

WebRTC2 Utils - Cross-platform WebRTC utility functions for device detection, media management, error handling, and performance optimization

/**
 * @webrtc2/utils
 * 
 * Utility functions for WebRTC2 ecosystem
 */

// Device Detection Utils
export function isMobile(): boolean {
    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
}

export function isIOS(): boolean {
    return /iPad|iPhone|iPod/.test(navigator.userAgent);
}

export function isAndroid(): boolean {
    return /Android/.test(navigator.userAgent);
}

// Media Utils
export function getMediaDevices(): Promise<MediaDeviceInfo[]> {
    if (!navigator.mediaDevices?.enumerateDevices) {
        return Promise.reject(new Error('Media devices not supported'));
    }
    return navigator.mediaDevices.enumerateDevices();
}

export function getVideoDevices(): Promise<MediaDeviceInfo[]> {
    return getMediaDevices().then(devices =>
        devices.filter(device => device.kind === 'videoinput')
    );
}

export function getAudioDevices(): Promise<MediaDeviceInfo[]> {
    return getMediaDevices().then(devices =>
        devices.filter(device => device.kind === 'audioinput')
    );
}

// Stream Utils
export function stopMediaStream(stream: MediaStream | null): void {
    if (!stream) return;

    stream.getTracks().forEach(track => {
        track.stop();
    });
}

export function muteStream(stream: MediaStream, muted: boolean): void {
    stream.getAudioTracks().forEach(track => {
        track.enabled = !muted;
    });
}

export function toggleVideo(stream: MediaStream, enabled: boolean): void {
    stream.getVideoTracks().forEach(track => {
        track.enabled = enabled;
    });
}

// URL Utils
export function generateRoomId(): string {
    return Math.random().toString(36).substring(2, 15) +
        Math.random().toString(36).substring(2, 15);
}

export function isValidRoomId(roomId: string): boolean {
    return /^[a-zA-Z0-9]{8,32}$/.test(roomId);
}

// Error Utils
export class WebRTCError extends Error {
    constructor(
        message: string,
        public code: string,
        public details?: any
    ) {
        super(message);
        this.name = 'WebRTCError';
    }
}

export function createError(code: string, message: string, details?: any): WebRTCError {
    return new WebRTCError(message, code, details);
}

// Performance Utils
export function measureLatency(startTime: number): number {
    return performance.now() - startTime;
}

export function debounce<T extends (...args: any[]) => any>(
    func: T,
    wait: number
): (...args: Parameters<T>) => void {
    let timeout: ReturnType<typeof setTimeout>;
    return (...args: Parameters<T>) => {
        clearTimeout(timeout);
        timeout = setTimeout(() => func(...args), wait);
    };
}

export const VERSION = '1.0.0';