react-native-audio-browser 0.2.0-next.9 → 0.2.0

package/src/web/TrackPlayer/Player.dispatch.test.ts

@@ -1,229 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { Playback, PlaybackState } from '../../features'
-import type { PlaybackEvent } from './PlaybackStateMachine'
-import { Player } from './Player'
-import { QueuePlayer } from './QueuePlayer'
-
-// Exercises the integration seam between the element/Shaka events and the state
-// machine — the web-specific behaviour the pure machine test doesn't cover.
-class TestPlayer extends Player {
-  forceState(state: PlaybackState): void {
-    this.state = { state }
-  }
-  forceStopped(stopped: boolean): void {
-    this._isStopped = stopped
-  }
-  emit(event: PlaybackEvent): void {
-    this.dispatch(event)
-  }
-  read(): Playback {
-    return this.state
-  }
-}
-
-class TestQueuePlayer extends QueuePlayer {
-  endedCount = 0
-  protected onTrackEnded(): void {
-    this.endedCount++
-  }
-  forceStopped(stopped: boolean): void {
-    this._isStopped = stopped
-  }
-  emit(event: PlaybackEvent): void {
-    this.dispatch(event)
-  }
-}
-
-describe('Player.dispatch', () => {
-  it('keeps the error when the post-unload pause arrives (the documented bug)', () => {
-    const player = new TestPlayer()
-    player.forceState('error')
-
-    // onError() unloads, which makes the element emit `pause` with the track
-    // still set. Pre-machine this clobbered the error with `paused`.
-    player.emit({ type: 'paused', hasAsset: true })
-
-    expect(player.read().state).toBe('error')
-  })
-
-  it('ignores element/Shaka events while stopped', () => {
-    const player = new TestPlayer()
-    player.forceState('stopped')
-    player.forceStopped(true)
-
-    player.emit({ type: 'playing' })
-    player.emit({ type: 'waiting' })
-
-    expect(player.read().state).toBe('stopped')
-  })
-
-  it('stays playing when a rebuffer finishes mid-playback (no ready flash)', () => {
-    const player = new TestPlayer()
-    player.forceState('playing')
-
-    player.emit({ type: 'bufferingSufficient' })
-
-    expect(player.read().state).toBe('playing')
-  })
-
-  it('settles to ready after a load completes', () => {
-    const player = new TestPlayer()
-    player.forceState('loading')
-
-    player.emit({ type: 'loadSeekCompleted' })
-
-    expect(player.read().state).toBe('ready')
-  })
-})
-
-// Uses the real onTrackEnded (unlike TestQueuePlayer) so the natural-end path
-// runs through to onQueueEnded.
-class TestQueueEndPlayer extends QueuePlayer {
-  emit(event: PlaybackEvent): void {
-    this.dispatch(event)
-  }
-}
-
-// Overrides onQueueEnded without calling super — the intent clear must not
-// depend on subclasses remembering to (NativeAudioBrowser overrides this hook).
-class OverridingQueueEndPlayer extends QueuePlayer {
-  queueEndedCount = 0
-  emit(event: PlaybackEvent): void {
-    this.dispatch(event)
-  }
-  protected onQueueEnded(): void {
-    this.queueEndedCount++
-  }
-}
-
-// Records the relative order of the intent drop, the state landing, and the
-// queue-ended hook — pinned to the native order (intent → state → queueEnded).
-class OrderRecordingPlayer extends QueuePlayer {
-  order: string[] = []
-  emit(event: PlaybackEvent): void {
-    this.dispatch(event)
-  }
-  protected get state(): Playback {
-    return super.state
-  }
-  protected set state(newState: Playback) {
-    super.state = newState
-    this.order.push(`state:${newState.state}`)
-  }
-  public get playWhenReady(): boolean {
-    return super.playWhenReady
-  }
-  public set playWhenReady(pwr: boolean) {
-    super.playWhenReady = pwr
-    this.order.push(`pwr:${pwr}`)
-  }
-  protected onQueueEnded(): void {
-    super.onQueueEnded()
-    this.order.push('queueEnded')
-  }
-}
-
-describe('QueuePlayer queue end', () => {
-  it('drops the play intent when the queue ends naturally', () => {
-    const player = new TestQueueEndPlayer()
-    player.playWhenReady = true
-
-    player.emit({ type: 'trackEndedNaturally' })
-
-    // A natural end exhausts the intent: keeping it set inverted
-    // togglePlayback (first press was a silent pause) and armed load()'s
-    // auto-play with phantom intent.
-    expect(player.playWhenReady).toBe(false)
-  })
-
-  it('drops the intent even when onQueueEnded overrides without super', () => {
-    const player = new OverridingQueueEndPlayer()
-    player.playWhenReady = true
-
-    player.emit({ type: 'trackEndedNaturally' })
-
-    expect(player.queueEndedCount).toBe(1)
-    expect(player.playWhenReady).toBe(false)
-  })
-
-  it('orders intent → state → queueEnded, matching native', () => {
-    const player = new OrderRecordingPlayer()
-    player.playWhenReady = true
-    player.order.length = 0
-
-    player.emit({ type: 'trackEndedNaturally' })
-
-    expect(player.order).toEqual(['pwr:false', 'state:ended', 'queueEnded'])
-  })
-})
-
-describe('QueuePlayer remove without a current track', () => {
-  it('keeps the shuffle order aligned with the post-remove layout', () => {
-    class ShuffleTestPlayer extends QueuePlayer {
-      seed(tracks: Array<{ src: string }>): void {
-        this.queue.setTracks(tracks as never)
-      }
-      setCurrent(index: number): void {
-        this.queue.currentIndex = index
-      }
-      neighbours(): [number | undefined, number | undefined] {
-        return [this.queue.previousIndex(), this.queue.nextIndex()]
-      }
-    }
-    const player = new ShuffleTestPlayer()
-    player.setShuffleEnabled(true)
-    player.seed([{ src: 'a' }, { src: 'b' }])
-
-    // 'no-current' outcome: tracks are still spliced, so a stale order would
-    // keep indexing the pre-remove layout.
-    player.remove([0])
-
-    // One track left: a stale two-entry order (either permutation) would give
-    // the survivor a neighbour that no longer exists.
-    player.setCurrent(0)
-    expect(player.neighbours()).toEqual([undefined, undefined])
-  })
-})
-
-describe('QueuePlayer skip while stopped', () => {
-  it('reloads instead of seeking the unloaded element', () => {
-    const loads: string[] = []
-    class SkipTestPlayer extends QueuePlayer {
-      load(track: { src?: string }): void {
-        loads.push(track.src ?? '')
-      }
-      seekTo(): void {}
-      forceStopped(): void {
-        this._isStopped = true
-      }
-    }
-    const player = new SkipTestPlayer()
-    player.add([{ src: 's0' } as never])
-    expect(loads).toEqual(['s0'])
-    player.forceStopped()
-
-    player.skip(0)
-
-    // Same-index skip took the seek branch, which is dead while stopped.
-    expect(loads).toEqual(['s0', 's0'])
-  })
-})
-
-describe('QueuePlayer queue advance', () => {
-  it('advances the queue when a track ends naturally', () => {
-    const player = new TestQueuePlayer()
-
-    player.emit({ type: 'trackEndedNaturally' })
-
-    expect(player.endedCount).toBe(1)
-  })
-
-  it('does not advance the queue on an end event while stopped', () => {
-    const player = new TestQueuePlayer()
-    player.forceStopped(true)
-
-    player.emit({ type: 'trackEndedNaturally' })
-
-    expect(player.endedCount).toBe(0)
-  })
-})

