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

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/CarPlay/CarPlayNowPlayingManager.swift

@@ -11,7 +11,7 @@ final class CarPlayNowPlayingManager {
   private let interfaceController: CPInterfaceController
   private let audioBrowser: HybridAudioBrowser
   /// Read on each use: a re-setup replaces the bridge's player.
-  private var player: Player? { audioBrowser.getPlayer() }
+  private var player: Player? { audioBrowser.player }
   private let listItem: (Track, ((CPSelectableListItem, @escaping () -> Void) -> Void)?) -> CPListItem
   /// Pushes a browse destination: the album line's.
   private let navigate: (_ path: String, _ title: String) -> Void
@@ -131,7 +131,7 @@ final class CarPlayNowPlayingManager {
   private func refreshButtons() {
     // A gate hides the custom buttons; the transport controls stay, as a gate never blocks
     // playback.
-    let configured = audioBrowser.browseGate.isActive ? [] : audioBrowser.carPlayNowPlayingButtons
+    let configured = audioBrowser.browseGate.isActive ? [] : audioBrowser.playerOptions.carPlayNowPlayingButtons
     // The template caps custom buttons at 5 (CPNowPlayingTemplate.h) and says
     // nothing about overflow — unlike lists (trim) or the tab bar (throw). The
     // config comes straight from JS, where duplicates and excess are
@@ -319,7 +319,7 @@ final class CarPlayNowPlayingManager {
   }
 
   private func handlePlaybackRateButtonTapped() {
-    let rates = audioBrowser.playbackRates
+    let rates = audioBrowser.playerOptions.playbackRates
     guard !rates.isEmpty, let player else { return }
 
     let currentRate = Double(player.rate)
@@ -349,7 +349,7 @@ final class CarPlayNowPlayingManager {
   }
 
   private func updateUpNextButton() {
-    CPNowPlayingTemplate.shared.isUpNextButtonEnabled = audioBrowser.carPlayUpNextButton && (player?.tracks.count ?? 0) > 1
+    CPNowPlayingTemplate.shared.isUpNextButtonEnabled = audioBrowser.playerOptions.carPlayUpNextButton && (player?.tracks.count ?? 0) > 1
   }
 
   fileprivate func handleUpNextButtonTapped() {

package/ios/CarPlay/CarPlaySession.swift

@@ -12,7 +12,7 @@ final class CarPlaySession {
   let interfaceController: CPInterfaceController
   let audioBrowser: HybridAudioBrowser
   /// Read on each use: a re-setup replaces the bridge's player.
-  var player: Player? { audioBrowser.getPlayer() }
+  var player: Player? { audioBrowser.player }
   let trackSelector: TrackSelector
   let imageLoader: CarPlayImageLoader
   let listItemFactory: CarPlayListItemFactory
@@ -58,7 +58,7 @@ final class CarPlaySession {
     )
     listItemFactory = CarPlayListItemFactory(
       isActiveTrack: { [weak audioBrowser] identity in
-        identity != nil && audioBrowser?.getPlayer()?.currentTrack?.identity == identity
+        identity != nil && audioBrowser?.player?.currentTrack?.identity == identity
       },
     )
     listItemFactory.imageLoader = imageLoader
@@ -156,7 +156,7 @@ final class CarPlaySession {
   // MARK: - Playing Indicators
 
   var playingIndicatorLocation: CPListItemPlayingIndicatorLocation {
-    switch audioBrowser.carPlayPlayingIndicatorLocation {
+    switch audioBrowser.playerOptions.carPlayPlayingIndicatorLocation {
     case .trailing: .trailing
     case .leading: .leading
     }

package/ios/CarPlay/MediaIntentPlayback.swift

@@ -69,6 +69,6 @@ enum MediaIntentPlayback {
   /// destroyed player.
   @MainActor
   private static func livePlayer(of browser: HybridAudioBrowser) -> Player? {
-    HybridAudioBrowser.shared === browser ? browser.getPlayer() : nil
+    HybridAudioBrowser.shared === browser ? browser.player : nil
   }
 }

package/ios/Extension/Capability+RemoteCommand.swift

@@ -1,74 +1,27 @@
 import Foundation
-import NitroModules
 
-/// Extension to build RemoteCommands from PlayerCapabilities
-extension PlayerCapabilities {
-  /// Build array of enabled RemoteCommands based on capabilities
-  /// All capabilities are enabled by default - only false values disable them
-  func buildRemoteCommands(
-    forwardJumpInterval: NSNumber?,
-    backwardJumpInterval: NSNumber?,
-    playbackRates: [Double],
-  ) -> [RemoteCommand] {
-    var commands: [RemoteCommand] = []
-
-    // Play/Pause/Stop
-    if play != false {
-      commands.append(.play)
-    }
-    if pause != false {
-      commands.append(.pause)
-    }
-    if stop != false {
-      commands.append(.stop)
-    }
-
-    // Navigation
-    if skipToNext != false {
-      commands.append(.next)
-    }
-    if skipToPrevious != false {
-      commands.append(.previous)
-    }
-
-    // Seeking
-    if seekTo != false {
-      commands.append(.changePlaybackPosition)
-    }
+#if canImport(NitroModules)
+  import NitroModules
+#endif
 
-    // Jump forward/backward
-    if jumpForward != false {
-      commands.append(.skipForward(
-        preferredIntervals: [(forwardJumpInterval ?? backwardJumpInterval) ?? 15],
-      ))
-    }
-    if jumpBackward != false {
-      commands.append(.skipBackward(
-        preferredIntervals: [(backwardJumpInterval ?? forwardJumpInterval) ?? 15],
-      ))
-    }
-
-    // NOTE: We deliberately do NOT register MPRemoteCommandCenter.likeCommand for the
-    // `favorite` capability. That MPFeedbackCommand had a single system surface — a
-    // pre-iOS-15 lock-screen menu shown in place of the previous-track button — which
-    // Apple silently removed. On the iOS 16+ target it can never be invoked: CarPlay
-    // uses its own CPNowPlayingButton heart, and Siri "I like this" routes through
-    // INUpdateMediaAffinityIntent. The `favorite` capability still drives the
-    // favorite row indicators via setFavoriteEnabled. See issues #67 / #71.
-
-    // Mode controls
-    if shuffleMode != false {
-      commands.append(.changeShuffleMode)
-    }
-    if repeatMode != false {
-      commands.append(.changeRepeatMode)
-    }
-    if playbackRate != false {
-      commands.append(.changePlaybackRate(
-        supportedPlaybackRates: playbackRates.map { NSNumber(value: $0) },
-      ))
-    }
-
-    return commands
+extension PlayerCapabilities {
+  /// The remote commands the capabilities enable: each one unless set to false. `favorite`
+  /// enables none: no iOS 16+ surface invokes `likeCommand`; CarPlay has its own heart button and
+  /// Siri its affinity intent.
+  var remoteCommands: Set<RemoteCommand> {
+    let enabled: [(Bool?, RemoteCommand)] = [
+      (play, .play),
+      (pause, .pause),
+      (stop, .stop),
+      (skipToNext, .next),
+      (skipToPrevious, .previous),
+      (seekTo, .changePlaybackPosition),
+      (jumpForward, .skipForward),
+      (jumpBackward, .skipBackward),
+      (shuffleMode, .changeShuffleMode),
+      (repeatMode, .changeRepeatMode),
+      (playbackRate, .changePlaybackRate),
+    ]
+    return Set(enabled.compactMap { $0.0 == false ? nil : $0.1 })
   }
 }

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+AVPlayer.swift

@@ -4,22 +4,6 @@ import NitroModules
 
 /// Extension to make Nitro Track work with AVPlayer
 extension Track {
-  /// The URL for AVPlayer playback (uses src for playback URL)
-  var playbackUrl: URL? {
-    guard let src else { return nil }
-    return URL(string: src)
-  }
-
-  /// Whether this is a local file URL
-  var isLocalFile: Bool {
-    playbackUrl?.isFileURL ?? false
-  }
-
-  /// The source type (file or stream) based on the URL scheme
-  var sourceType: SourceType {
-    isLocalFile ? .file : .stream
-  }
-
   /// Builds an `ImageSource` from the track's artwork fields, skipping SF Symbol strings.
   var artworkImageSource: ImageSource? {
     if let source = artworkSource {

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)")
     }