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

package/ios/Tests/SectionScopeTests.swift

@@ -111,4 +111,57 @@ struct SectionScopeTests {
   @Test func childlessPageHasNoSections() {
     #expect(ResolvedTrack(path: "/p", title: "P").normalizedSections == nil)
   }
+
+  // MARK: - Queue
+
+  private func queue(_ sections: [Section], _ path: String, singleTrack: Bool = false) -> ([String?], Int)? {
+    SectionScope.queue(in: sections, path: path, singleTrack: singleTrack).map { ($0.tracks.map(\.src), $0.selectedIndex) }
+  }
+
+  @Test func queuesThePlayableTracksOfTheTappedSection() {
+    let page = [
+      section("First", [track("a"), Track(id: "off", src: "off", disabled: true), Track(path: "/browse"), track("b")]),
+      section("Second", [track("c")]),
+    ]
+    let result = queue(page, "/p?__trackId=b&__index=3")
+    #expect(result?.0 == ["a", "b"])
+    #expect(result?.1 == 1)
+  }
+
+  @Test func thePinnedCopyIsTheSelectedOne() {
+    let page = [section(nil, [track("a"), track("b"), track("a")])]
+    #expect(queue(page, "/p?__trackId=a&__index=2")?.1 == 2)
+    #expect(queue(page, "/p?__trackId=a")?.1 == 0)
+  }
+
+  @Test func aStaleIndexSelectsTheFirstIdentityMatch() {
+    let page = [section(nil, [track("x"), track("a"), track("a")])]
+    #expect(queue(page, "/p?__trackId=a&__index=0")?.1 == 1)
+  }
+
+  @Test func singleTrackQueuesOnlyTheTappedTrack() {
+    let page = [section(nil, [track("a"), track("b"), track("c")])]
+    let result = queue(page, "/p?__trackId=b&__index=1", singleTrack: true)
+    #expect(result?.0 == ["b"])
+    #expect(result?.1 == 0)
+  }
+
+  @Test func aDisabledTappedTrackQueuesNothing() {
+    let page = [section(nil, [track("a"), Track(id: "off", src: "off", disabled: true)])]
+    #expect(queue(page, "/p?__trackId=off&__index=1") == nil)
+    #expect(queue(page, "/p?__trackId=off") == nil)
+  }
+
+  @Test func aVanishedIdentityOrAPlainPathQueuesNothing() {
+    let page = [section(nil, [track("a")])]
+    #expect(queue(page, "/p?__trackId=gone") == nil)
+    #expect(queue(page, "/p") == nil)
+  }
+
+  @Test func isPlayableNeedsASrcAndNoDisabled() {
+    #expect(Track(src: "s").isPlayable)
+    #expect(Track(src: "s", disabled: false).isPlayable)
+    #expect(!Track(src: "s", disabled: true).isPlayable)
+    #expect(!Track(path: "/p").isPlayable)
+  }
 }

package/ios/Tests/SimpleRouterTests.swift

@@ -7,9 +7,7 @@ private struct TestRoute: RouteEntry {
 }
 
 private func match(_ path: String, _ patterns: [String]) -> (route: TestRoute, match: RouteMatch)? {
-  let router = SimpleRouter()
-  let routes = patterns.map { TestRoute(path: $0) }
-  return router.findBestMatch(path: path, routes: routes)
+  SimpleRouter.findBestMatch(path: path, routes: patterns.map { TestRoute(path: $0) })
 }
 
 // MARK: - exact matches
@@ -137,3 +135,40 @@ private func match(_ path: String, _ patterns: [String]) -> (route: TestRoute, m
   let result = match("/api/v1/users", ["/api/{version}/**", "/api/v1/**"])
   #expect(result!.route.path == "/api/v1/**")
 }