package/src/web/TrackPlayer/Player.load.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { Playback } from '../../features'
-import type { Track } from '../../types'
-import { Player } from './Player'
-
-// A Shaka load interrupted by stop() or a newer load() rejects; only the
-// active load may surface that rejection — otherwise the .catch clobbers the
-// Stopped state (or tears down the newer load via onError's unload).
-class LoadTestPlayer extends Player {
-  rejecters: Array<(err: unknown) => void> = []
-  resolvers: Array<() => void> = []
-  unloadCalls = 0
-
-  constructor() {
-    super()
-    this.element = {
-      play: () => Promise.resolve(),
-      pause: () => {}
-    } as unknown as HTMLMediaElement
-    this.player = {
-      load: () =>
-        new Promise<void>((resolve, reject) => {
-          this.resolvers.push(resolve)
-          this.rejecters.push(reject)
-        }),
-      unload: () => {
-        this.unloadCalls++
-        return Promise.resolve()
-      }
-    } as unknown as typeof this.player
-  }
-
-  read(): Playback {
-    return this.state
-  }
-
-  rejectLoad(index: number, err: unknown): void {
-    this.rejecters[index]?.(err)
-  }
-}
-
-const track = (n: number): Track =>
-  ({
-    id: `t${n}`,
-    src: `https://example.com/${n}.mp3`,
-    title: `T${n}`
-  }) as Track
-
-const tick = () => new Promise((resolve) => setTimeout(resolve, 0))
-
-describe('Player.load rejection staleness', () => {
-  it('a load rejected after stop() does not clobber the stopped state', async () => {
-    const player = new LoadTestPlayer()
-    player.load(track(1))
-    player.stop()
-
-    player.rejectLoad(0, new Error('LOAD_INTERRUPTED'))
-    await tick()
-
-    expect(player.read().state).toBe('stopped')
-  })
-
-  it('a load rejected after a newer load() stays silent', async () => {
-    const player = new LoadTestPlayer()
-    player.load(track(1))
-    player.load(track(2))
-    const unloadsBefore = player.unloadCalls
-
-    player.rejectLoad(0, new Error('LOAD_INTERRUPTED'))
-    await tick()
-
-    // The stale rejection must not set error state or unload the new load.
-    expect(player.read().state).not.toBe('error')
-    expect(player.unloadCalls).toBe(unloadsBefore)
-  })
-
-  it('the active load still surfaces its own failure', async () => {
-    const player = new LoadTestPlayer()
-    player.load(track(1))
-
-    player.rejectLoad(0, new Error('boom'))
-    await tick()
-
-    expect(player.read().state).toBe('error')
-  })
-})

