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

package/src/web/http/RequestConfigBuilder.ts

@@ -8,7 +8,6 @@ import type {
   ImageContext,
   ImageQueryParams
 } from '../../types'
-import { artworkUrl as resolveArtworkUrl } from '../../utils/artwork'
 import { BrowserPathHelper } from '../util/BrowserPathHelper'
 
 /**
@@ -94,59 +93,46 @@ export const RequestConfigBuilder = {
   },
 
   /**
-   * Applies one request-config layer (request / kind / route) onto a base.
-   * A layer with a transform wins completely — it receives the base (plus route
-   * params) and its result replaces the base; the layer's own static fields are
-   * ignored. A layer without a transform merges its static fields over the base.
-   * `path` is carried from the base — only a transform may change it.
+   * Merges a base RequestConfig with a MediaRequestConfig.
+   * Returns the merged config for use in media URL resolution.
+   * Supports the transform callback like Android's RequestConfigBuilder.
    *
-   * Mirrors native's BrowserManager.applyLayer so web resolves the shared
-   * `request` → `<kind>` → route chain identically across platforms.
+   * Note: MediaRequestConfig inherits transform from TransformableRequestConfig,
+   * which takes (request, routeParams?) directly, not MediaTransformParams.
    */
-  async applyLayer(
+  async mergeMediaConfig(
     base: RequestConfig,
-    layer: TransformableRequestConfig | undefined,
-    params?: Record<string, string>
+    override: MediaRequestConfig
   ): Promise<RequestConfig> {
-    if (!layer) return base
-    // A transform (async and/or sync) wins completely: it receives the base and
-    // its result replaces it. When both are set they run as a pipeline — async
-    // first, then sync (mirrors native applyLayer).
-    if (layer.transform || layer.transformSync) {
-      let cfg = base
-      if (layer.transform) cfg = await layer.transform(cfg, params)
-      if (layer.transformSync) cfg = layer.transformSync(cfg, params)
-      return cfg
-    }
-    return {
-      method: layer.method ?? base.method,
-      path: base.path,
-      baseUrl: layer.baseUrl ?? base.baseUrl,
-      headers: this.mergeHeaders(base.headers, layer.headers),
-      query: this.mergeQuery(base.query, layer.query),
-      body: layer.body ?? base.body,
-      contentType: layer.contentType ?? base.contentType,
-      userAgent: layer.userAgent ?? base.userAgent
+    // Apply transform function if provided - transform result wins completely
+    if (override.transform) {
+      try {
+        // TransformableRequestConfig.transform takes (request, routeParams?) directly
+        const transformed = await override.transform(base)
+        return transformed
+      } catch (e) {
+        console.error(
+          'Failed to apply media transform function, using base config',
+          e
+        )
+        return base
+      }
     }
+
+    // No transform - merge static config
+    return this.mergeConfig(base, this.toRequestConfig(override))
   },
 
   /**
-   * Applies an ordered list of layers onto a base via {@link applyLayer}, each
-   * layer receiving the previous one's output. `undefined` layers are skipped.
-   * This is the single primitive for the `request → <kind> → route` chain —
-   * browse, search, and media all build a base and reduce their layers through
-   * it, so the ladder lives in exactly one place.
+   * Merges a base RequestConfig with an ArtworkRequestConfig.
+   * Returns the merged config for use in artwork URL resolution.
    */
-  async applyLayers(
+  mergeArtworkConfig(
     base: RequestConfig,
-    layers: (TransformableRequestConfig | undefined)[],
-    params?: Record<string, string>
-  ): Promise<RequestConfig> {
-    let merged = base
-    for (const layer of layers) {
-      merged = await this.applyLayer(merged, layer, params)
-    }
-    return merged
+    override: ArtworkRequestConfig
+  ): RequestConfig {
+    // On web, we don't support resolve/transform callbacks - just merge the static config
+    return this.mergeConfig(base, this.toRequestConfig(override))
   },
 
   /**
@@ -175,67 +161,39 @@ export const RequestConfigBuilder = {
    * Creates a RequestConfig with the track's src as the path, then builds the URL.
    * Supports the transform callback for URL manipulation.
    *
-   * The shared `request` layer is applied first (its transform runs for media
-   * too, per the documented contract — e.g. a dynamic baseUrl), then the media
-   * transform / static fields on top. Mirrors native's resolveMediaUrl,
-   * including its best-effort behaviour: if a transform throws, fall back to the
-   * original `src` rather than failing the load.
-   *
    * @param src The track's src value (may be relative or absolute)
-   * @param requestConfig The shared request configuration (applied first)
    * @param mediaConfig The media request configuration
    * @returns The resolved absolute URL
    */
   async resolveMediaUrl(
     src: string,
-    requestConfig: TransformableRequestConfig | undefined,
     mediaConfig: MediaRequestConfig | undefined
   ): Promise<string> {
-    try {
-      const config = await this.applyLayers({ path: src }, [
-        requestConfig,
-        mediaConfig
-      ])
-      return BrowserPathHelper.buildUrl(config.baseUrl, config.path ?? src)
-    } catch (e) {
-      console.error('Failed to resolve media URL, using original src', e)
+    if (!mediaConfig) {
       return BrowserPathHelper.buildUrl(undefined, src)
     }
+
+    const config = await this.mergeMediaConfig({ path: src }, mediaConfig)
+    return BrowserPathHelper.buildUrl(config.baseUrl, config.path ?? src)
   },
 
   /**
    * Resolves an artwork URL and creates an ImageSource.
    * Matches Android's artwork URL transformation behavior.
    *
-   * The shared `request` layer's static fields are applied first; this sync path
-   * cannot run an async `request.transform`, so transform-based shaping (e.g. a
-   * dynamic baseUrl) only applies on the async resolution paths. Queue tracks
-   * usually already carry an `artworkSource` resolved at browse-time, so this
-   * sync fallback rarely runs.
-   *
    * @param artworkUrl The artwork URL (may be relative or absolute)
-   * @param requestConfig The shared request configuration (static fields only)
    * @param artworkConfig The artwork request configuration
    * @returns ImageSource with resolved URI, or undefined if no artwork
    */
   resolveArtworkSource(
     artworkUrl: string | undefined,
-    requestConfig: TransformableRequestConfig | undefined,
     artworkConfig: ArtworkRequestConfig | undefined
   ): ImageSource | undefined {
     if (!artworkUrl) return undefined
 
-    // Base path stays the artwork URL; the request layer contributes baseUrl /
-    // query / headers, then the artwork config overrides on top.
-    let config: RequestConfig = { path: artworkUrl }
-    if (requestConfig) {
-      config = this.mergeConfig(this.toRequestConfig(requestConfig), {
-        path: artworkUrl
-      })
-    }
-    if (artworkConfig) {
-      config = this.mergeConfig(config, this.toRequestConfig(artworkConfig))
-    }
+    const config = artworkConfig
+      ? this.mergeArtworkConfig({ path: artworkUrl }, artworkConfig)
+      : { path: artworkUrl }
 
     const resolvedUri = BrowserPathHelper.buildUrl(
       config.baseUrl,
@@ -252,30 +210,25 @@ export const RequestConfigBuilder = {
   /**
    * Resolves an artwork URL asynchronously with full Track access.
    * Supports resolve and transform callbacks from ArtworkRequestConfig.
-   * Matches the native platforms' BrowserManager resolveArtworkUrl behavior.
+   * Matches Android's CoilBitmapLoader.transformArtworkUrlForTrack() behavior.
    *
    * The resolution order is:
-   * 0. Apply the shared `request` layer (its transform runs for artwork too)
    * 1. If resolve callback exists, call it with the track to get per-track config
    * 2. Merge base config + resolved config
    * 3. Apply imageQueryParams if context has dimensions
    * 4. Apply transform callback if present
    *
    * @param track The track to resolve artwork for (full Track object)
-   * @param requestConfig The shared request configuration (applied first)
    * @param artworkConfig The artwork request configuration
    * @param imageContext Optional image context with size hints (width/height)
    * @returns ImageSource with resolved URI, or undefined if no artwork
    */
   async resolveArtworkSourceAsync(
     track: Track,
-    requestConfig: TransformableRequestConfig | undefined,
     artworkConfig: ArtworkRequestConfig | undefined,
     imageContext?: ImageContext
   ): Promise<ImageSource | undefined> {
-    // Collapses a per-appearance pair to one URL: this pipeline produces a
-    // single `ImageSource`, and the web fallback renders one <Image>.
-    const artworkUrl = resolveArtworkUrl(track.artwork)
+    const artworkUrl = track.artwork
 
     // If no config and no track.artwork, nothing to transform
     if (!artworkConfig && !artworkUrl) {
@@ -288,35 +241,18 @@ export const RequestConfigBuilder = {
     }
 
     try {
-      // Step 0: Apply the shared request layer, with track.artwork as the path.
-      // Its transform (if any) runs for artwork too — e.g. a dynamic baseUrl.
-      const baseConfig = await this.applyLayer(
-        { path: artworkUrl },
-        requestConfig
-      )
-
-      // Step 1: Per-track resolution — async `resolve` first, then `resolveSync`
-      // merged over it (mirrors native).
+      // Step 1: Call resolve callback if provided to get per-track config
       let resolvedConfig: RequestConfig | undefined
       if (artworkConfig.resolve) {
         resolvedConfig = await artworkConfig.resolve(track)
-      }
-      if (artworkConfig.resolveSync) {
-        const r = artworkConfig.resolveSync(track)
-        resolvedConfig = resolvedConfig
-          ? this.mergeConfig(resolvedConfig, r)
-          : r
-      }
-      // If a resolver ran but produced nothing and there's no artwork URL, no artwork
-      if (
-        (artworkConfig.resolve || artworkConfig.resolveSync) &&
-        !resolvedConfig &&
-        artworkUrl === undefined
-      ) {
-        return undefined
+        // If resolve callback returned null/undefined, that means no artwork
+        if (!resolvedConfig && artworkUrl === undefined) {
+          return undefined
+        }
       }
 
       // Step 2: Merge base config + resolved per-track config
+      const baseConfig: RequestConfig = { path: artworkUrl }
       let mergedConfig = this.mergeConfig(
         this.mergeConfig(baseConfig, this.toRequestConfig(artworkConfig)),
         resolvedConfig ?? {}
@@ -329,19 +265,13 @@ export const RequestConfigBuilder = {
         imageContext
       )
 
-      // Step 4: Apply transform — async first, then sync (pipeline)
+      // Step 4: Apply transform callback if present
       if (artworkConfig.transform) {
         mergedConfig = await artworkConfig.transform({
           request: mergedConfig,
           context: imageContext
         })
       }
-      if (artworkConfig.transformSync) {
-        mergedConfig = artworkConfig.transformSync({
-          request: mergedConfig,
-          context: imageContext
-        })
-      }
 
       // Build final URL
       const resolvedUri = BrowserPathHelper.buildUrl(
@@ -369,21 +299,18 @@ export const RequestConfigBuilder = {
    * Matches Android's transformArtworkUrl behavior.
    *
    * @param track The track to transform
-   * @param requestConfig The shared request configuration (static fields only)
    * @param artworkConfig The artwork request configuration
    * @returns Track with artworkSource populated
    */
   transformTrackArtwork(
     track: Track,
-    requestConfig: TransformableRequestConfig | undefined,
     artworkConfig: ArtworkRequestConfig | undefined
   ): Track {
     // If artworkSource is already set, don't override it
     if (track.artworkSource) return track
 
     const artworkSource = this.resolveArtworkSource(
-      resolveArtworkUrl(track.artwork),
-      requestConfig,
+      track.artwork,
       artworkConfig
     )
     if (!artworkSource) return track
@@ -394,6 +321,22 @@ export const RequestConfigBuilder = {
     }
   },
 
+  /**
+   * Transforms artwork URLs for an array of tracks.
+   *
+   * @param tracks Array of tracks to transform
+   * @param artworkConfig The artwork request configuration
+   * @returns Tracks with artworkSource populated
+   */
+  transformTracksArtwork(
+    tracks: Track[],
+    artworkConfig: ArtworkRequestConfig | undefined
+  ): Track[] {
+    return tracks.map((track) =>
+      this.transformTrackArtwork(track, artworkConfig)
+    )
+  },
+
   /**
    * Merges header maps, with override values taking precedence.
    */

package/src/web/player/NowPlayingManager.ts

@@ -1,6 +1,5 @@
 import type { NowPlayingUpdate, NowPlayingMetadata } from '../../features'
 import type { Track } from '../../types'
-import { artworkUrl } from '../../utils/artwork'
 
 /**
  * Manages now playing metadata overrides.
@@ -34,8 +33,8 @@ export class NowPlayingManager {
       ? {
           title: update.title ?? currentTrack.title,
           artist: update.artist ?? currentTrack.artist,
-          album: update.album ?? currentTrack.album,
-          artwork: artworkUrl(currentTrack.artwork),
+          album: currentTrack.album,
+          artwork: currentTrack.artwork,
           description: currentTrack.description,
           mediaId: currentTrack.src ?? currentTrack.url,
           genre: currentTrack.genre,
@@ -45,7 +44,7 @@ export class NowPlayingManager {
           title: currentTrack.title,
           artist: currentTrack.artist,
           album: currentTrack.album,
-          artwork: artworkUrl(currentTrack.artwork),
+          artwork: currentTrack.artwork,
           description: currentTrack.description,
           mediaId: currentTrack.src ?? currentTrack.url,
           genre: currentTrack.genre,
@@ -71,8 +70,8 @@ export class NowPlayingManager {
     return {
       title: this.override?.title ?? currentTrack.title,
       artist: this.override?.artist ?? currentTrack.artist,
-      album: this.override?.album ?? currentTrack.album,
-      artwork: artworkUrl(currentTrack.artwork),
+      album: currentTrack.album,
+      artwork: currentTrack.artwork,
       description: currentTrack.description,
       mediaId: currentTrack.src ?? currentTrack.url,
       genre: currentTrack.genre,

package/src/web/player/OptionsManager.ts

@@ -59,21 +59,27 @@ export class OptionsManager {
     // Store merged options
     this.options = mergedOptions
 
-    this.onOptionsChanged(this.toOptions())
-  }
-
-  /** The current options in their resolved shape. */
-  getOptions(): Options {
-    return this.toOptions()
+    // Call callback with full Options type (including repeatMode)
+    const fullOptions: Options = {
+      forwardJumpInterval: mergedOptions.forwardJumpInterval ?? 15,
+      backwardJumpInterval: mergedOptions.backwardJumpInterval ?? 15,
+      progressUpdateEventInterval:
+        mergedOptions.progressUpdateEventInterval ?? 15,
+      capabilities: mergedOptions.capabilities ?? {},
+      repeatMode: mergedOptions.repeatMode
+    }
+    this.onOptionsChanged(fullOptions)
   }
 
-  private toOptions(): Options {
+  /**
+   * Gets current player options (excluding repeatMode).
+   */
+  getOptions(): UpdateOptions {
     return {
-      forwardJumpInterval: this.options.forwardJumpInterval ?? 15,
-      backwardJumpInterval: this.options.backwardJumpInterval ?? 15,
-      progressUpdateEventInterval:
-        this.options.progressUpdateEventInterval ?? null,
-      capabilities: this.options.capabilities ?? {}
+      forwardJumpInterval: this.options.forwardJumpInterval,
+      backwardJumpInterval: this.options.backwardJumpInterval,
+      progressUpdateEventInterval: this.options.progressUpdateEventInterval,
+      capabilities: this.options.capabilities
     }
   }
 

package/android/src/main/java/com/audiobrowser/browser/ArtworkResolutionRegistry.kt

@@ -1,37 +0,0 @@
-package com.audiobrowser.browser
-
-import com.margelo.nitro.audiobrowser.ArtworkRequestConfig
-import com.margelo.nitro.audiobrowser.Track
-
-/**
- * Remembers how an artwork URI was produced (which Track, which artwork-config kind) so the
- * display-time bitmap loader can re-resolve it Track-first with a real size hint — instead of
- * re-running the artwork Transform on an already-transformed URL, which is only safe for idempotent
- * transforms. Bounded LRU; thread-safe (registered from browse coroutines and the now-playing
- * scope, read from the bitmap loader's IO scope).
- */
-class ArtworkResolutionRegistry(private val maxEntries: Int = 256) {
-
-  data class Entry(val track: Track, val perRouteConfig: ArtworkRequestConfig?)
-
-  private val entries =
-    object : LinkedHashMap<String, Entry>(16, 0.75f, true) {
-      override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, Entry>): Boolean =
-        size > maxEntries
-    }
-
-  @Synchronized
-  fun register(uri: String, track: Track, perRouteConfig: ArtworkRequestConfig?) {
-    entries[uri] = Entry(track, perRouteConfig)
-  }
-
-  @Synchronized fun lookup(uri: String): Entry? = entries[uri]
-
-  /**
-   * Drops all entries. Must run whenever the browser config is replaced or content is invalidated:
-   * entries pin Tracks and ArtworkRequestConfigs whose transform/resolve fields are Nitro handles
-   * to JS closures — keeping them past their config's lifetime both retains dead closures and
-   * resolves display-time artwork through stale callbacks.
-   */
-  @Synchronized fun clear() = entries.clear()
-}

package/android/src/main/java/com/audiobrowser/browser/BrowseArtworkRegistry.kt

@@ -1,34 +0,0 @@
-package com.audiobrowser.browser
-
-/**
- * Token → resolved browse artwork, the [com.audiobrowser.util.ArtworkContentProvider]'s only data
- * source. Stores plain resolved data (no Track / Nitro handles), so unlike
- * [ArtworkResolutionRegistry] it pins no JS closures and can be sized generously. Cleared when the
- * browser config is replaced or content is invalidated. Thread-safe: written from browse
- * coroutines, read from the provider's IO scope.
- */
-class BrowseArtworkRegistry(private val maxEntries: Int = 2048) {
-
-  private val entries =
-    object : LinkedHashMap<String, ResolvedArtwork>(16, 0.75f, true) {
-      override fun removeEldestEntry(
-        eldest: MutableMap.MutableEntry<String, ResolvedArtwork>
-      ): Boolean = size > maxEntries
-    }
-
-  @Synchronized
-  fun register(token: String, artwork: ResolvedArtwork) {
-    entries[token] = artwork
-  }
-
-  @Synchronized fun lookup(token: String): ResolvedArtwork? = entries[token]
-
-  @Synchronized fun clear() = entries.clear()
-}
-
-/** Everything the provider needs to fetch one artwork, resolved at browse-build time. */
-data class ResolvedArtwork(
-  val finalUrl: String,
-  val headers: Map<String, String>?,
-  val isSvg: Boolean,
-)