@javascriptcommon/react-native-track-player 1.2.9 → 4.1.4

package/lib/web/TrackPlayer/Player.js

@@ -0,0 +1,188 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,181 @@
+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

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

package/lib/web/TrackPlayer/RepeatMode.js

@@ -0,0 +1,6 @@
+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

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

package/lib/web/TrackPlayer/SetupNotCalledError.js

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

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

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

package/lib/web/TrackPlayer/index.js

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

package/lib/web/TrackPlayerModule.d.ts

@@ -0,0 +1,63 @@
+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;
+}

package/lib/web/TrackPlayerModule.js

@@ -0,0 +1,153 @@
+import { DeviceEventEmitter } from 'react-native';
+import { Event, State } from '../src';
+import { PlaylistPlayer, RepeatMode } from './TrackPlayer';
+import { SetupNotCalledError } from './TrackPlayer/SetupNotCalledError';
+export class TrackPlayerModule extends PlaylistPlayer {
+    emitter = DeviceEventEmitter;
+    progressUpdateEventInterval;
+    // Capabilities
+    CAPABILITY_PLAY = 'CAPABILITY_PLAY';
+    CAPABILITY_PLAY_FROM_ID = 'CAPABILITY_PLAY_FROM_ID';
+    CAPABILITY_PLAY_FROM_SEARCH = 'CAPABILITY_PLAY_FROM_SEARCH';
+    CAPABILITY_PAUSE = 'CAPABILITY_PAUSE';
+    CAPABILITY_STOP = 'CAPABILITY_STOP';
+    CAPABILITY_SEEK_TO = 'CAPABILITY_SEEK_TO';
+    CAPABILITY_SKIP = 'CAPABILITY_SKIP';
+    CAPABILITY_SKIP_TO_NEXT = 'CAPABILITY_SKIP_TO_NEXT';
+    CAPABILITY_SKIP_TO_PREVIOUS = 'CAPABILITY_SKIP_TO_PREVIOUS';
+    CAPABILITY_JUMP_FORWARD = 'CAPABILITY_JUMP_FORWARD';
+    CAPABILITY_JUMP_BACKWARD = 'CAPABILITY_JUMP_BACKWARD';
+    CAPABILITY_SET_RATING = 'CAPABILITY_SET_RATING';
+    CAPABILITY_LIKE = 'CAPABILITY_LIKE';
+    CAPABILITY_DISLIKE = 'CAPABILITY_DISLIKE';
+    CAPABILITY_BOOKMARK = 'CAPABILITY_BOOKMARK';
+    // States
+    STATE_NONE = 'STATE_NONE';
+    STATE_READY = 'STATE_READY';
+    STATE_PLAYING = 'STATE_PLAYING';
+    STATE_PAUSED = 'STATE_PAUSED';
+    STATE_STOPPED = 'STATE_STOPPED';
+    STATE_BUFFERING = 'STATE_BUFFERING';
+    STATE_CONNECTING = 'STATE_CONNECTING';
+    // Rating Types
+    RATING_HEART = 'RATING_HEART';
+    RATING_THUMBS_UP_DOWN = 'RATING_THUMBS_UP_DOWN';
+    RATING_3_STARS = 'RATING_3_STARS';
+    RATING_4_STARS = 'RATING_4_STARS';
+    RATING_5_STARS = 'RATING_5_STARS';
+    RATING_PERCENTAGE = 'RATING_PERCENTAGE';
+    // Repeat Modes
+    REPEAT_OFF = RepeatMode.Off;
+    REPEAT_TRACK = RepeatMode.Track;
+    REPEAT_QUEUE = RepeatMode.Playlist;
+    // Pitch Algorithms
+    PITCH_ALGORITHM_LINEAR = 'PITCH_ALGORITHM_LINEAR';
+    PITCH_ALGORITHM_MUSIC = 'PITCH_ALGORITHM_MUSIC';
+    PITCH_ALGORITHM_VOICE = 'PITCH_ALGORITHM_VOICE';
+    // observe and emit state changes
+    get state() {
+        return super.state;
+    }
+    set state(newState) {
+        super.state = newState;
+        this.emitter.emit(Event.PlaybackState, newState);
+    }
+    async updateOptions(options) {
+        this.setupProgressUpdates(options.progressUpdateEventInterval);
+    }
+    setupProgressUpdates(interval) {
+        // clear and reset interval
+        this.clearUpdateEventInterval();
+        if (interval) {
+            this.clearUpdateEventInterval();
+            this.progressUpdateEventInterval = setInterval(async () => {
+                if (this.state.state === State.Playing) {
+                    const progress = await this.getProgress();
+                    this.emitter.emit(Event.PlaybackProgressUpdated, {
+                        ...progress,
+                        track: this.currentIndex,
+                    });
+                }
+            }, interval * 1000);
+        }
+    }
+    clearUpdateEventInterval() {
+        if (this.progressUpdateEventInterval) {
+            clearInterval(this.progressUpdateEventInterval);
+        }
+    }
+    async onTrackEnded() {
+        const position = this.element.currentTime;
+        await super.onTrackEnded();
+        this.emitter.emit(Event.PlaybackTrackChanged, {
+            track: this.lastIndex,
+            position,
+            nextTrack: this.currentIndex,
+        });
+    }
+    async onPlaylistEnded() {
+        await super.onPlaylistEnded();
+        this.emitter.emit(Event.PlaybackQueueEnded, {
+            track: this.currentIndex,
+            position: this.element.currentTime,
+        });
+    }
+    get playWhenReady() {
+        return super.playWhenReady;
+    }
+    set playWhenReady(pwr) {
+        const didChange = pwr !== this._playWhenReady;
+        super.playWhenReady = pwr;
+        if (didChange) {
+            this.emitter.emit(Event.PlaybackPlayWhenReadyChanged, { playWhenReady: this._playWhenReady });
+        }
+    }
+    getPlayWhenReady() {
+        return this.playWhenReady;
+    }
+    setPlayWhenReady(pwr) {
+        this.playWhenReady = pwr;
+        return this.playWhenReady;
+    }
+    async load(track) {
+        if (!this.element)
+            throw new SetupNotCalledError();
+        const lastTrack = this.current;
+        const lastPosition = this.element.currentTime;
+        await super.load(track);
+        this.emitter.emit(Event.PlaybackActiveTrackChanged, {
+            lastTrack,
+            lastPosition,
+            lastIndex: this.lastIndex,
+            index: this.currentIndex,
+            track,
+        });
+    }
+    getQueue() {
+        return this.playlist;
+    }
+    async setQueue(queue) {
+        await this.stop();
+        this.playlist = queue;
+    }
+    getActiveTrack() {
+        return this.current;
+    }
+    getActiveTrackIndex() {
+        // per the existing spec, this should throw if setup hasn't been called
+        if (!this.element || !this.player)
+            throw new SetupNotCalledError();
+        return this.currentIndex;
+    }
+    /**
+     * @deprecated
+     * @returns State
+     */
+    getState() {
+        return this.state.state;
+    }
+    getPlaybackState() {
+        return this.state;
+    }
+}
+;

package/lib/web/index.d.ts

@@ -0,0 +1,3 @@
+import { TrackPlayerModule } from './TrackPlayerModule';
+declare const module: TrackPlayerModule;
+export default module;

package/lib/web/index.js

@@ -0,0 +1,3 @@
+import { TrackPlayerModule } from './TrackPlayerModule';
+const module = new TrackPlayerModule();
+export default module;