package/src/web/TrackPlayer/PlayingStateFactory.test.ts

@@ -1,51 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { PlaybackState } from '../../features'
-import { derivePlayingState } from './PlayingStateFactory'
-
-// Ported from the native truth table (android PlayingStateFactoryTest.kt /
-// ios PlayingStateManager) so web derives PlayingState identically.
-const ALL_STATES: PlaybackState[] = [
-  'none',
-  'ready',
-  'playing',
-  'paused',
-  'stopped',
-  'loading',
-  'buffering',
-  'error',
-  'ended'
-]
-
-describe('derivePlayingState', () => {
-  it('playWhenReady false is never playing nor buffering', () => {
-    for (const state of ALL_STATES) {
-      expect(derivePlayingState(false, state)).toEqual({
-        playing: false,
-        buffering: false
-      })
-    }
-  })
-
-  it('playWhenReady true plays except in terminal or empty states', () => {
-    const notPlaying = new Set<PlaybackState>([
-      'error',
-      'ended',
-      'none',
-      'stopped'
-    ])
-    for (const state of ALL_STATES) {
-      expect(derivePlayingState(true, state).playing).toBe(
-        !notPlaying.has(state)
-      )
-    }
-  })
-
-  it('buffers only while loading or rebuffering with playWhenReady', () => {
-    const buffering = new Set<PlaybackState>(['loading', 'buffering'])
-    for (const state of ALL_STATES) {
-      expect(derivePlayingState(true, state).buffering).toBe(
-        buffering.has(state)
-      )
-    }
-  })
-})

