@umituz/react-native-sound 1.2.31 → 1.2.33

package/src/presentation/useSound.ts

@@ -0,0 +1,183 @@
+/**
+ * useSound Hook - Event-Driven with Proper Lifecycle Management
+ * Single hook for all sound functionality
+ */
+
+import { useEffect, useCallback, useRef } from 'react';
+import { useSoundStore, setupEventListeners } from './SoundStore';
+import { SoundService } from '../application/SoundService';
+import type { SoundSourceValue } from '../domain/value-objects';
+import type { PlaybackOptions } from '../types';
+import { Logger } from '../infrastructure/Logger';
+
+let serviceInstance: SoundService | null = null;
+let serviceRefCount = 0;
+let cleanupEventListeners: (() => void) | null = null;
+
+const getService = (): SoundService => {
+    if (!serviceInstance) {
+        serviceInstance = SoundService.getInstance();
+        // Access events through public API
+        cleanupEventListeners = setupEventListeners(serviceInstance.getEvents());
+    }
+    serviceRefCount++;
+    return serviceInstance;
+};
+
+const releaseService = async (): Promise<void> => {
+    serviceRefCount--;
+    if (serviceRefCount <= 0 && serviceInstance) {
+        try {
+            await serviceInstance.dispose();
+        } catch (error) {
+            Logger.warn('Error during service cleanup', error);
+        }
+        cleanupEventListeners?.();
+        cleanupEventListeners = null;
+        serviceInstance = null;
+        serviceRefCount = 0;
+    }
+};
+
+export const useSound = () => {
+    const state = useSoundStore();
+    const serviceRef = useRef<SoundService | null>(null);
+    const isMountedRef = useRef(true);
+
+    // Initialize service on mount
+    useEffect(() => {
+        serviceRef.current = getService();
+        isMountedRef.current = true;
+
+        return () => {
+            isMountedRef.current = false;
+            // Don't await in cleanup - fire and forget
+            releaseService().catch((error) => Logger.warn('Error in useSound cleanup', error));
+        };
+    }, []);
+
+    // Memoize all functions to prevent re-renders
+    const play = useCallback(
+        (id: string, source: SoundSourceValue, options?: PlaybackOptions) => {
+            if (isMountedRef.current && serviceRef.current) {
+                return serviceRef.current.play(id, source, options);
+            }
+        },
+        []
+    );
+
+    const pause = useCallback(() => {
+        if (isMountedRef.current && serviceRef.current) {
+            return serviceRef.current.pause();
+        }
+    }, []);
+
+    const resume = useCallback(() => {
+        if (isMountedRef.current && serviceRef.current) {
+            return serviceRef.current.resume();
+        }
+    }, []);
+
+    const stop = useCallback(() => {
+        if (isMountedRef.current && serviceRef.current) {
+            return serviceRef.current.stop();
+        }
+    }, []);
+
+    const seek = useCallback(
+        (positionMillis: number) => {
+            if (isMountedRef.current && serviceRef.current) {
+                return serviceRef.current.seek(positionMillis);
+            }
+        },
+        []
+    );
+
+    const setVolume = useCallback(
+        (volume: number) => {
+            if (isMountedRef.current && serviceRef.current) {
+                return serviceRef.current.setVolume(volume);
+            }
+        },
+        []
+    );
+
+    const setRate = useCallback(
+        (rate: number) => {
+            if (isMountedRef.current && serviceRef.current) {
+                return serviceRef.current.setRate(rate);
+            }
+        },
+        []
+    );
+
+    const preload = useCallback(
+        (id: string, source: SoundSourceValue, options?: PlaybackOptions) => {
+            if (isMountedRef.current && serviceRef.current) {
+                return serviceRef.current.preload(id, source, options);
+            }
+        },
+        []
+    );
+
+    const unload = useCallback(() => {
+        if (isMountedRef.current && serviceRef.current) {
+            return serviceRef.current.unload();
+        }
+    }, []);
+
+    const clearCache = useCallback(async () => {
+        if (isMountedRef.current && serviceRef.current) {
+            await serviceRef.current.clearCache();
+        }
+    }, []);
+
+    const isCached = useCallback(
+        (id: string) => {
+            if (serviceRef.current) {
+                return serviceRef.current.isCached(id);
+            }
+            return false;
+        },
+        []
+    );
+
+    const subscribe = useCallback(
+        (eventType: string, listener: (payload: unknown) => void) => {
+            if (serviceRef.current) {
+                return serviceRef.current.on(eventType, listener);
+            }
+            return () => {};
+        },
+        []
+    );
+
+    return {
+        // State
+        isPlaying: state.isPlaying,
+        isBuffering: state.isBuffering,
+        isLooping: state.isLooping,
+        position: state.positionMillis,
+        duration: state.durationMillis,
+        currentId: state.currentId,
+        error: state.error,
+        volume: state.volume,
+        rate: state.rate,
+
+        // Actions (memoized)
+        play,
+        pause,
+        resume,
+        stop,
+        seek,
+        setVolume,
+        setRate,
+        preload,
+        unload,
+        clearCache,
+        isCached,
+
+        // Advanced: Event subscription
+        on: subscribe,
+    };
+};

