@umituz/react-native-sound 1.2.19 → 1.2.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-sound",
-  "version": "1.2.19",
+  "version": "1.2.21",
   "description": "Universal sound playback and caching library for React Native apps",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -32,13 +32,49 @@
     "react-native": ">=0.74.0"
   },
   "devDependencies": {
+    "@gorhom/bottom-sheet": "^5.2.8",
     "@react-native-async-storage/async-storage": "^2.2.0",
+    "@react-navigation/bottom-tabs": "^7.15.5",
+    "@react-navigation/elements": "^2.9.10",
+    "@react-navigation/native": "^7.1.33",
+    "@react-navigation/stack": "^7.8.5",
+    "@tanstack/react-query": "^5.90.21",
+    "@types/node": "^25.5.0",
     "@types/react": "~19.1.10",
-    "@umituz/react-native-design-system": "latest",
+    "@types/react-native": "^0.72.8",
+    "@types/uuid": "^10.0.0",
+    "@umituz/react-native-design-system": "^4.25.97",
+    "@umituz/react-native-settings": "^5.3.48",
+    "expo-application": "^55.0.9",
+    "expo-auth-session": "^55.0.8",
     "expo-av": "~13.4.1",
-    "react": "19.1.0",
+    "expo-clipboard": "^55.0.8",
+    "expo-crypto": "^55.0.9",
+    "expo-device": "^55.0.9",
+    "expo-file-system": "^55.0.10",
+    "expo-font": "^55.0.4",
+    "expo-haptics": "^55.0.8",
+    "expo-image": "^55.0.6",
+    "expo-image-manipulator": "^55.0.10",
+    "expo-image-picker": "^55.0.12",
+    "expo-localization": "^55.0.8",
+    "expo-media-library": "^55.0.9",
+    "expo-modules-core": "^55.0.15",
+    "expo-network": "^55.0.8",
+    "expo-secure-store": "^55.0.8",
+    "expo-sharing": "^55.0.11",
+    "expo-video": "^55.0.10",
+    "expo-web-browser": "^55.0.9",
+    "i18next": "^25.8.18",
+    "react": "^19.1.0",
+    "react-i18next": "^16.5.8",
     "react-native": "0.81.5",
+    "react-native-gesture-handler": "^2.30.0",
+    "react-native-safe-area-context": "^5.7.0",
+    "react-native-svg": "^15.15.3",
+    "rn-emoji-keyboard": "^1.7.0",
     "typescript": "~5.9.2",
+    "uuid": "^13.0.0",
     "zustand": "^5.0.9"
   },
   "publishConfig": {

package/src/AudioManager.ts

@@ -1,13 +1,13 @@
 import { Audio, AVPlaybackStatus, InterruptionModeIOS, InterruptionModeAndroid } from 'expo-av';
 import { useSoundStore } from './store';
+import { PlaybackOptions, SoundSource } from './types';
 import {
-    PlaybackOptions,
-    SoundSource,
     isPlaybackStatusSuccess,
     isSoundSourceValid,
     clampVolume,
     clampRate,
-} from './types';
+    validateSoundId,
+} from './utils';
 
 interface CachedSound {
     sound: Audio.Sound;
@@ -23,7 +23,9 @@ class AudioManager {
     private readonly cacheExpireMs = 5 * 60 * 1000;
 
     constructor() {
-        this.configureAudio();
+        this.configureAudio().catch((error) => {
+            if (__DEV__) console.error('[AudioManager] Failed to configure audio on initialization:', error);
+        });
     }
 
     private async configureAudio() {
@@ -56,6 +58,10 @@ class AudioManager {
         store.setBuffering(status.isBuffering);
         store.setProgress(status.positionMillis, status.durationMillis || 0);
 
+        if (status.isLoaded) {
+            store.setRateState(status.rate || 1.0);
+        }
+
         if (status.didJustFinish && !status.isLooping) {
             store.setPlaying(false);
             store.setProgress(status.durationMillis || 0, status.durationMillis || 0);
@@ -66,7 +72,9 @@ class AudioManager {
         const now = Date.now();
         for (const [id, cached] of this.cache) {
             if (now - cached.loadedAt > this.cacheExpireMs) {
-                cached.sound.unloadAsync().catch(() => {});
+                cached.sound.unloadAsync().catch((error) => {
+                    if (__DEV__) console.warn('[AudioManager] Failed to unload expired cache:', id, error);
+                });
                 this.cache.delete(id);
                 if (__DEV__) console.log('[AudioManager] Expired cache removed:', id);
             }
@@ -78,14 +86,20 @@ class AudioManager {
             const firstKey = this.cache.keys().next().value;
             if (firstKey) {
                 const cached = this.cache.get(firstKey);
-                cached?.sound.unloadAsync().catch(() => {});
+                cached?.sound.unloadAsync().catch((error) => {
+                    if (__DEV__) console.warn('[AudioManager] Failed to unload sound during cache limit enforcement:', firstKey, error);
+                });
                 this.cache.delete(firstKey);
                 if (__DEV__) console.log('[AudioManager] Cache limit enforced, removed:', firstKey);
             }
         }
     }
 
-    async preload(id: string, source: SoundSource, options?: PlaybackOptions) {
+    async preload(id: string, source: SoundSource, options?: PlaybackOptions): Promise<void> {
+        if (!validateSoundId(id)) {
+            throw new Error('Invalid sound id: id must be a non-empty string');
+        }
+
         if (!isSoundSourceValid(source)) {
             throw new Error('Invalid sound source: source is null or undefined');
         }
@@ -122,11 +136,17 @@ class AudioManager {
         }
     }
 
-    async play(id: string, source: SoundSource, options?: PlaybackOptions) {
+    async play(id: string, source: SoundSource, options?: PlaybackOptions): Promise<void> {
         const store = useSoundStore.getState();
 
         if (__DEV__) console.log('[AudioManager] Play called with ID:', id);
 
+        if (!validateSoundId(id)) {
+            const errorMsg = 'Invalid sound id: id must be a non-empty string';
+            store.setError(errorMsg);
+            throw new Error(errorMsg);
+        }
+
         if (!isSoundSourceValid(source)) {
             const errorMsg = 'Invalid sound source: source is null or undefined';
             store.setError(errorMsg);
@@ -137,9 +157,12 @@ class AudioManager {
             const status = await this.sound.getStatusAsync();
             if (status.isLoaded) {
                 if (status.isPlaying) {
+                    store.setPlaying(false);
+                    await this.sound.pauseAsync();
                     return;
                 } else {
                     if (__DEV__) console.log('[AudioManager] Resuming existing sound');
+                    store.setPlaying(true);
                     await this.sound.playAsync();
                     return;
                 }
@@ -151,6 +174,7 @@ class AudioManager {
 
             const volume = options?.volume !== undefined ? clampVolume(options.volume) : 1.0;
             const rate = options?.rate !== undefined ? clampRate(options.rate) : 1.0;
+            const isLooping = options?.isLooping ?? false;
 
             const cached = this.cache.get(id);
             if (cached) {
@@ -162,7 +186,7 @@ class AudioManager {
                     source,
                     {
                         shouldPlay: true,
-                        isLooping: options?.isLooping ?? false,
+                        isLooping,
                         volume,
                         rate,
                         positionMillis: options?.positionMillis ?? 0,
@@ -176,53 +200,88 @@ class AudioManager {
             this.currentId = id;
             store.setCurrent(id, source);
             store.setError(null);
+            store.setLooping(isLooping);
+            store.setRateState(rate);
+            store.setVolumeState(volume);
 
-            if (!cached) {
-                await this.sound?.playAsync();
-            } else {
-                await this.sound?.setVolumeAsync(volume);
-                await this.sound?.setRateAsync(rate, false);
-                await this.sound?.playAsync();
-            }
+            await this.sound?.playAsync();
         } catch (error) {
             const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
             if (__DEV__) console.error('[AudioManager] Error playing sound:', error);
             store.setError(errorMessage);
             this.currentId = null;
+            this.sound = null;
             throw error;
         }
     }
 
-    async pause() {
+    async pause(): Promise<void> {
         if (this.sound) {
-            await this.sound.pauseAsync();
+            try {
+                await this.sound.pauseAsync();
+                useSoundStore.getState().setPlaying(false);
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to pause sound';
+                if (__DEV__) console.error('[AudioManager] Error pausing sound:', error);
+                useSoundStore.getState().setError(errorMessage);
+                throw error;
+            }
         }
     }
 
-    async resume() {
+    async resume(): Promise<void> {
         if (this.sound) {
-            await this.sound.playAsync();
+            try {
+                await this.sound.playAsync();
+                useSoundStore.getState().setPlaying(true);
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to resume sound';
+                if (__DEV__) console.error('[AudioManager] Error resuming sound:', error);
+                useSoundStore.getState().setError(errorMessage);
+                throw error;
+            }
         }
     }
 
-    async stop() {
+    async stop(): Promise<void> {
         if (this.sound) {
-            await this.sound.stopAsync();
-            useSoundStore.getState().setPlaying(false);
-            useSoundStore.getState().setProgress(0, 0);
+            try {
+                await this.sound.stopAsync();
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to stop sound';
+                if (__DEV__) console.error('[AudioManager] Error stopping sound:', error);
+                useSoundStore.getState().setError(errorMessage);
+                useSoundStore.getState().setPlaying(false);
+                useSoundStore.getState().setProgress(0, 0);
+                throw error;
+            }
         }
     }
 
-    async seek(positionMillis: number) {
+    async seek(positionMillis: number): Promise<void> {
+        if (!Number.isFinite(positionMillis)) {
+            throw new Error('Invalid position: positionMillis must be a finite number');
+        }
+
         if (this.sound) {
-            const status = await this.sound.getStatusAsync();
-            if (status.isLoaded) {
-                await this.sound.setStatusAsync({ positionMillis: Math.max(0, positionMillis) });
+            try {
+                const status = await this.sound.getStatusAsync();
+                if (status.isLoaded) {
+                    const clampedPosition = Math.max(0, Math.min(status.durationMillis || 0, positionMillis));
+                    await this.sound.setStatusAsync({ positionMillis: clampedPosition });
+                } else {
+                    throw new Error('Cannot seek: sound is not loaded');
+                }
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to seek sound';
+                if (__DEV__) console.error('[AudioManager] Error seeking sound:', error);
+                useSoundStore.getState().setError(errorMessage);
+                throw error;
             }
         }
     }
 
-    async setVolume(volume: number) {
+    async setVolume(volume: number): Promise<void> {
         if (this.sound) {
             const clampedVolume = clampVolume(volume);
             await this.sound.setVolumeAsync(clampedVolume);
@@ -230,21 +289,25 @@ class AudioManager {
         }
     }
 
-    async setRate(rate: number) {
+    async setRate(rate: number): Promise<void> {
         if (this.sound) {
             const clampedRate = clampRate(rate);
             const status = await this.sound.getStatusAsync();
             if (status.isLoaded) {
                 try {
                     await this.sound.setRateAsync(clampedRate, false);
+                    useSoundStore.getState().setRateState(clampedRate);
                 } catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Failed to set rate';
                     if (__DEV__) console.warn('[AudioManager] Could not set rate:', error);
+                    useSoundStore.getState().setError(errorMessage);
+                    throw error;
                 }
             }
         }
     }
 
-    async unload() {
+    async unload(): Promise<void> {
         if (this.sound) {
             try {
                 await this.sound.unloadAsync();
@@ -257,18 +320,16 @@ class AudioManager {
         useSoundStore.getState().reset();
     }
 
-    clearCache() {
+    clearCache(): void {
         for (const cached of this.cache.values()) {
-            cached.sound.unloadAsync().catch(() => {});
+            cached.sound.unloadAsync().catch((error) => {
+                if (__DEV__) console.warn('[AudioManager] Failed to unload sound during cache clear:', error);
+            });
         }
         this.cache.clear();
         if (__DEV__) console.log('[AudioManager] Cache cleared');
     }
 
-    getCurrentId() {
-        return this.currentId;
-    }
-
     isCached(id: string): boolean {
         return this.cache.has(id);
     }

package/src/global.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Global type declarations for React Native
+ */
+
+declare const __DEV__: boolean;

package/src/index.ts

@@ -1,9 +1,11 @@
-/**
- * @umituz/react-native-sound
- * Universal sound playback library with caching
- */
-
-export * from './types';
-export * from './useSound';
+export type { SoundSource, PlaybackOptions, SoundState } from './types';
+export {
+    isPlaybackStatusSuccess,
+    isSoundSourceValid,
+    clampVolume,
+    clampRate,
+    validateSoundId,
+} from './utils';
 export { audioManager } from './AudioManager';
+export { useSound } from './useSound';
 export { useSoundStore } from './store';

package/src/store.ts

@@ -8,6 +8,8 @@ interface SoundActions {
     setError: (error: string | null) => void;
     setCurrent: (id: string | null, source: SoundSource | null) => void;
     setVolumeState: (volume: number) => void;
+    setRateState: (rate: number) => void;
+    setLooping: (isLooping: boolean) => void;
     reset: () => void;
 }
 
@@ -18,6 +20,7 @@ const initialSoundState: SoundState = {
     durationMillis: 0,
     volume: 1.0,
     rate: 1.0,
+    isLooping: false,
     error: null,
     currentSource: null,
     currentId: null,
@@ -35,6 +38,8 @@ export const useSoundStore = createStore<SoundState, SoundActions>({
         setError: (error) => set({ error }),
         setCurrent: (id, source) => set({ currentId: id, currentSource: source }),
         setVolumeState: (volume) => set({ volume }),
+        setRateState: (rate) => set({ rate }),
+        setLooping: (isLooping) => set({ isLooping }),
         reset: () => set(initialSoundState),
     }),
 });

package/src/types.ts

@@ -2,12 +2,11 @@
  * @umituz/react-native-sound Types
  */
 
-import { AVPlaybackStatus, AVPlaybackStatusSuccess } from 'expo-av';
+import { AVPlaybackStatus } from 'expo-av';
 
 export type SoundSource = number | { uri: string; headers?: Record<string, string> } | null;
 
 export interface PlaybackOptions {
-    shouldPlay?: boolean;
     isLooping?: boolean;
     volume?: number;
     rate?: number;
@@ -21,41 +20,8 @@ export interface SoundState {
     durationMillis: number;
     volume: number;
     rate: number;
+    isLooping: boolean;
     error: string | null;
     currentSource: SoundSource | null;
     currentId: string | null;
 }
-
-export type PlaybackStatus = AVPlaybackStatus;
-
-export interface SoundError {
-    message: string;
-    code?: string;
-    originalError?: unknown;
-}
-
-export type PlaybackStatusSuccess = AVPlaybackStatusSuccess;
-
-export function isPlaybackStatusSuccess(status: AVPlaybackStatus): status is PlaybackStatusSuccess {
-    return status.isLoaded;
-}
-
-export function isSoundSourceValid(source: SoundSource): source is number | { uri: string; headers?: Record<string, string> } {
-    return source !== null && source !== undefined;
-}
-
-export function validateVolume(volume: number): boolean {
-    return typeof volume === 'number' && volume >= 0 && volume <= 1;
-}
-
-export function validateRate(rate: number): boolean {
-    return typeof rate === 'number' && rate >= 0.5 && rate <= 2.0;
-}
-
-export function clampVolume(volume: number): number {
-    return Math.max(0, Math.min(1, volume));
-}
-
-export function clampRate(rate: number): number {
-    return Math.max(0.5, Math.min(2.0, rate));
-}

package/src/useSound.ts

@@ -1,36 +1,45 @@
-import { useCallback, useEffect } from 'react';
+import { useCallback } from 'react';
 import { useSoundStore } from './store';
 import { audioManager } from './AudioManager';
 import { PlaybackOptions, SoundSource } from './types';
 
-export const useSound = () => {
+export const useSound = (): {
+    play: (id: string, source: SoundSource, options?: PlaybackOptions) => Promise<void>;
+    pause: () => Promise<void>;
+    resume: () => Promise<void>;
+    stop: () => Promise<void>;
+    seek: (positionMillis: number) => Promise<void>;
+    setVolume: (vol: number) => Promise<void>;
+    setRate: (rate: number) => Promise<void>;
+    preload: (id: string, source: SoundSource, options?: PlaybackOptions) => Promise<void>;
+    unload: () => Promise<void>;
+    clearCache: () => void;
+    isCached: (id: string) => boolean;
+    isPlaying: boolean;
+    isBuffering: boolean;
+    isLooping: boolean;
+    position: number;
+    duration: number;
+    currentId: string | null;
+    error: string | null;
+    volume: number;
+    rate: number;
+} => {
     const isPlaying = useSoundStore((state) => state.isPlaying);
     const isBuffering = useSoundStore((state) => state.isBuffering);
+    const isLooping = useSoundStore((state) => state.isLooping);
     const position = useSoundStore((state) => state.positionMillis);
     const duration = useSoundStore((state) => state.durationMillis);
     const currentId = useSoundStore((state) => state.currentId);
     const error = useSoundStore((state) => state.error);
     const volume = useSoundStore((state) => state.volume);
-
-    useEffect(() => {
-        return () => {
-            if (__DEV__) console.log('[useSound] Cleanup on unmount');
-        };
-    }, []);
+    const rate = useSoundStore((state) => state.rate);
 
     const play = useCallback(
         async (id: string, source: SoundSource, options?: PlaybackOptions) => {
-            if (currentId === id) {
-                if (isPlaying) {
-                    await audioManager.pause();
-                } else {
-                    await audioManager.resume();
-                }
-            } else {
-                await audioManager.play(id, source, options);
-            }
+            await audioManager.play(id, source, options);
         },
-        [currentId, isPlaying]
+        []
     );
 
     const pause = useCallback(async () => {
@@ -87,10 +96,12 @@ export const useSound = () => {
         isCached,
         isPlaying,
         isBuffering,
+        isLooping,
         position,
         duration,
         currentId,
         error,
         volume,
+        rate,
     };
 };

package/src/utils.ts

@@ -0,0 +1,30 @@
+/**
+ * @umituz/react-native-sound Utility Functions
+ */
+
+import { AVPlaybackStatus, AVPlaybackStatusSuccess } from 'expo-av';
+import type { SoundSource } from './types';
+
+type PlaybackStatusSuccess = AVPlaybackStatusSuccess;
+
+export function isPlaybackStatusSuccess(status: AVPlaybackStatus): status is PlaybackStatusSuccess {
+    return status.isLoaded;
+}
+
+export function isSoundSourceValid(source: SoundSource): source is number | { uri: string; headers?: Record<string, string> } {
+    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 clampRate(rate: number): number {
+    if (!Number.isFinite(rate)) return 1.0;
+    return Math.max(0.5, Math.min(2.0, rate));
+}
+
+export function validateSoundId(id: string): boolean {
+    return typeof id === 'string' && id.trim().length > 0;
+}