@umituz/react-native-sound 1.2.32 → 1.2.34

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

@@ -1,30 +0,0 @@
-/**
- * Set Rate Use Case
- */
-
-import { BaseVoidUseCase } from './BaseUseCase';
-import { Rate } from '../../domain/value-objects/Rate';
-import type { IAudioService } from '../interfaces/IAudioService';
-import { SoundPresenter } from '../presenters/SoundPresenter';
-
-interface SetRateInput {
-    sound: unknown;
-    rate: number;
-}
-
-export class SetRateUseCase extends BaseVoidUseCase<SetRateInput> {
-    constructor(
-        private readonly audioService: IAudioService,
-        private readonly presenter: SoundPresenter
-    ) {
-        super();
-    }
-
-    protected async executeImpl(input: SetRateInput): Promise<void> {
-        if (!input.sound) return;
-
-        const rate = new Rate(input.rate);
-        await this.audioService.setRate(input.sound, rate.getValue());
-        this.presenter.onRateChange(rate.getValue());
-    }
-}

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

@@ -1,30 +0,0 @@
-/**
- * Set Volume Use Case
- */
-
-import { BaseVoidUseCase } from './BaseUseCase';
-import { Volume } from '../../domain/value-objects/Volume';
-import type { IAudioService } from '../interfaces/IAudioService';
-import { SoundPresenter } from '../presenters/SoundPresenter';
-
-interface SetVolumeInput {
-    sound: unknown;
-    volume: number;
-}
-
-export class SetVolumeUseCase extends BaseVoidUseCase<SetVolumeInput> {
-    constructor(
-        private readonly audioService: IAudioService,
-        private readonly presenter: SoundPresenter
-    ) {
-        super();
-    }
-
-    protected async executeImpl(input: SetVolumeInput): Promise<void> {
-        if (!input.sound) return;
-
-        const volume = new Volume(input.volume);
-        await this.audioService.setVolume(input.sound, volume.getValue());
-        this.presenter.onVolumeChange(volume.getValue());
-    }
-}

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

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

package/src/domain/entities/SoundState.ts

@@ -1,83 +0,0 @@
-/**
- * Sound State Entity
- */
-
-import { SoundSource } from '../value-objects/SoundSource';
-import { Volume } from '../value-objects/Volume';
-import { Rate } from '../value-objects/Rate';
-
-export interface SoundStateData {
-    isPlaying: boolean;
-    isBuffering: boolean;
-    positionMillis: number;
-    durationMillis: number;
-    volume: number;
-    rate: number;
-    isLooping: boolean;
-    error: string | null;
-    currentSource: SoundSource | null;
-    currentId: string | null;
-}
-
-export class SoundState {
-    constructor(private data: SoundStateData) {}
-
-    isPlaying(): boolean {
-        return this.data.isPlaying;
-    }
-
-    isBuffering(): boolean {
-        return this.data.isBuffering;
-    }
-
-    getPosition(): number {
-        return this.data.positionMillis;
-    }
-
-    getDuration(): number {
-        return this.data.durationMillis;
-    }
-
-    getVolume(): number {
-        return this.data.volume;
-    }
-
-    getRate(): number {
-        return this.data.rate;
-    }
-
-    isLooping(): boolean {
-        return this.data.isLooping;
-    }
-
-    getError(): string | null {
-        return this.data.error;
-    }
-
-    getCurrentSource(): SoundSource | null {
-        return this.data.currentSource;
-    }
-
-    getCurrentId(): string | null {
-        return this.data.currentId;
-    }
-
-    toData(): SoundStateData {
-        return { ...this.data };
-    }
-
-    static createEmpty(): SoundState {
-        return new SoundState({
-            isPlaying: false,
-            isBuffering: false,
-            positionMillis: 0,
-            durationMillis: 0,
-            volume: 1.0,
-            rate: 1.0,
-            isLooping: false,
-            error: null,
-            currentSource: null,
-            currentId: null,
-        });
-    }
-}

package/src/domain/value-objects/PlaybackPosition.ts

