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

package/ios/Browser/SimpleRouter.swift

@@ -8,11 +8,6 @@ struct RouteMatch {
 
   /// Specificity score (higher = more specific match)
   let specificity: Int
-
-  init(params: [String: String] = [:], specificity: Int = 0) {
-    self.params = params
-    self.specificity = specificity
-  }
 }
 
 /// Protocol for route entries that can be matched.
@@ -20,165 +15,99 @@ protocol RouteEntry {
   var path: String { get }
 }
 
-/// Simple route matcher for path patterns with parameter extraction.
+/// Route pattern matching with parameter extraction.
 ///
 /// Supports patterns like:
 /// - /artists - exact match
 /// - /artists/{id} - parameter extraction
-/// - /artists/{id}/albums - multiple segments with parameters
 /// - /artists/* - wildcard match (matches any single segment)
-/// - /files/** - tail wildcard (matches remaining path segments)
+/// - /files/** - tail wildcard (matches remaining path segments, captured as `tail`)
 ///
-/// Route specificity rules:
-/// - More path segments = higher specificity
-/// - Constant segments > parameter segments > wildcards > tail wildcards
-/// - Most specific route wins
-final class SimpleRouter {
-  /// Finds the best matching route for the given path.
-  ///
-  /// - Parameters:
-  ///   - path: The incoming path to match (e.g., "/artists/123")
-  ///   - routes: Array of route entries to match against
-  /// - Returns: Tuple of (route, match result) or nil if no match
-  func findBestMatch<T: RouteEntry>(path: String, routes: [T]) -> (route: T, match: RouteMatch)? {
-    var bestMatch: (route: T, match: RouteMatch)?
+/// The most specific route wins, the first on a tie: constant segments over parameters over
+/// wildcards over the tail wildcard, then more segments.
+enum SimpleRouter {
+  /// The route the top-level `browse:` source is flattened into.
+  static let defaultRoutePath = "__default__"
+  static let tabsRoutePath = "__tabs__"
+  static let searchRoutePath = "__search__"
+
+  /// The route that browses `path`: the best match among the routes that are not tabs, search or
+  /// the default, else the default route with `path` as its `path` param.
+  static func browseRoute<T: RouteEntry>(for path: String, in routes: [T]) -> (route: T, match: RouteMatch)? {
+    let browseRoutes = routes.filter {
+      $0.path != tabsRoutePath && $0.path != searchRoutePath && $0.path != defaultRoutePath
+    }
+    if let match = findBestMatch(path: path, routes: browseRoutes) {
+      return match
+    }
+    guard let defaultRoute = routes.first(where: { $0.path == defaultRoutePath }) else { return nil }
+    return (defaultRoute, RouteMatch(params: ["path": path], specificity: 0))
+  }
 
+  /// The most specific of `routes` matching `path`, or nil when none does.
+  static func findBestMatch<T: RouteEntry>(path: String, routes: [T]) -> (route: T, match: RouteMatch)? {
+    var best: (route: T, match: RouteMatch)?
     for route in routes {
-      if let match = matchPattern(pattern: route.path, path: path) {
-        if bestMatch == nil || match.specificity > bestMatch!.match.specificity {
-          bestMatch = (route, match)
-        }
+      guard let match = match(pattern: route.path, path: path) else { continue }
+      if best.map({ match.specificity > $0.match.specificity }) ?? true {
+        best = (route, match)
       }
     }
-
-    return bestMatch
+    return best
   }
 
-  /// Attempts to match a single pattern against a path.
-  ///
-  /// - Parameters:
-  ///   - pattern: Route pattern (e.g., "/artists/{id}", "/files/*", "/api/**")
-  ///   - path: Incoming path (e.g., "/artists/123")
-  /// - Returns: RouteMatch if successful, nil otherwise
-  private func matchPattern(pattern: String, path: String) -> RouteMatch? {
-    let patternSegments = pattern.split(separator: "/").map(String.init)
-    let pathSegments = path.split(separator: "/").map(String.init)
-
-    var params: [String: String] = [:]
-    var constantSegments = 0
-    var parameterSegments = 0
-    var wildcardSegments = 0
-    var hasTailWildcard = false
-
-    // Check for tail wildcard at end
-    if let lastSegment = patternSegments.last, lastSegment == "**" {
-      hasTailWildcard = true
-
-      // For tail wildcard, pattern must have <= path segments
-      if patternSegments.count - 1 > pathSegments.count {
-        return nil
-      }
-
-      // Match all segments except the tail wildcard
-      for i in 0 ..< (patternSegments.count - 1) {
-        guard
-          matchSingleSegment(
-            patternSegment: patternSegments[i],
-            pathSegment: pathSegments[i],
-            params: &params,
-          )
-        else {
-          return nil
-        }
-
-        updateSegmentCounts(
-          patternSegment: patternSegments[i],
-          constantSegments: &constantSegments,
-          parameterSegments: &parameterSegments,
-          wildcardSegments: &wildcardSegments,
-        )
-      }
-
-      // Capture remaining path segments as "tail" parameter (matches Kotlin behavior)
-      if pathSegments.count > patternSegments.count - 1 {
-        let remainingSegments = pathSegments.dropFirst(patternSegments.count - 1)
-        params["tail"] = remainingSegments.joined(separator: "/")
-      }
-    } else {
-      // Normal matching - must have same number of segments
-      if patternSegments.count != pathSegments.count {
-        return nil
+  private enum Segment {
+    case constant(Substring)
+    case param(String)
+    case wildcard
+
+    init(_ segment: Substring) {
+      if segment.hasPrefix("{"), segment.hasSuffix("}") {
+        self = .param(String(segment.dropFirst().dropLast()))
+      } else if segment == "*" {
+        self = .wildcard
+      } else {
+        self = .constant(segment)
       }
+    }
 
-      for i in patternSegments.indices {
-        guard
-          matchSingleSegment(
-            patternSegment: patternSegments[i],
-            pathSegment: pathSegments[i],
-            params: &params,
-          )
-        else {
-          return nil
-        }
-
-        updateSegmentCounts(
-          patternSegment: patternSegments[i],
-          constantSegments: &constantSegments,
-          parameterSegments: &parameterSegments,
-          wildcardSegments: &wildcardSegments,
-        )
+    var specificity: Int {
+      switch self {
+      case .constant: 1000
+      case .param: 100
+      case .wildcard: 10
       }
     }
-
-    // Specificity calculation (higher = more specific):
-    // - Constants: 1000 points each
-    // - Parameters: 100 points each
-    // - Single wildcards: 10 points each
-    // - Tail wildcard: 1 point
-    // - Base path length: segments count
-    let specificity =
-      (constantSegments * 1000)
-        + (parameterSegments * 100)
-        + (wildcardSegments * 10)
-        + (hasTailWildcard ? 1 : 0)
-        + patternSegments.count
-
-    return RouteMatch(params: params, specificity: specificity)
   }
 
-  private func matchSingleSegment(
-    patternSegment: String,
-    pathSegment: String,
-    params: inout [String: String],
-  ) -> Bool {
-    // Parameter segment: {paramName}
-    if patternSegment.hasPrefix("{"), patternSegment.hasSuffix("}") {
-      let paramName = String(patternSegment.dropFirst().dropLast())
-      params[paramName] = pathSegment
-      return true
-    }
+  private static func match(pattern: String, path: String) -> RouteMatch? {
+    var patternSegments = pattern.split(separator: "/")
+    let hasTailWildcard = patternSegments.last == "**"
+    if hasTailWildcard { patternSegments.removeLast() }
+    let pathSegments = path.split(separator: "/")
+    guard hasTailWildcard
+      ? pathSegments.count >= patternSegments.count
+      : pathSegments.count == patternSegments.count
+    else { return nil }
 
-    // Single wildcard: *
-    if patternSegment == "*" {
-      return true
+    var params: [String: String] = [:]
+    // Each segment counts once more, the tail wildcard twice (its segment and its own point).
+    var specificity = patternSegments.count + (hasTailWildcard ? 2 : 0)
+    for (patternSegment, pathSegment) in zip(patternSegments, pathSegments) {
+      let segment = Segment(patternSegment)
+      switch segment {
+      case let .constant(constant):
+        guard constant == pathSegment else { return nil }
+      case let .param(name):
+        params[name] = String(pathSegment)
+      case .wildcard:
+        break
+      }
+      specificity += segment.specificity
     }
-
-    // Constant segment: must match exactly
-    return patternSegment == pathSegment
-  }
-
-  private func updateSegmentCounts(
-    patternSegment: String,
-    constantSegments: inout Int,
-    parameterSegments: inout Int,
-    wildcardSegments: inout Int,
-  ) {
-    if patternSegment.hasPrefix("{"), patternSegment.hasSuffix("}") {
-      parameterSegments += 1
-    } else if patternSegment == "*" {
-      wildcardSegments += 1
-    } else {
-      constantSegments += 1
+    if hasTailWildcard, pathSegments.count > patternSegments.count {
+      params["tail"] = pathSegments.dropFirst(patternSegments.count).joined(separator: "/")
     }
+    return RouteMatch(params: params, specificity: specificity)
   }
 }

package/ios/Extension/SearchParams+Query.swift

@@ -0,0 +1,28 @@
+#if canImport(NitroModules)
+  import NitroModules
+#endif
+
+extension SearchParams {
+  /// The query params this search sends: `q` plus whichever filters are set, as on Android and
+  /// web. Also the search's cache identity, so a field added here distinguishes both.
+  var queryParams: [String: String] {
+    var query: [String: String] = ["q": query]
+    if let mode { query["mode"] = mode.stringValue }
+    if reference == .my { query["reference"] = "my" }
+    if let genre { query["genre"] = genre }
+    if let artist { query["artist"] = artist }
+    if let album { query["album"] = album }
+    if let title { query["title"] = title }
+    if let playlist { query["playlist"] = playlist }
+    return query
+  }
+
+  /// The cache identity: `queryParams`, sorted so key order is stable and `\u{1}`-delimited so
+  /// two param sets cannot serialize alike.
+  var cacheKey: String {
+    queryParams
+      .sorted { $0.key < $1.key }
+      .map { "\($0.key)=\($0.value)" }
+      .joined(separator: "\u{1}")
+  }
+}

package/ios/Extension/Track+Copying.swift

@@ -1,4 +1,6 @@
-import NitroModules
+#if canImport(NitroModules)
+  import NitroModules
+#endif
 
 extension Track {
   /// Returns a copy of this Track with only the specified fields changed.

package/ios/Extension/Track+Identity.swift

@@ -16,3 +16,10 @@ extension Track {
     return src
   }
 }
+
+extension Track {
+  /// Playable and not Disabled: a track the library may queue and play.
+  var isPlayable: Bool {
+    src != nil && disabled != true
+  }
+}

package/ios/Http/HttpClient.swift

@@ -13,27 +13,11 @@ final class HttpClient: @unchecked Sendable {
   /// HTTP request configuration (matches Kotlin HttpClient.HttpRequest).
   struct HttpRequest {
     let url: String
-    let method: String
+    let method: HttpMethod
     let headers: [String: String]?
     let body: String?
     let contentType: String
     let userAgent: String
-
-    init(
-      url: String,
-      method: String = "GET",
-      headers: [String: String]? = nil,
-      body: String? = nil,
-      contentType: String = HttpClient.defaultContentType,
-      userAgent: String = HttpClient.defaultUserAgent,
-    ) {
-      self.url = url
-      self.method = method
-      self.headers = headers
-      self.body = body
-      self.contentType = contentType
-      self.userAgent = userAgent
-    }
   }
 
   /// A non-2xx response (matches Kotlin HttpClient.HttpException).
@@ -55,14 +39,14 @@ final class HttpClient: @unchecked Sendable {
 
   enum HttpClientError: LocalizedError {
     case invalidUrl(String)
-    case unsupportedMethod(String)
+    case unsupportedMethod(HttpMethod)
     case notHttp
     case undecodable(String)
 
     var errorDescription: String? {
       switch self {
       case let .invalidUrl(url): "Invalid URL: \(url)"
-      case let .unsupportedMethod(method): "Unsupported HTTP method: \(method)"
+      case let .unsupportedMethod(method): "Unsupported HTTP method: \(method.stringValue)"
       case .notHttp: "Invalid response type"
       case let .undecodable(reason): reason
       }
@@ -74,7 +58,7 @@ final class HttpClient: @unchecked Sendable {
   }
 
   /// Sends `httpRequest` and returns the status code and body, whatever the status.
-  func request(_ httpRequest: HttpRequest) async throws -> (code: Int, data: Data) {
+  private func request(_ httpRequest: HttpRequest) async throws -> (code: Int, data: Data) {
     guard let url = URL(string: httpRequest.url) else { throw HttpClientError.invalidUrl(httpRequest.url) }
 
     var urlRequest = URLRequest(url: url)
@@ -87,21 +71,19 @@ final class HttpClient: @unchecked Sendable {
       urlRequest.setValue(httpRequest.userAgent, forHTTPHeaderField: "User-Agent")
     }
 
-    let method = httpRequest.method.uppercased()
-    switch method {
-    case "GET":
-      urlRequest.httpMethod = method
-    case "POST", "PUT", "PATCH":
-      urlRequest.httpMethod = method
+    urlRequest.httpMethod = httpRequest.method.stringValue
+    switch httpRequest.method {
+    case .get:
+      break
+    case .post, .put, .patch:
       urlRequest.setValue(httpRequest.contentType, forHTTPHeaderField: "Content-Type")
       urlRequest.httpBody = httpRequest.body?.data(using: .utf8)
-    case "DELETE":
-      urlRequest.httpMethod = method
+    case .delete:
       if let body = httpRequest.body {
         urlRequest.setValue(httpRequest.contentType, forHTTPHeaderField: "Content-Type")
         urlRequest.httpBody = body.data(using: .utf8)
       }
-    default:
+    case .head, .options:
       throw HttpClientError.unsupportedMethod(httpRequest.method)
     }
 
@@ -143,7 +125,7 @@ final class HttpClient: @unchecked Sendable {
 
 extension HttpClient {
   private func logRequest(_ request: HttpRequest) {
-    logger.debug("→ \(request.method) \(request.url)")
+    logger.debug("→ \(request.method.stringValue) \(request.url)")
     for (key, value) in request.headers ?? [:] {
       logger.debug("  \(key): \(value)")
     }

package/ios/HybridAudioBrowser+Browser.swift

@@ -93,29 +93,13 @@ public extension HybridAudioBrowser {
   }
 
   func invalidateAllContent() throws {
-    onMainActor { browserManager.clearContentCache() }
-
-    // Tell external controllers (CarPlay) to refresh every displayed template.
-    externalContentChangedEmitter.emit(Self.invalidateAllSentinel)
-
-    // Re-query the tabs source too: a callback source can resolve to new
-    // titles after an invalidation (e.g. a locale switch). BrowserManager
-    // emits tabsChanged only when the result actually differs, and a failed
-    // re-query keeps the current tabs. (Android needs no equivalent — its
-    // root re-query already runs queryTabs(); the web stub re-queries tabs on
-    // the re-navigation.)
-    Task {
-      _ = try? await browserManager.queryTabs()
-    }
-
-    // Re-resolve the JS-facing current path with the cache cleared.
-    Task { @MainActor in
-      do {
-        try await browserManager.load(browserManager.path, bypassCache: true)
-      } catch {
-        await reportNavigationError(error, path: browserManager.path)
+    onMainActor {
+      browserManager.invalidateAll { error, path in
+        await self.reportNavigationError(error, path: path)
       }
     }
+    // Tell external controllers (CarPlay) to refresh every displayed template.
+    externalContentChangedEmitter.emit(Self.invalidateAllSentinel)
   }
 
   func setFavorites(favorites: [String]) throws {

package/ios/HybridAudioBrowser+Player.swift

@@ -131,7 +131,7 @@ public extension HybridAudioBrowser {
 
   func getSleepTimer() throws -> SleepTimer {
     onMainActor {
-      player?.sleepTimer ?? .first(NullType.null)
+      player?.sleepTimerManager.get() ?? .first(NullType.null)
     }
   }
 
@@ -227,7 +227,7 @@ public extension HybridAudioBrowser {
       browserManager.setFavorited(identity: identity, favorited: favorited)
       // Back in the queue carrying the flag, since hydration never overrides a track's own value.
       let updated = track.copying(favorited: favorited)
-      try player.replace(player.currentIndex, updated)
+      try player.replace(player.queue.currentIndex, updated)
       // The only emit: a favorite toggle mutates the active track in place, so
       // onPlaybackActiveTrackChanged stays transition-only.
       favoriteChangedEmitter.emit(FavoriteChangedEvent(track: updated, favorited: favorited))
@@ -271,7 +271,7 @@ public extension HybridAudioBrowser {
 
   func getActiveTrackIndex() throws -> Double? {
     onMainActor {
-      guard let index = player?.currentIndex, index >= 0 else { return nil }
+      guard let index = player?.queue.currentIndex, index >= 0 else { return nil }
       return Double(index)
     }
   }

package/ios/Model/NitroTypeStubs.swift

@@ -28,6 +28,8 @@
     var query: [String: String]?
   }
 
+  /// Every property of the generated type, in its init's order, so the shared conversions in
+  /// JsonModels compile against both.
   struct Track: Equatable {
     var id: String?
     var path: String?
@@ -36,15 +38,26 @@
     var artworkSource: ImageSource?
     var request: TrackRequest?
     var title: String = ""
+    var subtitle: String?
     var artist: String?
     var albumPath: String?
     var album: String?
+    var description: String?
+    var genre: String?
+    var duration: Double?
     var style: TrackStyle?
     var disabled: Bool?
+    var favorited: Bool?
     var live: Bool?
     var icyCharset: String?
   }
 
+  struct NowPlayingUpdate: Equatable {
+    var title: String?
+    var artist: String?
+    var album: String?
+  }
+
   struct TrackLoadEvent {
     var track: Track
     var queue: [Track]
@@ -97,6 +110,71 @@
     case options
   }
 
+  enum SearchMode {
+    case any
+    case song
+    case playlist
+    case station
+    case podcast
+    case audiobook
+    case news
+    case music
+    case musicVideo
+    case movie
+    case tvShow
+    case tvShowEpisode
+
+    var stringValue: String {
+      switch self {
+      case .any: "any"
+      case .song: "song"
+      case .playlist: "playlist"
+      case .station: "station"
+      case .podcast: "podcast"
+      case .audiobook: "audiobook"
+      case .news: "news"
+      case .music: "music"
+      case .musicVideo: "music-video"
+      case .movie: "movie"
+      case .tvShow: "tv-show"
+      case .tvShowEpisode: "tv-show-episode"
+      }
+    }
+  }
+
+  enum MediaReference {
+    case my
+    case unknown
+
+    var stringValue: String {
+      switch self {
+      case .my: "my"
+      case .unknown: "unknown"
+      }
+    }
+  }
+
+  struct SearchParams {
+    var mode: SearchMode?
+    var query: String
+    var genre: String?
+    var artist: String?
+    var album: String?
+    var title: String?
+    var playlist: String?
+    var reference: MediaReference
+  }
+
+  struct ImageContext {
+    var width: Double?
+    var height: Double?
+  }
+
+  struct ImageQueryParams {
+    var width: String?
+    var height: String?
+  }
+
   struct ImageSource: Equatable {
     var uri: String
     var method: HttpMethod?

package/ios/Player/AudioSessionController.swift

@@ -12,6 +12,8 @@ protocol AudioSessionPlayer: AnyObject {
   func mediaServicesWereReset()
 }
 
+extension Player: AudioSessionPlayer {}
+
 /// Owns the app's `AVAudioSession`: its category, activation and release, and the interruption,
 /// route-change, media-services-reset and volume observers, installed once at init.
 ///

package/ios/Player/ErrorStatus.swift

@@ -7,12 +7,13 @@
 enum ErrorStatus: Equatable {
   case none
   case retrying(TrackPlayerError.PlaybackError)
-  case terminal(TrackPlayerError.PlaybackError)
+  /// `report` tells each terminal report from the last, so a repeat of the same error is a change.
+  case terminal(TrackPlayerError.PlaybackError, report: UInt)
 
   var error: TrackPlayerError.PlaybackError? {
     switch self {
     case .none: nil
-    case let .retrying(error), let .terminal(error): error
+    case let .retrying(error), let .terminal(error, _): error
     }
   }
 
@@ -24,4 +25,26 @@ enum ErrorStatus: Equatable {
   var nitroError: PlaybackError? {
     error?.toNitroError(retrying: isRetrying)
   }
+
+  /// The status once `event` moves the state from `old` to `new`: an error event is a new
+  /// terminal report; leaving `.error`, or reaching a state without an advisory error, clears it.
+  func after(event: PlaybackEvent, from old: PlaybackState, to new: PlaybackState) -> ErrorStatus {
+    if case let .errorOccurred(error) = event {
+      return .terminal(error, report: terminalReport &+ 1)
+    }
+    if old == .error || (isRetrying && !new.carriesAdvisoryError) { return .none }
+    return self
+  }
+
+  private var terminalReport: UInt {
+    if case let .terminal(_, report) = self { report } else { 0 }
+  }
+}
+
+extension PlaybackState {
+  /// Whether a retrying error shows over this state: the listener is waiting on it, and no audio
+  /// is playing to contradict it.
+  var carriesAdvisoryError: Bool {
+    self == .loading || self == .buffering || self == .paused
+  }
 }