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

package/ios/Tests/GenerationMemoTests.swift

@@ -0,0 +1,121 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+@MainActor
+@Suite("GenerationMemo")
+struct GenerationMemoTests {
+  struct Failure: Error {}
+
+  /// A computation that suspends until `release()`, counting its runs.
+  @MainActor
+  final class Gate {
+    var runs = 0
+    var input = 0
+    private var waiters: [CheckedContinuation<Void, Never>] = []
+
+    func run() async -> Int {
+      runs += 1
+      let input = input
+      await withCheckedContinuation { waiters.append($0) }
+      return input
+    }
+
+    func release() {
+      let pending = waiters
+      waiters = []
+      for waiter in pending {
+        waiter.resume()
+      }
+    }
+
+    /// Yields until `count` runs have started, recording an issue rather than hanging when they
+    /// never do.
+    func waitForRuns(_ count: Int, sourceLocation: SourceLocation = #_sourceLocation) async {
+      for _ in 0 ..< 1000 where runs < count {
+        await Task.yield()
+      }
+      if runs < count {
+        Issue.record("expected \(count) runs, saw \(runs)", sourceLocation: sourceLocation)
+        release()
+      }
+    }
+  }
+
+  @Test func concurrentCallersShareOneComputation() async throws {
+    let memo = GenerationMemo<Int>()
+    let gate = Gate()
+    gate.input = 1
+    let first = Task { try await memo.value { await gate.run() } }
+    let second = Task { try await memo.value { await gate.run() } }
+    await gate.waitForRuns(1)
+    gate.release()
+    #expect(try await first.value == 1)
+    #expect(try await second.value == 1)
+    #expect(gate.runs == 1)
+  }
+
+  @Test func keepsTheValueWithinAGeneration() async throws {
+    let memo = GenerationMemo<Int>()
+    _ = try await memo.value { 1 }
+    #expect(try await memo.value { 2 } == 1)
+  }
+
+  @Test func invalidateComputesAgain() async throws {
+    let memo = GenerationMemo<Int>()
+    _ = try await memo.value { 1 }
+    memo.invalidate()
+    #expect(try await memo.value { 2 } == 2)
+  }
+
+  @Test func aResultThatLandsAfterAnInvalidationIsRecomputed() async throws {
+    let memo = GenerationMemo<Int>()
+    let gate = Gate()
+    gate.input = 1
+    let result = Task { try await memo.value { await gate.run() } }
+    await gate.waitForRuns(1)
+    gate.input = 2
+    memo.invalidate()
+    gate.release()
+    await gate.waitForRuns(2)
+    gate.release()
+    #expect(try await result.value == 2)
+  }
+
+  @Test func aFailureIsNotKept() async throws {
+    let memo = GenerationMemo<Int>()
+    await #expect(throws: Failure.self) { try await memo.value { throw Failure() } }
+    #expect(try await memo.value { 3 } == 3)
+  }
+
+  @Test func aFailureThatLandsAfterAnInvalidationIsRetried() async throws {
+    let memo = GenerationMemo<Int>()
+    let gate = Gate()
+    let result = Task {
+      try await memo.value {
+        let input = await gate.run()
+        if input == 0 { throw Failure() }
+        return input
+      }
+    }
+    await gate.waitForRuns(1)
+    gate.input = 4
+    memo.invalidate()
+    gate.release()
+    await gate.waitForRuns(2)
+    gate.release()
+    #expect(try await result.value == 4)
+  }
+
+  @Test func aCancelledCallerStopsRetrying() async throws {
+    let memo = GenerationMemo<Int>()
+    let gate = Gate()
+    let result = Task { try await memo.value { await gate.run() } }
+    await gate.waitForRuns(1)
+    memo.invalidate()
+    result.cancel()
+    gate.release()
+    await #expect(throws: CancellationError.self) { try await result.value }
+    #expect(gate.runs == 1)
+  }
+}

package/ios/Tests/InertStyleDiagnosticTests.swift