@@ -1,30 +0,0 @@
-/**
- * Playback Position Value Object
- */
-
-import { SoundError } from '../errors/SoundError';
-
-export class PlaybackPosition {
-    private readonly value: number;
-    private readonly duration?: number;
-
-    constructor(value: number, duration?: number) {
-        if (!Number.isFinite(value)) {
-            throw SoundError.invalidPosition();
-        }
-        this.value = duration ? this.clamp(value, duration) : value;
-        this.duration = duration;
-    }
-
-    private clamp(value: number, max: number): number {
-        return Math.max(0, Math.min(max, value));
-    }
-
-    getValue(): number {
-        return this.value;
-    }
-
-    getDuration(): number | undefined {
-        return this.duration;
-    }
-}

package/src/domain/value-objects/Rate.ts

@@ -1,26 +0,0 @@
-/**
- * Rate Value Object
- */
-
-export class Rate {
-    private readonly MIN = 0.5;
-    private readonly MAX = 2.0;
-    private readonly value: number;
-
-    constructor(value: number) {
-        this.value = this.clamp(value);
-    }
-
-    private clamp(value: number): number {
-        if (!Number.isFinite(value)) return 1.0;
-        return Math.max(this.MIN, Math.min(this.MAX, value));
-    }
-
-    getValue(): number {
-        return this.value;
-    }
-
-    equals(other: Rate): boolean {
-        return this.value === other.value;
-    }
-}

package/src/domain/value-objects/SoundId.ts

@@ -1,22 +0,0 @@
-/**
- * Sound ID Value Object
- */
-
-export class SoundId {
-    private readonly value: string;
-
-    constructor(value: string) {
-        if (typeof value !== 'string' || value.trim().length === 0) {
-            throw new Error('Sound id must be a non-empty string');
-        }
-        this.value = value.trim();
-    }
-
-    toString(): string {
-        return this.value;
-    }
-
-    equals(other: SoundId): boolean {
-        return this.value === other.value;
-    }
-}

package/src/domain/value-objects/SoundSource.ts

@@ -1,30 +0,0 @@
-/**
- * Sound Source Value Object
- */
-
-import { SoundError } from '../errors/SoundError';
-
-export type SoundSourceValue = number | { uri: string; headers?: Record<string, string> };
-
-export class SoundSource {
-    private readonly value: SoundSourceValue;
-
-    constructor(value: SoundSourceValue | null | undefined) {
-        if (value === null || value === undefined) {
-            throw SoundError.invalidSoundSource();
-        }
-        this.value = value;
-    }
-
-    getValue(): SoundSourceValue {
-        return this.value;
-    }
-
-    isLocal(): boolean {
-        return typeof this.value === 'number';
-    }
-
-    isRemote(): boolean {
-        return typeof this.value === 'object' && 'uri' in this.value;
-    }
-}

package/src/domain/value-objects/Volume.ts

@@ -1,26 +0,0 @@
-/**
- * Volume Value Object
- */
-
-export class Volume {
-    private readonly MIN = 0;
-    private readonly MAX = 1;
-    private readonly value: number;
-
-    constructor(value: number) {
-        this.value = this.clamp(value);
-    }
-
-    private clamp(value: number): number {
-        if (!Number.isFinite(value)) return 1.0;
-        return Math.max(this.MIN, Math.min(this.MAX, value));
-    }
-
-    getValue(): number {
-        return this.value;
-    }
-
-    equals(other: Volume): boolean {
-        return this.value === other.value;
-    }
-}

package/src/infrastructure/ExpoAudioService.ts

@@ -1,88 +0,0 @@
-/**
- * Expo Audio Service Implementation
- */
-
-import { Audio } from 'expo-av';
-import type { IAudioService, PlaybackOptions, PlaybackStatus } from '../application/interfaces/IAudioService';
-import { SoundSourceValue } from '../domain/value-objects/SoundSource';
-import { Logger } from './Logger';
-
-export 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: { isLoaded: boolean } & any): PlaybackStatus {
-        if (!status.isLoaded) {
-            return {
-                isLoaded: false,
-                isPlaying: false,
-                isBuffering: false,
-                positionMillis: 0,
-                durationMillis: 0,
-                isLooping: false,
-                didJustFinish: false,
-            };
-        }
-        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,
-            error: status.error,
-        };
-    }
-}

