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

package/src/features/queue/activeTrack.ts

@@ -1,5 +1,5 @@
-import { nativeBrowser } from '../../native'
 import type { Track } from '../../types'
+import { nativeBrowser } from '../../native'
 import { NativeUpdatedValue } from '../../utils/NativeUpdatedValue'
 import { useNativeUpdatedValue } from '../../utils/useNativeUpdatedValue'
 

package/src/features/queue/queue.ts

@@ -1,5 +1,5 @@
-import { nativeBrowser } from '../../native'
 import type { Track } from '../../types'
+import { nativeBrowser } from '../../native'
 import { NativeUpdatedValue } from '../../utils/NativeUpdatedValue'
 import { useNativeUpdatedValue } from '../../utils/useNativeUpdatedValue'
 
@@ -31,7 +31,7 @@ export function add(tracks: Track[], insertBeforeIndex?: number): void
  * By default the track will be added to the end of the queue.
  */
 export function add(track: Track, insertBeforeIndex?: number): void
-export function add(tracks: Track | Track[], insertBeforeIndex = -1): void {
+export function add(tracks: Track | Track[], insertBeforeIndex?: number): void {
   const addTracks = Array.isArray(tracks) ? tracks : [tracks]
   if (addTracks.length > 0) {
     nativeBrowser.add(addTracks, insertBeforeIndex)

package/src/features/remoteControls.ts

@@ -1,11 +1,11 @@
-import { nativeBrowser } from '../native'
-import { LazyNativeEmitter } from '../utils/LazyNativeEmitter'
 import type {
   HeartRating,
   PercentageRating,
   StarRating,
   ThumbsRating
 } from './rating'
+import { nativeBrowser } from '../native'
+import { LazyNativeEmitter } from '../utils/LazyNativeEmitter'
 
 // MARK: - Event Interfaces
 

package/src/specs/audio-browser.nitro.ts

@@ -1,5 +1,4 @@
 import { type HybridObject } from 'react-native-nitro-modules'
-
 import type {
   BatteryOptimizationStatus,
   BatteryOptimizationStatusChangedEvent,

package/src/utils/useDebug.ts

@@ -1,4 +1,10 @@
 import { useEffect, useRef, useSyncExternalStore } from 'react'
+import type { NowPlayingMetadata } from '../features/metadata'
+import type { PlayingState } from '../features/playback/playing'
+import type { PlaybackState } from '../features/playback/state'
+import type { Options } from '../features/player/options'
+import type { RepeatMode } from '../features/queue/repeatMode'
+import type { Track } from '../types'
 import { useContent, usePath } from '../features/browser'
 import { useNavigationError, usePlaybackError } from '../features/errors'
 import {
@@ -8,21 +14,15 @@ import {
 } from '../features/metadata'
 import { useOnline } from '../features/network'
 import { useNowPlaying } from '../features/nowPlaying'
-import type { PlayingState } from '../features/playback/playing'
 import { usePlayingState } from '../features/playback/playing'
 import { usePlayWhenReady } from '../features/playback/playWhenReady'
 import { useProgress } from '../features/playback/progress'
-import type { PlaybackState } from '../features/playback/state'
 import { usePlayback } from '../features/playback/state'
-import type { Options } from '../features/player/options'
 import { useOptions } from '../features/player/options'
 import { useActiveTrack } from '../features/queue/activeTrack'
 import { useQueue } from '../features/queue/queue'
-import type { RepeatMode } from '../features/queue/repeatMode'
 import { useRepeatMode } from '../features/queue/repeatMode'
 import { useShuffle } from '../features/queue/shuffle'
-import type { NowPlayingMetadata } from '../features/metadata'
-import type { Track } from '../types'
 
 // MARK: - Types
 

package/src/utils/validation.ts

@@ -0,0 +1,27 @@
+function isNotNullish<T>(val: T | undefined | null | void): val is T {
+  return val !== undefined && val !== null
+}
+
+function assert(
+  condition: any,
+  message = 'assertion error'
+): asserts condition {
+  if (!condition) {
+    throw new Error(message)
+  }
+}
+
+export function assertNotNullish<T>(
+  val: T | undefined | null | void,
+  message = 'Expected value to not be nullish'
+): asserts val is T {
+  assert(isNotNullish(val), message)
+}
+
+export function assertedNotNullish<T>(
+  val: T | undefined | null | void,
+  message = 'Expected value to not be nullish'
+): T {
+  assertNotNullish(val, message)
+  return val
+}

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