package/src/types.ts

@@ -1,10 +1,8 @@
 /**
- * @umituz/react-native-sound Types
+ * Public Types
  */
 
-import { AVPlaybackStatus } from 'expo-av';
-
-export type SoundSource = number | { uri: string; headers?: Record<string, string> } | null;
+export type { SoundSourceValue } from './domain/value-objects';
 
 export interface PlaybackOptions {
     isLooping?: boolean;
@@ -22,6 +20,8 @@ export interface SoundState {
     rate: number;
     isLooping: boolean;
     error: string | null;
-    currentSource: SoundSource | null;
+    currentSource: any;
     currentId: string | null;
 }
+
+export type SoundSource = number | { uri: string; headers?: Record<string, string> } | null;

package/src/utils.ts

@@ -1,30 +1,188 @@
 /**
- * @umituz/react-native-sound Utility Functions
+ * Utility Functions - Backward Compatibility + Performance Utilities
  */
 
-import { AVPlaybackStatus, AVPlaybackStatusSuccess } from 'expo-av';
-import type { SoundSource } from './types';
+import { Volume } from './domain/value-objects';
+import { Rate } from './domain/value-objects';
+import type { PlaybackStatus } from './application/interfaces/IAudioService';
+import { Logger } from './infrastructure/Logger';
 
-type PlaybackStatusSuccess = AVPlaybackStatusSuccess;
+// ===== Backward Compatibility Functions =====
 
-export function isPlaybackStatusSuccess(status: AVPlaybackStatus): status is PlaybackStatusSuccess {
-    return status.isLoaded;
+export function clampVolume(volume: number): number {
+    return new Volume(volume).getValue();
+}
+
+export function clampRate(rate: number): number {
+    return new Rate(rate).getValue();
+}
+
+export function validateSoundId(id: string): boolean {
+    return typeof id === 'string' && id.trim().length > 0;
 }
 
-export function isSoundSourceValid(source: SoundSource): source is number | { uri: string; headers?: Record<string, string> } {
+export function isSoundSourceValid(source: unknown): boolean {
     return source !== null && source !== undefined;
 }
 
-export function clampVolume(volume: number): number {
-    if (!Number.isFinite(volume)) return 1.0;
-    return Math.max(0, Math.min(1, volume));
+export function isPlaybackStatusSuccess(status: PlaybackStatus): boolean {
+    return status.isLoaded === true;
 }
 
-export function clampRate(rate: number): number {
-    if (!Number.isFinite(rate)) return 1.0;
-    return Math.max(0.5, Math.min(2.0, rate));
+// ===== Performance Utilities =====
+
+/**
+ * Debounce function to limit execution frequency
+ * @param func Function to debounce
+ * @param wait Wait time in milliseconds
+ * @returns Debounced function
+ */
+export function debounce<T extends (...args: unknown[]) => unknown>(
+    func: T,
+    wait: number
+): (...args: Parameters<T>) => void {
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
+
+    return function (this: unknown, ...args: Parameters<T>) {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+
+        timeoutId = setTimeout(() => {
+            func.apply(this, args);
+            timeoutId = null;
+        }, wait);
+    };
 }
 
-export function validateSoundId(id: string): boolean {
-    return typeof id === 'string' && id.trim().length > 0;
+/**
+ * Throttle function to limit execution frequency
+ * @param func Function to throttle
+ * @param limit Time limit in milliseconds
+ * @returns Throttled function
+ */
+export function throttle<T extends (...args: unknown[]) => unknown>(
+    func: T,
+    limit: number
+): (...args: Parameters<T>) => void {
+    let inThrottle = false;
+    let lastArgs: Parameters<T> | null = null;
+    let lastContext: unknown = null;
+
+    return function (this: unknown, ...args: Parameters<T>) {
+        if (!inThrottle) {
+            func.apply(this, args);
+            inThrottle = true;
+            setTimeout(() => {
+                inThrottle = false;
+                if (lastArgs) {
+                    func.apply(lastContext, lastArgs);
+                    lastArgs = null;
+                    lastContext = null;
+                }
+            }, limit);
+        } else {
+            lastArgs = args;
+            lastContext = this;
+        }
+    };
+}
+
+/**
+ * Memory-safe rate limiter for periodic operations
+ */
+export class RateLimiter {
+    private lastExecution = 0;
+    private pendingExecution: (() => void) | null = null;
+
+    constructor(private readonly minInterval: number) {}
+
+    async execute(fn: () => void | Promise<void>): Promise<void> {
+        const now = Date.now();
+        const timeSinceLastExecution = now - this.lastExecution;
+
+        if (timeSinceLastExecution >= this.minInterval) {
+            this.lastExecution = now;
+            await fn();
+        } else {
+            // Schedule for later if not already pending
+            if (!this.pendingExecution) {
+                this.pendingExecution = fn;
+                const delay = this.minInterval - timeSinceLastExecution;
+                setTimeout(async () => {
+                    if (this.pendingExecution) {
+                        await this.pendingExecution();
+                        this.pendingExecution = null;
+                    }
+                    this.lastExecution = Date.now();
+                }, delay);
+            }
+        }
+    }
+
+    clearPending(): void {
+        this.pendingExecution = null;
+    }
 }
+
+/**
+ * Memory-safe periodic task scheduler
+ */
+export class PeriodicTask {
+    private timerId: ReturnType<typeof setInterval> | null = null;
+    private isRunning = false;
+
+    constructor(
+        private readonly task: () => void | Promise<void>,
+        private readonly interval: number
+    ) {}
+
+    start(): void {
+        if (this.isRunning) return;
+
+        this.isRunning = true;
+        this.timerId = setInterval(async () => {
+            try {
+                await this.task();
+            } catch (error) {
+                Logger.error('Periodic task error', error);
+            }
+        }, this.interval);
+    }
+
+    stop(): void {
+        if (this.timerId) {
+            clearInterval(this.timerId);
+            this.timerId = null;
+        }
+        this.isRunning = false;
+    }
+
+    isActive(): boolean {
+        return this.isRunning;
+    }
+}
+
+/**
+ * WeakMap-based cache for automatic garbage collection
+ */
+export class AutoGCWeakCache<K extends object, V> {
+    private cache = new WeakMap<K, V>();
+
+    set(key: K, value: V): void {
+        this.cache.set(key, value);
+    }
+
+    get(key: K): V | undefined {
+        return this.cache.get(key);
+    }
+
+    has(key: K): boolean {
+        return this.cache.has(key);
+    }
+
+    delete(key: K): boolean {
+        return this.cache.delete(key);
+    }
+}
+