expo-tvos-search 1.2.0

package/ios/MarqueeText.swift

@@ -0,0 +1,168 @@
+import SwiftUI
+
+#if os(tvOS)
+
+/// A text view that scrolls horizontally when content exceeds container width.
+/// Uses PreferenceKey for reactive measurement and Task for cancellable animations.
+struct MarqueeText: View {
+    let text: String
+    let font: Font
+    let leftFade: CGFloat
+    let rightFade: CGFloat
+    let startDelay: Double
+    let animate: Bool
+
+    @State private var textWidth: CGFloat = 0
+    @State private var containerWidth: CGFloat = 0
+    @State private var offset: CGFloat = 0
+    @State private var animationTask: Task<Void, Never>?
+
+    private let calculator = MarqueeAnimationCalculator()
+
+    init(
+        _ text: String,
+        font: Font = .callout,
+        leftFade: CGFloat = 10,
+        rightFade: CGFloat = 10,
+        startDelay: Double = 1.5,
+        animate: Bool = true
+    ) {
+        self.text = text
+        self.font = font
+        self.leftFade = leftFade
+        self.rightFade = rightFade
+        self.startDelay = startDelay
+        self.animate = animate
+    }
+
+    private var needsScroll: Bool {
+        calculator.shouldScroll(textWidth: textWidth, containerWidth: containerWidth)
+    }
+
+    var body: some View {
+        GeometryReader { geometry in
+            ZStack(alignment: .leading) {
+                // Hidden text to measure actual width
+                Text(text)
+                    .font(font)
+                    .fixedSize()
+                    .background(
+                        GeometryReader { textGeometry in
+                            Color.clear
+                                .preference(key: TextWidthKey.self, value: textGeometry.size.width)
+                        }
+                    )
+                    .hidden()
+
+                // Visible text content
+                Group {
+                    if needsScroll {
+                        // Duplicated text for seamless scroll loop
+                        Text(text + "     " + text)
+                            .font(font)
+                            .fixedSize()
+                            .offset(x: offset)
+                    } else {
+                        Text(text)
+                            .font(font)
+                            .lineLimit(1)
+                    }
+                }
+            }
+            .frame(width: geometry.size.width, alignment: .leading)
+            .clipped()
+            .mask(fadeMask)
+            .onPreferenceChange(TextWidthKey.self) { width in
+                textWidth = width
+            }
+            .onChange(of: geometry.size.width) { newWidth in
+                containerWidth = newWidth
+            }
+            .onAppear {
+                containerWidth = geometry.size.width
+            }
+            .onChange(of: animate) { shouldAnimate in
+                if shouldAnimate && needsScroll {
+                    startScrolling()
+                } else {
+                    stopScrolling()
+                }
+            }
+            .onChange(of: needsScroll) { scrollNeeded in
+                if animate && scrollNeeded {
+                    startScrolling()
+                } else {
+                    stopScrolling()
+                }
+            }
+            .onDisappear {
+                // Cancel animation task when view disappears to prevent memory leaks
+                animationTask?.cancel()
+                animationTask = nil
+            }
+        }
+    }
+
+    private var fadeMask: some View {
+        HStack(spacing: 0) {
+            LinearGradient(
+                colors: [.clear, .black],
+                startPoint: .leading,
+                endPoint: .trailing
+            )
+            .frame(width: needsScroll ? leftFade : 0)
+
+            Color.black
+
+            LinearGradient(
+                colors: [.black, .clear],
+                startPoint: .leading,
+                endPoint: .trailing
+            )
+            .frame(width: needsScroll ? rightFade : 0)
+        }
+    }
+
+    private func startScrolling() {
+        animationTask?.cancel()
+        offset = 0
+
+        let distance = calculator.scrollDistance(textWidth: textWidth)
+        let duration = calculator.animationDuration(for: distance)
+
+        animationTask = Task {
+            do {
+                try await Task.sleep(nanoseconds: UInt64(startDelay * 1_000_000_000))
+            } catch {
+                return // Task was cancelled
+            }
+
+            guard !Task.isCancelled else { return }
+
+            await MainActor.run {
+                withAnimation(.linear(duration: duration).repeatForever(autoreverses: false)) {
+                    offset = -distance
+                }
+            }
+        }
+    }
+
+    private func stopScrolling() {
+        animationTask?.cancel()
+        animationTask = nil
+        withAnimation(.easeOut(duration: 0.2)) {
+            offset = 0
+        }
+    }
+}
+
+/// PreferenceKey for measuring text width reactively
+private struct TextWidthKey: PreferenceKey {
+    static var defaultValue: CGFloat = 0
+
+    static func reduce(value: inout CGFloat, nextValue: () -> CGFloat) {
+        value = nextValue()
+    }
+}
+
+#endif

