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

package/src/web/TrackPlayer/SleepTimer.ts

@@ -2,14 +2,12 @@
  * Manages a sleep timer that calls a completion callback after a specified duration.
  *
  * The timer stores the expiration time as a timestamp and uses setTimeout to schedule the completion
- * callback. Supports both time-based and end-of-track modes, plus an optional fade-out that starts
- * `fadeDuration` seconds before the deadline so silence lands exactly when the timer completes.
+ * callback. Supports both time-based and end-of-track modes.
  */
 export class SleepTimerManager {
   public time: number | null = null
   public sleepWhenPlayedToEnd: boolean = false
   private timeoutId: NodeJS.Timeout | null = null
-  private fadeTimeoutId: NodeJS.Timeout | null = null
 
   get isRunning(): boolean {
     return this.time !== null || this.sleepWhenPlayedToEnd
@@ -19,28 +17,15 @@ export class SleepTimerManager {
    * Sets a timer to complete after the specified number of seconds.
    *
    * @param seconds Number of seconds until the timer completes
-   * @param fadeDuration Seconds over which to fade out before completion; clamped to `seconds`
    */
-  sleepAfter(seconds: number, fadeDuration?: number): void {
+  sleepAfter(seconds: number): void {
     this.stopTimer()
-    this.onFadeCancel()
     this.sleepWhenPlayedToEnd = false
 
     this.timeoutId = setTimeout(() => {
       this.complete()
     }, seconds * 1000)
     this.time = Date.now() + seconds * 1000
-
-    if (fadeDuration !== undefined && fadeDuration > 0) {
-      const fade = Math.min(fadeDuration, seconds)
-      this.fadeTimeoutId = setTimeout(
-        () => {
-          this.fadeTimeoutId = null
-          this.onFadeStart(fade)
-        },
-        (seconds - fade) * 1000
-      )
-    }
   }
 
   /**
@@ -49,7 +34,6 @@ export class SleepTimerManager {
    */
   setToEndOfTrack(): void {
     this.stopTimer()
-    this.onFadeCancel()
     this.time = null
     this.sleepWhenPlayedToEnd = true
   }
@@ -62,7 +46,6 @@ export class SleepTimerManager {
   clear(): boolean {
     const wasRunning = this.isRunning
     this.stopTimer()
-    this.onFadeCancel()
     this.time = null
     this.sleepWhenPlayedToEnd = false
     return wasRunning
@@ -73,23 +56,9 @@ export class SleepTimerManager {
     // Default implementation does nothing - override in subclass
   }
 
-  /** Override to begin fading the volume; the timer still completes at its deadline. */
-  protected onFadeStart(_durationSeconds: number): void {
-    // Default implementation does nothing - override in subclass
-  }
-
-  /** Override to handle a fade cancelled before completion — restore the volume. */
-  protected onFadeCancel(): void {
-    // Default implementation does nothing - override in subclass
-  }
-
   private complete(): void {
     if (!this.isRunning) return
-    // Tear down without onFadeCancel: completion pauses first, then the
-    // completion handler restores the volume.
-    this.stopTimer()
-    this.time = null
-    this.sleepWhenPlayedToEnd = false
+    this.clear()
     this.onComplete()
   }
 
@@ -98,9 +67,5 @@ export class SleepTimerManager {
       clearTimeout(this.timeoutId)
       this.timeoutId = null
     }
-    if (this.fadeTimeoutId !== null) {
-      clearTimeout(this.fadeTimeoutId)
-      this.fadeTimeoutId = null
-    }
   }
 }

package/src/web/TrackPlayer/index.ts

@@ -1,5 +1,4 @@
 export * from './Player'
-export * from './QueuePlayer'
+export * from './PlaylistPlayer'
 export * from './RepeatMode'
 export { SleepTimerManager } from './SleepTimer'
-export { VolumeFader } from './VolumeFader'

package/src/web/browser/BrowserManager.ts

@@ -1,9 +1,5 @@
 import type { NavigationErrorType } from '../../features'
-import type {
-  Track,
-  ResolvedTrack,
-  TransformableRequestConfig
-} from '../../types'
+import type { Track, ResolvedTrack } from '../../types'
 import type { NativeBrowserConfiguration } from '../../types/browser-native'
 import type { HttpClient } from '../http/HttpClient'
 import type { FavoriteManager } from './FavoriteManager'
@@ -12,8 +8,6 @@ import { assertedNotNullish } from '../../utils/validation'
 import { RequestConfigBuilder } from '../http/RequestConfigBuilder'
 import { SimpleRouter } from '../SimpleRouter'
 import { BrowserPathHelper } from '../util/BrowserPathHelper'
-import { assertBrowsePageShape } from './assertBrowsePageShape'
-import { parseSearchResponse } from './parseSearchResponse'
 
 /**
  * Manages browser navigation, route resolution, and content loading.
@@ -27,19 +21,6 @@ export class BrowserManager {
   private _configuration: NativeBrowserConfiguration = {}
   private router = new SimpleRouter()
 
-  // Layer resolution: any present request/browse resolver is invoked once per
-  // content generation, and the resolved TransformableRequestConfig is cached
-  // and fed into applyLayers in place of the static request/browse config. The
-  // generation bumps on config-set and on invalidateAllContent().
-  private _layerGeneration = 0
-  private _resolvedLayerGeneration = -1
-  private _resolvedRequest?: TransformableRequestConfig
-  private _resolvedBrowse?: TransformableRequestConfig
-  // Dedupes concurrent resolution within a generation (config-set triggers an
-  // initial navigate that can overlap with an explicit navigatePath), so a
-  // resolver is invoked exactly once per generation even under concurrency.
-  private _layerResolution?: { generation: number; promise: Promise<void> }
-
   // Navigation tracking to prevent race conditions (matches Android's @Volatile currentNavigationId)
   private currentNavigationId = 0
 
@@ -151,10 +132,14 @@ export class BrowserManager {
    */
   set configuration(value: NativeBrowserConfiguration) {
     this._configuration = value
-    this._layerGeneration += 1
     this.navigationErrorManager.clearNavigationError()
     this.navigationErrorManager.setFormatCallback(value.formatNavigationError)
 
+    // Update HTTP client base config
+    if (value.request) {
+      this.httpClient.setBaseRequestConfig(value.request)
+    }
+
     // Determine initial path
     let initialPath = value.path
 
@@ -204,18 +189,6 @@ export class BrowserManager {
     }
   }
 
-  /**
-   * Invalidates all browse content. Web shows a single path at a time and
-   * doesn't keep a content cache, so this just re-navigates the current path
-   * to re-resolve it.
-   */
-  invalidateAllContent(): void {
-    this._layerGeneration += 1
-    if (this._path) {
-      void this.navigate(this._path)
-    }
-  }
-
   /**
    * Main navigation logic.
    * Resolves content for the given path and updates state.
@@ -346,20 +319,21 @@ export class BrowserManager {
 
     // Handle callback-based search
     if (searchRoute.searchCallback) {
-      searchResults = await searchRoute.searchCallback({
-        query,
-        reference: 'unknown'
-      })
+      searchResults = await searchRoute.searchCallback({ query })
     }
-    // Handle request config-based search via the shared layered fetch.
+    // Handle request config-based search
     else if (searchRoute.searchConfig) {
+      const searchQueryParams: Record<string, string> = { q: query }
+      const requestConfig = this.httpClient.mergeRequestConfig(
+        searchRoute.searchConfig,
+        {
+          query: searchQueryParams
+        }
+      )
+
       try {
-        searchResults = await this.fetchSearchResults(
-          searchRoute.searchConfig,
-          {
-            q: query
-          }
-        )
+        const response = await this.httpClient.executeRequest(requestConfig)
+        searchResults = Array.isArray(response) ? (response as Track[]) : []
       } catch (error) {
         console.error('Search failed:', error)
         return undefined
@@ -387,16 +361,11 @@ export class BrowserManager {
     if (!artworkConfig) {
       return content
     }
-    // The shared request layer applies to artwork too — use the resolved layer
-    // (resolver result or static config) so a resolver-only config still works.
-    await this.ensureLayersResolved()
-    const requestConfig = this._resolvedRequest
 
     // Transform parent artwork
     const parentArtworkSource =
       await RequestConfigBuilder.resolveArtworkSourceAsync(
         content,
-        requestConfig,
         artworkConfig
       )
 
@@ -408,7 +377,6 @@ export class BrowserManager {
           const artworkSource =
             await RequestConfigBuilder.resolveArtworkSourceAsync(
               track,
-              requestConfig,
               artworkConfig
             )
           if (artworkSource && !track.artworkSource) {
@@ -478,16 +446,15 @@ export class BrowserManager {
       return route.browseStatic
     }
 
-    // Handle request config-based route via the layered request → browse → route
-    // chain (matches native's resolveRouteEntry → resolveFromConfig).
+    // Handle request config-based route
     if (route.browseConfig) {
+      const requestConfig = this.httpClient.mergeRequestConfig(
+        route.browseConfig,
+        { path }
+      )
       try {
-        return await this.resolveFromConfig(
-          this._configuration.browse,
-          route.browseConfig,
-          path,
-          routeParams
-        )
+        const response = await this.httpClient.executeRequest(requestConfig)
+        return response as ResolvedTrack
       } catch (error: unknown) {
         console.error(`Failed to resolve ${errorContext}:`, error)
         this.handleNavigationError(error, path)
@@ -498,98 +465,6 @@ export class BrowserManager {
     return undefined
   }
 
-  /**
-   * Ensures the request/browse layer configs are resolved for the current
-   * generation. Any present resolver is invoked once per generation and the
-   * result cached; a static config (no resolver) passes through unchanged.
-   */
-  private async ensureLayersResolved(): Promise<void> {
-    if (this._resolvedLayerGeneration === this._layerGeneration) return
-    // Reuse an in-flight resolution for the same generation so concurrent
-    // navigations (e.g. config-set's initial navigate overlapping an explicit
-    // navigatePath) don't each invoke the resolver.
-    if (this._layerResolution?.generation === this._layerGeneration) {
-      return this._layerResolution.promise
-    }
-    const generation = this._layerGeneration
-    const promise = (async () => {
-      const cfg = this._configuration
-      const resolvedRequest = cfg.requestResolver
-        ? await cfg.requestResolver()
-        : cfg.request
-      const resolvedBrowse = cfg.browseResolver
-        ? await cfg.browseResolver()
-        : cfg.browse
-      // Only commit if no newer generation superseded us mid-resolution.
-      if (this._layerGeneration === generation) {
-        this._resolvedRequest = resolvedRequest
-        this._resolvedBrowse = resolvedBrowse
-        this._resolvedLayerGeneration = generation
-      }
-    })().catch((err) => {
-      // A failed resolution must not wedge the generation — clear the in-flight
-      // cache so the next navigation retries (e.g. a transient async resolver error).
-      if (this._layerResolution?.generation === generation) {
-        this._layerResolution = undefined
-      }
-      throw err
-    })
-    this._layerResolution = { generation, promise }
-    return promise
-  }
-
-  /**
-   * Resolves content from the layered request config chain:
-   * `request` (shared) → `kindConfig` (browse/search) → `routeConfig` (route).
-   * Each layer's transform receives the previous layer's output; a layer with no
-   * transform merges its static fields. `routeConfig` is undefined for the
-   * implicit browse default; `kindConfig` is undefined for search.
-   *
-   * Mirrors native's BrowserManager.resolveFromConfig.
-   */
-  private async resolveFromConfig(
-    kindConfig: TransformableRequestConfig | undefined,
-    routeConfig: TransformableRequestConfig | undefined,
-    path: string,
-    params: Record<string, string>
-  ): Promise<ResolvedTrack> {
-    await this.ensureLayersResolved()
-    const merged = await RequestConfigBuilder.applyLayers(
-      { path },
-      [
-        this._resolvedRequest,
-        // fall back to the route's kind config when no browse layer is configured
-        this._resolvedBrowse ?? kindConfig,
-        routeConfig
-      ],
-      params
-    )
-    const response = await this.httpClient.executeRequest(merged)
-    return assertBrowsePageShape(response, path)
-  }
-
-  /**
-   * Fetches search results from a `searchConfig` via the layered
-   * `request → search` chain (search is its own kind — no browse layer). The
-   * query params are seeded on the base so they survive both the static merge
-   * and a search `transform`. Shared by `resolveSearchContent` (navigating to a
-   * search path) and `SearchManager` (the voice/`onSearch` API), so the ladder
-   * isn't duplicated. Errors propagate to the caller.
-   */
-  async fetchSearchResults(
-    searchConfig: TransformableRequestConfig,
-    queryParams: Record<string, string>
-  ): Promise<Track[]> {
-    await this.ensureLayersResolved()
-    const merged = await RequestConfigBuilder.applyLayers(
-      { path: searchConfig.path, query: queryParams },
-      [this._resolvedRequest, searchConfig],
-      queryParams
-    )
-    const response = await this.httpClient.executeRequest(merged)
-    return parseSearchResponse(response)
-  }
-
   /**
    * Resolves content for a specific path using configured routes.
    */
@@ -597,78 +472,50 @@ export class BrowserManager {
     path: string
   ): Promise<ResolvedTrack | undefined> {
     const routes = this._configuration.routes
+    if (!routes || routes.length === 0) {
+      return undefined
+    }
 
-    if (routes && routes.length > 0) {
-      // Convert routes array to record for SimpleRouter
-      const routePatterns: Record<
-        string,
-        {
-          browseCallback?: (typeof routes)[0]['browseCallback']
-          browseConfig?: (typeof routes)[0]['browseConfig']
-          browseStatic?: (typeof routes)[0]['browseStatic']
-        }
-      > = {}
-
-      for (const route of routes) {
-        // Skip special routes
-        if (route.path.startsWith('__')) continue
-
-        routePatterns[route.path] = {
-          browseCallback: route.browseCallback,
-          browseConfig: route.browseConfig,
-          browseStatic: route.browseStatic
-        }
+    // Convert routes array to record for SimpleRouter
+    const routePatterns: Record<
+      string,
+      {
+        browseCallback?: (typeof routes)[0]['browseCallback']
+        browseConfig?: (typeof routes)[0]['browseConfig']
+        browseStatic?: (typeof routes)[0]['browseStatic']
       }
+    > = {}
 
-      // Try to match route
-      const match = this.router.findBestMatch(path, routePatterns)
-      if (match) {
-        const [matchedPattern, routeMatch] = match
-        const matchedRoute = routes.find((r) => r.path === matchedPattern)
-        if (matchedRoute) {
-          return this.resolveRouteContent(
-            matchedRoute,
-            path,
-            routeMatch.params,
-            'Route'
-          )
-        }
+    for (const route of routes) {
+      // Skip special routes
+      if (route.path.startsWith('__')) continue
+
+      routePatterns[route.path] = {
+        browseCallback: route.browseCallback,
+        browseConfig: route.browseConfig,
+        browseStatic: route.browseStatic
       }
+    }
 
-      // Fall back to the custom __default__ route ('*') if configured
-      const defaultRoute = routes.find((r) => r.path === '__default__')
-      if (defaultRoute) {
+    // Try to match route
+    const match = this.router.findBestMatch(path, routePatterns)
+    if (match) {
+      const [matchedPattern, routeMatch] = match
+      const matchedRoute = routes.find((r) => r.path === matchedPattern)
+      if (matchedRoute) {
         return this.resolveRouteContent(
-          defaultRoute,
+          matchedRoute,
           path,
-          { path },
-          'Default route'
+          routeMatch.params,
+          'Route'
         )
       }
     }
 
-    // Implicit default — no matching route, fetch the path via the layered
-    // request → browse chain. Only attempt this when there's something to fetch
-    // (a configured request or browse layer, static or resolver); otherwise
-    // there's no content.
-    if (
-      this._configuration.request ||
-      this._configuration.requestResolver ||
-      this._configuration.browse ||
-      this._configuration.browseResolver
-    ) {
-      try {
-        return await this.resolveFromConfig(
-          this._configuration.browse,
-          undefined,
-          path,
-          { path }
-        )
-      } catch (error: unknown) {
-        console.error('Failed to resolve default browse content:', error)
-        this.handleNavigationError(error, path)
-        return undefined
-      }
+    // Fall back to __default__ route
+    const defaultRoute = routes.find((r) => r.path === '__default__')
+    if (defaultRoute) {
+      return this.resolveRouteContent(defaultRoute, path, {}, 'Default route')
     }
 
     return undefined
@@ -688,26 +535,10 @@ export class BrowserManager {
     const result = await this.resolveRouteContent(tabsRoute, '/', {}, 'Tabs')
     const tabs = result?.children ?? []
 
-    // Transform artwork URLs on tabs via the async resolver so the shared
-    // request layer (incl. its transform) applies, matching content/search.
-    const artworkConfig = this._configuration.artwork
-    if (!artworkConfig) return tabs
-    // Resolved request layer (resolver or static), matching content/search.
-    await this.ensureLayersResolved()
-    const requestConfig = this._resolvedRequest
-    return Promise.all(
-      tabs.map(async (track) => {
-        const artworkSource =
-          await RequestConfigBuilder.resolveArtworkSourceAsync(
-            track,
-            requestConfig,
-            artworkConfig
-          )
-        if (artworkSource && !track.artworkSource) {
-          return { ...track, artworkSource }
-        }
-        return track
-      })
+    // Transform artwork URLs on tabs
+    return RequestConfigBuilder.transformTracksArtwork(
+      tabs,
+      this._configuration.artwork
     )
   }
 

package/src/web/browser/NavigationErrorManager.ts

@@ -11,9 +11,7 @@ const ERROR_TITLES: Record<NavigationErrorType, string> = {
   'http-error': 'Server Error',
   'content-not-found': 'Content Not Found',
   'callback-error': 'Error',
-  'unknown-error': 'Error',
-  'empty-content': 'Nothing here',
-  'timeout': "Couldn't load"
+  'unknown-error': 'Error'
 }
 
 /**

package/src/web/browser/SearchManager.ts

@@ -1,4 +1,5 @@
 import type { Track, SearchParams } from '../../types'
+import type { HttpClient } from '../http/HttpClient'
 import type { BrowserManager } from './BrowserManager'
 import { RequestConfigBuilder } from '../http/RequestConfigBuilder'
 
@@ -8,7 +9,10 @@ import { RequestConfigBuilder } from '../http/RequestConfigBuilder'
  * Matches Android's search architecture.
  */
 export class SearchManager {
-  constructor(private browserManager: BrowserManager) {}
+  constructor(
+    private browserManager: BrowserManager,
+    private httpClient: HttpClient
+  ) {}
 
   /**
    * Executes a search query using the __search__ route configuration.
@@ -39,20 +43,22 @@ export class SearchManager {
         q: params.query
       }
       if (params.mode) searchQueryParams.mode = params.mode
-      if (params.reference === 'my') searchQueryParams.reference = 'my'
       if (params.genre) searchQueryParams.genre = params.genre
       if (params.artist) searchQueryParams.artist = params.artist
       if (params.album) searchQueryParams.album = params.album
       if (params.title) searchQueryParams.title = params.title
       if (params.playlist) searchQueryParams.playlist = params.playlist
 
-      // Delegate to the shared layered fetch (request → search) on BrowserManager
-      // so the ladder lives in one place.
+      const requestConfig = this.httpClient.mergeRequestConfig(
+        searchRoute.searchConfig,
+        {
+          query: searchQueryParams
+        }
+      )
+
       try {
-        results = await this.browserManager.fetchSearchResults(
-          searchRoute.searchConfig,
-          searchQueryParams
-        )
+        const response = await this.httpClient.executeRequest(requestConfig)
+        results = Array.isArray(response) ? (response as Track[]) : []
       } catch (error) {
         console.error('Search failed:', error)
         return []
@@ -60,15 +66,13 @@ export class SearchManager {
     }
 
     // Transform artwork URLs on search results using async method with full Track access
-    const { request: requestConfig, artwork: artworkConfig } =
-      this.browserManager.configuration
+    const artworkConfig = this.browserManager.configuration.artwork
     if (artworkConfig) {
       results = await Promise.all(
         results.map(async (track) => {
           const artworkSource =
             await RequestConfigBuilder.resolveArtworkSourceAsync(
               track,
-              requestConfig,
               artworkConfig
             )
           if (artworkSource && !track.artworkSource) {

package/src/web/http/HttpClient.ts

@@ -1,5 +1,5 @@
 import type { NavigationErrorType } from '../../features'
-import type { RequestConfig } from '../../types'
+import type { RequestConfig, TransformableRequestConfig } from '../../types'
 import { RequestConfigBuilder } from './RequestConfigBuilder'
 
 type HttpError = Error & {
@@ -23,12 +23,42 @@ const TIMEOUT_MS = 30_000
 /**
  * HTTP client for making browser API requests.
  * Mirrors Android's HttpClient.kt
- *
- * Config layering (the shared `request` → `<kind>` → route chain) is handled by
- * the callers via RequestConfigBuilder.applyLayer; this client just builds the
- * URL from the fully-merged config and executes the request.
+ * Uses RequestConfigBuilder for URL building and config merging.
  */
 export class HttpClient {
+  private baseRequestConfig: Partial<TransformableRequestConfig>
+
+  constructor(baseRequestConfig: Partial<TransformableRequestConfig> = {}) {
+    this.baseRequestConfig = baseRequestConfig
+  }
+
+  /**
+   * Updates the base request configuration used for all requests.
+   */
+  setBaseRequestConfig(config: Partial<TransformableRequestConfig>): void {
+    this.baseRequestConfig = config
+  }
+
+  /**
+   * Merges multiple request configs with proper header and query parameter merging.
+   * Uses RequestConfigBuilder for consistent merging behavior.
+   */
+  mergeRequestConfig(
+    base: Partial<TransformableRequestConfig>,
+    overrides: Partial<RequestConfig>
+  ): RequestConfig {
+    // First merge base with the instance's base config
+    const withBase = RequestConfigBuilder.mergeConfig(
+      this.baseRequestConfig as RequestConfig,
+      base as RequestConfig
+    )
+    // Then merge with overrides
+    return RequestConfigBuilder.mergeConfig(
+      withBase,
+      overrides as RequestConfig
+    )
+  }
+
   /**
    * Executes an HTTP request and returns the JSON response.
    * Throws navigation errors for HTTP and network failures.