@@ -0,0 +1,209 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+// The dev diagnostic for declarations that can never render (ADR 0011): the
+// recovery for the compile-time invalid-combination errors the block model
+// deliberately gave up. Structural inertness only — a surface that can't draw
+// a property it understands is intended usage, never a finding.
+
+@Suite("InertStyleDiagnostic")
+struct InertStyleDiagnosticTests {
+  private func findings(
+    _ sections: [Section], page: SectionStyle? = nil, path: String = "/home",
+  ) -> [String] {
+    InertStyleDiagnostic.findings(path: path, pageStyle: page, sections: sections)
+  }
+
+  private func playable(_ src: String = "https://s/a.mp3", style: TrackStyle? = nil) -> Track {
+    Track(src: src, title: "T", style: style)
+  }
+
+  private func browsable(_ path: String = "/albums/1", style: TrackStyle? = nil) -> Track {
+    Track(path: path, title: "T", style: style)
+  }
+
+  // MARK: - Container properties
+
+  @Test func gridWrapOnAListSectionIsInert() {
+    let found = findings([Section(title: "Recent", style: SectionStyle(gridWrap: false), children: [])])
+    #expect(found.count == 1)
+    #expect(found[0].contains("section 'Recent'"))
+    #expect(found[0].contains("style.gridWrap"))
+    #expect(found[0].contains("display 'list'"))
+    #expect(found[0].contains("/home"))
+  }
+
+  @Test func gridWrapInAGridIsLive() {
+    let style = SectionStyle(gridWrap: false, display: .grid)
+    #expect(findings([Section(style: style, children: [])]).isEmpty)
+  }
+
+  @Test func aSectionInheritsThePagesGridDisplay() {
+    // `display` resolves by scope override, so the page's grid makes the
+    // section's `gridWrap` live without the section restating it.
+    let found = findings(
+      [Section(style: SectionStyle(gridWrap: false), children: [])],
+      page: SectionStyle(display: .grid),
+    )
+    #expect(found.isEmpty)
+  }
+
+  @Test func gridTileOnAListSectionIsInert() {
+    let found = findings([Section(style: SectionStyle(gridTile: .card), children: [])])
+    #expect(found.count == 1)
+    #expect(found[0].contains("style.gridTile"))
+    #expect(found[0].contains("section #1"))
+  }
+
+  // MARK: - Item properties
+
+  @Test func cardPropertiesNeedTheCardTreatment() {
+    let plainGrid = SectionStyle(display: .grid, cardTint: "#1e3a8a", cardImage: .background)
+    let found = findings([Section(title: "Featured", style: plainGrid, children: [])])
+    #expect(found.count == 2)
+    #expect(found.contains { $0.contains("style.cardTint") })
+    #expect(found.contains { $0.contains("style.cardImage") })
+    #expect(found.allSatisfy { $0.contains("display 'grid', gridTile 'plain'") })
+  }
+
+  @Test func cardPropertiesInACardGridAreLive() {
+    let cards = SectionStyle(gridTile: .card, display: .grid, cardTint: "#1e3a8a", cardImage: .background)
+    #expect(findings([Section(style: cards, children: [])]).isEmpty)
+  }
+
+  @Test func imageShapeNeedsAShapedTile() {
+    let list = SectionStyle(imageShape: .circular)
+    let plain = SectionStyle(display: .grid, imageShape: .circular)
+    let cards = SectionStyle(gridTile: .card, display: .grid, imageShape: .circular)
+    let condensed = SectionStyle(gridTile: .condensed, display: .grid, imageShape: .circular)
+    let image = SectionStyle(gridTile: .image, display: .grid, imageShape: .circular)
+    #expect(findings([Section(style: list, children: [])]).count == 1)
+    #expect(findings([Section(style: plain, children: [])]).count == 1)
+    #expect(findings([Section(style: cards, children: [])]).count == 1)
+    #expect(findings([Section(style: condensed, children: [])]).isEmpty)
+    #expect(findings([Section(style: image, children: [])]).isEmpty)
+  }
+
+  @Test func accessorySymbolNeedsAnAccessorySlot() {
+    let rows = SectionStyle(accessorySymbol: "lock.fill")
+    let condensed = SectionStyle(gridTile: .condensed, display: .grid, accessorySymbol: "lock.fill")
+    let image = SectionStyle(gridTile: .image, display: .grid, accessorySymbol: "lock.fill")
+    let plain = SectionStyle(display: .grid, accessorySymbol: "lock.fill")
+    let cards = SectionStyle(gridTile: .card, display: .grid, accessorySymbol: "lock.fill")
+    #expect(findings([Section(style: rows, children: [])]).isEmpty)
+    #expect(findings([Section(style: condensed, children: [])]).isEmpty)
+    #expect(findings([Section(style: image, children: [])]).isEmpty)
+    for style in [plain, cards] {
+      let found = findings([Section(style: style, children: [])])
+      #expect(found.count == 1)
+      #expect(found[0].contains("accessory slot"))
+    }
+  }
+
+  @Test func artworkRenderingIsNeverInert() {
+    let stencilled = SectionStyle(gridTile: .card, display: .grid, artworkRendering: .stencil)
+    #expect(findings([Section(style: stencilled, children: [])]).isEmpty)
+  }
+
+  // MARK: - Track-level declarations
+
+  @Test func trackDeclarationsAreReportedPerSection() {
+    let section = Section(
+      title: "Results", style: SectionStyle(display: .grid),
+      children: [
+        playable(style: TrackStyle(cardTint: "#111")),
+        playable("https://s/b.mp3", style: TrackStyle(cardTint: "#222")),
+        playable("https://s/c.mp3"),
+      ],
+    )
+    let found = findings([section])
+    #expect(found.count == 1)
+    #expect(found[0].contains("2 tracks in section 'Results'"))
+    #expect(found[0].contains("style.cardTint"))
+  }
+
+  @Test func aTracksOwnShapeIsLiveInAShapedGrid() {
+    let section = Section(
+      style: SectionStyle(gridTile: .image, display: .grid),
+      children: [playable(style: TrackStyle(imageShape: .circular))],
+    )
+    #expect(findings([section]).isEmpty)
+  }
+
+  // MARK: - The page block
+
+  @Test func aPageDeclarationLiveInOneSectionIsNotReported() {
+    // Card tint reaches both sections; one renders cards. Live is live.
+    let found = findings(
+      [
+        Section(style: SectionStyle(gridTile: .card, display: .grid), children: []),
+        Section(style: SectionStyle(display: .grid), children: []),
+      ],
+      page: SectionStyle(cardTint: "#1e3a8a"),
+    )
+    #expect(found.isEmpty)
+  }
+
+  @Test func aPageDeclarationNoSectionRendersIsReportedOnce() {
+    let found = findings(
+      [
+        Section(title: "A", style: SectionStyle(display: .grid), children: []),
+        Section(title: "B", children: []),
+      ],
+      page: SectionStyle(cardTint: "#1e3a8a"),
+    )
+    #expect(found.count == 1)
+    #expect(found[0].contains("the page block"))
+    #expect(found[0].contains("no section that inherits it"))
+  }
+
+  @Test func aSectionOverrideShadowsThePageValue() {
+    // Every section declares its own tint, so the page's is never resolved —
+    // shadowed, not inert; the diagnostic reports what can't render, not what
+    // isn't reached.
+    let found = findings(
+      [Section(style: SectionStyle(gridTile: .card, display: .grid, cardTint: "#000"), children: [])],
+      page: SectionStyle(cardTint: "#1e3a8a"),
+    )
+    #expect(found.isEmpty)
+  }
+
+  @Test func aPageWideGridMakesSectionDeclarationsLive() {
+    let found = findings(
+      [Section(style: SectionStyle(cardTint: "#111"), children: [])],
+      page: SectionStyle(gridTile: .card, display: .grid),
+    )
+    #expect(found.isEmpty)
+  }
+
+  // MARK: - The positional `display`
+
+  @Test func displayOnAPlayableTrackIsInert() {
+    let section = Section(
+      title: "Tracks",
+      children: [
+        playable(style: TrackStyle(display: .grid)),
+        browsable(style: TrackStyle(display: .grid)),
+      ],
+    )
+    let found = findings([section])
+    #expect(found.count == 1)
+    #expect(found[0].contains("1 track in section 'Tracks'"))
+    #expect(found[0].contains("style.display"))
+    #expect(found[0].contains("opens none"))
+  }
+
+  @Test func displayOnASectionOrPageIsNeverInert() {
+    let found = findings(
+      [Section(style: SectionStyle(display: .list), children: [browsable()])],
+      page: SectionStyle(display: .grid),
+    )
+    #expect(found.isEmpty)
+  }
+
+  @Test func anUnstyledPageIsSilent() {
+    #expect(findings([Section(children: [playable(), browsable()])]).isEmpty)
+    #expect(findings([]).isEmpty)
+  }
+}