package/src/web/TrackPlayer/PlayingStateFactory.ts

@@ -1,24 +0,0 @@
-import type { PlaybackState, PlayingState } from '../../features'
-
-/**
- * Derives the two-flag {@link PlayingState} (playing / buffering) from the
- * player's intent (`playWhenReady`) and its current {@link PlaybackState}.
- *
- * A faithful port of the native derivations (android `PlayingStateFactory.derive`,
- * ios `PlayingStateManager.update`) so all platforms agree on what "playing" and
- * "buffering" mean for the now-playing UI.
- */
-export function derivePlayingState(
-  playWhenReady: boolean,
-  state: PlaybackState
-): PlayingState {
-  return {
-    playing:
-      playWhenReady &&
-      state !== 'error' &&
-      state !== 'ended' &&
-      state !== 'none' &&
-      state !== 'stopped',
-    buffering: playWhenReady && (state === 'loading' || state === 'buffering')
-  }
-}

package/src/web/TrackPlayer/QueueManager.test.ts

@@ -1,289 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { Track } from '../../types'
-import { QueueManager } from './QueueManager'
-import { RepeatMode } from './RepeatMode'
-
-// Make shuffle deterministic (identity) so the shuffle-order navigation path is
-// assertable: shuffleOrder becomes [0,1,2,…] before the current-first swap.
-vi.mock('../util/shuffle', () => ({
-  fisherYatesShuffle: () => {}
-}))
-
-const tracks = (n: number): Track[] =>
-  Array.from({ length: n }, (_, i) => ({ src: `s${i}` }) as Track)
-
-describe('QueueManager', () => {
-  let q: QueueManager
-
-  beforeEach(() => {
-    q = new QueueManager()
-  })
-
-  describe('current index', () => {
-    it('tracks the previous index as lastIndex on set', () => {
-      q.currentIndex = 2
-      expect(q.lastIndex).toBeUndefined()
-      q.currentIndex = 5
-      expect(q.lastIndex).toBe(2)
-      expect(q.currentIndex).toBe(5)
-    })
-  })
-
-  describe('insert', () => {
-    it('adjusts currentIndex when inserting before the current track', () => {
-      q.setTracks(tracks(3))
-      q.currentIndex = 1
-
-      q.insert([{ src: 'x' } as Track], 0)
-
-      // The pointer must stay on the same track (remove()/move() already do
-      // this; native adjusts automatically).
-      expect(q.currentIndex).toBe(2)
-      expect(q.getTrack(q.currentIndex!)?.src).toBe('s1')
-    })
-
-    it('keeps currentIndex when inserting after the current track', () => {
-      q.setTracks(tracks(3))
-      q.currentIndex = 1
-
-      q.insert([{ src: 'x' } as Track], 2)
-
-      expect(q.currentIndex).toBe(1)
-    })
-
-    it('keeps currentIndex when appending', () => {
-      q.setTracks(tracks(3))
-      q.currentIndex = 1
-
-      q.insert([{ src: 'x' } as Track])
-
-      expect(q.currentIndex).toBe(1)
-    })
-  })
-
-  describe('sequential navigation', () => {
-    beforeEach(() => {
-      q.setTracks(tracks(3))
-      q.currentIndex = 0
-    })
-
-    it('advances and stops at the end (no wrap by default)', () => {
-      expect(q.nextIndex()).toBe(1)
-      q.currentIndex = 2
-      expect(q.nextIndex()).toBeUndefined()
-    })
-
-    it('goes back and stops at the start', () => {
-      q.currentIndex = 1
-      expect(q.previousIndex()).toBe(0)
-      q.currentIndex = 0
-      expect(q.previousIndex()).toBeUndefined()
-    })
-
-    it('returns undefined navigation when there is no current track', () => {
-      const empty = new QueueManager()
-      empty.setTracks(tracks(3))
-      expect(empty.nextIndex()).toBeUndefined()
-      expect(empty.previousIndex()).toBeUndefined()
-    })
-  })
-
-  describe('wrap-around (repeat playlist)', () => {
-    beforeEach(() => {
-      q.setTracks(tracks(3))
-      q.currentIndex = 2
-    })
-
-    it('only wraps when repeat mode is playlist', () => {
-      expect(q.wrapAroundFirstIndex()).toBeUndefined()
-      expect(q.wrapAroundLastIndex()).toBeUndefined()
-      q.repeatMode = RepeatMode.Queue
-      expect(q.wrapAroundFirstIndex()).toBe(0)
-      expect(q.wrapAroundLastIndex()).toBe(2)
-    })
-  })
-
-  describe('shuffle navigation', () => {
-    beforeEach(() => {
-      q.setTracks(tracks(4))
-      q.currentIndex = 0
-      q.setShuffleEnabled(true) // identity shuffle → order [0,1,2,3]
-    })
-
-    it('navigates along the shuffle order with the current track first', () => {
-      // current (0) is already at position 0, so order stays [0,1,2,3]
-      expect(q.nextIndex()).toBe(1)
-      q.currentIndex = 3
-      expect(q.nextIndex()).toBeUndefined()
-      expect(q.previousIndex()).toBe(2)
-    })
-
-    it('moves the current track to the front of the shuffle order on regen', () => {
-      q.currentIndex = 2
-      q.regenerateShuffleOrder()
-      // order was [0,1,2,3]; current (2) swapped to front → [2,1,0,3]
-      expect(q.previousIndex()).toBeUndefined()
-      expect(q.nextIndex()).toBe(1)
-    })
-
-    // Mutations maintain the shuffle order in place (matching iOS/ExoPlayer)
-    // instead of regenerating it — a regeneration erased the played history,
-    // leaving previous() dead after any add/remove/move.
-
-    it('keeps the shuffle history across an append', () => {
-      q.currentIndex = 2 // identity order [0,1,2,3], position 2
-      const random = vi.spyOn(Math, 'random').mockReturnValue(0.999)
-      try {
-        q.insert([{ src: 'x' } as Track]) // appended at the order's end
-      } finally {
-        random.mockRestore()
-      }
-      expect(q.previousIndex()).toBe(1)
-      expect(q.nextIndex()).toBe(3)
-    })
-
-    it('keeps the shuffle history across a remove of another track', () => {
-      q.currentIndex = 2
-      q.remove([0]) // order [0,1,2,3] → [0,1,2] with current now at index 1
-      expect(q.currentIndex).toBe(1)
-      expect(q.previousIndex()).toBe(0)
-      expect(q.nextIndex()).toBe(2)
-    })
-
-    it('does not let a stale order survive clear()', () => {
-      // Mutations no longer regenerate the order, so clear() must reset it —
-      // otherwise the first post-clear insert shifts a 4-entry ghost order.
-      q.clear()
-      q.insert(tracks(1))
-      q.currentIndex = 0
-      expect(q.previousIndex()).toBeUndefined()
-      expect(q.nextIndex()).toBeUndefined()
-    })
-
-    it('keeps every track at its shuffle position across a move', () => {
-      q.currentIndex = 1
-      q.move(1, 3) // tracks [s0,s2,s3,s1]; order remapped to [0,3,1,2]
-      expect(q.currentIndex).toBe(3)
-      expect(q.previousIndex()).toBe(0)
-      expect(q.nextIndex()).toBe(1)
-    })
-  })
-
-  describe('insert', () => {
-    it('appends when no insert index is given', () => {
-      q.setTracks(tracks(2))
-      q.insert(tracks(1))
-      expect(q.length).toBe(3)
-    })
-
-    it('splices at the given index', () => {
-      q.setTracks([{ src: 'a' }, { src: 'b' }] as Track[])
-      q.insert([{ src: 'x' }] as Track[], 1)
-      expect(q.tracks.map((t) => t.src)).toEqual(['a', 'x', 'b'])
-    })
-
-    it('throws on a negative index other than the -1 append sentinel', () => {
-      q.setTracks(tracks(3))
-      q.currentIndex = 1
-      // -2 used to splice from the end while still shifting the pointer,
-      // leaving currentIndex on a different track (native throws here).
-      expect(() => q.insert(tracks(1), -2)).toThrow('use -1 to append')
-      expect(q.currentIndex).toBe(1)
-      expect(q.length).toBe(3)
-    })
-
-    it('throws on a past-the-end index', () => {
-      q.setTracks(tracks(3))
-      expect(() => q.insert(tracks(1), 4)).toThrow('out of bounds')
-    })
-  })
-
-  describe('remove', () => {
-    beforeEach(() => {
-      q.setTracks(tracks(5)) // s0..s4
-      q.currentIndex = 2
-    })
-
-    it('keeps the current track, shifting its index down for removals before it', () => {
-      const result = q.remove([0])
-      expect(result).toEqual({ kind: 'kept' })
-      expect(q.currentIndex).toBe(1)
-    })
-
-    it('reports the index to reload when the current track is removed', () => {
-      const result = q.remove([2])
-      // index clamped into the shrunken queue; current reset so caller reloads
-      expect(result).toEqual({ kind: 'reload', index: 2 })
-      expect(q.currentIndex).toBeUndefined()
-    })
-
-    it('wraps to the first track when the current track was the last', () => {
-      const result = q.remove([4])
-      expect(result).toEqual({ kind: 'kept' })
-      q.currentIndex = 3 // now the last track
-      // Documented contract (and iOS behavior): removing the last-and-current
-      // track activates the first, not the new last.
-      expect(q.remove([3])).toEqual({ kind: 'reload', index: 0 })
-    })
-
-    it('reports emptied when the last remaining track is removed', () => {
-      q.setTracks(tracks(1))
-      q.currentIndex = 0
-      expect(q.remove([0])).toEqual({ kind: 'emptied' })
-    })
-
-    it('reports no-current when nothing is playing', () => {
-      const idle = new QueueManager()
-      idle.setTracks(tracks(3))
-      expect(idle.remove([0])).toEqual({ kind: 'no-current' })
-      expect(idle.length).toBe(2) // filter still applied
-    })
-  })
-
-  describe('move', () => {
-    beforeEach(() => {
-      q.setTracks(tracks(4)) // s0..s3
-    })
-
-    it('follows the current track to its new position', () => {
-      q.currentIndex = 1
-      q.move(1, 3)
-      expect(q.tracks.map((t) => t.src)).toEqual(['s0', 's2', 's3', 's1'])
-      expect(q.currentIndex).toBe(3)
-    })
-
-    it('shifts the current index when a track moves across it', () => {
-      q.currentIndex = 2
-      q.move(0, 3) // moving an earlier track past current shifts current down
-      expect(q.currentIndex).toBe(1)
-    })
-
-    it('throws on an out-of-bounds source index', () => {
-      expect(() => q.move(9, 0)).toThrow('index out of bounds')
-    })
-
-    it('throws on an out-of-bounds destination index', () => {
-      expect(() => q.move(0, 9)).toThrow('index out of bounds')
-      expect(() => q.move(0, -1)).toThrow('index out of bounds')
-    })
-  })
-
-  describe('removeUpcoming', () => {
-    it('drops everything after the current track', () => {
-      q.setTracks(tracks(5))
-      q.currentIndex = 1
-      q.removeUpcoming()
-      expect(q.tracks.map((t) => t.src)).toEqual(['s0', 's1'])
-    })
-  })
-
-  describe('clear', () => {
-    it('empties the queue and resets the index', () => {
-      q.setTracks(tracks(3))
-      q.currentIndex = 1
-      q.clear()
-      expect(q.length).toBe(0)
-      expect(q.currentIndex).toBeUndefined()
-    })
-  })
-})