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

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
+  }
 }