@javascriptcommon/react-native-track-player 4.1.8 → 4.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@javascriptcommon/react-native-track-player",
-  "version": "4.1.8",
+  "version": "4.1.9",
   "description": "A fully fledged audio module created for music apps",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",
@@ -31,7 +31,6 @@
     "android/src/**/*",
     "android/build.gradle",
     "android/proguard-rules.txt",
-    "web/**/*",
     "*.podspec",
     "specs"
   ],

package/lib/src/TrackPlayerModule.web.d.ts

@@ -1,2 +0,0 @@
-import TrackPlayerModule from '../web';
-export default TrackPlayerModule;

package/lib/src/TrackPlayerModule.web.js

@@ -1,2 +0,0 @@
-import TrackPlayerModule from '../web';
-export default TrackPlayerModule;

package/lib/src/resolveAssetSource.web.d.ts

@@ -1,2 +0,0 @@
-declare const resolveAssetResource: (base64: unknown) => unknown;
-export default resolveAssetResource;

package/lib/src/resolveAssetSource.web.js

@@ -1,8 +0,0 @@
-const resolveAssetResource = (base64) => {
-    if (/^https?:\/\//.test(base64)) {
-        return base64;
-    }
-    // TODO: resolveAssetResource for web
-    return base64;
-};
-export default resolveAssetResource;

package/lib/web/TrackPlayer/Player.d.ts

@@ -1,40 +0,0 @@
-import { State } from '../../src/constants/State';
-import type { Track, Progress, PlaybackState } from '../../src/interfaces';
-export declare class Player {
-    protected hasInitialized: boolean;
-    protected element?: HTMLMediaElement;
-    protected player?: shaka.Player;
-    protected _current?: Track;
-    protected _playWhenReady: boolean;
-    protected _state: PlaybackState;
-    get current(): Track | undefined;
-    set current(cur: Track | undefined);
-    get state(): PlaybackState;
-    set state(newState: PlaybackState);
-    get playWhenReady(): boolean;
-    set playWhenReady(pwr: boolean);
-    setupPlayer(): Promise<void>;
-    /**
-     * event handlers
-     */
-    protected onStateUpdate(state: Exclude<State, State.Error>): void;
-    protected onError(error: any): void;
-    /**
-     * player control
-     */
-    load(track: Track): Promise<void>;
-    retry(): Promise<void>;
-    stop(): Promise<void>;
-    play(): Promise<void>;
-    pause(): void;
-    setRate(rate: number): number;
-    getRate(): number;
-    seekBy(offset: number): void;
-    seekTo(seconds: number): void;
-    setVolume(volume: number): void;
-    getVolume(): number;
-    getDuration(): number;
-    getPosition(): number;
-    getProgress(): Progress;
-    getBufferedPosition(): (index: number) => number;
-}

package/lib/web/TrackPlayer/Player.js

