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

package/ios/Browser/JsonModels.swift

@@ -75,35 +75,17 @@ extension JsonArtwork {
 /// payload). `init(from:)` therefore never throws, and unknown enum values
 /// map to nil at `toNitro` time.
 struct JsonStyle: Codable, Equatable {
-  let display: String?
-  let gridWrap: Bool?
-  let gridTile: String?
-  let artworkRendering: String?
-  let imageShape: String?
-  let accessorySymbol: String?
-  let cardTint: String?
-  let cardImage: String?
-
-  init(
-    display: String? = nil,
-    gridWrap: Bool? = nil,
-    gridTile: String? = nil,
-    artworkRendering: String? = nil,
-    imageShape: String? = nil,
-    accessorySymbol: String? = nil,
-    cardTint: String? = nil,
-    cardImage: String? = nil,
-  ) {
-    self.display = display
-    self.gridWrap = gridWrap
-    self.gridTile = gridTile
-    self.artworkRendering = artworkRendering
-    self.imageShape = imageShape
-    self.accessorySymbol = accessorySymbol
-    self.cardTint = cardTint
-    self.cardImage = cardImage
-  }
+  var display: String? = nil
+  var gridWrap: Bool? = nil
+  var gridTile: String? = nil
+  var artworkRendering: String? = nil
+  var imageShape: String? = nil
+  var accessorySymbol: String? = nil
+  var cardTint: String? = nil
+  var cardImage: String? = nil
+}
 
+extension JsonStyle {
   init(from decoder: Decoder) throws {
     // A non-object value (the retired `style: 'grid'` string) decodes as an
     // empty block rather than failing the parent.
@@ -132,61 +114,51 @@ extension JsonStyle {
   /// maps to nil, so "no declaration" has one shape on every platform
   /// (Android's lenient mapper makes the same collapse).
   func toTrackStyle() -> TrackStyle? {
-    let display = display.flatMap { StyleDisplay(fromString: $0.lowercased()) }
-    let artworkRendering = artworkRendering.flatMap { ArtworkRendering(fromString: $0.lowercased()) }
-    let imageShape = imageShape.flatMap { ImageShape(fromString: $0.lowercased()) }
-    // The 'none' sentinel is a legitimate value; only emptiness collapses.
-    let accessorySymbol = accessorySymbol?.isEmpty == false ? accessorySymbol : nil
-    let cardTint = cardTint?.isEmpty == false ? cardTint : nil
-    let cardImage = cardImage.flatMap { CardImage(fromString: $0.lowercased()) }
-    guard display != nil || artworkRendering != nil || imageShape != nil
-      || accessorySymbol != nil || cardTint != nil || cardImage != nil
-    else { return nil }
-    return TrackStyle(
-      display: display,
-      artworkRendering: artworkRendering,
-      imageShape: imageShape,
-      accessorySymbol: accessorySymbol,
-      cardTint: cardTint,
-      cardImage: cardImage,
-    )
+    let declarations = trackDeclarations
+    return Self.declaresAnything(declarations) ? declarations : nil
   }
 
   func toSectionStyle() -> SectionStyle? {
-    let display = display.flatMap { StyleDisplay(fromString: $0.lowercased()) }
+    let declarations = trackDeclarations
     let gridTile = gridTile.flatMap { GridTile(fromString: $0.lowercased()) }
-    let artworkRendering = artworkRendering.flatMap { ArtworkRendering(fromString: $0.lowercased()) }
-    let imageShape = imageShape.flatMap { ImageShape(fromString: $0.lowercased()) }
-    let accessorySymbol = accessorySymbol?.isEmpty == false ? accessorySymbol : nil
-    let cardTint = cardTint?.isEmpty == false ? cardTint : nil
-    let cardImage = cardImage.flatMap { CardImage(fromString: $0.lowercased()) }
-    guard display != nil || artworkRendering != nil || gridWrap != nil
-      || gridTile != nil || imageShape != nil || accessorySymbol != nil
-      || cardTint != nil || cardImage != nil
-    else { return nil }
+    guard Self.declaresAnything(declarations) || gridWrap != nil || gridTile != nil else { return nil }
     // Argument order is the generated init's (own properties before
     // inherited ones — Nitro flattens `extends` own-props-first).
     return SectionStyle(
       gridWrap: gridWrap,
       gridTile: gridTile,
-      display: display,
-      artworkRendering: artworkRendering,
-      imageShape: imageShape,
-      accessorySymbol: accessorySymbol,
-      cardTint: cardTint,
-      cardImage: cardImage,
+      display: declarations.display,
+      artworkRendering: declarations.artworkRendering,
+      imageShape: declarations.imageShape,
+      accessorySymbol: declarations.accessorySymbol,
+      cardTint: declarations.cardTint,
+      cardImage: declarations.cardImage,
+    )
+  }
+
+  /// The declarations a section shares with a track, each nil when absent or unknown.
+  private var trackDeclarations: TrackStyle {
+    TrackStyle(
+      display: display.flatMap { StyleDisplay(fromString: $0.lowercased()) },
+      artworkRendering: artworkRendering.flatMap { ArtworkRendering(fromString: $0.lowercased()) },
+      imageShape: imageShape.flatMap { ImageShape(fromString: $0.lowercased()) },
+      // The 'none' sentinel is a legitimate value; only emptiness collapses.
+      accessorySymbol: accessorySymbol?.isEmpty == false ? accessorySymbol : nil,
+      cardTint: cardTint?.isEmpty == false ? cardTint : nil,
+      cardImage: cardImage.flatMap { CardImage(fromString: $0.lowercased()) },
     )
   }
 
+  private static func declaresAnything(_ style: TrackStyle) -> Bool {
+    style.display != nil || style.artworkRendering != nil || style.imageShape != nil
+      || style.accessorySymbol != nil || style.cardTint != nil || style.cardImage != nil
+  }
+
   /// Snapshot a live track block back to its JSON model (for persistence).
   /// An all-nil block snapshots as no block — the decoders collapse it to
   /// "no declaration" anyway, so never persist the distinction.
   init?(_ style: TrackStyle?) {
-    guard let style,
-          style.display != nil || style.artworkRendering != nil
-          || style.imageShape != nil || style.accessorySymbol != nil
-          || style.cardTint != nil || style.cardImage != nil
-    else { return nil }
+    guard let style, Self.declaresAnything(style) else { return nil }
     self.init(
       display: Self.string(style.display),
       artworkRendering: Self.string(style.artworkRendering),
@@ -234,22 +206,10 @@ extension JsonStyle {
 /// keys in payloads are simply unknown to these models and decode as
 /// ignored dead weight.
 struct JsonSection: Codable {
-  let title: String?
-  let style: JsonStyle?
-  let path: String?
-  let children: [JsonTrack]
-
-  init(
-    title: String? = nil,
-    style: JsonStyle? = nil,
-    path: String? = nil,
-    children: [JsonTrack],
-  ) {
-    self.title = title
-    self.style = style
-    self.path = path
-    self.children = children
-  }
+  var title: String? = nil
+  var style: JsonStyle? = nil
+  var path: String? = nil
+  var children: [JsonTrack]
 }
 
 /// JSON model for per-track HTTP request configuration.
@@ -265,126 +225,46 @@ struct JsonTrackRequest: Codable {
 
 /// JSON model for resolved track (container with children).
 struct JsonResolvedTrack: Codable {
-  let id: String?
-  let path: String
-  let title: String
-  let subtitle: String?
-  let artwork: JsonArtwork?
-  let artist: String?
-  let albumPath: String?
-  let album: String?
-  let description: String?
-  let genre: String?
-  let duration: Double?
-  let sections: [JsonSection]?
-  let children: [JsonTrack]?
-  let src: String?
-  let style: JsonStyle?
-  let disabled: Bool?
-  let live: Bool?
-  let icyCharset: String?
-  let carPlaySiriListButton: String?
-
-  init(
-    id: String? = nil,
-    path: String,
-    title: String,
-    subtitle: String? = nil,
-    artwork: JsonArtwork? = nil,
-    artist: String? = nil,
-    albumPath: String? = nil,
-    album: String? = nil,
-    description: String? = nil,
-    genre: String? = nil,
-    duration: Double? = nil,
-    sections: [JsonSection]? = nil,
-    children: [JsonTrack]? = nil,
-    src: String? = nil,
-    style: JsonStyle? = nil,
-    disabled: Bool? = nil,
-    live: Bool? = nil,
-    icyCharset: String? = nil,
-    carPlaySiriListButton: String? = nil,
-  ) {
-    self.path = path
-    self.title = title
-    self.subtitle = subtitle
-    self.artwork = artwork
-    self.artist = artist
-    self.albumPath = albumPath
-    self.album = album
-    self.description = description
-    self.genre = genre
-    self.duration = duration
-    self.sections = sections
-    self.children = children
-    self.src = src
-    self.style = style
-    self.disabled = disabled
-    self.live = live
-    self.icyCharset = icyCharset
-    self.carPlaySiriListButton = carPlaySiriListButton
-    self.id = id
-  }
+  var id: String? = nil
+  var path: String
+  var title: String
+  var subtitle: String? = nil
+  var artwork: JsonArtwork? = nil
+  var artist: String? = nil
+  var albumPath: String? = nil
+  var album: String? = nil
+  var description: String? = nil
+  var genre: String? = nil
+  var duration: Double? = nil
+  var sections: [JsonSection]? = nil
+  var children: [JsonTrack]? = nil
+  var src: String? = nil
+  var style: JsonStyle? = nil
+  var disabled: Bool? = nil
+  var live: Bool? = nil
+  var icyCharset: String? = nil
+  var carPlaySiriListButton: String? = nil
 }
 
 /// JSON model for individual tracks.
 struct JsonTrack: Codable {
-  let id: String?
-  let path: String?
-  let title: String
-  let subtitle: String?
-  let artwork: JsonArtwork?
-  let artist: String?
-  let albumPath: String?
-  let album: String?
-  let description: String?
-  let genre: String?
-  let duration: Double?
-  let src: String?
-  let request: JsonTrackRequest?
-  let style: JsonStyle?
-  let disabled: Bool?
-  let live: Bool?
-  let icyCharset: String?
-
-  init(
-    id: String? = nil,
-    path: String? = nil,
-    title: String,
-    subtitle: String? = nil,
-    artwork: JsonArtwork? = nil,
-    artist: String? = nil,
-    albumPath: String? = nil,
-    album: String? = nil,
-    description: String? = nil,
-    genre: String? = nil,
-    duration: Double? = nil,
-    src: String? = nil,
-    request: JsonTrackRequest? = nil,
-    style: JsonStyle? = nil,
-    disabled: Bool? = nil,
-    live: Bool? = nil,
-    icyCharset: String? = nil,
-  ) {
-    self.path = path
-    self.title = title
-    self.subtitle = subtitle
-    self.artwork = artwork
-    self.artist = artist
-    self.albumPath = albumPath
-    self.album = album
-    self.description = description
-    self.genre = genre
-    self.duration = duration
-    self.src = src
-    self.request = request
-    self.style = style
-    self.disabled = disabled
-    self.live = live
-    self.icyCharset = icyCharset
-    self.id = id
-  }
+  var id: String? = nil
+  var path: String? = nil
+  var title: String
+  var subtitle: String? = nil
+  var artwork: JsonArtwork? = nil
+  var artist: String? = nil
+  var albumPath: String? = nil
+  var album: String? = nil
+  var description: String? = nil
+  var genre: String? = nil
+  var duration: Double? = nil
+  var src: String? = nil
+  var request: JsonTrackRequest? = nil
+  var style: JsonStyle? = nil
+  var disabled: Bool? = nil
+  var live: Bool? = nil
+  var icyCharset: String? = nil
 }
 
 // MARK: - Snapshot live Nitro types back to JSON models (for persistence)

package/ios/Browser/PageResolver.swift

@@ -7,17 +7,7 @@ import os.log
 /// artwork). Also resolves the tabs and search routes.
 @MainActor
 final class PageResolver {
-  /// Internal path used for the default/root browse source
-  static let defaultRoutePath = "__default__"
-
-  /// Internal path used for navigation tabs
-  static let tabsRoutePath = "__tabs__"
-
-  /// Internal path used for search
-  static let searchRoutePath = "__search__"
-
   let logger = Logger(subsystem: "com.audiobrowser", category: "PageResolver")
-  private let router = SimpleRouter()
   private let requests: RequestPipeline
 
   private var config: BrowserConfig {
@@ -32,7 +22,7 @@ final class PageResolver {
   func resolve(_ path: String) async throws -> ResolvedTrack {
     // Match an explicit route (or the '*' default). With no match, fall back to
     // the implicit default: fetch the path via the request + browse config.
-    let routeEntry = (config.routes).flatMap { findBestRouteMatch(path: path, routes: $0) }
+    let routeEntry = config.routes.flatMap { SimpleRouter.browseRoute(for: path, in: $0) }
 
     let resolvedTrack: ResolvedTrack = if let (entry, routeMatch) = routeEntry {
       try await resolveRouteEntry(entry, path: path, params: routeMatch.params)
@@ -62,16 +52,16 @@ final class PageResolver {
 
   /// The tabs: the `__tabs__` route's page, flattened. Nil when there is no such route.
   func tabs() async throws -> [Track]? {
-    guard let tabsEntry = config.routes?.first(where: { $0.path == Self.tabsRoutePath }) else { return nil }
-    let resolved = try await resolveRouteEntry(tabsEntry, path: Self.tabsRoutePath, params: [:])
+    guard let tabsEntry = config.routes?.first(where: { $0.path == SimpleRouter.tabsRoutePath }) else { return nil }
+    let resolved = try await resolveRouteEntry(tabsEntry, path: SimpleRouter.tabsRoutePath, params: [:])
     // Tabs are a flat list, not a page: a sectioned tabs source flattens.
     return resolved.flattenedChildren ?? []
   }
 
   /// The `__search__` route's results for `params`, unhydrated.
   func search(_ params: SearchParams) async throws -> [Track] {
-    guard let searchEntry = config.routes?.first(where: { $0.path == Self.searchRoutePath }) else {
-      throw BrowserError.contentNotFound(path: Self.searchRoutePath)
+    guard let searchEntry = config.routes?.first(where: { $0.path == SimpleRouter.searchRoutePath }) else {
+      throw BrowserError.contentNotFound(path: SimpleRouter.searchRoutePath)
     }
     if let callback = searchEntry.searchCallback {
       return try await callback(params).await().await()
@@ -79,54 +69,11 @@ final class PageResolver {
     if let searchConfig = searchEntry.searchConfig {
       return try await requests.fetchSearch(searchConfig, params: params)
     }
-    throw BrowserError.contentNotFound(path: Self.searchRoutePath)
-  }
-
-  /// The query params a structured search sends: `q` plus whichever filters are
-  /// set. Mirrors Android's `executeSearchApiRequest` and the web stub.
-  ///
-  /// Single source of truth for "what distinguishes one search from another" —
-  /// the request sends exactly this, and the cache keys on exactly this, so a
-  /// field added here can't be forgotten in one place and silently serve one
-  /// search's results for another.
-  static func searchQueryParams(_ params: SearchParams) -> [String: String] {
-    var query: [String: String] = ["q": params.query]
-    if let mode = params.mode { query["mode"] = mode.stringValue }
-    if params.reference == .my { query["reference"] = "my" }
-    if let genre = params.genre { query["genre"] = genre }
-    if let artist = params.artist { query["artist"] = artist }
-    if let album = params.album { query["album"] = album }
-    if let title = params.title { query["title"] = title }
-    if let playlist = params.playlist { query["playlist"] = playlist }
-    return query
+    throw BrowserError.contentNotFound(path: SimpleRouter.searchRoutePath)
   }
 
   // MARK: - Route Resolution
 
-  private func findBestRouteMatch(
-    path: String,
-    routes: [NativeRouteEntry],
-  ) -> (NativeRouteEntry, RouteMatch)? {
-    // Filter out special routes
-    let browseRoutes = routes.filter {
-      $0.path != Self.tabsRoutePath &&
-        $0.path != Self.searchRoutePath &&
-        $0.path != Self.defaultRoutePath
-    }
-
-    // Try to find a matching route
-    if let match = router.findBestMatch(path: path, routes: browseRoutes) {
-      return match
-    }
-
-    // Fall back to __default__ if present
-    if let defaultRoute = routes.first(where: { $0.path == Self.defaultRoutePath }) {
-      return (defaultRoute, RouteMatch(params: ["path": path]))
-    }
-
-    return nil
-  }
-
   private func resolveRouteEntry(
     _ entry: NativeRouteEntry,
     path: String,
@@ -169,43 +116,17 @@ final class PageResolver {
 
   // MARK: - Stamping
 
+  /// `sections` stamped with contextual paths, every track's browse-time artwork (no size
+  /// context) resolved at once.
   private func transformSections(
     _ sections: [Section],
     parentPath: String,
     routeEntry: NativeRouteEntry?,
   ) async throws -> [Section] {
-    // The contextual index is the flat page position — children concatenated
-    // in section order (ADR 0009/0010).
-    var flatIndex = 0
-    var pageTracks: [[Track]] = []
-    for section in sections {
-      var tracks: [Track] = []
-      for track in section.children {
-        let index = flatIndex
-        flatIndex += 1
-        if track.path == nil, track.src == nil {
-          throw BrowserError.invalidConfiguration(
-            "Track must have either 'path' or 'src' for stable identification: \(track.title)",
-          )
-        }
-        if track.src != nil, track.path == nil {
-          // src != nil guarantees a non-nil identity (id when non-blank, else src).
-          // The flat page position rides along as a duplicate-identity tie-breaker.
-          let contextualPath = BrowserPathHelper.build(
-            parentPath: parentPath, trackId: track.identity!, index: index,
-          )
-          tracks.append(track.copying(path: contextualPath))
-        } else {
-          tracks.append(track)
-        }
-      }
-      pageTracks.append(tracks)
-    }
-
-    // Every track's browse-time artwork (no size context) resolves at once.
-    let artworkConfig = routeEntry?.artwork ?? config.artwork
-    let artworkLoads = pageTracks.map { tracks in
-      tracks.map { track in
+    let stamped = try BrowserPathHelper.stampingContextualPaths(sections, parentPath: parentPath)
+    let artworkConfig = routeEntry?.artwork
+    let artworkLoads = stamped.map { section in
+      section.children.map { track in
         Task<ImageSource?, Never> { @MainActor in
           await self.requests.resolveArtworkUrl(track: track, perRouteConfig: artworkConfig)
         }
@@ -213,14 +134,13 @@ final class PageResolver {
     }
 
     var transformed: [Section] = []
-    for sectionIndex in sections.indices {
+    for (section, loads) in zip(stamped, artworkLoads) {
       var children: [Track] = []
-      for trackIndex in pageTracks[sectionIndex].indices {
-        let track = pageTracks[sectionIndex][trackIndex]
-        let artwork = await artworkLoads[sectionIndex][trackIndex].value
+      for (track, load) in zip(section.children, loads) {
+        let artwork = await load.value
         children.append(artwork.map { track.copying(artworkSource: $0) } ?? track)
       }
-      transformed.append(sections[sectionIndex].copying(children: children))
+      transformed.append(section.copying(children: children))
     }
     return transformed
   }

package/ios/Browser/RequestLayer.swift

@@ -1,7 +1,10 @@
 import Foundation
+#if canImport(NitroModules)
+  import NitroModules
+#endif
 
-/// A request config's fields: the Nitro `RequestConfig` in the app, a plain struct in tests.
-protocol RequestFields {
+/// A request config's fields, as every config kind (request, browse, media, artwork) has them.
+protocol RequestFieldValues<Method> {
   associatedtype Method
   var method: Method? { get }
   var path: String? { get }
@@ -11,7 +14,10 @@ protocol RequestFields {
   var body: String? { get }
   var contentType: String? { get }
   var userAgent: String? { get }
+}
 
+/// A request config the layers build: the Nitro `RequestConfig` in the app, a plain struct in tests.
+protocol RequestFields: RequestFieldValues {
   init(
     method: Method?,
     path: String?,
@@ -24,6 +30,21 @@ protocol RequestFields {
   )
 }
 
+extension RequestFields {
+  /// The config a layer stack starts from: only `path` set.
+  static func base(path: String?) -> Self {
+    Self(method: nil, path: path, baseUrl: nil, headers: nil, query: nil, body: nil, contentType: nil, userAgent: nil)
+  }
+
+  /// `fields`' values, copied.
+  init(fieldsOf fields: some RequestFieldValues<Method>) {
+    self.init(
+      method: fields.method, path: fields.path, baseUrl: fields.baseUrl, headers: fields.headers,
+      query: fields.query, body: fields.body, contentType: fields.contentType, userAgent: fields.userAgent,
+    )
+  }
+}
+
 /// How Request-Config Layers compose, least specific first, each over the one before. The one
 /// implementation of these rules; Android and the web stub follow the same ones.
 enum RequestLayer {
@@ -87,4 +108,78 @@ enum RequestLayer {
     guard let override else { return base }
     return base.merging(override) { _, new in new }
   }
+
+  // MARK: - Artwork
+
+  /// An artwork request, in order: `artwork`'s static fields over `base`, path included; the
+  /// per-track config `resolve` produces; `sizeQuery`; the transforms, each handed the result of
+  /// the one before; then the track's `id` for `{id}`. Nil when `resolve` produces nothing for a
+  /// track without artwork, or when no path remains.
+  nonisolated(nonsending) static func artwork<C: RequestFields>(
+    _ artwork: C,
+    over base: C,
+    resolve: (nonisolated(nonsending)() async throws -> C?)?,
+    trackHasArtwork: Bool,
+    sizeQuery: [String: String],
+    transforms: [nonisolated(nonsending)(C) async throws -> C],
+    id: String?,
+  ) async throws -> C? {
+    var request = merge(base, artwork)
+    if let resolve {
+      if let resolved = try await resolve() {
+        request = merge(request, resolved)
+      } else if !trackHasArtwork {
+        return nil
+      }
+    }
+    if !sizeQuery.isEmpty {
+      request = merge(request, C(
+        method: nil, path: nil, baseUrl: nil, headers: nil,
+        query: sizeQuery, body: nil, contentType: nil, userAgent: nil,
+      ))
+    }
+    for transform in transforms {
+      request = try await transform(request)
+    }
+    request = C(
+      method: request.method,
+      path: TrackIdTemplate.substitute(request.path, id: id),
+      baseUrl: request.baseUrl,
+      headers: TrackIdTemplate.substitute(request.headers, id: id),
+      query: TrackIdTemplate.substitute(request.query, id: id),
+      body: request.body,
+      contentType: request.contentType,
+      userAgent: request.userAgent,
+    )
+    return request.path == nil ? nil : request
+  }
+
+  /// The image-size query `params` names for `context`'s width and height, in whole pixels.
+  static func sizeQuery(_ params: ImageQueryParams?, _ context: ImageContext?) -> [String: String] {
+    guard let params, let context else { return [:] }
+    var query: [String: String] = [:]
+    if let key = params.width, let width = context.width { query[key] = String(Int(width)) }
+    if let key = params.height, let height = context.height { query[key] = String(Int(height)) }
+    return query
+  }
+
+  /// Whether `request` still carries an `{id}` token: the track had no id to fill it.
+  static func hasUnfilledIdToken(_ request: some RequestFieldValues) -> Bool {
+    TrackIdTemplate.containsToken(request.path)
+      || TrackIdTemplate.containsToken(request.query)
+      || TrackIdTemplate.containsToken(request.headers)
+  }
+
+  /// The headers an image load sends: `request.headers`, plus `userAgent` as `User-Agent` and
+  /// `contentType` as `Content-Type` unless a header sets them. Nil when there are none.
+  static func imageHeaders(_ request: some RequestFieldValues) -> [String: String]? {
+    var headers = request.headers ?? [:]
+    if let userAgent = request.userAgent, headers["User-Agent"] == nil {
+      headers["User-Agent"] = userAgent
+    }
+    if let contentType = request.contentType, headers["Content-Type"] == nil {
+      headers["Content-Type"] = contentType
+    }
+    return headers.isEmpty ? nil : headers
+  }
 }