package/ios/Tests/MarqueeAnimationCalculatorTests.swift

@@ -0,0 +1,103 @@
+import XCTest
+
+/// Unit tests for MarqueeAnimationCalculator
+final class MarqueeAnimationCalculatorTests: XCTestCase {
+    var calculator: MarqueeAnimationCalculator!
+
+    override func setUp() {
+        super.setUp()
+        calculator = MarqueeAnimationCalculator()
+    }
+
+    override func tearDown() {
+        calculator = nil
+        super.tearDown()
+    }
+
+    // MARK: - shouldScroll Tests
+
+    func testShouldScroll_textWiderThanContainer_returnsTrue() {
+        XCTAssertTrue(calculator.shouldScroll(textWidth: 500, containerWidth: 300))
+    }
+
+    func testShouldScroll_textFitsContainer_returnsFalse() {
+        XCTAssertFalse(calculator.shouldScroll(textWidth: 200, containerWidth: 300))
+    }
+
+    func testShouldScroll_zeroContainerWidth_returnsFalse() {
+        XCTAssertFalse(calculator.shouldScroll(textWidth: 500, containerWidth: 0))
+    }
+
+    func testShouldScroll_equalWidths_returnsFalse() {
+        XCTAssertFalse(calculator.shouldScroll(textWidth: 300, containerWidth: 300))
+    }
+
+    func testShouldScroll_zeroTextWidth_returnsFalse() {
+        XCTAssertFalse(calculator.shouldScroll(textWidth: 0, containerWidth: 300))
+    }
+
+    func testShouldScroll_negativeContainerWidth_returnsFalse() {
+        XCTAssertFalse(calculator.shouldScroll(textWidth: 500, containerWidth: -100))
+    }
+
+    // MARK: - scrollDistance Tests
+
+    func testScrollDistance_defaultSpacing() {
+        XCTAssertEqual(calculator.scrollDistance(textWidth: 400), 440)
+    }
+
+    func testScrollDistance_customSpacing() {
+        let customCalculator = MarqueeAnimationCalculator(spacing: 20)
+        XCTAssertEqual(customCalculator.scrollDistance(textWidth: 400), 420)
+    }
+
+    func testScrollDistance_zeroSpacing() {
+        let noSpacingCalculator = MarqueeAnimationCalculator(spacing: 0)
+        XCTAssertEqual(noSpacingCalculator.scrollDistance(textWidth: 400), 400)
+    }
+
+    func testScrollDistance_zeroTextWidth() {
+        XCTAssertEqual(calculator.scrollDistance(textWidth: 0), 40)
+    }
+
+    // MARK: - animationDuration Tests
+
+    func testAnimationDuration_defaultSpeed() {
+        XCTAssertEqual(calculator.animationDuration(for: 300), 10.0, accuracy: 0.001)
+    }
+
+    func testAnimationDuration_customSpeed() {
+        let fastCalculator = MarqueeAnimationCalculator(pixelsPerSecond: 60)
+        XCTAssertEqual(fastCalculator.animationDuration(for: 300), 5.0, accuracy: 0.001)
+    }
+
+    func testAnimationDuration_zeroDistance() {
+        XCTAssertEqual(calculator.animationDuration(for: 0), 0.0, accuracy: 0.001)
+    }
+
+    func testAnimationDuration_largeDistance() {
+        XCTAssertEqual(calculator.animationDuration(for: 3000), 100.0, accuracy: 0.001)
+    }
+
+    // MARK: - Integration Tests
+
+    func testFullCalculation_typicalLongTitle() {
+        let textWidth: CGFloat = 500
+        let containerWidth: CGFloat = 280
+
+        XCTAssertTrue(calculator.shouldScroll(textWidth: textWidth, containerWidth: containerWidth))
+
+        let distance = calculator.scrollDistance(textWidth: textWidth)
+        XCTAssertEqual(distance, 540)
+
+        let duration = calculator.animationDuration(for: distance)
+        XCTAssertEqual(duration, 18.0, accuracy: 0.001)
+    }
+
+    func testFullCalculation_shortTitle() {
+        let textWidth: CGFloat = 200
+        let containerWidth: CGFloat = 280
+
+        XCTAssertFalse(calculator.shouldScroll(textWidth: textWidth, containerWidth: containerWidth))
+    }
+}