package/src/infrastructure/SoundCache.ts

@@ -1,70 +0,0 @@
-/**
- * Sound Cache Implementation
- */
-
-import { ISoundCache, CachedSound } from '../application/interfaces/ISoundCache';
-import { IAudioService } from '../application/interfaces/IAudioService';
-import { Logger } from './Logger';
-
-export class SoundCache implements ISoundCache {
-    private cache = new Map<string, CachedSound>();
-    private readonly maxCacheSize = 3;
-    private readonly cacheExpireMs = 5 * 60 * 1000;
-
-    constructor(private readonly audioService: IAudioService) {}
-
-    get(id: string): CachedSound | undefined {
-        return this.cache.get(id);
-    }
-
-    set(id: string, cached: CachedSound): void {
-        this.cleanExpired();
-        this.enforceLimit();
-        this.cache.set(id, cached);
-        Logger.debug(`Cached: ${id}`);
-    }
-
-    delete(id: string): void {
-        const cached = this.cache.get(id);
-        if (cached) {
-            this.audioService.unload(cached.sound).catch((error) => {
-                Logger.warn(`Failed to unload cache: ${id}`, error);
-            });
-        }
-        this.cache.delete(id);
-    }
-
-    has(id: string): boolean {
-        return this.cache.has(id);
-    }
-
-    clear(): void {
-        for (const cached of this.cache.values()) {
-            this.audioService.unload(cached.sound).catch((error) => {
-                Logger.warn('Failed to unload during cache clear', error);
-            });
-        }
-        this.cache.clear();
-        Logger.debug('Cache cleared');
-    }
-
-    cleanExpired(): void {
-        const now = Date.now();
-        for (const [id, cached] of this.cache) {
-            if (now - cached.loadedAt > this.cacheExpireMs) {
-                this.delete(id);
-                Logger.debug(`Expired cache removed: ${id}`);
-            }
-        }
-    }
-
-    enforceLimit(): void {
-        if (this.cache.size >= this.maxCacheSize) {
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey) {
-                this.delete(firstKey);
-                Logger.debug(`Cache limit enforced, removed: ${firstKey}`);
-            }
-        }
-    }
-}

package/src/presentation/hooks/useSound.ts

@@ -1,47 +0,0 @@
-/**
- * useSound Hook - Presentation Layer
- */
-
-import { useSoundStore } from '../store';
-import { SoundServiceFacade } from '../../application/SoundServiceFacade';
-
-let facade: SoundServiceFacade | null = null;
-
-const getFacade = (): SoundServiceFacade => {
-    if (!facade) {
-        facade = SoundServiceFacade.create(useSoundStore.getState());
-    }
-    return facade;
-};
-
-export const useSound = () => {
-    const state = useSoundStore();
-
-    const facade = getFacade();
-
-    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
-        play: (id: string, source: any, options?: any) => facade.play(id, source, options),
-        pause: () => facade.pause(),
-        resume: () => facade.resume(),
-        stop: () => facade.stop(),
-        seek: (positionMillis: number) => facade.seek(positionMillis),
-        setVolume: (volume: number) => facade.setVolume(volume),
-        setRate: (rate: number) => facade.setRate(rate),
-        preload: (id: string, source: any, options?: any) => facade.preload(id, source, options),
-        unload: () => facade.unload(),
-        clearCache: () => facade.clearCache(),
-        isCached: (id: string) => facade.isCached(id),
-    };
-};

package/src/presentation/store.ts

@@ -1,58 +0,0 @@
-/**
- * Sound Store - State Management
- */
-
-import { createStore } from '@umituz/react-native-design-system/storage';
-
-interface SoundState {
-    isPlaying: boolean;
-    isBuffering: boolean;
-    positionMillis: number;
-    durationMillis: number;
-    volume: number;
-    rate: number;
-    isLooping: boolean;
-    error: string | null;
-    currentId: string | 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: any) => 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,
-};
-
-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) => set({ currentId }),
-        setVolumeState: (volume) => set({ volume }),
-        setRateState: (rate) => set({ rate }),
-        setLooping: (isLooping) => set({ isLooping }),
-        reset: () => set(initialState),
-    }),
-});