@@ -1,188 +0,0 @@
-import { State } from '../../src/constants/State';
-import { SetupNotCalledError } from './SetupNotCalledError';
-export class Player {
-    hasInitialized = false;
-    element;
-    player;
-    _current = undefined;
-    _playWhenReady = false;
-    _state = { state: State.None };
-    // current getter/setter
-    get current() {
-        return this._current;
-    }
-    set current(cur) {
-        this._current = cur;
-    }
-    // state getter/setter
-    get state() {
-        return this._state;
-    }
-    set state(newState) {
-        this._state = newState;
-    }
-    // playWhenReady getter/setter
-    get playWhenReady() {
-        return this._playWhenReady;
-    }
-    set playWhenReady(pwr) {
-        this._playWhenReady = pwr;
-    }
-    async setupPlayer() {
-        // shaka only runs in a browser
-        if (typeof window === 'undefined')
-            return;
-        if (this.hasInitialized === true) {
-            // TODO: double check the structure of this error message
-            throw { code: 'player_already_initialized', message: 'The player has already been initialized via setupPlayer.' };
-        }
-        // @ts-ignore
-        const shaka = (await import('shaka-player/dist/shaka-player.ui')).default;
-        // Install built-in polyfills to patch browser incompatibilities.
-        shaka.polyfill.installAll();
-        // Check to see if the browser supports the basic APIs Shaka needs.
-        if (!shaka.Player.isBrowserSupported()) {
-            // This browser does not have the minimum set of APIs we need.
-            this.state = {
-                state: State.Error,
-                error: {
-                    code: 'not_supported',
-                    message: 'Browser not supported.',
-                },
-            };
-            throw new Error('Browser not supported.');
-        }
-        // build dom element and attach shaka-player
-        this.element = document.createElement('audio');
-        this.element.setAttribute('id', 'react-native-track-player');
-        this.player = new shaka.Player();
-        this.player?.attach(this.element);
-        // Listen for relevant events events.
-        this.player.addEventListener('error', (error) => {
-            // Extract the shaka.util.Error object from the event.
-            this.onError(error.detail);
-        });
-        this.element.addEventListener('ended', this.onStateUpdate.bind(this, State.Ended));
-        this.element.addEventListener('playing', this.onStateUpdate.bind(this, State.Playing));
-        this.element.addEventListener('pause', this.onStateUpdate.bind(this, State.Paused));
-        this.player.addEventListener('loading', this.onStateUpdate.bind(this, State.Loading));
-        this.player.addEventListener('loaded', this.onStateUpdate.bind(this, State.Ready));
-        this.player.addEventListener('buffering', ({ buffering }) => {
-            if (buffering === true) {
-                this.onStateUpdate(State.Buffering);
-            }
-        });
-        // Attach player to the window to make it easy to access in the JS console.
-        // @ts-ignore
-        window.rntp = this.player;
-        this.hasInitialized = true;
-    }
-    /**
-     * event handlers
-     */
-    onStateUpdate(state) {
-        this.state = { state };
-    }
-    onError(error) {
-        // unload the current track to allow for clean playback on other
-        this.player?.unload();
-        this.state = {
-            state: State.Error,
-            error: {
-                code: error.code.toString(),
-                message: error.message,
-            },
-        };
-        // Log the error.
-        console.debug('Error code', error.code, 'object', error);
-    }
-    /**
-     * player control
-     */
-    async load(track) {
-        if (!this.player)
-            throw new SetupNotCalledError();
-        await this.player.load(track.url);
-        this.current = track;
-    }
-    async retry() {
-        if (!this.player)
-            throw new SetupNotCalledError();
-        this.player.retryStreaming();
-    }
-    async stop() {
-        if (!this.player)
-            throw new SetupNotCalledError();
-        this.current = undefined;
-        await this.player.unload();
-    }
-    play() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        this.playWhenReady = true;
-        return this.element.play()
-            .catch(err => {
-            console.error(err);
-        });
-    }
-    pause() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        this.playWhenReady = false;
-        return this.element.pause();
-    }
-    setRate(rate) {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.playbackRate = rate;
-    }
-    getRate() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.playbackRate;
-    }
-    seekBy(offset) {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        this.element.currentTime += offset;
-    }
-    seekTo(seconds) {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        this.element.currentTime = seconds;
-    }
-    setVolume(volume) {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        this.element.volume = volume;
-    }
-    getVolume() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.volume;
-    }
-    getDuration() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.duration;
-    }
-    getPosition() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.currentTime;
-    }
-    getProgress() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return {
-            position: this.element.currentTime,
-            duration: this.element.duration || 0,
-            buffered: 0, // TODO: this.element.buffered.end,
-        };
-    }
-    getBufferedPosition() {
-        if (!this.element)
-            throw new SetupNotCalledError();
-        return this.element.buffered.end;
-    }
-}

package/lib/web/TrackPlayer/PlaylistPlayer.d.ts

