@umituz/react-native-sound 1.2.32 → 1.2.33

package/src/index.ts

@@ -1,41 +1,50 @@
 /**
  * @umituz/react-native-sound
  * DDD-based audio management for React Native
+ * Optimized architecture with minimal code duplication
  */
 
-// Public API
-export { useSound } from './presentation/hooks/useSound';
-export { useSoundStore } from './presentation/store';
+// ===== Public API =====
+export { useSound } from './presentation/useSound';
+export { useSoundStore, setupEventListeners } from './presentation/SoundStore';
 
-// Types
+// ===== Types =====
 export type { PlaybackOptions, SoundState, SoundSource } from './types';
+export type { PlaybackStatus, PlaybackOptions as ServicePlaybackOptions } from './application/interfaces/IAudioService';
+export type { CachedSound, ISoundCache } from './application/interfaces/ISoundCache';
 
-// Utilities (backward compatibility)
+// ===== Domain (Advanced Usage) =====
+export { SoundError, SoundErrorCode } from './domain/errors/SoundError';
+export {
+    SoundId,
+    SoundSource as SoundSourceVO,
+    Volume,
+    Rate,
+    PlaybackPosition,
+    SoundValueObjects,
+    type SoundSourceValue,
+} from './domain/value-objects';
+
+// ===== Infrastructure (Testing/Customization) =====
+export { Logger } from './infrastructure/Logger';
+export { AudioConfig } from './infrastructure/AudioConfig';
+export { AudioRepository } from './infrastructure/AudioRepository';
+
+// ===== Application (Testing/Customization) =====
+export { SoundService } from './application/SoundService';
+export { SoundCommandProcessor, type SoundCommand, type PlayCommand, type PreloadCommand } from './application/SoundCommands';
+export { SoundEvents, type SoundEvent, type PlaybackStartedEvent } from './application/SoundEvents';
+
+// ===== Utilities =====
 export {
     clampVolume,
     clampRate,
     validateSoundId,
     isSoundSourceValid,
     isPlaybackStatusSuccess,
+    debounce,
+    throttle,
+    RateLimiter,
+    PeriodicTask,
+    AutoGCWeakCache,
 } from './utils';
-
-// Domain exports (for advanced usage)
-export { SoundError } from './domain/errors/SoundError';
-export { SoundId } from './domain/value-objects/SoundId';
-export { SoundSource as SoundSourceVO } from './domain/value-objects/SoundSource';
-export { Volume } from './domain/value-objects/Volume';
-export { Rate } from './domain/value-objects/Rate';
-export { PlaybackPosition } from './domain/value-objects/PlaybackPosition';
-export { SoundState as SoundStateEntity } from './domain/entities/SoundState';
-
-// Infrastructure exports (for testing/customization)
-export { Logger } from './infrastructure/Logger';
-export { AudioConfig } from './infrastructure/AudioConfig';
-export { ExpoAudioService } from './infrastructure/ExpoAudioService';
-export { SoundCache } from './infrastructure/SoundCache';
-
-// Application exports (for testing/customization)
-export { SoundServiceFacade } from './application/SoundServiceFacade';
-export type { IAudioService, PlaybackStatus } from './application/interfaces/IAudioService';
-export type { ISoundCache, CachedSound } from './application/interfaces/ISoundCache';
-export { SoundPresenter } from './application/presenters/SoundPresenter';

package/src/infrastructure/AudioConfig.ts

@@ -3,7 +3,6 @@
  */
 
 import { Audio, InterruptionModeIOS, InterruptionModeAndroid } from 'expo-av';
