@umituz/react-native-sound 1.2.32 → 1.2.34

package/src/utils.ts

@@ -1,9 +1,13 @@
 /**
- * Utility Functions - Backward Compatibility
+ * Utility Functions - Backward Compatibility + Performance Utilities
  */
 
-import { Volume } from './domain/value-objects/Volume';
-import { Rate } from './domain/value-objects/Rate';
+import { Volume } from './domain/value-objects';
+import { Rate } from './domain/value-objects';
+import type { PlaybackStatus } from './application/interfaces/IAudioService';
+import { Logger } from './infrastructure/Logger';
+
+// ===== Backward Compatibility Functions =====
 
 export function clampVolume(volume: number): number {
     return new Volume(volume).getValue();
@@ -17,10 +21,168 @@ export function validateSoundId(id: string): boolean {
     return typeof id === 'string' && id.trim().length > 0;
 }
 
-export function isSoundSourceValid(source: any): boolean {
+export function isSoundSourceValid(source: unknown): boolean {
     return source !== null && source !== undefined;
 }
 
-export function isPlaybackStatusSuccess(status: any): boolean {
+export function isPlaybackStatusSuccess(status: PlaybackStatus): boolean {
     return status.isLoaded === true;
 }
+
+// ===== 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);
+    };
+}
+
+/**
+ * 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);
+    }
+}
+

package/src/application/SoundServiceFacade.ts

@@ -1,112 +0,0 @@
-/**
- * Sound Service Facade - Simplified Interface
- */
-
-import { AudioConfig } from '../infrastructure/AudioConfig';
-import { ExpoAudioService } from '../infrastructure/ExpoAudioService';
-import { SoundCache } from '../infrastructure/SoundCache';
-import { SoundPresenter } from './presenters/SoundPresenter';
-import { PlaySoundUseCase } from './use-cases/PlaySoundUseCase';
-import { PauseSoundUseCase } from './use-cases/PauseSoundUseCase';
-import { ResumeSoundUseCase } from './use-cases/ResumeSoundUseCase';
-import { StopSoundUseCase } from './use-cases/StopSoundUseCase';
-import { SeekSoundUseCase } from './use-cases/SeekSoundUseCase';
-import { SetVolumeUseCase } from './use-cases/SetVolumeUseCase';
-import { SetRateUseCase } from './use-cases/SetRateUseCase';
-import { PreloadSoundUseCase } from './use-cases/PreloadSoundUseCase';
-import { ClearCacheUseCase } from './use-cases/ClearCacheUseCase';
-
-export class SoundServiceFacade {
-    private static instance: SoundServiceFacade | null = null;
-
-    private readonly audioService = new ExpoAudioService();
-    private readonly cache = new SoundCache(this.audioService);
-    private readonly presenter: SoundPresenter;
-
-    private readonly playUseCase: PlaySoundUseCase;
-    private readonly pauseUseCase: PauseSoundUseCase;
-    private readonly resumeUseCase: ResumeSoundUseCase;
-    private readonly stopUseCase: StopSoundUseCase;
-    private readonly seekUseCase: SeekSoundUseCase;
-    private readonly setVolumeUseCase: SetVolumeUseCase;
-    private readonly setRateUseCase: SetRateUseCase;
-    private readonly preloadUseCase: PreloadSoundUseCase;
-    private readonly clearCacheUseCase: ClearCacheUseCase;
-
-    private constructor(store: SoundPresenter['store']) {
-        AudioConfig.configure().catch(() => {});
-
-        this.presenter = new SoundPresenter(store);
-
-        this.playUseCase = new PlaySoundUseCase(this.audioService, this.cache, this.presenter);
-        this.pauseUseCase = new PauseSoundUseCase(this.audioService, this.presenter);
-        this.resumeUseCase = new ResumeSoundUseCase(this.audioService, this.presenter);
-        this.stopUseCase = new StopSoundUseCase(this.audioService, this.presenter);
-        this.seekUseCase = new SeekSoundUseCase(this.audioService);
-        this.setVolumeUseCase = new SetVolumeUseCase(this.audioService, this.presenter);
-        this.setRateUseCase = new SetRateUseCase(this.audioService, this.presenter);
-        this.preloadUseCase = new PreloadSoundUseCase(this.audioService, this.cache);
-        this.clearCacheUseCase = new ClearCacheUseCase(this.cache);
-    }
-
-    static create(store: SoundPresenter['store']): SoundServiceFacade {
-        if (!this.instance) {
-            this.instance = new SoundServiceFacade(store);
-        }
-        return this.instance;
-    }
-
-    async play(id: string, source: any, options?: any): Promise<void> {
-        await this.playUseCase.execute({ id, source, ...options });
-    }
-
-    async pause(): Promise<void> {
-        const sound = this.playUseCase.getCurrentSound();
-        await this.pauseUseCase.execute({ sound });
-    }
-
-    async resume(): Promise<void> {
-        const sound = this.playUseCase.getCurrentSound();
-        await this.resumeUseCase.execute({ sound });
-    }
-
-    async stop(): Promise<void> {
-        const sound = this.playUseCase.getCurrentSound();
-        await this.stopUseCase.execute({ sound });
-    }
-
-    async seek(positionMillis: number): Promise<void> {
-        const sound = this.playUseCase.getCurrentSound();
-        await this.seekUseCase.execute({ sound, positionMillis });
-    }
-
-    async setVolume(volume: number): Promise<void> {
-        const sound = this.playUseCase.getCurrentSound();
-        await this.setVolumeUseCase.execute({ sound, volume });
-    }
-
-    async setRate(rate: number): Promise<void> {
-        const sound = this.playUseCase.getCurrentSound();
-        await this.setRateUseCase.execute({ sound, rate });
-    }
-
-    async preload(id: string, source: any, options?: any): Promise<void> {
-        await this.preloadUseCase.execute({ id, source, ...options });
-    }
-
-    async unload(): Promise<void> {
-        await this.playUseCase.unload();
-    }
-
-    clearCache(): void {
-        this.clearCacheUseCase.execute();
-    }
-
-    isCached(id: string): boolean {
-        return this.cache.has(id);
-    }
-
-    getCurrentId(): string | null {
-        return this.playUseCase.getCurrentId();
-    }
-}

package/src/application/presenters/SoundPresenter.ts

@@ -1,78 +0,0 @@
-/**
- * Sound Presenter - Manages Store Updates
- */
-
-import { PlaybackStatus } from '../interfaces/IAudioService';
-import { SoundSourceValue } from '../../domain/value-objects/SoundSource';
-import { Logger } from '../../infrastructure/Logger';
-
-export interface SoundStore {
-    setPlaying: (isPlaying: boolean) => void;
-    setBuffering: (isBuffering: boolean) => void;
-    setProgress: (position: number, duration: number) => void;
-    setError: (error: string | null) => void;
-    setCurrent: (id: string | null, source: SoundSourceValue | null) => void;
-    setVolumeState: (volume: number) => void;
-    setRateState: (rate: number) => void;
-    setLooping: (isLooping: boolean) => void;
-    reset: () => void;
-}
-
-export class SoundPresenter {
-    constructor(private readonly store: SoundStore) {}
-
-    onPlaybackUpdate(status: PlaybackStatus): void {
-        if (!status.isLoaded && status.error) {
-            this.store.setError(status.error);
-            this.store.setPlaying(false);
-            return;
-        }
-
-        if (status.isLoaded) {
-            this.store.setPlaying(status.isPlaying);
-            this.store.setBuffering(status.isBuffering);
-            this.store.setProgress(status.positionMillis, status.durationMillis);
-
-            if (status.rate !== undefined) {
-                this.store.setRateState(status.rate);
-            }
-
-            if (status.didJustFinish && !status.isLooping) {
-                this.store.setPlaying(false);
-                this.store.setProgress(status.durationMillis, status.durationMillis);
-            }
-        }
-    }
-
-    onPlaybackStart(id: string, source: SoundSourceValue, options: { volume: number; rate: number; isLooping: boolean }): void {
-        this.store.setCurrent(id, source);
-        this.store.setError(null);
-        this.store.setVolumeState(options.volume);
-        this.store.setRateState(options.rate);
-        this.store.setLooping(options.isLooping);
-        Logger.debug(`Playback started: ${id}`);
-    }
-
-    onPlaybackError(error: string): void {
-        this.store.setError(error);
-        Logger.error('Playback error', error);
-    }
-
-    onPlaybackStop(): void {
-        this.store.setPlaying(false);
-        Logger.debug('Playback stopped');
-    }
-
-    onVolumeChange(volume: number): void {
-        this.store.setVolumeState(volume);
-    }
-
-    onRateChange(rate: number): void {
-        this.store.setRateState(rate);
-    }
-
-    onReset(): void {
-        this.store.reset();
-        Logger.debug('State reset');
-    }
-}

package/src/application/use-cases/BaseUseCase.ts

@@ -1,36 +0,0 @@
-/**
- * Base Use Case - Common Error Handling
- */
-
-import { SoundError } from '../../domain/errors/SoundError';
-import { Logger } from '../../infrastructure/Logger';
-
-export abstract class BaseUseCase<TInput, TOutput> {
-    async execute(input: TInput): Promise<TOutput> {
-        try {
-            return await this.executeImpl(input);
-        } catch (error) {
-            if (error instanceof SoundError) {
-                throw error;
-            }
-            throw SoundError.playbackFailed(error);
-        }
-    }
-
-    protected abstract executeImpl(input: TInput): Promise<TOutput>;
-}
-
-export abstract class BaseVoidUseCase<TInput> {
-    async execute(input: TInput): Promise<void> {
-        try {
-            await this.executeImpl(input);
-        } catch (error) {
-            if (error instanceof SoundError) {
-                throw error;
-            }
-            throw SoundError.playbackFailed(error);
-        }
-    }
-
-    protected abstract executeImpl(input: TInput): Promise<void>;
-}

package/src/application/use-cases/ClearCacheUseCase.ts

@@ -1,16 +0,0 @@
-/**
- * Clear Cache Use Case
- */
-
-import { BaseVoidUseCase } from './BaseUseCase';
-import type { ISoundCache } from '../interfaces/ISoundCache';
-
-export class ClearCacheUseCase extends BaseVoidUseCase<void> {
-    constructor(private readonly cache: ISoundCache) {
-        super();
-    }
-
-    protected async executeImpl(): Promise<void> {
-        this.cache.clear();
-    }
-}

package/src/application/use-cases/PauseSoundUseCase.ts

@@ -1,26 +0,0 @@
-/**
- * Pause Sound Use Case
- */
-
-import { BaseVoidUseCase } from './BaseUseCase';
-import type { IAudioService } from '../interfaces/IAudioService';
-import { SoundPresenter } from '../presenters/SoundPresenter';
-
-interface PauseSoundInput {
-    sound: unknown;
-}
-
-export class PauseSoundUseCase extends BaseVoidUseCase<PauseSoundInput> {
-    constructor(
-        private readonly audioService: IAudioService,
-        private readonly presenter: SoundPresenter
-    ) {
-        super();
-    }
-
-    protected async executeImpl(input: PauseSoundInput): Promise<void> {
-        if (!input.sound) return;
-        await this.audioService.pause(input.sound);
-        this.presenter.onPlaybackStop();
-    }
-}

package/src/application/use-cases/PlaySoundUseCase.ts

@@ -1,106 +0,0 @@
-/**
- * Play Sound Use Case
- */
-
-import { BaseVoidUseCase } from './BaseUseCase';
-import { SoundId } from '../../domain/value-objects/SoundId';
-import { SoundSource } from '../../domain/value-objects/SoundSource';
-import { Volume } from '../../domain/value-objects/Volume';
-import { Rate } from '../../domain/value-objects/Rate';
-import type { IAudioService } from '../interfaces/IAudioService';
-import type { ISoundCache } from '../interfaces/ISoundCache';
-import { SoundPresenter } from '../presenters/SoundPresenter';
-
-interface PlaySoundInput {
-    id: string;
-    source: number | { uri: string; headers?: Record<string, string> };
-    volume?: number;
-    rate?: number;
-    isLooping?: boolean;
-    positionMillis?: number;
-}
-
-export class PlaySoundUseCase extends BaseVoidUseCase<PlaySoundInput> {
-    private currentSound: unknown | null = null;
-    private currentId: string | null = null;
-
-    constructor(
-        private readonly audioService: IAudioService,
-        private readonly cache: ISoundCache,
-        private readonly presenter: SoundPresenter
-    ) {
-        super();
-    }
-
-    protected async executeImpl(input: PlaySoundInput): Promise<void> {
-        const soundId = new SoundId(input.id);
-        const soundSource = new SoundSource(input.source);
-        const volume = new Volume(input.volume ?? 1.0);
-        const rate = new Rate(input.rate ?? 1.0);
-
-        // Toggle if same sound
-        if (this.currentId === soundId.toString() && this.currentSound) {
-            const status = await this.audioService.getStatus(this.currentSound);
-            if (status?.isPlaying) {
-                await this.audioService.pause(this.currentSound);
-                this.presenter.onPlaybackStop();
-                return;
-            }
-        }
-
-        // Unload current
-        if (this.currentSound) {
-            await this.audioService.unload(this.currentSound);
-        }
-
-        // Try cache first
-        const cached = this.cache.get(soundId.toString());
-        if (cached) {
-            this.currentSound = cached.sound;
-            this.cache.delete(soundId.toString());
-        } else {
-            const { sound } = await this.audioService.createSound(
-                soundSource.getValue(),
-                {
-                    shouldPlay: true,
-                    isLooping: input.isLooping ?? false,
-                    volume: volume.getValue(),
-                    rate: rate.getValue(),
-                    positionMillis: input.positionMillis,
-                },
-                (status) => this.presenter.onPlaybackUpdate(status)
-            );
-            this.currentSound = sound;
-        }
-
-        await this.audioService.play(this.currentSound);
-        this.currentId = soundId.toString();
-
-        this.presenter.onPlaybackStart(
-            soundId.toString(),
-            soundSource.getValue(),
-            {
-                volume: volume.getValue(),
-                rate: rate.getValue(),
-                isLooping: input.isLooping ?? false,
-            }
-        );
-    }
-
-    getCurrentSound(): unknown | null {
-        return this.currentSound;
-    }
-
-    getCurrentId(): string | null {
-        return this.currentId;
-    }
-
-    async unload(): Promise<void> {
-        if (this.currentSound) {
-            await this.audioService.unload(this.currentSound);
-        }
-        this.currentSound = null;
-        this.currentId = null;
-        this.presenter.onReset();
-    }
-}

package/src/application/use-cases/PreloadSoundUseCase.ts

@@ -1,56 +0,0 @@
-/**
- * Preload Sound Use Case
- */
-
-import { BaseVoidUseCase } from './BaseUseCase';
-import { SoundId } from '../../domain/value-objects/SoundId';
-import { SoundSource } from '../../domain/value-objects/SoundSource';
-import { Volume } from '../../domain/value-objects/Volume';
-import { Rate } from '../../domain/value-objects/Rate';
-import type { IAudioService } from '../interfaces/IAudioService';
-import type { ISoundCache } from '../interfaces/ISoundCache';
-
-interface PreloadSoundInput {
-    id: string;
-    source: number | { uri: string; headers?: Record<string, string> };
-    volume?: number;
-    rate?: number;
-    isLooping?: boolean;
-}
-
-export class PreloadSoundUseCase extends BaseVoidUseCase<PreloadSoundInput> {
-    constructor(
-        private readonly audioService: IAudioService,
-        private readonly cache: ISoundCache
-    ) {
-        super();
-    }
-
-    protected async executeImpl(input: PreloadSoundInput): Promise<void> {
-        const soundId = new SoundId(input.id);
-        const soundSource = new SoundSource(input.source);
-        const volume = new Volume(input.volume ?? 1.0);
-        const rate = new Rate(input.rate ?? 1.0);
-
-        if (this.cache.has(soundId.toString())) {
-            return;
-        }
-
-        const { sound } = await this.audioService.createSound(
-            soundSource.getValue(),
-            {
-                shouldPlay: false,
-                isLooping: input.isLooping ?? false,
-                volume: volume.getValue(),
-                rate: rate.getValue(),
-            },
-            () => {}
-        );
-
-        this.cache.set(soundId.toString(), {
-            sound,
-            source: soundSource.getValue(),
-            loadedAt: Date.now(),
-        });
-    }
-}

package/src/application/use-cases/ResumeSoundUseCase.ts

@@ -1,25 +0,0 @@
-/**
- * Resume Sound Use Case
- */
-
-import { BaseVoidUseCase } from './BaseUseCase';
-import type { IAudioService } from '../interfaces/IAudioService';
-import { SoundPresenter } from '../presenters/SoundPresenter';
-
-interface ResumeSoundInput {
-    sound: unknown;
-}
-
-export class ResumeSoundUseCase extends BaseVoidUseCase<ResumeSoundInput> {
-    constructor(
-        private readonly audioService: IAudioService,
-        private readonly presenter: SoundPresenter
-    ) {
-        super();
-    }
-
-    protected async executeImpl(input: ResumeSoundInput): Promise<void> {
-        if (!input.sound) return;
-        await this.audioService.play(input.sound);
-    }
-}

package/src/application/use-cases/SeekSoundUseCase.ts

@@ -1,26 +0,0 @@
-/**
- * Seek Sound Use Case
- */
-
-import { BaseVoidUseCase } from './BaseUseCase';
-import { PlaybackPosition } from '../../domain/value-objects/PlaybackPosition';
-import type { IAudioService } from '../interfaces/IAudioService';
-
-interface SeekSoundInput {
-    sound: unknown;
-    positionMillis: number;
-    durationMillis?: number;
-}
-
-export class SeekSoundUseCase extends BaseVoidUseCase<SeekSoundInput> {
-    constructor(private readonly audioService: IAudioService) {
-        super();
-    }
-
-    protected async executeImpl(input: SeekSoundInput): Promise<void> {
-        if (!input.sound) return;
-
-        const position = new PlaybackPosition(input.positionMillis, input.durationMillis);
-        await this.audioService.setPosition(input.sound, position.getValue());
-    }
-}