package/ios/Tests/JsonModelsTests.swift

@@ -40,7 +40,7 @@ struct JsonTrackArtworkTests {
     // The shape that shipped broken: a container decodes its children eagerly,
     // so one unparseable row rejected the whole page rather than losing an image.
     let json = """
-    { "url": "/favorites", "title": "Favorites", "children": [
+    { "path": "/favorites", "title": "Favorites", "children": [
       { "title": "Playlist", "artwork": { "light": "https://e.example/l.png", "dark": "https://e.example/d.png" } }
     ] }
     """.data(using: .utf8)!
@@ -56,3 +56,166 @@ struct JsonTrackArtworkTests {
     }
   }
 }
+
+// MARK: - Style blocks (ADR 0011)
+
+@Suite("JsonTrack.style")
+struct JsonStyleTests {
+  @Test func decodesABlockOntoTrackStyle() throws {
+    let json = Data(
+      """
+      {"title":"X","style":{"display":"grid","artworkRendering":"stencil"}}
+      """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    #expect(track.style?.display == .grid)
+    #expect(track.style?.artworkRendering == .stencil)
+  }
+
+  @Test func decodesABlockOntoSectionStyle() throws {
+    let json = Data(
+      """
+      {"path":"/home","title":"Home","sections":[
+        {"style":{"display":"grid","gridWrap":false},"children":[{"title":"C","src":"s"}]}
+      ]}
+      """.utf8)
+    let resolved = try JSONDecoder().decode(JsonResolvedTrack.self, from: json).toNitro()
+    let style = resolved.sections?.first?.style
+    #expect(style?.display == .grid)
+    #expect(style?.gridWrap == false)
+  }
+
+  @Test func staleStringStyleDecodesAsNoDeclaration() throws {
+    // The retired string vocabulary must never kill the page (tolerant
+    // decoding, ADR 0011) — it decodes as an empty block.
+    let json = Data(
+      """
+      {"path":"/home","title":"Home","style":"rail","children":[
+        {"title":"C","src":"s","style":"grid"}
+      ]}
+      """.utf8)
+    let resolved = try JSONDecoder().decode(JsonResolvedTrack.self, from: json).toNitro()
+    #expect(resolved.style == nil)
+    #expect(resolved.children?.first?.style == nil)
+  }
+
+  @Test func unknownEnumValuesDecodeAsNoDeclaration() throws {
+    let json = Data(
+      """
+      {"title":"X","style":{"display":"carousel","artworkRendering":"embossed","gridWrap":"yes"}}
+      """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    // All-unknown declarations collapse to "no block" — one shape for "no
+    // declaration" on every platform.
+    #expect(track.style == nil)
+  }
+
+  @Test func decodesDisabled() throws {
+    let json = Data("""
+    {"title":"X","src":"s","disabled":true}
+    """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    #expect(track.disabled == true)
+  }
+
+  @Test func decodesImageShapeAndAccessorySymbol() throws {
+    let json = Data(
+      """
+      {"title":"X","style":{"imageShape":"circular","accessorySymbol":"lock.fill"}}
+      """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    #expect(track.style?.imageShape == .circular)
+    #expect(track.style?.accessorySymbol == "lock.fill")
+  }
+
+  @Test func accessorySymbolNoneIsAValueNotEmptiness() throws {
+    // The inheritance-escape sentinel must survive the wire — collapsing it
+    // to "no declaration" would let the section value flow back in.
+    let json = Data(
+      """
+      {"title":"X","style":{"accessorySymbol":"none"}}
+      """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    #expect(track.style?.accessorySymbol == "none")
+  }
+
+  @Test func unknownImageShapeDecodesAsNoDeclaration() throws {
+    let json = Data(
+      """
+      {"title":"X","style":{"imageShape":"hexagonal"}}
+      """.utf8)
+    let track = try JSONDecoder().decode(JsonTrack.self, from: json).toNitro()
+    #expect(track.style == nil)
+  }
+
+  @Test func decodesTheCardFamily() throws {
+    let json = Data(
+      """
+      {"path":"/home","title":"Home","sections":[
+        {"style":{"display":"grid","gridTile":"card","cardTint":"#1e3a8a","cardImage":"background"},
+         "children":[{"title":"C","src":"s"}]}
+      ]}
+      """.utf8)
+    let resolved = try JSONDecoder().decode(JsonResolvedTrack.self, from: json).toNitro()
+    let style = resolved.sections?.first?.style
+    #expect(style?.gridTile == .card)
+    #expect(style?.cardTint == "#1e3a8a")
+    #expect(style?.cardImage == .background)
+  }
+
+  @Test func decodesTheImageFamily() throws {
+    let json = Data(
+      """
+      {"path":"/home","title":"Home","sections":[
+        {"style":{"display":"grid","gridTile":"image","imageShape":"circular"},
+         "children":[{"title":"C","src":"s"}]}
+      ]}
+      """.utf8)
+    let resolved = try JSONDecoder().decode(JsonResolvedTrack.self, from: json).toNitro()
+    let style = resolved.sections?.first?.style
+    #expect(style?.gridTile == .image)
+    #expect(style?.imageShape == .circular)
+  }
+
+  @Test func unknownGridTileDecodesAsNoDeclaration() throws {
+    let json = Data(
+      """
+      {"path":"/home","title":"Home","sections":[
+        {"style":{"gridTile":"hexagon"},"children":[{"title":"C","src":"s"}]}
+      ]}
+      """.utf8)
+    let resolved = try JSONDecoder().decode(JsonResolvedTrack.self, from: json).toNitro()
+    #expect(resolved.sections?.first?.style == nil)
+  }
+
+  @Test func styleAndDisabledSurviveThePersistenceRoundTrip() throws {
+    // Restored queues keep their visible fidelity across process death.
+    let original = JsonTrack(
+      title: "X", src: "s",
+      style: JsonStyle(
+        display: "grid", artworkRendering: "stencil",
+        imageShape: "circular", accessorySymbol: "lock.fill",
+      ),
+      disabled: true,
+    )
+    let encoded = try JSONEncoder().encode(original)
+    let decoded = try JSONDecoder().decode(JsonTrack.self, from: encoded)
+    #expect(decoded.style == original.style)
+    #expect(decoded.disabled == true)
+  }
+
+  @Test func liveBlockSnapshotsAllItemProperties() throws {
+    // The persistence snapshot (JsonStyle from a live TrackStyle) must not
+    // drop the newer item properties.
+    let snapshot = JsonStyle(
+      TrackStyle(
+        display: nil, artworkRendering: .stencil,
+        imageShape: .circular, accessorySymbol: "none",
+        cardTint: "#1e3a8a", cardImage: .background,
+      ))
+    #expect(snapshot?.artworkRendering == "stencil")
+    #expect(snapshot?.imageShape == "circular")
+    #expect(snapshot?.accessorySymbol == "none")
+    #expect(snapshot?.cardTint == "#1e3a8a")
+    #expect(snapshot?.cardImage == "background")
+  }
+}

package/ios/Tests/LRUCacheTests.swift

@@ -0,0 +1,110 @@
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("LRUCache")
+@MainActor
+struct LRUCacheTests {
+  /// A class so the tests can observe release through a weak reference.
+  private final class Box {
+    let id: Int
+    init(_ id: Int) { self.id = id }
+  }
+
+  @Test func evictsTheLeastRecentlyUsed() {
+    let cache = LRUCache<String, Int>(maxSize: 2)
+    cache.set("a", value: 1)
+    cache.set("b", value: 2)
+    cache.set("c", value: 3)
+
+    #expect(cache.get("a") == nil)
+    #expect(cache.get("b") == 2)
+    #expect(cache.get("c") == 3)
+    #expect(cache.count == 2)
+  }
+
+  /// A read is a use: it must move the entry off the eviction end.
+  @Test func readingPromotesAnEntry() {
+    let cache = LRUCache<String, Int>(maxSize: 2)
+    cache.set("a", value: 1)
+    cache.set("b", value: 2)
+    _ = cache.get("a")
+    cache.set("c", value: 3)
+
+    #expect(cache.get("a") == 1)
+    #expect(cache.get("b") == nil)
+  }
+
+  @Test func removeDropsOnlyItsOwnEntry() {
+    let cache = LRUCache<String, Int>(maxSize: 3)
+    cache.set("a", value: 1)
+    cache.set("b", value: 2)
+    cache.set("c", value: 3)
+
+    cache.remove("b")
+
+    #expect(cache.get("b") == nil)
+    #expect(cache.get("a") == 1)
+    #expect(cache.get("c") == 3)
+    #expect(cache.count == 2)
+  }
+
+  /// Clearing releases every value the cache held (#96).
+  @Test func clearReleasesEveryNode() {
+    let cache = LRUCache<String, Box>(maxSize: 10)
+    weak var first: Box?
+    weak var middle: Box?
+    weak var last: Box?
+
+    do {
+      let a = Box(1), b = Box(2), c = Box(3)
+      (first, middle, last) = (a, b, c)
+      cache.set("a", value: a)
+      cache.set("b", value: b)
+      cache.set("c", value: c)
+    }
+
+    #expect(first != nil, "the cache should still hold its entries")
+
+    cache.clear()
+
+    #expect(first == nil)
+    #expect(middle == nil)
+    #expect(last == nil)
+    #expect(cache.count == 0)
+  }
+
+  /// So does dropping the cache itself.
+  @Test func droppingTheCacheReleasesEveryNode() {
+    weak var first: Box?
+    weak var last: Box?
+
+    do {
+      let cache = LRUCache<String, Box>(maxSize: 10)
+      let a = Box(1), b = Box(2)
+      (first, last) = (a, b)
+      cache.set("a", value: a)
+      cache.set("b", value: b)
+      #expect(first != nil)
+    }
+
+    #expect(first == nil)
+    #expect(last == nil)
+  }
+
+  /// And evicting an entry releases its value.
+  @Test func evictionReleasesTheEvictedNode() {
+    let cache = LRUCache<String, Box>(maxSize: 1)
+    weak var evicted: Box?
+
+    do {
+      let a = Box(1)
+      evicted = a
+      cache.set("a", value: a)
+      cache.set("b", value: Box(2))
+    }
+
+    #expect(evicted == nil)
+  }
+}

package/ios/Tests/MediaIntentCriteriaTests.swift

@@ -57,12 +57,12 @@ struct MediaIntentCriteriaFromTests {
     mediaTypeMode: String? = nil,
     reference: MediaIntentCriteria.Reference = .unknown,
     hasMediaType: Bool = false,
-    appName: String? = "Radio Garden"
+    appName: String? = "Radio Garden",
   ) -> MediaIntentCriteria {
     MediaIntentCriteria.from(
       mediaName: mediaName, genreNames: genreNames, artistName: artistName,
       albumName: albumName, mediaTypeMode: mediaTypeMode,
-      reference: reference, hasMediaType: hasMediaType, appName: appName
+      reference: reference, hasMediaType: hasMediaType, appName: appName,
     )
   }