-import type { Audio as AudioType } from 'expo-av';
 import { Logger } from './Logger';
 
 export class AudioConfig {

package/src/infrastructure/AudioRepository.ts

@@ -0,0 +1,216 @@
+/**
+ * Audio Repository - Combines Cache + Audio Service
+ * Single responsibility: Audio resource management
+ */
+
+import { Audio } from 'expo-av';
+import type { AVPlaybackStatus } from 'expo-av';
+import type { IAudioService, PlaybackStatus, PlaybackOptions } from '../application/interfaces/IAudioService';
+import type { ISoundCache, CachedSound } from '../application/interfaces/ISoundCache';
+import type { SoundSourceValue } from '../domain/value-objects';
+import { SoundEvents } from '../application/SoundEvents';
+import { Logger } from './Logger';
+import { RateLimiter } from '../utils';
+
+// ===== Audio Service Implementation =====
+class ExpoAudioService implements IAudioService {
+    async createSound(
+        source: SoundSourceValue,
+        options: PlaybackOptions,
+        onStatusUpdate: (status: PlaybackStatus) => void
+    ): Promise<{ sound: Audio.Sound }> {
+        const { sound } = await Audio.Sound.createAsync(
+            source,
+            {
+                shouldPlay: options.shouldPlay,
+                isLooping: options.isLooping,
+                volume: options.volume,
+                rate: options.rate,
+                positionMillis: options.positionMillis,
+            },
+            (status) => onStatusUpdate(this.mapStatus(status))
+        );
+        Logger.debug('Sound created');
+        return { sound };
+    }
+
+    async play(sound: unknown): Promise<void> {
+        await (sound as Audio.Sound).playAsync();
+    }
+
+    async pause(sound: unknown): Promise<void> {
+        await (sound as Audio.Sound).pauseAsync();
+    }
+
+    async stop(sound: unknown): Promise<void> {
+        await (sound as Audio.Sound).stopAsync();
+    }
+
+    async unload(sound: unknown): Promise<void> {
+        await (sound as Audio.Sound).unloadAsync();
+    }
+
+    async setVolume(sound: unknown, volume: number): Promise<void> {
+        await (sound as Audio.Sound).setVolumeAsync(volume);
+    }
+
+    async setRate(sound: unknown, rate: number): Promise<void> {
+        await (sound as Audio.Sound).setRateAsync(rate, false);
+    }
+
+    async setPosition(sound: unknown, positionMillis: number): Promise<void> {
+        await (sound as Audio.Sound).setStatusAsync({ positionMillis });
+    }
+
+    async getStatus(sound: unknown): Promise<PlaybackStatus | null> {
+        const status = await (sound as Audio.Sound).getStatusAsync();
+        return status.isLoaded ? this.mapStatus(status) : null;
+    }
+
+    private mapStatus(status: AVPlaybackStatus): PlaybackStatus {
+        if (!status.isLoaded) {
+            const statusRecord = status as Record<string, unknown>;
+            const hasError = 'error' in statusRecord;
+            const error = hasError && statusRecord.error instanceof Error ? statusRecord.error.message : undefined;
+            return {
+                isLoaded: false,
+                isPlaying: false,
+                isBuffering: false,
+                positionMillis: 0,
+                durationMillis: 0,
+                isLooping: false,
+                didJustFinish: false,
+                error,
+            };
+        }
+        return {
+            isLoaded: true,
+            isPlaying: status.isPlaying,
+            isBuffering: status.isBuffering,
+            positionMillis: status.positionMillis,
+            durationMillis: status.durationMillis || 0,
+            rate: status.rate,
+            isLooping: status.isLooping,
+            didJustFinish: status.didJustFinish,
+        };
+    }
+}
+
+// ===== Sound Cache Configuration =====
+const CACHE_CONFIG = {
+    MAX_SIZE: 3,
+    EXPIRE_MS: 5 * 60 * 1000, // 5 minutes
+    CLEAN_INTERVAL_MS: 30 * 1000, // 30 seconds
+} as const;
+
+// ===== Sound Cache Implementation =====
+class SoundCache implements ISoundCache {
+    private cache = new Map<string, CachedSound>();
+    private accessOrder: string[] = [];
+    private readonly maxSize = CACHE_CONFIG.MAX_SIZE;
+    private readonly expireMs = CACHE_CONFIG.EXPIRE_MS;
+    private lastCleanTime = 0;
+    private readonly cleanIntervalMs = CACHE_CONFIG.CLEAN_INTERVAL_MS;
+    private cleanLimiter = new RateLimiter(this.cleanIntervalMs);
+
+    constructor(
+        private readonly audioService: IAudioService,
+        private readonly events: SoundEvents
+    ) {}
+
+    get(id: string): CachedSound | undefined {
+        const cached = this.cache.get(id);
+        if (cached) {
+            this.updateAccessOrder(id);
+        }
+        return cached;
+    }
+
+    async set(id: string, cached: CachedSound): Promise<void> {
+        await this.cleanExpiredThrottled();
+        await this.enforceLimit();
+        this.cache.set(id, cached);
+        this.updateAccessOrder(id);
+        Logger.debug(`Cached: ${id}`);
+    }
+
+    async delete(id: string): Promise<void> {
+        const cached = this.cache.get(id);
+        if (cached) {
+            try {
+                await this.audioService.unload(cached.sound);
+            } catch (error) {
+                Logger.warn(`Failed to unload: ${id}`, error);
+            }
+        }
+        this.cache.delete(id);
+        this.removeFromAccessOrder(id);
+    }
+
+    has(id: string): boolean {
+        return this.cache.has(id);
+    }
+
+    async clear(): Promise<void> {
+        const unloadPromises = Array.from(this.cache.values()).map((cached) =>
+            this.audioService.unload(cached.sound).catch((error) => {
+                Logger.warn('Failed to unload during clear', error);
+            })
+        );
+        await Promise.all(unloadPromises);
+        this.cache.clear();
+        this.accessOrder = [];
+        Logger.debug('Cache cleared');
+    }
+
+    private async cleanExpiredThrottled(): Promise<void> {
+        await this.cleanLimiter.execute(async () => {
+            const now = Date.now();
+            const expiredIds: string[] = [];
+            for (const [id, cached] of this.cache) {
+                if (now - cached.loadedAt > this.expireMs) {
+                    expiredIds.push(id);
+                }
+            }
+            for (const id of expiredIds) {
+                await this.delete(id);
+                Logger.debug(`Expired cache removed: ${id}`);
+            }
+        });
+    }
+
+    private async enforceLimit(): Promise<void> {
+        while (this.cache.size >= this.maxSize && this.accessOrder.length > 0) {
+            const lruId = this.accessOrder[0];
+            if (lruId && this.cache.has(lruId)) {
+                await this.delete(lruId);
+                Logger.debug(`LRU enforced, removed: ${lruId}`);
+            } else {
+                break;
+            }
+        }
+    }
+
+    private updateAccessOrder(id: string): void {
+        this.removeFromAccessOrder(id);
+        this.accessOrder.push(id);
+    }
+
+    private removeFromAccessOrder(id: string): void {
+        const index = this.accessOrder.indexOf(id);
+        if (index > -1) {
+            this.accessOrder.splice(index, 1);
+        }
+    }
+}
+
+// ===== Repository Export =====
+export class AudioRepository {
+    readonly audioService: IAudioService;
+    readonly cache: ISoundCache;
+
+    constructor(events: SoundEvents) {
+        this.audioService = new ExpoAudioService();
+        this.cache = new SoundCache(this.audioService, events);
+    }
+}

package/src/presentation/SoundStore.ts

@@ -0,0 +1,156 @@
+/**
+ * Event-Driven Sound Store - Eliminates Presenter Pattern
+ * Direct event subscription from SoundService
+ */
+
+import { createStore } from '@umituz/react-native-design-system/storage';
+import type { PlaybackStatus } from '../application/interfaces/IAudioService';
+import type { SoundSourceValue } from '../domain/value-objects';
+import type { SoundEvents } from '../application/SoundEvents';
+
+// ===== Store State =====
+interface SoundState {
+    isPlaying: boolean;
+    isBuffering: boolean;
+    positionMillis: number;
+    durationMillis: number;
+    volume: number;
+    rate: number;
+    isLooping: boolean;
+    error: string | null;
+    currentId: string | null;
+    currentSource: SoundSourceValue | null;
+}
+
+interface SoundActions {
+    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;
+}
+
+const initialState: SoundState = {
+    isPlaying: false,
+    isBuffering: false,
+    positionMillis: 0,
+    durationMillis: 0,
+    volume: 1.0,
+    rate: 1.0,
+    isLooping: false,
+    error: null,
+    currentId: null,
+    currentSource: null,
+};
+
+// ===== Store Creation =====
+export const useSoundStore = createStore<SoundState, SoundActions>({
+    name: 'sound-store',
+    initialState,
+    persist: false,
+    actions: (set) => ({
+        setPlaying: (isPlaying) => set({ isPlaying }),
+        setBuffering: (isBuffering) => set({ isBuffering }),
+        setProgress: (position, duration) => set({ positionMillis: position, durationMillis: duration }),
+        setError: (error) => set({ error }),
+        setCurrent: (currentId, currentSource) => set({ currentId, currentSource }),
+        setVolumeState: (volume) => set({ volume }),
+        setRateState: (rate) => set({ rate }),
+        setLooping: (isLooping) => set({ isLooping }),
+        reset: () => set(initialState),
+    }),
+});
+
+// ===== Event Integration =====
+export function setupEventListeners(events: SoundEvents): () => void {
+    const unsubscribers: Array<() => void> = [];
+
+    // Playback started
+    unsubscribers.push(
+        events.on('PLAYBACK_STARTED', (payload) => {
+            const p = payload as { id: string; source: SoundSourceValue; volume: number; rate: number; isLooping: boolean };
+            const store = useSoundStore.getState();
+            store.setCurrent(p.id, p.source);
+            store.setError(null);
+            store.setVolumeState(p.volume);
+            store.setRateState(p.rate);
+            store.setLooping(p.isLooping);
+            store.setPlaying(true);
+        })
+    );
+
+    // Playback stopped
+    unsubscribers.push(
+        events.on('PLAYBACK_STOPPED', () => {
+            const store = useSoundStore.getState();
+            store.setPlaying(false);
+        })
+    );
+
+    // Status update
+    unsubscribers.push(
+        events.on('STATUS_UPDATE', (payload) => {
+            const status = payload as PlaybackStatus;
+            const store = useSoundStore.getState();
+            if (status.isLoaded) {
+                store.setPlaying(status.isPlaying);
+                store.setBuffering(status.isBuffering);
+                store.setProgress(status.positionMillis, status.durationMillis);
+
+                if (status.rate !== undefined) {
+                    store.setRateState(status.rate);
+                }
+
+                if (status.didJustFinish && !status.isLooping) {
+                    store.setPlaying(false);
+                    store.setProgress(status.durationMillis, status.durationMillis);
+                }
+            }
+
+            if (status.error) {
+                store.setError(status.error);
+                store.setPlaying(false);
+            }
+        })
+    );
+
+    // Volume changed
+    unsubscribers.push(
+        events.on('VOLUME_CHANGED', (payload) => {
+            useSoundStore.getState().setVolumeState(payload as number);
+        })
+    );
+
+    // Rate changed
+    unsubscribers.push(
+        events.on('RATE_CHANGED', (payload) => {
+            useSoundStore.getState().setRateState(payload as number);
+        })
+    );
+
+    // State reset
+    unsubscribers.push(
+        events.on('STATE_RESET', () => {
+            useSoundStore.getState().reset();
+        })
+    );
+
+    // Error
+    unsubscribers.push(
+        events.on('ERROR', (payload) => {
+            const error = payload as string;
+            const store = useSoundStore.getState();
+            store.setError(error);
+            store.setPlaying(false);
+        })
+    );
+
+    // Return cleanup function
+    return () => {
+        unsubscribers.forEach((unsub) => unsub());
+    };
+}

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

@@ -2,8 +2,7 @@
  * Public Types
  */
 
-export type { SoundSourceValue } from './domain/value-objects/SoundSource';
-export type { SoundStateData } from './domain/entities/SoundState';
+export type { SoundSourceValue } from './domain/value-objects';
 
 export interface PlaybackOptions {
     isLooping?: boolean;