@@ -1,31 +0,0 @@
-import { Player } from './Player';
-import type { Track } from '../../src/interfaces';
-import { RepeatMode } from './RepeatMode';
-import { State } from '../../src';
-export declare class PlaylistPlayer extends Player {
-    protected playlist: Track[];
-    protected lastIndex?: number;
-    protected _currentIndex?: number;
-    protected repeatMode: RepeatMode;
-    protected onStateUpdate(state: Exclude<State, State.Error>): Promise<void>;
-    protected onTrackEnded(): Promise<void>;
-    protected onPlaylistEnded(): void;
-    protected get currentIndex(): number | undefined;
-    protected set currentIndex(current: number | undefined);
-    protected goToIndex(index: number, initialPosition?: number): Promise<void>;
-    add(tracks: Track[], insertBeforeIndex?: number): Promise<void>;
-    skip(index: number, initialPosition?: number): Promise<void>;
-    skipToNext(initialPosition?: number): Promise<void>;
-    skipToPrevious(initialPosition?: number): Promise<void>;
-    getTrack(index: number): Track | null;
-    setRepeatMode(mode: RepeatMode): void;
-    getRepeatMode(): RepeatMode;
-    remove(indexes: number[]): Promise<void>;
-    stop(): Promise<void>;
-    reset(): Promise<void>;
-    removeUpcomingTracks(): Promise<void>;
-    move(fromIndex: number, toIndex: number): Promise<void>;
-    updateMetadataForTrack(index: number, metadata: Partial<Track>): void;
-    clearNowPlayingMetadata(): void;
-    updateNowPlayingMetadata(metadata: Partial<Track>): void;
-}

package/lib/web/TrackPlayer/PlaylistPlayer.js