package/ios/Tests/SearchResultItemTests.swift

@@ -0,0 +1,200 @@
+import XCTest
+
+#if os(tvOS)
+
+/// Unit tests for SearchResultItem data model
+final class SearchResultItemTests: XCTestCase {
+
+    // MARK: - Initialization Tests
+
+    func testInit_allProperties() {
+        let item = SearchResultItem(
+            id: "123",
+            title: "Test Movie",
+            subtitle: "2024",
+            imageUrl: "https://example.com/poster.jpg"
+        )
+
+        XCTAssertEqual(item.id, "123")
+        XCTAssertEqual(item.title, "Test Movie")
+        XCTAssertEqual(item.subtitle, "2024")
+        XCTAssertEqual(item.imageUrl, "https://example.com/poster.jpg")
+    }
+
+    func testInit_minimalProperties() {
+        let item = SearchResultItem(
+            id: "456",
+            title: "Minimal Movie",
+            subtitle: nil,
+            imageUrl: nil
+        )
+
+        XCTAssertEqual(item.id, "456")
+        XCTAssertEqual(item.title, "Minimal Movie")
+        XCTAssertNil(item.subtitle)
+        XCTAssertNil(item.imageUrl)
+    }
+
+    // MARK: - Identifiable Conformance
+
+    func testIdentifiable_idProperty() {
+        let item = SearchResultItem(
+            id: "unique-123",
+            title: "Title",
+            subtitle: nil,
+            imageUrl: nil
+        )
+
+        XCTAssertEqual(item.id, "unique-123")
+    }
+
+    func testIdentifiable_emptyId() {
+        let item = SearchResultItem(
+            id: "",
+            title: "Title",
+            subtitle: nil,
+            imageUrl: nil
+        )
+
+        XCTAssertEqual(item.id, "")
+    }
+
+    // MARK: - Equatable Conformance
+
+    func testEquality_sameValues_areEqual() {
+        let item1 = SearchResultItem(
+            id: "1",
+            title: "Movie",
+            subtitle: "2024",
+            imageUrl: "https://example.com/img.jpg"
+        )
+        let item2 = SearchResultItem(
+            id: "1",
+            title: "Movie",
+            subtitle: "2024",
+            imageUrl: "https://example.com/img.jpg"
+        )
+
+        XCTAssertEqual(item1, item2)
+    }
+
+    func testEquality_differentId_notEqual() {
+        let item1 = SearchResultItem(id: "1", title: "Movie", subtitle: nil, imageUrl: nil)
+        let item2 = SearchResultItem(id: "2", title: "Movie", subtitle: nil, imageUrl: nil)
+
+        XCTAssertNotEqual(item1, item2)
+    }
+
+    func testEquality_differentTitle_notEqual() {
+        let item1 = SearchResultItem(id: "1", title: "Movie A", subtitle: nil, imageUrl: nil)
+        let item2 = SearchResultItem(id: "1", title: "Movie B", subtitle: nil, imageUrl: nil)
+
+        XCTAssertNotEqual(item1, item2)
+    }
+
+    func testEquality_differentSubtitle_notEqual() {
+        let item1 = SearchResultItem(id: "1", title: "Movie", subtitle: "2023", imageUrl: nil)
+        let item2 = SearchResultItem(id: "1", title: "Movie", subtitle: "2024", imageUrl: nil)
+
+        XCTAssertNotEqual(item1, item2)
+    }
+
+    func testEquality_differentImageUrl_notEqual() {
+        let item1 = SearchResultItem(id: "1", title: "Movie", subtitle: nil, imageUrl: "url1")
+        let item2 = SearchResultItem(id: "1", title: "Movie", subtitle: nil, imageUrl: "url2")
+
+        XCTAssertNotEqual(item1, item2)
+    }
+
+    func testEquality_nilVsValue_notEqual() {
+        let item1 = SearchResultItem(id: "1", title: "Movie", subtitle: nil, imageUrl: nil)
+        let item2 = SearchResultItem(id: "1", title: "Movie", subtitle: "2024", imageUrl: nil)
+
+        XCTAssertNotEqual(item1, item2)
+    }
+
+    func testEquality_bothNil_areEqual() {
+        let item1 = SearchResultItem(id: "1", title: "Movie", subtitle: nil, imageUrl: nil)
+        let item2 = SearchResultItem(id: "1", title: "Movie", subtitle: nil, imageUrl: nil)
+
+        XCTAssertEqual(item1, item2)
+    }
+
+    // MARK: - Optional Properties Tests
+
+    func testOptionalProperties_nilSubtitle() {
+        let item = SearchResultItem(
+            id: "1",
+            title: "Title",
+            subtitle: nil,
+            imageUrl: "https://example.com"
+        )
+
+        XCTAssertNil(item.subtitle)
+        XCTAssertNotNil(item.imageUrl)
+    }
+
+    func testOptionalProperties_nilImageUrl() {
+        let item = SearchResultItem(
+            id: "1",
+            title: "Title",
+            subtitle: "Subtitle",
+            imageUrl: nil
+        )
+
+        XCTAssertNotNil(item.subtitle)
+        XCTAssertNil(item.imageUrl)
+    }
+
+    func testOptionalProperties_emptyStringSubtitle() {
+        let item = SearchResultItem(
+            id: "1",
+            title: "Title",
+            subtitle: "",
+            imageUrl: nil
+        )
+
+        XCTAssertNotNil(item.subtitle)
+        XCTAssertEqual(item.subtitle, "")
+    }
+
+    // MARK: - Edge Cases
+
+    func testLongTitle() {
+        let longTitle = String(repeating: "A", count: 500)
+        let item = SearchResultItem(
+            id: "1",
+            title: longTitle,
+            subtitle: nil,
+            imageUrl: nil
+        )
+
+        XCTAssertEqual(item.title.count, 500)
+    }
+
+    func testSpecialCharactersInTitle() {
+        let specialTitle = "Movie: The Sequel (2024) - Director's Cut [4K]"
+        let item = SearchResultItem(
+            id: "1",
+            title: specialTitle,
+            subtitle: nil,
+            imageUrl: nil
+        )
+
+        XCTAssertEqual(item.title, specialTitle)
+    }
+
+    func testUnicodeTitle() {
+        let unicodeTitle = "映画 🎬 Film"
+        let item = SearchResultItem(
+            id: "1",
+            title: unicodeTitle,
+            subtitle: nil,
+            imageUrl: nil
+        )
+
+        XCTAssertEqual(item.title, unicodeTitle)
+    }
+}
+
+#endif

