react-native-audio-browser 0.2.0-next.32 → 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/Model/NitroTypeStubs.swift

@@ -110,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/Tests/BrowserPathHelperTests.swift

@@ -177,3 +177,36 @@ import Testing
   #expect(BrowserPathHelper.isSearchPath("/search?q=jazz") == false)
   #expect(BrowserPathHelper.isSearchPath("/__searchable") == false)
 }
+
+// MARK: - stampingContextualPaths
+
+@Test func stampsPlayableOnlyTracksWithTheirFlatPagePosition() throws {
+  let sections = [
+    Section(children: [Track(path: "/a", title: "A"), Track(src: "one.mp3", title: "One")]),
+    Section(children: [Track(id: "two", src: "two.mp3", title: "Two")]),
+  ]
+  let stamped = try BrowserPathHelper.stampingContextualPaths(sections, parentPath: "/page")
+  #expect(stamped.map { $0.children.map(\.path) } == [
+    ["/a", "/page?__trackId=one.mp3&__index=1"],
+    ["/page?__trackId=two&__index=2"],
+  ])
+}
+
+@Test func keepsTheSectionsAndATrackThatHasAPath() throws {
+  let track = Track(path: "/a", src: "a.mp3", title: "A")
+  let sections = [Section(title: "Top", path: "/top", children: [track])]
+  #expect(try BrowserPathHelper.stampingContextualPaths(sections, parentPath: "/page") == sections)
+}
+
+@Test func stampsBesideAnExistingQuery() throws {
+  let sections = [Section(children: [Track(src: "s.mp3", title: "S")])]
+  let stamped = try BrowserPathHelper.stampingContextualPaths(sections, parentPath: "/search?q=jazz")
+  #expect(stamped[0].children[0].path == "/search?q=jazz&__trackId=s.mp3&__index=0")
+}
+
+@Test func rejectsATrackWithNeitherPathNorSrc() {
+  let sections = [Section(children: [Track(id: "only-id", title: "Nowhere")])]
+  #expect(throws: BrowserError.self) {
+    try BrowserPathHelper.stampingContextualPaths(sections, parentPath: "/page")
+  }
+}

package/ios/Tests/FavoriteSetTests.swift

@@ -0,0 +1,60 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+struct FavoriteSetTests {
+  private func favorites(_ identities: [String], enabled: Bool = true) -> FavoriteSet {
+    var set = FavoriteSet()
+    set.enabled = enabled
+    _ = set.replace(with: identities)
+    return set
+  }
+
+  @Test func replaceReportsWhetherTheIdentitiesChanged() {
+    var set = FavoriteSet()
+    let changes = [["a", "b"], ["b", "a"], ["a", "b", "a"], []].map { set.replace(with: $0) }
+    #expect(changes == [true, false, false, true])
+  }
+
+  @Test func hydratesTrueOrFalseByIdentity() {
+    let set = favorites(["a", "stable"])
+    #expect(set.hydrate(Track(src: "a")).favorited == true)
+    #expect(set.hydrate(Track(src: "b")).favorited == false)
+    #expect(set.hydrate(Track(id: "stable", src: "x")).favorited == true)
+    #expect(set.hydrate(Track(id: "other", src: "a")).favorited == false)
+  }
+
+  @Test func leavesATrackAloneWhenDisabled() {
+    #expect(favorites(["a"], enabled: false).hydrate(Track(src: "a")).favorited == nil)
+  }
+
+  @Test func leavesATrackWithoutIdentityAlone() {
+    #expect(favorites(["a"]).hydrate(Track(path: "/browse")).favorited == nil)
+  }
+
+  @Test func aFavoritedTheTrackCarriesWins() {
+    let set = favorites(["a"])
+    #expect(set.hydrate(Track(src: "a", favorited: false)).favorited == false)
+    #expect(set.hydrate(Track(src: "b", favorited: true)).favorited == true)
+  }
+
+  @Test func aLocalToggleHoldsUntilTheNextReplace() {
+    var set = favorites(["a"])
+    set.set("b", favorited: true)
+    set.set("a", favorited: false)
+    #expect(set.hydrate(Track(src: "a")).favorited == false)
+    #expect(set.hydrate(Track(src: "b")).favorited == true)
+    _ = set.replace(with: ["a"])
+    #expect(set.hydrate(Track(src: "b")).favorited == false)
+  }
+
+  @Test func hydratesEverySectionOfAPage() {
+    let page = ResolvedTrack(
+      path: "/p",
+      sections: [Section(children: [Track(src: "a")]), Section(children: [Track(src: "b")])],
+      title: "P",
+    )
+    let hydrated = favorites(["b"]).hydrate(page)
+    #expect(hydrated.sections?.map { $0.children.map(\.favorited) } == [[false], [true]])
+  }
+}