+
+@Test func treatsADoubleStarBeforeTheEndAsAConstant() {
+  #expect(match("/a/**/b", ["/a/**/b"]) != nil)
+  #expect(match("/a/x/b", ["/a/**/b"]) == nil)
+}
+
+@Test func theFirstRouteWinsATie() {
+  let result = match("/artists/123", ["/artists/{id}", "/artists/{name}"])
+  #expect(result!.route.path == "/artists/{id}")
+}
+
+// MARK: - browse route
+
+private func browseRoute(_ path: String, _ patterns: [String]) -> (route: TestRoute, match: RouteMatch)? {
+  SimpleRouter.browseRoute(for: path, in: patterns.map { TestRoute(path: $0) })
+}
+
+@Test func theSpecialRoutesNeverMatchABrowsePath() {
+  #expect(browseRoute("/__tabs__", ["__tabs__", "__search__"]) == nil)
+  #expect(browseRoute("__search__", ["__search__"]) == nil)
+}
+
+@Test func aMatchingRouteWinsOverTheDefault() {
+  let result = browseRoute("/artists/1", ["__default__", "/artists/{id}"])
+  #expect(result!.route.path == "/artists/{id}")
+  #expect(result!.match.params == ["id": "1"])
+}
+
+@Test func withoutAMatchTheDefaultRouteBrowsesThePath() {
+  let result = browseRoute("/a/b", ["/artists", "__default__"])
+  #expect(result!.route.path == "__default__")
+  #expect(result!.match.params == ["path": "/a/b"])
+}
+
+@Test func withoutAMatchOrADefaultThereIsNoBrowseRoute() {
+  #expect(browseRoute("/a/b", ["/artists", "__tabs__"]) == nil)
+}

package/ios/Tests/SleepTimerManagerTests.swift

@@ -5,103 +5,127 @@ import Testing
 // Timing tests drive a ManualSleepTimerScheduler rather than the main queue:
 // every deadline below is virtual, so nothing races the real clock.
 