package/ios/Tests/SearchViewModelTests.swift

@@ -0,0 +1,202 @@
+import XCTest
+
+#if os(tvOS)
+
+/// Unit tests for SearchViewModel
+final class SearchViewModelTests: XCTestCase {
+    var viewModel: SearchViewModel!
+
+    override func setUp() {
+        super.setUp()
+        viewModel = SearchViewModel()
+    }
+
+    override func tearDown() {
+        viewModel = nil
+        super.tearDown()
+    }
+
+    // MARK: - Initial State Tests
+
+    func testInitialState_resultsEmpty() {
+        XCTAssertTrue(viewModel.results.isEmpty)
+    }
+
+    func testInitialState_isLoadingFalse() {
+        XCTAssertFalse(viewModel.isLoading)
+    }
+
+    func testInitialState_searchTextEmpty() {
+        XCTAssertEqual(viewModel.searchText, "")
+    }
+
+    func testInitialState_defaultColumns() {
+        XCTAssertEqual(viewModel.columns, 5)
+    }
+
+    func testInitialState_defaultPlaceholder() {
+        XCTAssertEqual(viewModel.placeholder, "Search movies and videos...")
+    }
+
+    func testInitialState_showTitleFalse() {
+        XCTAssertFalse(viewModel.showTitle)
+    }
+
+    func testInitialState_showSubtitleFalse() {
+        XCTAssertFalse(viewModel.showSubtitle)
+    }
+
+    func testInitialState_showFocusBorderFalse() {
+        XCTAssertFalse(viewModel.showFocusBorder)
+    }
+
+    func testInitialState_topInsetZero() {
+        XCTAssertEqual(viewModel.topInset, 0)
+    }
+
+    // MARK: - Title Overlay Config Initial State
+
+    func testInitialState_showTitleOverlayTrue() {
+        XCTAssertTrue(viewModel.showTitleOverlay)
+    }
+
+    func testInitialState_enableMarqueeTrue() {
+        XCTAssertTrue(viewModel.enableMarquee)
+    }
+
+    func testInitialState_marqueeDelayDefault() {
+        XCTAssertEqual(viewModel.marqueeDelay, 1.5, accuracy: 0.001)
+    }
+
+    // MARK: - Property Updates
+
+    func testColumnsUpdate() {
+        viewModel.columns = 3
+        XCTAssertEqual(viewModel.columns, 3)
+    }
+
+    func testPlaceholderUpdate() {
+        viewModel.placeholder = "Custom placeholder"
+        XCTAssertEqual(viewModel.placeholder, "Custom placeholder")
+    }
+
+    func testShowTitleUpdate() {
+        viewModel.showTitle = true
+        XCTAssertTrue(viewModel.showTitle)
+    }
+
+    func testShowSubtitleUpdate() {
+        viewModel.showSubtitle = true
+        XCTAssertTrue(viewModel.showSubtitle)
+    }
+
+    func testShowFocusBorderUpdate() {
+        viewModel.showFocusBorder = true
+        XCTAssertTrue(viewModel.showFocusBorder)
+    }
+
+    func testTopInsetUpdate() {
+        viewModel.topInset = 100
+        XCTAssertEqual(viewModel.topInset, 100)
+    }
+
+    // MARK: - Title Overlay Config Updates
+
+    func testShowTitleOverlayUpdate() {
+        viewModel.showTitleOverlay = false
+        XCTAssertFalse(viewModel.showTitleOverlay)
+    }
+
+    func testEnableMarqueeUpdate() {
+        viewModel.enableMarquee = false
+        XCTAssertFalse(viewModel.enableMarquee)
+    }
+
+    func testMarqueeDelayUpdate() {
+        viewModel.marqueeDelay = 2.5
+        XCTAssertEqual(viewModel.marqueeDelay, 2.5, accuracy: 0.001)
+    }
+
+    func testMarqueeDelayUpdate_zeroValue() {
+        viewModel.marqueeDelay = 0
+        XCTAssertEqual(viewModel.marqueeDelay, 0, accuracy: 0.001)
+    }
+
+    // MARK: - Results Tests
+
+    func testResultsUpdate() {
+        let item = SearchResultItem(id: "1", title: "Test Movie", subtitle: "2024", imageUrl: nil)
+        viewModel.results = [item]
+
+        XCTAssertEqual(viewModel.results.count, 1)
+        XCTAssertEqual(viewModel.results.first?.title, "Test Movie")
+    }
+
+    func testResultsClear() {
+        let item = SearchResultItem(id: "1", title: "Test Movie", subtitle: nil, imageUrl: nil)
+        viewModel.results = [item]
+        viewModel.results = []
+
+        XCTAssertTrue(viewModel.results.isEmpty)
+    }
+
+    // MARK: - Callback Tests
+
+    func testOnSearchCallback() {
+        var capturedQuery: String?
+        viewModel.onSearch = { query in
+            capturedQuery = query
+        }
+
+        viewModel.onSearch?("test query")
+
+        XCTAssertEqual(capturedQuery, "test query")
+    }
+
+    func testOnSelectItemCallback() {
+        var capturedId: String?
+        viewModel.onSelectItem = { id in
+            capturedId = id
+        }
+
+        viewModel.onSelectItem?("item-123")
+
+        XCTAssertEqual(capturedId, "item-123")
+    }
+
+    func testOnSearchCallback_emptyQuery() {
+        var capturedQuery: String?
+        viewModel.onSearch = { query in
+            capturedQuery = query
+        }
+
+        viewModel.onSearch?("")
+
+        XCTAssertEqual(capturedQuery, "")
+    }
+
+    func testCallbacksNil_noError() {
+        viewModel.onSearch = nil
+        viewModel.onSelectItem = nil
+
+        viewModel.onSearch?("test")
+        viewModel.onSelectItem?("test")
+    }
+
+    // MARK: - Published Property Tests
+
+    func testIsLoadingPublished() {
+        viewModel.isLoading = true
+        XCTAssertTrue(viewModel.isLoading)
+
+        viewModel.isLoading = false
+        XCTAssertFalse(viewModel.isLoading)
+    }
+
+    func testSearchTextPublished() {
+        viewModel.searchText = "action"
+        XCTAssertEqual(viewModel.searchText, "action")
+    }
+}
+
+#endif