@5stones/react-native-audio-browser 0.1.4 → 0.1.6

package/src/web/NativeAudioBrowser.ts

@@ -1,9 +1,3 @@
-import type { AudioBrowser as AudioBrowserSpec, IosOutput } from '../specs/audio-browser.nitro'
-import type {
-  ResolvedTrack,
-  Track,
-} from '../types'
-import type { NativeBrowserConfiguration } from '../types/browser-native'
 import type {
   PlaybackErrorEvent,
   PlaybackError,
@@ -40,23 +34,32 @@ import type {
   BatteryOptimizationStatus,
   BatteryOptimizationStatusChangedEvent,
   BatteryWarningPendingChangedEvent,
-  PartialSetupPlayerOptions,
+  PartialSetupPlayerOptions
 } from '../features'
-import { PlaylistPlayer, SleepTimerManager } from './TrackPlayer'
-import { HttpClient } from './http/HttpClient'
+import type {
+  AudioBrowser as AudioBrowserSpec,
+  IosOutput
+} from '../specs/audio-browser.nitro'
+import type { ResolvedTrack, Track } from '../types'
+import type { NativeBrowserConfiguration } from '../types/browser-native'
 import { BrowserManager } from './browser/BrowserManager'
 import { FavoriteManager } from './browser/FavoriteManager'
 import { NavigationErrorManager } from './browser/NavigationErrorManager'
 import { SearchManager } from './browser/SearchManager'
-import { OptionsManager } from './player/OptionsManager'
-import { NowPlayingManager } from './player/NowPlayingManager'
+import { HttpClient } from './http/HttpClient'
 import { RequestConfigBuilder } from './http/RequestConfigBuilder'
+import { NowPlayingManager } from './player/NowPlayingManager'
+import { OptionsManager } from './player/OptionsManager'
+import { PlaylistPlayer, SleepTimerManager } from './TrackPlayer'
 import { BrowserPathHelper } from './util/BrowserPathHelper'
 
 /**
  * Web implementation of AudioBrowser (unified browser + player)
  */
-export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSpec {
+export class NativeAudioBrowser
+  extends PlaylistPlayer
+  implements AudioBrowserSpec
+{
   // HybridObject stuff
   readonly name = 'WebAudioBrowser'
   equals() {
@@ -83,8 +86,10 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
   private nowPlayingManager: NowPlayingManager
 
   // Player state
+  private currentLoadId = 0
   private progressUpdateEventInterval: NodeJS.Timeout | undefined
-  private _online: boolean = typeof navigator !== 'undefined' ? navigator.onLine : true
+  private _online: boolean =
+    typeof navigator !== 'undefined' ? navigator.onLine : true
   private onlineHandler: (() => void) | undefined
   private offlineHandler: (() => void) | undefined
   private sleepTimer = new (class extends SleepTimerManager {
@@ -128,17 +133,24 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
   onContentChanged: (content: ResolvedTrack | undefined) => void = () => {}
   onTabsChanged: (tabs: Track[]) => void = () => {}
   onNavigationError: (data: NavigationErrorEvent) => void = () => {}
-  onFormattedNavigationError: (formattedError: FormattedNavigationError | undefined) => void = () => {}
+  onFormattedNavigationError: (
+    formattedError: FormattedNavigationError | undefined
+  ) => void = () => {}
 
   // MARK: Player event callbacks
   onChapterMetadata: (chapters: ChapterMetadata[]) => void = () => {}
   onTrackMetadata: (metadata: TrackMetadata) => void = () => {}
   onTimedMetadata: (metadata: TimedMetadata) => void = () => {}
-  onPlaybackActiveTrackChanged: (data: PlaybackActiveTrackChangedEvent) => void = () => {}
+  onPlaybackActiveTrackChanged: (
+    data: PlaybackActiveTrackChangedEvent
+  ) => void = () => {}
   onPlaybackError: (data: PlaybackErrorEvent) => void = () => {}
-  onPlaybackPlayWhenReadyChanged: (data: PlaybackPlayWhenReadyChangedEvent) => void = () => {}
+  onPlaybackPlayWhenReadyChanged: (
+    data: PlaybackPlayWhenReadyChangedEvent
+  ) => void = () => {}
   onPlaybackPlayingState: (data: PlayingState) => void = () => {}
-  onPlaybackProgressUpdated: (data: PlaybackProgressUpdatedEvent) => void = () => {}
+  onPlaybackProgressUpdated: (data: PlaybackProgressUpdatedEvent) => void =
+    () => {}
   onPlaybackQueueEnded: (data: PlaybackQueueEndedEvent) => void = () => {}
   onPlaybackQueueChanged: (queue: Track[]) => void = () => {}
   onPlaybackRepeatModeChanged: (data: RepeatModeChangedEvent) => void = () => {}
@@ -165,25 +177,36 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
   onNowPlayingChanged: (metadata: NowPlayingMetadata) => void = () => {}
   onOnlineChanged: (online: boolean) => void = () => {}
   onEqualizerChanged: (settings: EqualizerSettings) => void = () => {}
-  onBatteryWarningPendingChanged: (event: BatteryWarningPendingChangedEvent) => void = () => {}
-  onBatteryOptimizationStatusChanged: (event: BatteryOptimizationStatusChangedEvent) => void = () => {}
+  onBatteryWarningPendingChanged: (
+    event: BatteryWarningPendingChangedEvent
+  ) => void = () => {}
+  onBatteryOptimizationStatusChanged: (
+    event: BatteryOptimizationStatusChangedEvent
+  ) => void = () => {}
   onSystemVolumeChanged: (volume: number) => void = () => {}
   onIosOutputChanged: (output: IosOutput) => void = () => {}
 
   // MARK: Remote handlers
   handleRemoteBookmark: (() => void) | undefined = undefined
   handleRemoteDislike: (() => void) | undefined = undefined
-  handleRemoteJumpBackward: ((event: RemoteJumpBackwardEvent) => void) | undefined = undefined
-  handleRemoteJumpForward: ((event: RemoteJumpForwardEvent) => void) | undefined = undefined
+  handleRemoteJumpBackward:
+    | ((event: RemoteJumpBackwardEvent) => void)
+    | undefined = undefined
+  handleRemoteJumpForward:
+    | ((event: RemoteJumpForwardEvent) => void)
+    | undefined = undefined
   handleRemoteLike: (() => void) | undefined = undefined
   handleRemoteNext: (() => void) | undefined = undefined
   handleRemotePause: (() => void) | undefined = undefined
   handleRemotePlay: (() => void) | undefined = undefined
-  handleRemotePlayId: ((event: RemotePlayIdEvent) => void) | undefined = undefined
-  handleRemotePlaySearch: ((event: RemotePlaySearchEvent) => void) | undefined = undefined
+  handleRemotePlayId: ((event: RemotePlayIdEvent) => void) | undefined =
+    undefined
+  handleRemotePlaySearch: ((event: RemotePlaySearchEvent) => void) | undefined =
+    undefined
   handleRemotePrevious: (() => void) | undefined = undefined
   handleRemoteSeek: ((event: RemoteSeekEvent) => void) | undefined = undefined
-  handleRemoteSetRating: ((event: RemoteSetRatingEvent) => void) | undefined = undefined
+  handleRemoteSetRating: ((event: RemoteSetRatingEvent) => void) | undefined =
+    undefined
   handleRemoteSkip: (() => void) | undefined = undefined
   handleRemoteStop: (() => void) | undefined = undefined
 
@@ -204,19 +227,21 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
       this.navigationErrorManager
     )
 
-    this.searchManager = new SearchManager(
-      this.browserManager,
-      this.httpClient
-    )
+    this.searchManager = new SearchManager(this.browserManager, this.httpClient)
 
     // Wire up event callbacks from managers to class callbacks
     this.browserManager.onPathChanged = (path) => this.onPathChanged(path)
-    this.browserManager.onContentChanged = (content) => this.onContentChanged(content)
+    this.browserManager.onContentChanged = (content) =>
+      this.onContentChanged(content)
     this.browserManager.onTabsChanged = (tabs) => this.onTabsChanged(tabs)
-    this.navigationErrorManager.onNavigationError = (data) => this.onNavigationError(data)
-    this.navigationErrorManager.onFormattedNavigationError = (error) => this.onFormattedNavigationError(error)
-    this.optionsManager.onOptionsChanged = (options) => this.onOptionsChanged(options)
-    this.nowPlayingManager.onNowPlayingChanged = (metadata) => this.onNowPlayingChanged(metadata)
+    this.navigationErrorManager.onNavigationError = (data) =>
+      this.onNavigationError(data)
+    this.navigationErrorManager.onFormattedNavigationError = (error) =>
+      this.onFormattedNavigationError(error)
+    this.optionsManager.onOptionsChanged = (options) =>
+      this.onOptionsChanged(options)
+    this.nowPlayingManager.onNowPlayingChanged = (metadata) =>
+      this.onNowPlayingChanged(metadata)
 
     // Setup online/offline listeners
     if (typeof window !== 'undefined') {
@@ -243,7 +268,8 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
     const didStateChange = newState.state !== oldState.state
     const didErrorChange =
       newState.state === 'error' && oldState.state === 'error'
-        ? newState.error !== oldState.error
+        ? newState.error?.code !== oldState.error?.code ||
+          newState.error?.message !== oldState.error?.message
         : false
 
     super.state = newState
@@ -261,10 +287,18 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
     }
   }
 
+  /**
+   * Derives PlayingState from playback state and playWhenReady.
+   * Matches Android's PlayingStateFactory.derive() logic.
+   */
   private getPlayingStateFromPlayback(playback: Playback): PlayingState {
+    const state = playback.state
+    const pwr = this._playWhenReady
     return {
-      playing: playback.state === 'playing',
-      buffering: playback.state === 'buffering',
+      playing:
+        pwr && state !== 'error' && state !== 'ended' && state !== 'none',
+      buffering:
+        pwr && (state === 'loading' || state === 'buffering')
     }
   }
 
@@ -272,11 +306,17 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
     this.clearUpdateEventInterval()
     if (interval) {
       this.progressUpdateEventInterval = setInterval(() => {
-        if (this.state.state === 'playing') {
+        const state = this.state.state
+        // Match Android: emit progress during loading, buffering, and playing
+        if (
+          state === 'playing' ||
+          state === 'loading' ||
+          state === 'buffering'
+        ) {
           const progress = this.getProgress()
           const event: PlaybackProgressUpdatedEvent = {
             ...progress,
-            track: this.currentIndex || 0,
+            track: this.currentIndex || 0
           }
           this.onPlaybackProgressUpdated(event)
         }
@@ -294,7 +334,7 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
     super.onPlaylistEnded()
     this.onPlaybackQueueEnded({
       track: this.currentIndex ?? 0,
-      position: this.element?.currentTime ?? 0,
+      position: this.element?.currentTime ?? 0
     })
   }
 
@@ -317,13 +357,16 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
    * @param parentPath The parent path to check against queueSourcePath
    * @returns true if successfully skipped to existing track, false otherwise
    */
-  private trySkipToExistingQueueTrack(trackId: string, parentPath: string): boolean {
+  private trySkipToExistingQueueTrack(
+    trackId: string,
+    parentPath: string
+  ): boolean {
     if (parentPath !== this.browserManager.queueSourcePath) {
       return false
     }
 
     const queue = this.getQueue()
-    const index = queue.findIndex(t => t.src === trackId)
+    const index = queue.findIndex((t) => t.src === trackId)
 
     if (index < 0) {
       return false
@@ -359,7 +402,10 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
    * Async implementation of track navigation with queue expansion support.
    * Matches Android's MediaSessionCallback behavior.
    */
-  private async navigateTrackAsync(track: Track, url: string | undefined): Promise<void> {
+  private async navigateTrackAsync(
+    track: Track,
+    url: string | undefined
+  ): Promise<void> {
     try {
       // Handle contextual URL (playable track with queue context)
       if (url && BrowserPathHelper.isContextual(url)) {
@@ -469,24 +515,49 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
     // Clear now playing override when track changes (matches Android's PlayerListener.onMediaItemTransition)
     this.nowPlayingManager.clearNowPlayingOverride()
 
+    // Match Android: load() modifies the queue.
+    // If queue is empty, add the track. If queue has items, replace at currentIndex.
+    if (this.playlist.length === 0) {
+      this.playlist = [track]
+      this._currentIndex = 0
+      this.onPlaybackQueueChanged(this.playlist)
+    } else if (
+      this.currentIndex !== undefined &&
+      this.playlist[this.currentIndex] !== track
+    ) {
+      this.playlist[this.currentIndex] = track
+      this.onPlaybackQueueChanged(this.playlist)
+    }
+
     const lastTrack = this.current
     const lastPosition = element.currentTime
     const lastIndex = this.lastIndex
     const currentIndex = this.currentIndex
 
+    // Set loading flag early so seekTo() calls during async URL resolution
+    // are captured as pending seeks rather than silently dropped
+    this._loadInProgress = true
+    this._pendingSeek = undefined
+
     // Resolve the media URL before loading (async but we don't await)
+    const loadId = ++this.currentLoadId
     const doLoad = async () => {
       const resolvedTrack: Track = track.src
         ? { ...track, src: await this.resolveMediaUrl(track.src) }
         : track
 
+      // A newer load() was called while resolving — discard this stale result
+      if (loadId !== this.currentLoadId) {
+        return
+      }
+
       super.load(resolvedTrack, (loadedTrack) => {
         this.onPlaybackActiveTrackChanged({
           lastTrack,
           lastPosition,
           lastIndex,
           index: currentIndex,
-          track,
+          track
         })
 
         // Update now playing metadata
@@ -504,14 +575,13 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
 
     // Execute async load without blocking, with error handling
     doLoad().catch((error: unknown) => {
+      this._loadInProgress = false
+      this._pendingSeek = undefined
       console.error('Error loading track:', error)
-      const message = error instanceof Error ? error.message : 'Failed to load track'
-      this.onPlaybackError({
-        error: {
-          code: 'load-error',
-          message,
-        },
-      })
+      const message =
+        error instanceof Error ? error.message : 'Failed to load track'
+      const playbackError = { code: 'load-error', message }
+      this.state = { state: 'error', error: playbackError }
     })
   }
 
@@ -525,7 +595,7 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
 
     if (didChange) {
       this.onPlaybackPlayWhenReadyChanged({
-        playWhenReady: this._playWhenReady,
+        playWhenReady: this._playWhenReady
       })
     }
   }
@@ -553,7 +623,7 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
 
     if (didChange) {
       this.onPlaybackRepeatModeChanged({
-        repeatMode: mode,
+        repeatMode: mode
       })
     }
   }
@@ -619,14 +689,24 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
   }
 
   // MARK: Queue management
-  setQueue(tracks: Track[], startIndex?: number, startPositionMs?: number): void {
+  setQueue(
+    tracks: Track[],
+    startIndex?: number,
+    startPositionMs?: number
+  ): void {
     this.stop()
+    // Clear stale references from previous queue
+    this.current = undefined
+    this._currentIndex = undefined
     // Hydrate favorites and transform artwork URLs on all tracks in the queue
     const artworkConfig = this.browserManager.configuration.artwork
-    this.playlist = tracks.map(track => {
+    this.playlist = tracks.map((track) => {
       try {
         const hydratedTrack = this.favoriteManager.hydrateFavorite(track)
-        return RequestConfigBuilder.transformTrackArtwork(hydratedTrack, artworkConfig)
+        return RequestConfigBuilder.transformTrackArtwork(
+          hydratedTrack,
+          artworkConfig
+        )
       } catch (error) {
         console.error('Failed to transform track:', error)
         return track // Use original track as fallback
@@ -673,7 +753,7 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
     // Create updated track with new favorited state
     const updatedTrack: Track = {
       ...track,
-      favorited,
+      favorited
     }
 
     // Replace the track in the playlist
@@ -688,7 +768,7 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
       lastTrack: track,
       lastPosition: this.element?.currentTime ?? 0,
       index,
-      track: updatedTrack,
+      track: updatedTrack
     })
 
     // Emit queue changed so useQueue() hook updates
@@ -777,5 +857,4 @@ export class NativeAudioBrowser extends PlaylistPlayer implements AudioBrowserSp
   openIosOutputPicker(): void {
     // No-op on web
   }
-
 }

package/src/web/SimpleRouter.ts

@@ -14,6 +14,8 @@
  * - Most specific route wins
  */
 
+import { assertedNotNullish } from '../utils/validation'
+
 export interface RouteMatch {
   params: Record<string, string>
   specificity: number
@@ -81,13 +83,19 @@ export class SimpleRouter {
 
       // Match all segments except the tail wildcard
       for (let i = 0; i < patternSegments.length - 1; i++) {
-        if (!this.matchSingleSegment(patternSegments[i]!, pathSegments[i]!, params)) {
+        if (
+          !this.matchSingleSegment(
+            assertedNotNullish(patternSegments[i]),
+            assertedNotNullish(pathSegments[i]),
+            params
+          )
+        ) {
           return null
         }
         // Note: The Kotlin implementation doesn't update counts here (appears to be a bug)
         // but we'll match it exactly for consistency
         this.updateSegmentCounts(
-          patternSegments[i]!,
+          assertedNotNullish(patternSegments[i]),
           constantSegments,
           parameterSegments,
           wildcardSegments
@@ -106,15 +114,22 @@ export class SimpleRouter {
       }
 
       for (let i = 0; i < patternSegments.length; i++) {
-        if (!this.matchSingleSegment(patternSegments[i]!, pathSegments[i]!, params)) {
+        if (
+          !this.matchSingleSegment(
+            assertedNotNullish(patternSegments[i]),
+            assertedNotNullish(pathSegments[i]),
+            params
+          )
+        ) {
           return null
         }
-        const [constCount, paramCount, wildcardCount] = this.updateSegmentCounts(
-          patternSegments[i]!,
-          constantSegments,
-          parameterSegments,
-          wildcardSegments
-        )
+        const [constCount, paramCount, wildcardCount] =
+          this.updateSegmentCounts(
+            assertedNotNullish(patternSegments[i]),
+            constantSegments,
+            parameterSegments,
+            wildcardSegments
+          )
         constantSegments = constCount
         parameterSegments = paramCount
         wildcardSegments = wildcardCount

package/src/web/TrackPlayer/Player.ts

@@ -1,14 +1,14 @@
-import { State } from './State'
-import type { State as StateType } from './State'
+import type shaka from 'shaka-player/dist/shaka-player.ui'
 import type {
   Progress,
   PartialSetupPlayerOptions,
   Playback,
-  PlaybackError,
+  PlaybackError
 } from '../../features'
 import type { Track } from '../../types'
+import type { State as StateType } from './State'
 import { SetupNotCalledError } from './SetupNotCalledError'
-import type shaka from 'shaka-player/dist/shaka-player.ui'
+import { State } from './State'
 
 // Extend Window interface for debug purposes
 declare global {
@@ -38,6 +38,9 @@ export class Player {
   protected _current?: Track = undefined
   protected _playWhenReady = false
   protected _state: Playback = { state: State.None }
+  protected _isStopped = false
+  protected _loadInProgress = false
+  protected _pendingSeek: number | undefined
 
   // current getter/setter
   public get current(): Track | undefined {
@@ -86,7 +89,7 @@ export class Player {
     if (this.hasInitialized === true) {
       const error: PlaybackError = {
         code: 'player_already_initialized',
-        message: 'The player has already been initialized via setupPlayer.',
+        message: 'The player has already been initialized via setupPlayer.'
       }
       // eslint-disable-next-line @typescript-eslint/only-throw-error
       throw error
@@ -102,8 +105,8 @@ export class Player {
         state: State.Error,
         error: {
           code: 'not_supported',
-          message: 'Browser not supported...',
-        },
+          message: 'Browser not supported...'
+        }
       }
       throw new Error('Browser not supported.')
     }
@@ -152,6 +155,8 @@ export class Player {
    * event handlers
    */
   protected onStateUpdate(state: Exclude<StateType, typeof State.Error>): void {
+    // Ignore Shaka/element events while stopped (e.g., from unload)
+    if (this._isStopped) return
     this.state = { state }
   }
 
@@ -178,34 +183,33 @@ export class Player {
 
     const error: PlaybackError = {
       code: shakaError.code.toString(),
-      message: shakaError.message,
+      message: shakaError.message
     }
 
     this.state = {
       state: State.Error,
-      error,
+      error
     }
 
     // Log the error.
     console.debug('Error code', shakaError.code, 'object', shakaError)
   }
 
-  /**
-   * NOTE: this method is sync despite the actual load being async. This
-   * behavior is intentional as it mirrors what happens in Android. State
-   * changes should be captured by event listeners.
-   */
-  public load(track: Track, onComplete?: (track: Track) => void): void {
+  public load(track: Track, onLoaded?: (track: Track) => void): void {
     const player = this.requirePlayer()
+    this._isStopped = false
+    this._loadInProgress = true
 
     if (!track.src) {
+      this._loadInProgress = false
+      this._pendingSeek = undefined
       const error: PlaybackError = {
         code: 'invalid_track',
-        message: 'Track does not have a valid src URL',
+        message: 'Track does not have a valid src URL'
       }
       this.state = {
         state: State.Error,
-        error,
+        error
       }
       return
     }
@@ -213,8 +217,15 @@ export class Player {
     player
       .load(track.src)
       .then(() => {
+        this._loadInProgress = false
         this.current = track
-        onComplete?.(track)
+        onLoaded?.(track)
+
+        // Execute any pending seek that arrived during loading
+        if (this._pendingSeek !== undefined) {
+          this.requireElement().currentTime = this._pendingSeek
+          this._pendingSeek = undefined
+        }
 
         // Auto-play if playWhenReady is true
         if (this.playWhenReady) {
@@ -222,19 +233,23 @@ export class Player {
         }
       })
       .catch((err: unknown) => {
+        this._loadInProgress = false
+        this._pendingSeek = undefined
         this.onError(this.toNormalizedError(err))
       })
   }
 
-  /**
-   * NOTE: this method is sync despite the actual load being async. This
-   * behavior is intentional as it mirrors what happens in Android. State
-   * changes should be captured by event listeners.
-   */
   public stop(onComplete?: () => void): void {
     const player = this.requirePlayer()
 
-    this.current = undefined
+    // Match Android: stop sets playWhenReady=false and state=stopped,
+    // but keeps the current track so play() can resume.
+    this._isStopped = true
+    this._loadInProgress = false
+    this._pendingSeek = undefined
+    this.playWhenReady = false
+    this.state = { state: State.Stopped }
+
     player
       .unload()
       .then(() => onComplete?.())
@@ -244,11 +259,6 @@ export class Player {
       })
   }
 
-  /**
-   * NOTE: this method is sync despite the actual load being async. This
-   * behavior is intentional as it mirrors what happens in Android. State
-   * changes should be captured by event listeners.
-   */
   public play(): void {
     const element = this.requireElement()
     this.playWhenReady = true
@@ -258,6 +268,12 @@ export class Player {
       return
     }
 
+    // Match Android: play() after stop() re-prepares the current track
+    if (this._isStopped && this.current) {
+      this.load(this.current)
+      return
+    }
+
     element.play().catch((err: unknown) => console.error(err))
   }
 
@@ -293,11 +309,19 @@ export class Player {
   }
 
   public seekBy(offset: number): void {
+    if (this._loadInProgress) {
+      this._pendingSeek = (this._pendingSeek ?? 0) + offset
+      return
+    }
     const element = this.requireElement()
     element.currentTime += offset
   }
 
   public seekTo(seconds: number): void {
+    if (this._loadInProgress) {
+      this._pendingSeek = seconds
+      return
+    }
     const element = this.requireElement()
     element.currentTime = seconds
   }
@@ -314,10 +338,14 @@ export class Player {
 
   public getProgress(): Progress {
     const element = this.requireElement()
+    let buffered = 0
+    if (element.buffered.length > 0) {
+      buffered = element.buffered.end(element.buffered.length - 1)
+    }
     return {
       position: element.currentTime,
       duration: element.duration || 0,
-      buffered: 0, // TODO: element.buffered.end,
+      buffered
     }
   }
 }