react-native-audio-browser 0.2.0-next.32 → 0.2.0-next.33

package/ios/Browser/RequestPipeline.swift

@@ -30,7 +30,7 @@ final class RequestPipeline {
 
   /// The request and browse layers of the current config: each resolver's result, or the
   /// static layer when it has none. The resolvers run one after the other, request first, as on
-  /// Android and web, and a config change or `clearContentCache` while they run resolves them
+  /// Android and web, and a config change or `invalidateAll` while they run resolves them
   /// again.
   func resolvedLayers() async throws -> ResolvedLayers {
     try await layers.value { [weak self] in
@@ -45,12 +45,12 @@ final class RequestPipeline {
     }
   }
 
-  /// Applies one Request-Config Layer (request / browse / route) onto `base`: its transforms
-  /// (async, then sync) when it has any, else its static fields (`RequestLayer.apply`).
+  /// Applies one Request-Config Layer (request / browse / media / route) onto `base`: its
+  /// transforms (async, then sync) when it has any, else its static fields (`RequestLayer.apply`).
   func applyLayer(
-    _ layer: TransformableRequestConfig?,
+    _ layer: (some TransformableLayer)?,
     to base: RequestConfig,
-    params: [String: String],
+    params: [String: String]?,
   ) async throws -> RequestConfig {
     guard let layer else { return base }
     var transforms: [nonisolated(nonsending)(RequestConfig) async throws -> RequestConfig] = []
@@ -60,11 +60,7 @@ final class RequestPipeline {
     if let transformSync = layer.transformSync {
       transforms.append { try await self.awaitSyncConfig(transformSync($0, params)) }
     }
-    let fields = RequestConfig(
-      method: layer.method, path: nil, baseUrl: layer.baseUrl, headers: layer.headers,
-      query: layer.query, body: layer.body, contentType: layer.contentType, userAgent: layer.userAgent,
-    )
-    return try await RequestLayer.apply(fields, transforms: transforms, to: base)
+    return try await RequestLayer.apply(RequestConfig(fieldsOf: layer), transforms: transforms, to: base)
   }
 
   /// Builds the HTTP request for an API-backed route by layering
@@ -82,10 +78,7 @@ final class RequestPipeline {
     params: [String: String],
     initialQuery: [String: String]? = nil,
   ) async throws -> HttpClient.HttpRequest {
-    var merged = RequestConfig(
-      method: nil, path: path, baseUrl: nil, headers: nil,
-      query: nil, body: nil, contentType: nil, userAgent: nil,
-    )
+    var merged = RequestConfig.base(path: path)
     let layers = try await resolvedLayers()
     merged = try await applyLayer(layers.request, to: merged, params: params)
     if let initialQuery, !initialQuery.isEmpty {
@@ -99,7 +92,7 @@ final class RequestPipeline {
     }
     return HttpClient.HttpRequest(
       url: RequestLayer.buildUrl(merged, defaultPath: path),
-      method: merged.method?.stringValue ?? "GET",
+      method: merged.method ?? .get,
       headers: merged.headers,
       body: merged.body,
       contentType: merged.contentType ?? HttpClient.defaultContentType,
@@ -139,7 +132,7 @@ final class RequestPipeline {
   func fetchSearch(_ searchConfig: TransformableRequestConfig, params: SearchParams) async throws -> [Track] {
     let request = try await buildApiRequest(
       kind: nil, searchConfig, path: searchConfig.path ?? "", params: ["q": params.query],
-      initialQuery: PageResolver.searchQueryParams(params),
+      initialQuery: params.queryParams,
     )
     logger.debug("Searching via API: \(request.url)")
     let jsonTracks: [JsonTrack] = try await httpClient.requestJson(request, as: [JsonTrack].self)
@@ -148,38 +141,18 @@ final class RequestPipeline {
 
   // MARK: - Media URL Resolution
 
-  /// Resolves a media URL using the configured media transform.
-  /// Returns the transformed URL, headers, and user-agent for playback.
-  ///
-  /// Resolution layers, least- to most-specific: shared `request` layer →
-  /// `media` transform / static fields → `media.resolve(track)`. The final
-  /// `resolve` layer (if configured) is merged last,
-  /// so its fields win. The `track` is only used to feed `resolve`; we do NOT
-  /// auto-merge `track.request` here.
+  /// The media request for `originalUrl`: the shared `request` layer, then the `media` layer,
+  /// then `media.resolve(track)` merged over them. `track` only feeds `resolve`; its own
+  /// `request` is not merged here. A failing layer leaves the URL as it is.
   func resolveMediaUrl(_ originalUrl: String, track: Track? = nil) async -> MediaResolvedUrl {
-    logger.debug("Resolving media URL: \(originalUrl)")
-
-    // Apply the shared `request` layer first (its transform runs for media too,
-    // per the documented contract — e.g. a dynamic baseUrl), then the media
-    // transform / static fields on top. The request layer applies even when no
-    // `media` config is present, so a relative src still gets baseUrl.
-    let baseRequest: RequestConfig
+    let base: RequestConfig
     do {
-      baseRequest = try await applyLayer(
-        resolvedLayers().request,
-        to: RequestConfig(
-          method: nil, path: originalUrl, baseUrl: nil, headers: nil,
-          query: nil, body: nil, contentType: nil, userAgent: nil,
-        ),
-        params: [:],
-      )
+      base = try await applyLayer(resolvedLayers().request, to: .base(path: originalUrl), params: [:])
     } catch {
       logger.error("Media request layer failed: \(error.localizedDescription)")
       return MediaResolvedUrl(url: originalUrl, headers: nil, userAgent: nil)
     }
 
-    // Resolve the consumer-supplied final media layer once, up front. This is the
-    // most-specific layer and is merged over every branch's result below.
     let resolveLayer: RequestConfig?
     do {
       resolveLayer = try await resolveMediaTrackConfig(track)
@@ -188,228 +161,106 @@ final class RequestPipeline {
       resolveLayer = nil
     }
 
-    // request → media (kind layer) → media.resolve(track), resolve winning.
-    // Matches the web stub and Android. (The old static branch dropped a media
-    // config's static query/method/body/contentType, and dropped its headers
-    // entirely when no baseUrl was configured anywhere.)
     do {
-      var merged = baseRequest
-      if let mediaConfig = config.media {
-        merged = try await applyMediaLayer(mediaConfig, to: merged)
-      }
+      var merged = try await applyLayer(config.media, to: base, params: nil)
       if let resolveLayer { merged = RequestLayer.merge(merged, resolveLayer) }
       let finalUrl = RequestLayer.buildUrl(merged)
       logger.debug("Media URL resolved: \(originalUrl) -> \(finalUrl)")
-      return MediaResolvedUrl(
-        url: finalUrl,
-        headers: merged.headers,
-        userAgent: merged.userAgent,
-      )
+      return MediaResolvedUrl(url: finalUrl, headers: merged.headers, userAgent: merged.userAgent)
     } catch {
       logger.error("Media transform failed: \(error.localizedDescription)")
       return MediaResolvedUrl(url: originalUrl, headers: nil, userAgent: nil)
     }
   }
 
-  /// The media kind's Request-Config Layer over `base`: its transforms, when it has any, else
-  /// its static fields (`RequestLayer.apply`).
-  private func applyMediaLayer(_ media: MediaRequestConfig, to base: RequestConfig) async throws -> RequestConfig {
-    var transforms: [nonisolated(nonsending)(RequestConfig) async throws -> RequestConfig] = []
-    if let transform = media.transform {
-      transforms.append { try await self.awaitAsyncConfig(transform($0, nil)) }
-    }
-    if let transformSync = media.transformSync {
-      transforms.append { try await self.awaitSyncConfig(transformSync($0, nil)) }
-    }
-    let fields = RequestConfig(
-      method: media.method, path: nil, baseUrl: media.baseUrl, headers: media.headers,
-      query: media.query, body: media.body, contentType: media.contentType, userAgent: media.userAgent,
-    )
-    return try await RequestLayer.apply(fields, transforms: transforms, to: base)
-  }
-
-  /// Invokes the consumer-supplied `media.resolve`/`resolveSync(track)` and merges
-  /// the results (async first, then sync, sync winning) into a concrete
-  /// `RequestConfig`. Returns `nil` when neither is configured or no track is
-  /// available. Each result is copied out of the Nitro bridge immediately.
+  /// The config the `media.resolve` / `resolveSync(track)` callbacks produce, nil when neither is
+  /// configured or there is no track.
   func resolveMediaTrackConfig(_ track: Track?) async throws -> RequestConfig? {
     guard let track, let media = config.media else { return nil }
+    return try await resolved(media.resolve, media.resolveSync, for: track)
+  }
+
+  /// What a `resolve` (async) and `resolveSync` produce for `track`, the sync one winning.
+  private func resolved(
+    _ resolve: ((Track) -> Promise<Promise<RequestConfig>>)?,
+    _ resolveSync: ((Track) -> Promise<RequestConfig>)?,
+    for track: Track,
+  ) async throws -> RequestConfig? {
     var asyncResolved: RequestConfig?
-    if let resolve = media.resolve { asyncResolved = try await awaitAsyncConfig(resolve(track)) }
+    if let resolve { asyncResolved = try await awaitAsyncConfig(resolve(track)) }
     var syncResolved: RequestConfig?
-    if let resolveSync = media.resolveSync { syncResolved = try await awaitSyncConfig(resolveSync(track)) }
+    if let resolveSync { syncResolved = try await awaitSyncConfig(resolveSync(track)) }
     return RequestLayer.mergeResolved(async: asyncResolved, sync: syncResolved)
   }
 
   // MARK: - Artwork URL Resolution
 
-  /// Resolves an artwork URL for a track using the configured artwork transform.
-  /// Returns an ImageSource with transformed URL and headers for image loading.
-  ///
-  /// - Parameters:
-  ///   - track: The track whose artwork URL should be transformed
-  ///   - perRouteConfig: Optional per-route artwork config that overrides global config
-  ///   - imageContext: Optional size context for CDN URL generation (nil at browse-time)
-  /// - Returns: ImageSource ready for image loading, or nil if no artwork
+  /// The image source for `track`'s artwork: an SF Symbol rendered to a file, the artwork URL
+  /// as is without an artwork config, else the shared `request` layer and the artwork config in
+  /// `RequestLayer.artwork`'s order. `perRouteConfig` replaces the global artwork config;
+  /// `imageContext` is the display size, nil at browse time. Nil when there is no artwork or a
+  /// callback fails.
   func resolveArtworkUrl(track: Track, perRouteConfig: ArtworkRequestConfig?, imageContext: ImageContext? = nil) async -> ImageSource? {
-    if let artwork = track.artwork?.url, SFSymbolRenderer.isSFSymbol(artwork) {
+    let artworkUrl = track.artwork?.url
+    if let artworkUrl, SFSymbolRenderer.isSFSymbol(artworkUrl) {
       let canvasSize: CGSize = if let w = imageContext?.width, let h = imageContext?.height {
         CGSize(width: w, height: h)
       } else {
         SFSymbolRenderer.defaultCanvasSize
       }
-      if let uri = SFSymbolRenderer.shared.render(artwork, canvasSize: canvasSize) {
-        return ImageSource(uri: uri, method: nil, headers: nil, body: nil)
-      }
-      return nil
-    }
-
-    // Determine effective artwork config: per-route overrides global
-    let effectiveArtworkConfig = perRouteConfig ?? config.artwork
-
-    // If no artwork config and no track.artwork, nothing to transform
-    if effectiveArtworkConfig == nil, track.artwork == nil {
-      return nil
+      return SFSymbolRenderer.shared.render(artworkUrl, canvasSize: canvasSize)
+        .map { ImageSource(uri: $0, method: nil, headers: nil, body: nil) }
     }
 
-    // If no artwork config, return original artwork URL as simple ImageSource
-    guard let artworkConfig = effectiveArtworkConfig else {
-      guard let artwork = track.artwork?.url else { return nil }
-      return ImageSource(uri: artwork, method: nil, headers: nil, body: nil)
+    guard let artworkConfig = perRouteConfig ?? config.artwork else {
+      return artworkUrl.map { ImageSource(uri: $0, method: nil, headers: nil, body: nil) }
     }
 
     do {
-      // Base config via the shared `request` layer (its transform runs for
-      // artwork too), with track.artwork as the default path. Artwork then
-      // shapes further via its own resolve / static fields / transform.
-      var mergedConfig = try await applyLayer(
-        resolvedLayers().request,
-        to: RequestConfig(
-          method: nil, path: track.artwork?.url, baseUrl: nil, headers: nil,
-          query: nil, body: nil, contentType: nil, userAgent: nil,
-        ),
-        params: [:],
-      )
-
-      // Artwork config's static fields always apply (not resolve/transform — those
-      // run separately), with the per-track resolve merged over them — resolve
-      // wins. Matches the web stub and Android (the old either/or skipped static
-      // fields whenever a resolver was configured).
-      let artworkStaticConfig = RequestConfig(
-        method: artworkConfig.method,
-        path: artworkConfig.path,
-        baseUrl: artworkConfig.baseUrl,
-        headers: artworkConfig.headers,
-        query: artworkConfig.query,
-        body: artworkConfig.body,
-        contentType: artworkConfig.contentType,
-        userAgent: artworkConfig.userAgent,
-      )
-      mergedConfig = RequestLayer.merge(mergedConfig, artworkStaticConfig)
-
-      if artworkConfig.resolve != nil || artworkConfig.resolveSync != nil {
-        var asyncResolved: RequestConfig?
-        if let resolve = artworkConfig.resolve { asyncResolved = try await awaitAsyncConfig(resolve(track)) }
-        var syncResolved: RequestConfig?
-        if let resolveSync = artworkConfig.resolveSync { syncResolved = try await awaitSyncConfig(resolveSync(track)) }
-        if let resolved = RequestLayer.mergeResolved(async: asyncResolved, sync: syncResolved) {
-          mergedConfig = RequestLayer.merge(mergedConfig, resolved)
-        } else if track.artwork == nil {
-          // A resolver ran but produced nothing, and there's no artwork URL either
-          // → no artwork (matches the web stub).
-          return nil
+      let base = try await applyLayer(resolvedLayers().request, to: .base(path: artworkUrl), params: [:])
+      let resolve: (nonisolated(nonsending)() async throws -> RequestConfig?)? =
+        if artworkConfig.resolve != nil || artworkConfig.resolveSync != nil {
+          { try await self.resolved(artworkConfig.resolve, artworkConfig.resolveSync, for: track) }
+        } else {
+          nil
         }
-      }
-
-      // Apply image query params if configured and imageContext is provided
-      let queryParams = artworkConfig.imageQueryParams
-      if let queryParams, let imageContext {
-        var contextQuery: [String: String] = [:]
-        if let widthKey = queryParams.width, let width = imageContext.width {
-          contextQuery[widthKey] = String(Int(width))
-        }
-        if let heightKey = queryParams.height, let height = imageContext.height {
-          contextQuery[heightKey] = String(Int(height))
-        }
-
-        if !contextQuery.isEmpty {
-          logger.debug("Adding image query params: \(contextQuery)")
-          mergedConfig = mergedConfig.copying(query: RequestLayer.mergeDicts(mergedConfig.query, contextQuery))
-        }
-      }
-
-      // Transform (async first, then sync), receiving the image context — which is
-      // nil at browse time, matching the web stub and Android. (Previously skipped
-      // without a size, leaving browse-time `artworkSource` untransformed for JS
-      // consumers; load-time surfaces re-resolve Track-first with the real size,
-      // so running it here cannot double-transform.)
+      var transforms: [nonisolated(nonsending)(RequestConfig) async throws -> RequestConfig] = []
       if let transform = artworkConfig.transform {
-        mergedConfig = try await awaitAsyncConfig(transform(MediaTransformParams(request: mergedConfig, context: imageContext)))
+        transforms.append { try await self.awaitAsyncConfig(transform(MediaTransformParams(request: $0, context: imageContext))) }
       }
       if let transformSync = artworkConfig.transformSync {
-        mergedConfig = try await awaitSyncConfig(transformSync(MediaTransformParams(request: mergedConfig, context: imageContext)))
-      }
-
-      // Substitute the `{id}` template token with the track's id across path/query/header values.
-      // (Configs without the token are unaffected — e.g. browse artwork.) A track without a
-      // non-blank id leaves the token LITERALLY in place — the request then visibly 404s, which
-      // is intended (self-describing error trail) — with a single warning logged below once the
-      // URL is built.
-      mergedConfig = substituteTrackId(in: mergedConfig, id: track.id)
-      let hasUnfilledIdToken = TrackIdTemplate.containsToken(mergedConfig.path)
-        || TrackIdTemplate.containsToken(mergedConfig.query)
-        || TrackIdTemplate.containsToken(mergedConfig.headers)
-
-      // Build final URL - if no path after merging, no artwork to transform
-      guard mergedConfig.path != nil else {
-        return nil
+        transforms.append { try await self.awaitSyncConfig(transformSync(MediaTransformParams(request: $0, context: imageContext))) }
       }
-
-      let uri = RequestLayer.buildUrl(mergedConfig)
-
-      // Build headers map, merging explicit headers with userAgent
-      var headers = mergedConfig.headers ?? [:]
-      if let userAgent = mergedConfig.userAgent, headers["User-Agent"] == nil {
-        headers["User-Agent"] = userAgent
-      }
-
-      if hasUnfilledIdToken {
+      guard let request = try await RequestLayer.artwork(
+        RequestConfig(fieldsOf: artworkConfig),
+        over: base,
+        resolve: resolve,
+        trackHasArtwork: track.artwork != nil,
+        sizeQuery: RequestLayer.sizeQuery(artworkConfig.imageQueryParams, imageContext),
+        transforms: transforms,
+        id: track.id,
+      ) else { return nil }
+
+      let uri = RequestLayer.buildUrl(request)
+      // An unfilled `{id}` stays in the URL, so the request fails visibly.
+      if RequestLayer.hasUnfilledIdToken(request) {
         logger.warning("nowPlayingArtwork: track has no id — '{id}' left unfilled in \(uri)")
       }
-
-      logger.debug("Artwork URL transformed: \(track.artwork?.url ?? "nil") -> \(uri)")
-
+      logger.debug("Artwork URL transformed: \(artworkUrl ?? "nil") -> \(uri)")
       return ImageSource(
         uri: uri,
-        method: mergedConfig.method,
-        headers: headers.isEmpty ? nil : headers,
-        body: mergedConfig.body,
+        method: request.method,
+        headers: RequestLayer.imageHeaders(request),
+        body: request.body,
       )
     } catch {
       logger.error("Failed to transform artwork URL for track: \(track.title), error: \(error.localizedDescription)")
-      // On error, return nil to avoid broken images
       return nil
     }
   }
 
   // MARK: - Config Utilities
 
-  /// Replaces the `{id}` token with the track id in a request config's path, query values, and
-  /// header values. Used so a `nowPlayingArtwork` like `{ path: "/artwork/{id}" }` resolves.
-  /// A nil/blank id leaves the values unchanged (token left literal — see TrackIdTemplate).
-  private func substituteTrackId(in config: RequestConfig, id: String?) -> RequestConfig {
-    RequestConfig(
-      method: config.method,
-      path: TrackIdTemplate.substitute(config.path, id: id),
-      baseUrl: config.baseUrl,
-      headers: TrackIdTemplate.substitute(config.headers, id: id),
-      query: TrackIdTemplate.substitute(config.query, id: id),
-      body: config.body,
-      contentType: config.contentType,
-      userAgent: config.userAgent,
-    )
-  }
-
   /// Awaits an **async** config callback and copies the result out of the Nitro
   /// bridge. The callback lowers to `Promise<Promise<RequestConfig>>` (bridge hop →
   /// JS promise), so it is a DOUBLE await. This await depth is the bug-prone part
@@ -425,23 +276,23 @@ final class RequestPipeline {
     try await extractConfig(promise.await())
   }
 
-  /// Extracts all values from a RequestConfig into a new instance to avoid
-  /// memory corruption in Nitro's Swift-C++ bridge when the Promise is deallocated.
+  /// A copy of `config`, so nothing reads the Nitro bridge's value after its Promise is gone.
   func extractConfig(_ config: RequestConfig) -> RequestConfig {
-    RequestConfig(
-      method: config.method,
-      path: config.path,
-      baseUrl: config.baseUrl,
-      headers: config.headers,
-      query: config.query,
-      body: config.body,
-      contentType: config.contentType,
-      userAgent: config.userAgent,
-    )
+    RequestConfig(fieldsOf: config)
   }
 }
 
 extension RequestConfig: RequestFields {}
+extension ArtworkRequestConfig: RequestFieldValues {}
+
+/// A Request-Config Layer with transforms: the request, browse, media and route configs.
+protocol TransformableLayer: RequestFieldValues where Method == HttpMethod {
+  var transform: ((RequestConfig, [String: String]?) -> Promise<Promise<RequestConfig>>)? { get }
+  var transformSync: ((RequestConfig, [String: String]?) -> Promise<RequestConfig>)? { get }
+}
+
+extension TransformableRequestConfig: TransformableLayer {}
+extension MediaRequestConfig: TransformableLayer {}
 
 extension RequestPipeline: MediaResolving {
   /// Runs the `nowPlayingArtwork` config for every playing track, id or not: an id-less track

package/ios/Browser/SectionScope.swift

@@ -47,6 +47,31 @@ enum SectionScope {
     }
     return nil
   }
+
+  /// The queue a tap on the contextual `path` plays: the playable tracks of the tapped section,
+  /// at the tapped copy when the stamped index still pins it, else at the first identity match;
+  /// only that track when `singleTrack`. Nil when the identity is gone from the page or the
+  /// tapped track is not playable, so the caller falls back to the stored track.
+  static func queue(
+    in sections: [Section],
+    path: String,
+    singleTrack: Bool,
+  ) -> (tracks: [Track], selectedIndex: Int)? {
+    guard let trackId = BrowserPathHelper.extractTrackId(path),
+          let scoped = scoped(in: sections, containing: trackId, tappedIndex: BrowserPathHelper.extractIndex(path))
+    else { return nil }
+    let children = scoped.section.children
+    let playable = children.filter(\.isPlayable)
+    let selectedIndex: Int
+    if let offset = scoped.tappedOffset, children[offset].isPlayable {
+      selectedIndex = children.prefix(through: offset).count(where: \.isPlayable) - 1
+    } else if let index = playable.firstIndex(where: { $0.identity == trackId }) {
+      selectedIndex = index
+    } else {
+      return nil
+    }
+    return singleTrack ? ([playable[selectedIndex]], 0) : (playable, selectedIndex)
+  }
 }
 
 // MARK: - Page shape helpers (ADR 0010)