+@MainActor
+private final class Volume {
+  var level: Float = 0.8
+}
+
+@MainActor
+private func makeManager() -> (SleepTimerManager, ManualSleepTimerScheduler, Volume, VolumeFader) {
+  let clock = ManualSleepTimerScheduler()
+  let volume = Volume()
+  let fader = VolumeFader(getVolume: { volume.level }, setVolume: { volume.level = $0 })
+  return (SleepTimerManager(fader: fader, scheduler: clock), clock, volume, fader)
+}
+
 @Suite("SleepTimerManager - fade scheduling")
 struct SleepTimerManagerTests {
   @Test @MainActor
-  func fadeFiresBeforeDeadline_completionDoesNotEmitFadeCancel() {
-    let clock = ManualSleepTimerScheduler()
-    let manager = SleepTimerManager(scheduler: clock)
-    var fadeStarts: [TimeInterval] = []
+  func fadeStartsBeforeDeadline_completionRestoresAfterHalting() {
+    let (manager, clock, volume, fader) = makeManager()
     var completes = 0
-    var cancels = 0
-    manager.onFadeStart = { fadeStarts.append($0) }
-    manager.onComplete = { completes += 1 }
+    var volumeAtHalt: Float?
+    manager.onComplete = {
+      completes += 1
+      volumeAtHalt = volume.level
+    }
     manager.set(seconds: 0.3, fadeDuration: 0.15)
-    // Attach after set() — replacing a timer emits a defensive onFadeCancel.
-    manager.onFadeCancel = { cancels += 1 }
 
     clock.advance(to: 0.05) // before the fade window
-    #expect(fadeStarts.isEmpty)
+    #expect(!manager.isFading)
     #expect(manager.get() != nil)
 
     clock.advance(to: 0.22) // inside the fade window
-    #expect(fadeStarts == [0.15])
+    #expect(manager.isFading)
+    #expect(fader.duration == 0.15)
+    #expect(fader.originalVolume == 0.8)
     #expect(completes == 0)
+    volume.level = 0.1 // mid-fade
 
     clock.advance(to: 0.4) // past the deadline
     #expect(completes == 1)
-    #expect(cancels == 0)
+    #expect(volumeAtHalt == 0.1) // halted before the restore
+    #expect(volume.level == 0.8)
+    #expect(!manager.isFading)
     #expect(manager.get() == nil)
   }
 
   @Test @MainActor
   func fadeLongerThanTimer_clampsAndStartsImmediately() {
-    let clock = ManualSleepTimerScheduler()
-    let manager = SleepTimerManager(scheduler: clock)
-    var fadeStarts: [TimeInterval] = []
-    manager.onFadeStart = { fadeStarts.append($0) }
+    let (manager, clock, _, fader) = makeManager()
 
     manager.set(seconds: 0.2, fadeDuration: 5)
 
     clock.advance(to: 0.1) // fade should have begun
-    #expect(fadeStarts == [0.2])
+    #expect(manager.isFading)
+    #expect(fader.duration == 0.2)
   }
 
   @Test @MainActor
-  func clear_emitsFadeCancel_andCancelsScheduledFade() {
-    let clock = ManualSleepTimerScheduler()
-    let manager = SleepTimerManager(scheduler: clock)
-    var fadeStarts = 0
+  func clear_restoresVolume_andCancelsScheduledFade() {
+    let (manager, clock, volume, _) = makeManager()
     manager.set(seconds: 0.2, fadeDuration: 0.15)
-    var cancels = 0
-    manager.onFadeStart = { _ in fadeStarts += 1 }
-    manager.onFadeCancel = { cancels += 1 }
+    clock.advance(to: 0.1)
+    volume.level = 0.1 // mid-fade
 
     #expect(manager.clear())
-    #expect(cancels == 1)
+    #expect(volume.level == 0.8)
+    #expect(!manager.isFading)
 
     clock.advance(to: 0.3) // well past the would-be deadline
-    #expect(fadeStarts == 0)
+    #expect(!manager.isFading)
+  }
+
+  @Test @MainActor
+  func clearBeforeFade_cancelsScheduledFade() {
+    let (manager, clock, _, _) = makeManager()
+    manager.set(seconds: 0.2, fadeDuration: 0.15)
+
+    #expect(manager.clear())
+
+    clock.advance(to: 0.3)
+    #expect(!manager.isFading)
   }
 
   @Test @MainActor
-  func replacingTimer_emitsFadeCancel() {
-    let manager = SleepTimerManager(scheduler: ManualSleepTimerScheduler())
+  func replacingTimer_cancelsTheFade() {
+    let (manager, clock, volume, _) = makeManager()
     manager.set(seconds: 60, fadeDuration: 10)
-    var cancels = 0
-    manager.onFadeCancel = { cancels += 1 }
+    clock.advance(to: 55)
+    volume.level = 0.1 // mid-fade
 
     manager.set(seconds: 30)
 
-    #expect(cancels == 1)
+    #expect(!manager.isFading)
+    #expect(volume.level == 0.8)
   }
 
   @Test @MainActor
-  func switchingToEndOfTrack_emitsFadeCancel() {
-    let manager = SleepTimerManager(scheduler: ManualSleepTimerScheduler())
+  func switchingToEndOfTrack_cancelsTheFade() {
+    let (manager, clock, volume, _) = makeManager()
     manager.set(seconds: 60, fadeDuration: 10)
-    var cancels = 0
-    manager.onFadeCancel = { cancels += 1 }
+    clock.advance(to: 55)
+    volume.level = 0.1 // mid-fade
 
     manager.setToEndOfTrack()
 
-    #expect(cancels == 1)
+    #expect(!manager.isFading)
+    #expect(volume.level == 0.8)
     #expect(manager.get() == .third(SleepTimerEndOfTrack(sleepWhenPlayedToEnd: true)))
   }
 
   @Test @MainActor
   func noFadeDuration_schedulesNoFade() {
-    let clock = ManualSleepTimerScheduler()
-    let manager = SleepTimerManager(scheduler: clock)
-    var fadeStarts = 0
+    let (manager, clock, volume, _) = makeManager()
     var completes = 0
-    manager.onFadeStart = { _ in fadeStarts += 1 }
     manager.onComplete = { completes += 1 }
 
     manager.set(seconds: 0.1)
 
+    clock.advance(to: 0.05)
+    #expect(!manager.isFading)
     clock.advance(to: 0.2)
-    #expect(fadeStarts == 0)
     #expect(completes == 1)
+    #expect(volume.level == 0.8)
   }
 }

package/ios/Tests/Support/TestTypes.swift

@@ -118,11 +118,11 @@ func makePlayer(
   engine: MockPlayerEngine = MockPlayerEngine(),
   retry: RetryLoop = makeRetryLoop(),
   retries: Bool = true,
-  sleepTimer: SleepTimerManager = SleepTimerManager(scheduler: ManualSleepTimerScheduler()),
+  sleepTimerScheduler: any SleepTimerScheduling = ManualSleepTimerScheduler(),
   saveInterval: Duration = .seconds(5),
 ) -> Player {
   let player = Player(
-    engine: engine, retry: retry, sleepTimerManager: sleepTimer,
+    engine: engine, retry: retry, sleepTimerScheduler: sleepTimerScheduler,
     persistenceDefaults: UserDefaults(suiteName: "PlayerTests")!, persistenceSaveInterval: saveInterval,
   )
   retry.shouldRetry = { retries }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-browser",
-  "version": "0.2.0-next.31",
+  "version": "0.2.0-next.33",
   "description": "react-native-audio-browser is a react native package built with Nitro",
   "keywords": [
     "react-native",