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

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;
-}

package/lib/web/TrackPlayerModule.js

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

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

package/lib/web/index.js

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

package/src/TrackPlayerModule.web.ts

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

package/src/resolveAssetSource.web.ts

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

package/web/TrackPlayer/Player.ts

@@ -1,201 +0,0 @@
-import { State } from '../../src/constants/State';
-import type { Track, Progress, PlaybackState } from '../../src/interfaces';
-import { SetupNotCalledError } from './SetupNotCalledError';
-
-export class Player {
-  protected hasInitialized: boolean = false;
-  protected element?: HTMLMediaElement;
-  protected player?: shaka.Player;
-  protected _current?: Track = undefined;
-  protected _playWhenReady: boolean = false;
-  protected _state: PlaybackState = { state: State.None };
-
-  // current getter/setter
-  public get current(): Track | undefined {
-    return this._current;
-  }
-  public set current(cur: Track | undefined) {
-    this._current = cur;
-  }
-
-  // state getter/setter
-  public get state(): PlaybackState {
-    return this._state;
-  }
-  public set state(newState: PlaybackState) {
-    this._state = newState;
-  }
-
-  // playWhenReady getter/setter
-  public get playWhenReady(): boolean {
-    return this._playWhenReady;
-  }
-  public set playWhenReady(pwr: boolean) {
-    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: any) => {
-      // 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 }: any) => {
-      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
-   */
-  protected onStateUpdate(state: Exclude<State, State.Error>) {
-    this.state = { state };
- }
-
-  protected onError(error: any) {
-    // 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
-   */
-  public async load(track: Track) {
-    if (!this.player) throw new SetupNotCalledError();
-    await this.player.load(track.url as string);
-    this.current = track;
-  }
-
-  public async retry() {
-    if (!this.player) throw new SetupNotCalledError();
-    this.player.retryStreaming();
-  }
-
-  public async stop() {
-    if (!this.player) throw new SetupNotCalledError();
-    this.current = undefined;
-    await this.player.unload()
-  }
-
-  public play() {
-    if (!this.element) throw new SetupNotCalledError();
-    this.playWhenReady = true;
-    return this.element.play()
-      .catch(err => {
-        console.error(err);
-      })
-    ;
-  }
-
-  public pause() {
-    if (!this.element) throw new SetupNotCalledError();
-    this.playWhenReady = false;
-    return this.element.pause();
-  }
-
-  public setRate(rate: number) {
-    if (!this.element) throw new SetupNotCalledError();
-    return this.element.playbackRate = rate;
-  }
-
-  public getRate() {
-    if (!this.element) throw new SetupNotCalledError();
-    return this.element.playbackRate;
-  }
-
-  public seekBy(offset: number) {
-    if (!this.element) throw new SetupNotCalledError();
-    this.element.currentTime += offset;
-  }
-
-  public seekTo(seconds: number) {
-    if (!this.element) throw new SetupNotCalledError();
-    this.element.currentTime = seconds;
-  }
-
-  public setVolume(volume: number) {
-    if (!this.element) throw new SetupNotCalledError();
-    this.element.volume = volume;
-  }
-
-  public getVolume() {
-    if (!this.element) throw new SetupNotCalledError();
-    return this.element.volume;
-  }
-
-  public getDuration() {
-    if (!this.element) throw new SetupNotCalledError();
-    return this.element.duration
-  }
-
-  public getPosition() {
-    if (!this.element) throw new SetupNotCalledError();
-    return this.element.currentTime
-  }
-
-  public getProgress(): Progress {
-    if (!this.element) throw new SetupNotCalledError();
-    return {
-      position: this.element.currentTime,
-      duration: this.element.duration || 0,
-      buffered: 0, // TODO: this.element.buffered.end,
-    }
-  }
-
-  public getBufferedPosition() {
-    if (!this.element) throw new SetupNotCalledError();
-    return this.element.buffered.end;
-  }
-}

package/web/TrackPlayer/PlaylistPlayer.ts

@@ -1,215 +0,0 @@
-import { Player } from './Player';
-
-import type { Track } from '../../src/interfaces';
-import {RepeatMode} from './RepeatMode';
-import { State } from '../../src';
-
-export class PlaylistPlayer extends Player {
-  // TODO: use immer to make the `playlist` immutable
-  protected playlist: Track[] = [];
-  protected lastIndex?: number;
-  protected _currentIndex?: number;
-  protected repeatMode: RepeatMode = RepeatMode.Off;
-
-  protected async onStateUpdate(state: Exclude<State, State.Error>) {
-    super.onStateUpdate(state);
-
-    if (state === State.Ended) {
-      await this.onTrackEnded();
-    }
-  }
-
-  protected 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 as Error).message !== 'playlist_exhausted') {
-            throw err;
-          }
-          this.onPlaylistEnded();
-        }
-        break;
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  protected onPlaylistEnded() {}
-
-  protected get currentIndex() {
-    return this._currentIndex;
-  }
-
-  protected set currentIndex(current: number | undefined) {
-    this.lastIndex = this.currentIndex;
-    this._currentIndex = current;
-  }
-
-  protected async goToIndex(index: number, initialPosition?: number) {
-    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();
-    }
-  }
-
-  public async add(tracks: Track[], insertBeforeIndex?: number) {
-    if (insertBeforeIndex !== -1 && insertBeforeIndex !== undefined) {
-      this.playlist.splice(insertBeforeIndex, 0, ...tracks);
-    } else {
-      this.playlist.push(...tracks);
-    }
-
-    if (this.currentIndex === undefined) {
-      await this.goToIndex(0);
-    }
-  }
-
-  public async skip(index: number, initialPosition?: number) {
-    const track = this.playlist[index];
-
-    if (track === undefined) {
-      throw new Error('index out of bounds');
-    }
-
-    await this.goToIndex(index, initialPosition);
-  }
-
-  public async skipToNext(initialPosition?: number) {
-    if (this.currentIndex === undefined) return;
-
-    const index = this.currentIndex + 1;
-    await this.goToIndex(index, initialPosition);
-  }
-
-  public async skipToPrevious(initialPosition?: number) {
-    if (this.currentIndex === undefined) return;
-
-    const index = this.currentIndex - 1;
-    await this.goToIndex(index, initialPosition);
-  }
-
-  public getTrack(index: number): Track | null {
-    const track = this.playlist[index];
-    return track || null;
-  }
-
-  public setRepeatMode(mode: RepeatMode) {
-    this.repeatMode = mode;
-  }
-
-  public getRepeatMode() {
-    return this.repeatMode;
-  }
-
-  public async remove(indexes: number[]) {
-    const idxMap = indexes.reduce<Record<number, boolean>>((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();
-    }
-  }
-
-  public async stop() {
-    await super.stop();
-    this.currentIndex = undefined;
-  }
-
-  public async reset() {
-    await this.stop();
-    this.playlist = [];
-  }
-
-  public async removeUpcomingTracks() {
-    if (this.currentIndex === undefined) return;
-    this.playlist = this.playlist.slice(0, this.currentIndex + 1);
-  }
-
-  public async move(fromIndex: number, toIndex: number): Promise<void> {
-    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: number | undefined = 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
-  public updateMetadataForTrack(index: number, metadata: Partial<Track>) {}
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  public clearNowPlayingMetadata() {}
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  public updateNowPlayingMetadata(metadata: Partial<Track>) {}
-
-}