@@ -1,181 +0,0 @@
-import { Player } from './Player';
-import { RepeatMode } from './RepeatMode';
-import { State } from '../../src';
-export class PlaylistPlayer extends Player {
-    // TODO: use immer to make the `playlist` immutable
-    playlist = [];
-    lastIndex;
-    _currentIndex;
-    repeatMode = RepeatMode.Off;
-    async onStateUpdate(state) {
-        super.onStateUpdate(state);
-        if (state === State.Ended) {
-            await this.onTrackEnded();
-        }
-    }
-    async onTrackEnded() {
-        switch (this.repeatMode) {
-            case RepeatMode.Track:
-                if (this.currentIndex !== undefined) {
-                    await this.goToIndex(this.currentIndex);
-                }
-                break;
-            case RepeatMode.Playlist:
-                if (this.currentIndex === this.playlist.length - 1) {
-                    await this.goToIndex(0);
-                }
-                else {
-                    await this.skipToNext();
-                }
-                break;
-            default:
-                try {
-                    await this.skipToNext();
-                }
-                catch (err) {
-                    if (err.message !== 'playlist_exhausted') {
-                        throw err;
-                    }
-                    this.onPlaylistEnded();
-                }
-                break;
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    onPlaylistEnded() { }
-    get currentIndex() {
-        return this._currentIndex;
-    }
-    set currentIndex(current) {
-        this.lastIndex = this.currentIndex;
-        this._currentIndex = current;
-    }
-    async goToIndex(index, initialPosition) {
-        const track = this.playlist[index];
-        if (!track) {
-            throw new Error('playlist_exhausted');
-        }
-        if (this.currentIndex !== index) {
-            this.currentIndex = index;
-            await this.load(track);
-        }
-        if (initialPosition) {
-            this.seekTo(initialPosition);
-        }
-        if (this.playWhenReady) {
-            await this.play();
-        }
-    }
-    async add(tracks, insertBeforeIndex) {
-        if (insertBeforeIndex !== -1 && insertBeforeIndex !== undefined) {
-            this.playlist.splice(insertBeforeIndex, 0, ...tracks);
-        }
-        else {
-            this.playlist.push(...tracks);
-        }
-        if (this.currentIndex === undefined) {
-            await this.goToIndex(0);
-        }
-    }
-    async skip(index, initialPosition) {
-        const track = this.playlist[index];
-        if (track === undefined) {
-            throw new Error('index out of bounds');
-        }
-        await this.goToIndex(index, initialPosition);
-    }
-    async skipToNext(initialPosition) {
-        if (this.currentIndex === undefined)
-            return;
-        const index = this.currentIndex + 1;
-        await this.goToIndex(index, initialPosition);
-    }
-    async skipToPrevious(initialPosition) {
-        if (this.currentIndex === undefined)
-            return;
-        const index = this.currentIndex - 1;
-        await this.goToIndex(index, initialPosition);
-    }
-    getTrack(index) {
-        const track = this.playlist[index];
-        return track || null;
-    }
-    setRepeatMode(mode) {
-        this.repeatMode = mode;
-    }
-    getRepeatMode() {
-        return this.repeatMode;
-    }
-    async remove(indexes) {
-        const idxMap = indexes.reduce((acc, elem) => {
-            acc[elem] = true;
-            return acc;
-        }, {});
-        let isCurrentRemoved = false;
-        this.playlist = this.playlist.filter((_track, idx) => {
-            const keep = !idxMap[idx];
-            if (!keep && idx === this.currentIndex) {
-                isCurrentRemoved = true;
-            }
-            return keep;
-        });
-        if (this.currentIndex === undefined) {
-            return;
-        }
-        const hasItems = this.playlist.length > 0;
-        if (isCurrentRemoved && hasItems) {
-            await this.goToIndex(this.currentIndex % this.playlist.length);
-        }
-        else if (isCurrentRemoved) {
-            await this.stop();
-        }
-    }
-    async stop() {
-        await super.stop();
-        this.currentIndex = undefined;
-    }
-    async reset() {
-        await this.stop();
-        this.playlist = [];
-    }
-    async removeUpcomingTracks() {
-        if (this.currentIndex === undefined)
-            return;
-        this.playlist = this.playlist.slice(0, this.currentIndex + 1);
-    }
-    async move(fromIndex, toIndex) {
-        if (!this.playlist[fromIndex]) {
-            throw new Error('index out of bounds');
-        }
-        if (this.currentIndex === fromIndex) {
-            throw new Error('you cannot move the currently playing track');
-        }
-        if (this.currentIndex === toIndex) {
-            throw new Error('you cannot replace the currently playing track');
-        }
-        // calculate `currentIndex` after move
-        let shift = undefined;
-        if (this.currentIndex) {
-            if (fromIndex < this.currentIndex && toIndex > this.currentIndex) {
-                shift = -1;
-            }
-            else if (fromIndex > this.currentIndex && toIndex < this.currentIndex) {
-                shift = +1;
-            }
-        }
-        // move the track
-        const fromItem = this.playlist[fromIndex];
-        this.playlist.splice(fromIndex, 1);
-        this.playlist.splice(toIndex, 0, fromItem);
-        if (this.currentIndex && shift) {
-            this.currentIndex = this.currentIndex + shift;
-        }
-    }
-    // TODO
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    updateMetadataForTrack(index, metadata) { }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    clearNowPlayingMetadata() { }
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    updateNowPlayingMetadata(metadata) { }
-}

package/lib/web/TrackPlayer/RepeatMode.d.ts

@@ -1,5 +0,0 @@
-export declare enum RepeatMode {
-    Off = "REPEAT_OFF",
-    Track = "REPEAT_TRACK",
-    Playlist = "REPEAT_PLAYLIST"
-}

package/lib/web/TrackPlayer/RepeatMode.js

@@ -1,6 +0,0 @@
-export var RepeatMode;
-(function (RepeatMode) {
-    RepeatMode["Off"] = "REPEAT_OFF";
-    RepeatMode["Track"] = "REPEAT_TRACK";
-    RepeatMode["Playlist"] = "REPEAT_PLAYLIST";
-})(RepeatMode || (RepeatMode = {}));

package/lib/web/TrackPlayer/SetupNotCalledError.d.ts

@@ -1,3 +0,0 @@
-export declare class SetupNotCalledError extends Error {
-    constructor();
-}

package/lib/web/TrackPlayer/SetupNotCalledError.js

@@ -1,5 +0,0 @@
-export class SetupNotCalledError extends Error {
-    constructor() {
-        super('You must call `setupPlayer` prior to interacting with the player.');
-    }
-}

package/lib/web/TrackPlayer/index.d.ts

@@ -1,3 +0,0 @@
-export * from './Player';
-export * from './PlaylistPlayer';
-export * from './RepeatMode';

package/lib/web/TrackPlayer/index.js

@@ -1,3 +0,0 @@
-export * from './Player';
-export * from './PlaylistPlayer';
-export * from './RepeatMode';

package/lib/web/TrackPlayerModule.d.ts

@@ -1,63 +0,0 @@
-import { PlaybackState, State } from '../src';
-import type { Track, UpdateOptions } from '../src';
-import { PlaylistPlayer, RepeatMode } from './TrackPlayer';
-export declare class TrackPlayerModule extends PlaylistPlayer {
-    protected emitter: import("react-native").DeviceEventEmitterStatic;
-    protected progressUpdateEventInterval: any;
-    readonly CAPABILITY_PLAY = "CAPABILITY_PLAY";
-    readonly CAPABILITY_PLAY_FROM_ID = "CAPABILITY_PLAY_FROM_ID";
-    readonly CAPABILITY_PLAY_FROM_SEARCH = "CAPABILITY_PLAY_FROM_SEARCH";
-    readonly CAPABILITY_PAUSE = "CAPABILITY_PAUSE";
-    readonly CAPABILITY_STOP = "CAPABILITY_STOP";
-    readonly CAPABILITY_SEEK_TO = "CAPABILITY_SEEK_TO";
-    readonly CAPABILITY_SKIP = "CAPABILITY_SKIP";
-    readonly CAPABILITY_SKIP_TO_NEXT = "CAPABILITY_SKIP_TO_NEXT";
-    readonly CAPABILITY_SKIP_TO_PREVIOUS = "CAPABILITY_SKIP_TO_PREVIOUS";
-    readonly CAPABILITY_JUMP_FORWARD = "CAPABILITY_JUMP_FORWARD";
-    readonly CAPABILITY_JUMP_BACKWARD = "CAPABILITY_JUMP_BACKWARD";
-    readonly CAPABILITY_SET_RATING = "CAPABILITY_SET_RATING";
-    readonly CAPABILITY_LIKE = "CAPABILITY_LIKE";
-    readonly CAPABILITY_DISLIKE = "CAPABILITY_DISLIKE";
-    readonly CAPABILITY_BOOKMARK = "CAPABILITY_BOOKMARK";
-    readonly STATE_NONE = "STATE_NONE";
-    readonly STATE_READY = "STATE_READY";
-    readonly STATE_PLAYING = "STATE_PLAYING";
-    readonly STATE_PAUSED = "STATE_PAUSED";
-    readonly STATE_STOPPED = "STATE_STOPPED";
-    readonly STATE_BUFFERING = "STATE_BUFFERING";
-    readonly STATE_CONNECTING = "STATE_CONNECTING";
-    readonly RATING_HEART = "RATING_HEART";
-    readonly RATING_THUMBS_UP_DOWN = "RATING_THUMBS_UP_DOWN";
-    readonly RATING_3_STARS = "RATING_3_STARS";
-    readonly RATING_4_STARS = "RATING_4_STARS";
-    readonly RATING_5_STARS = "RATING_5_STARS";
-    readonly RATING_PERCENTAGE = "RATING_PERCENTAGE";
-    readonly REPEAT_OFF = RepeatMode.Off;
-    readonly REPEAT_TRACK = RepeatMode.Track;
-    readonly REPEAT_QUEUE = RepeatMode.Playlist;
-    readonly PITCH_ALGORITHM_LINEAR = "PITCH_ALGORITHM_LINEAR";
-    readonly PITCH_ALGORITHM_MUSIC = "PITCH_ALGORITHM_MUSIC";
-    readonly PITCH_ALGORITHM_VOICE = "PITCH_ALGORITHM_VOICE";
-    get state(): PlaybackState;
-    set state(newState: PlaybackState);
-    updateOptions(options: UpdateOptions): Promise<void>;
-    protected setupProgressUpdates(interval?: number): void;
-    protected clearUpdateEventInterval(): void;
-    protected onTrackEnded(): Promise<void>;
-    protected onPlaylistEnded(): Promise<void>;
-    get playWhenReady(): boolean;
-    set playWhenReady(pwr: boolean);
-    getPlayWhenReady(): boolean;
-    setPlayWhenReady(pwr: boolean): boolean;
-    load(track: Track): Promise<void>;
-    getQueue(): Track[];
-    setQueue(queue: Track[]): Promise<void>;
-    getActiveTrack(): Track | undefined;
-    getActiveTrackIndex(): number | undefined;
-    /**
-     * @deprecated
-     * @returns State
-     */
-    getState(): State;
-    getPlaybackState(): PlaybackState;
-}