@shortkitsdk/react-native 0.2.35 → 0.2.36

package/android/src/main/java/com/shortkit/reactnative/ShortKitFeedView.kt

@@ -30,6 +30,15 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
     var feedId: String? = null
     var startAtItemId: String? = null
     var preloadId: String? = null
+    /**
+     * JSON-encoded `FeedInput[]` from the `feedItems` JS prop. Parsed at
+     * fragment-construction time only — post-mount changes are a no-op
+     * (matches iOS PR #150). Host apps that need post-mount item updates
+     * use the imperative `ShortKit.setFeedItems(feedId, items)` API.
+     *
+     * `preloadId` takes precedence when both are set.
+     */
+    var feedItemsJSON: String? = null
     // Fabric's generated delegate maps an absent boolean prop to the Java
     // primitive false, so Boolean? is always non-null from the bridge. Track
     // whether the prop was explicitly set so we can fall back to the provider
@@ -37,6 +46,62 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
     var debugPanel: Boolean = false
     var debugPanelPropSet: Boolean = false
 
+    /**
+     * URL of the thumbnail the host app is already rendering for the item that
+     * will be the first active cell. Looked up synchronously via Glide's cache
+     * (10ms cap; supports expo-image / FastImage clients) and seeded onto the
+     * fragment before its first lifecycle event. Falls back to the existing
+     * patchMissingThumbnailIfNeeded helper on cache miss or timeout.
+     *
+     * Mirrors iOS ShortKitFeedView.seedThumbnailUrl
+     * (react_native_sdk/ios/ShortKitFeedView.swift:28).
+     */
+    var seedThumbnailUrl: String? = null
+
+    /**
+     * Host-driven activation state, set by the `active` JS prop. Defaults to
+     * `true`. Mirrors iOS [`ShortKitFeedView.active`](react_native_sdk/ios/ShortKitFeedView.swift:46).
+     */
+    var active: Boolean = true
+        internal set
+
+    /**
+     * Tracks whether `active` was explicitly set by the host (vs. defaulted).
+     * Same purpose as `debugPanelPropSet` — distinguishes "absent" from "false"
+     * since Fabric maps absent boolean props to the Java primitive `false`.
+     *
+     * Used only by the first-mount race fix in [embedFeedFragmentIfNeeded] to
+     * decide whether a `false` value is a real host intent or a Fabric default.
+     */
+    var activePropSet: Boolean = false
+        internal set
+
+    /**
+     * Set the `active` prop from the bridge. The canonical entry point for
+     * all `active` state transitions — do not mutate the field directly.
+     *
+     * Behavior:
+     * - Always sets `activePropSet = true`.
+     * - On transition while a fragment is embedded:
+     *   - `true → false`: calls `fragment.deactivate()`.
+     *   - `false → true`: calls `fragment.activate()`.
+     * - Returns early if no fragment is yet embedded — the first-mount race
+     *   in [embedFeedFragmentIfNeeded] handles the deferred deactivate case.
+     *
+     * Invoked by [ShortKitFeedViewManager.setActive].
+     */
+    fun setActiveFromBridge(value: Boolean) {
+        val prev = active
+        active = value
+        activePropSet = true
+        val fragment = feedFragment ?: return
+        if (prev && !value) {
+            fragment.deactivate()
+        } else if (!prev && value) {
+            fragment.activate()
+        }
+    }
+
     // -----------------------------------------------------------------------
     // Fragment management
     // -----------------------------------------------------------------------
@@ -140,7 +205,15 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
         synchronized(ShortKitBridge.staticPendingFeedViews) {
             ShortKitBridge.staticPendingFeedViews.remove(this)
         }
-        suspendFeedFragment()
+        // Mirror iOS willMove(toWindow:) at react_native_sdk/ios/ShortKitFeedView.swift:91-99 —
+        // suspend only if leaving the window AND the prop says we should be active.
+        // When active=false the host has already driven the fragment into deactivate
+        // (or will once setActiveFromBridge runs), and we mustn't double-suspend.
+        // Default active=true preserves legacy window-inference behavior for hosts
+        // that never set the active prop.
+        if (active) {
+            suspendFeedFragment()
+        }
         super.onDetachedFromWindow()
     }
 
@@ -167,7 +240,11 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
                         .beginTransaction()
                         .show(existingFragment)
                         .commitNowAllowingStateLoss()
-                    existingFragment.activate()
+                    // Mirror iOS: only auto-activate if the host's active prop says so.
+                    // Default active=true preserves legacy "always activate on un-hide" behavior.
+                    if (active) {
+                        existingFragment.activate()
+                    }
                 } catch (e: Exception) {
                     Log.e(TAG, "Failed to show feed fragment", e)
                 }
@@ -188,24 +265,58 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
 
         var feedConfig = ShortKitBridge.parseFeedConfig(config ?: "{}", context)
 
-        preloadId?.let { id ->
-            val preload = ShortKitBridge.shared?.consumePreload(id)
+        val explicitPreloadId = preloadId
+        val explicitFeedItemsJSON = feedItemsJSON
+        if (explicitPreloadId != null) {
+            val preload = ShortKitBridge.shared?.consumePreload(explicitPreloadId)
             if (preload != null) {
                 feedConfig = feedConfig.copy(preload = preload)
             }
+        } else if (explicitFeedItemsJSON != null) {
+            // Mount-time custom-feed fast-path (SHO-29 / iOS PR #150).
+            // Parse JSON → FeedInput[] → sdk.preloadFeed(items=) which
+            // internally calls FeedPreload.forCustomItems with the SDK's
+            // own scope. Assign to feedConfig.preload BEFORE constructing
+            // the fragment, so FeedPreload.consume() returns synchronously
+            // on the first cell bind. Requires Task 1's sync-payload fix
+            // in FeedPreload.kt.
+            //
+            // Using sdk.preloadFeed(items=) (the public SDK entry point at
+            // ShortKit.kt:232) instead of FeedPreload.forCustomItems
+            // directly — avoids needing to promote internal SDK helpers
+            // for cross-module access from the bridge.
+            val parsed = ShortKitBridge.parseFeedInputs(explicitFeedItemsJSON)
+            if (parsed != null && parsed.isNotEmpty()) {
+                val preload = sdk.preloadFeed(items = parsed)
+                feedConfig = feedConfig.copy(preload = preload)
+            } else {
+                Log.w(TAG, "feedItemsJSON parsed to null/empty — ignoring (config feedSource will drive the fetch path)")
+            }
         }
 
         val fragment = ShortKitFeedFragment.newInstance(sdk, feedConfig, startAtItemId)
 
         val debugPanelEnabled = if (debugPanelPropSet) debugPanel else sdk.debugPanelEnabled
         if (debugPanelEnabled) {
-            fragment.debugPanelFactory = { active, prev, next, lifecycleOwner ->
+            fragment.debugPanelFactory = { activeMetrics, prev, next, lifecycleOwner ->
                 com.shortkit.sdk.debug.DebugPanelView(context).also { panel ->
-                    panel.subscribe(active, prev, next, lifecycleOwner)
+                    panel.subscribe(activeMetrics, prev, next, lifecycleOwner)
                 }
             }
         }
 
+        // SHO-11: seed a thumbnail from the host app's image cache so the first
+        // cell renders with a visible thumbnail from frame zero. Synchronous
+        // Glide lookup (memory-only via 10ms cap) — no network. If null (cache
+        // miss, timeout, or Glide not linked), the existing
+        // patchMissingThumbnailIfNeeded helper handles the fallback at feed-open
+        // time. Mirrors iOS ShortKitFeedView.swift:170-173.
+        seedThumbnailUrl?.let { url ->
+            com.shortkit.sdk.feed.SeedThumbnailResolver.resolveFromCache(context, url)?.let { bitmap ->
+                fragment.seedThumbnail = bitmap
+            }
+        }
+
         try {
             activity.supportFragmentManager
                 .beginTransaction()
@@ -213,6 +324,24 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
                 .commitNowAllowingStateLoss()
             this.feedFragment = fragment
 
+            // Android-specific first-mount race: Fabric may have set active=false
+            // BEFORE we got to embed the fragment. The fragment self-claims the
+            // player pool in onResume (ShortKitFeedFragment.kt:2112), so by the
+            // time commitNowAllowingStateLoss returns the fragment is already
+            // active. Retroactively deactivate to honor the host's intent.
+            //
+            // Note: this produces a brief claim-then-yield window (microseconds).
+            // Acceptable for normal use; if a host needs strictly never-active
+            // mounts, the fragment's onResume self-claim would need a managed-mode
+            // flag to suppress (separate ticket).
+            //
+            // activePropSet guard: only fires when the host explicitly set the prop.
+            // Fabric maps absent booleans to Java false, so without this guard
+            // every fragment would deactivate at mount.
+            if (activePropSet && !active) {
+                fragment.deactivate()
+            }
+
             // View.generateViewId() can return IDs that collide with Fabric-
             // managed views (e.g. ReactSurfaceView also gets id=1).  When that
             // happens, FragmentManager.replace() places the fragment view in

package/android/src/main/java/com/shortkit/reactnative/ShortKitFeedViewManager.kt

@@ -35,12 +35,27 @@ class ShortKitFeedViewManager : SimpleViewManager<ShortKitFeedView>() {
         view.preloadId = preloadId
     }
 
+    @ReactProp(name = "feedItemsJSON")
+    fun setFeedItemsJSON(view: ShortKitFeedView, feedItemsJSON: String?) {
+        view.feedItemsJSON = feedItemsJSON
+    }
+
     @ReactProp(name = "debugPanel")
     fun setDebugPanel(view: ShortKitFeedView, debugPanel: Boolean) {
         view.debugPanel = debugPanel
         view.debugPanelPropSet = true
     }
 
+    @ReactProp(name = "active")
+    fun setActive(view: ShortKitFeedView, active: Boolean) {
+        view.setActiveFromBridge(active)
+    }
+
+    @ReactProp(name = "seedThumbnailUrl")
+    fun setSeedThumbnailUrl(view: ShortKitFeedView, url: String?) {
+        view.seedThumbnailUrl = url
+    }
+
     override fun onDropViewInstance(view: ShortKitFeedView) {
         view.destroy()
         super.onDropViewInstance(view)

package/android/src/main/java/com/shortkit/reactnative/ShortKitModule.kt

@@ -136,6 +136,11 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
     @ReactMethod
     override fun pause() { bridge?.pause() }
 
+    @ReactMethod
+    override fun setFeedScrollEnabled(enabled: Boolean) {
+        bridge?.setFeedScrollEnabled(enabled)
+    }
+
     @ReactMethod
     override fun seek(seconds: Double) { bridge?.seek(seconds) }
 
@@ -149,28 +154,30 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
     override fun skipToPrevious() { bridge?.skipToPrevious() }
 
     // -----------------------------------------------------------------
-    // Carousel commands — stubs for PR 1.
-    // TODO: PR 2 — replace these stubs with real bridge to ShortKit.activeInstance.get().carousel
+    // Carousel commands — bridge to ShortKit.activeInstance().carousel.
+    // Mirrors iOS RN bridge from PR #136. SHO-15.
+    // Boundary semantics: returns false / -1 / 0 when no ShortKit instance
+    // is active or no fragment is bound, matching iOS `?? false` / `?? nil`
+    // fallbacks via the namespace's onMain shim + null-tolerance.
     // -----------------------------------------------------------------
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun carouselNext(): Boolean = false
+    override fun carouselNext(): Boolean = bridge?.carouselNext() ?: false
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun carouselPrevious(): Boolean = false
+    override fun carouselPrevious(): Boolean = bridge?.carouselPrevious() ?: false
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun carouselSetActiveIndex(index: Double): Boolean = false
-
-    // Carousel accessors — stubs for PR 1.
-    // onCarouselActiveVideoCompleted emitter intentionally unwired — never fires on Android in PR 1.
-    // PR 2 will subscribe to ShortKit.activeInstance.get().carousel.activeVideoCompleted.
+    override fun carouselSetActiveIndex(index: Double): Boolean =
+        bridge?.carouselSetActiveIndex(index.toInt()) ?: false
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun getCarouselActiveIndex(): Double = -1.0
+    override fun getCarouselActiveIndex(): Double =
+        (bridge?.carouselActiveIndex() ?: -1).toDouble()
 
     @ReactMethod(isBlockingSynchronousMethod = true)
-    override fun getCarouselVideoCount(): Double = 0.0
+    override fun getCarouselVideoCount(): Double =
+        (bridge?.carouselVideoCount() ?: 0).toDouble()
 
     @ReactMethod
     override fun setMuted(muted: Boolean) { bridge?.setMuted(muted) }
@@ -326,6 +333,7 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
                 "onContentTapped" -> emitOnContentTapped(params)
                 "onDismiss" -> emitOnDismiss(params)
                 "onRefreshStateChanged" -> emitOnRefreshStateChanged(params)
+                "onRefreshStateChangedPerFeed" -> emitOnRefreshStateChangedPerFeed(params)
                 "onDidFetchContentItems" -> emitOnDidFetchContentItems(params)
                 "onFeedReady" -> emitOnFeedReady(params)
                 "onOverlayActiveChanged" -> emitOnOverlayActiveChanged(params)
@@ -341,8 +349,10 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
                 "onCarouselActiveImageChanged" -> emitOnCarouselActiveImageChanged(params)
                 "onCarouselItemChanged" -> emitOnCarouselItemChanged(params)
                 "onVideoCarouselActiveVideoChanged" -> emitOnVideoCarouselActiveVideoChanged(params)
+                "onVideoCarouselCellTap" -> emitOnVideoCarouselCellTap(params)
                 "onVideoCarouselItemChanged" -> emitOnVideoCarouselItemChanged(params)
                 "onCarouselActiveVideoCompleted" -> emitOnCarouselActiveVideoCompleted(params)
+                "onVideoCarouselCellTap" -> emitOnVideoCarouselCellTap(params)
                 else -> {
                     android.util.Log.w("SK:Module", "sendEvent: unknown event name '$name', using legacy emitter")
                     reactApplicationContext

package/android/src/test/java/com/shortkit/reactnative/ReactCarouselOverlayHostEmitTest.kt

@@ -0,0 +1,134 @@
+package com.shortkit.reactnative
+
+import android.content.Context
+import android.os.Bundle
+import android.view.ViewGroup
+import androidx.test.core.app.ApplicationProvider
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.interfaces.TaskInterface
+import com.facebook.react.interfaces.fabric.ReactSurface
+import com.shortkit.sdk.model.CarouselImage
+import com.shortkit.sdk.model.ImageCarouselItem
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import java.util.concurrent.TimeUnit
+
+/**
+ * Tests SHO-8 emit-on-change gating in ReactCarouselOverlayHost.
+ *
+ * Behavior under test (mirrors iOS ReactCarouselOverlayHost.swift:132-145):
+ *   - First configure() with item A → applySurfaceProps path; no emit.
+ *   - Second configure() with same item A → no emit, no setProperties.
+ *   - Second configure() with different item B → emit onCarouselItemChanged
+ *     with payload { surfaceId, item, isActive: false, activeImageIndex: 0 }.
+ */
+@RunWith(RobolectricTestRunner::class)
+class ReactCarouselOverlayHostEmitTest {
+
+    /** No-op TaskInterface returned by stub surface lifecycle methods. */
+    private object NoOpTask : TaskInterface<Void> {
+        override fun waitForCompletion() = Unit
+        override fun waitForCompletion(duration: Long, timeUnit: TimeUnit): Boolean = true
+        override fun getResult(): Void? = null
+        override fun getError(): Exception? = null
+        override fun isCompleted(): Boolean = true
+        override fun isCancelled(): Boolean = false
+        override fun isFaulted(): Boolean = false
+    }
+
+    /**
+     * Minimal ReactSurface stub for Robolectric tests. ApplicationProvider does
+     * not supply a ReactApplication, so createSurfaceIfNeeded() would normally
+     * fail silently with reactHost == null. The createSurface seam lets tests
+     * inject this stub so surface != null after pushProps(), allowing
+     * hasPushedInitialProps to flip correctly (the bug-fix gate under test).
+     *
+     * isRunning is false so applySurfaceProps() calls start() (no-op here) and
+     * the updateInitProps cast to ReactSurfaceImpl is a safe no-op via `as?`.
+     */
+    private class StubReactSurface(private val ctx: Context) : ReactSurface {
+        override val surfaceID: Int = 0
+        override val moduleName: String = "StubSurface"
+        override val isRunning: Boolean = false
+        override val view: ViewGroup? = null
+        override val context: Context get() = ctx
+        override fun prerender(): TaskInterface<Void> = NoOpTask
+        override fun start(): TaskInterface<Void> = NoOpTask
+        override fun stop(): TaskInterface<Void> = NoOpTask
+        override fun clear() = Unit
+        override fun detach() = Unit
+    }
+
+    private fun makeHost(): ReactCarouselOverlayHost {
+        val ctx = ApplicationProvider.getApplicationContext<Context>()
+        return ReactCarouselOverlayHost(ctx).also {
+            // JavaOnlyMap is a pure-Java WritableMap that avoids the JNI init
+            // requirement of WritableNativeMap in Robolectric unit tests.
+            it.createMap = { com.facebook.react.bridge.JavaOnlyMap() }
+            // Inject a stub surface so createSurfaceIfNeeded() succeeds and
+            // hasPushedInitialProps flips after the first configure().
+            it.createSurface = { _, _ -> StubReactSurface(ctx) }
+        }
+    }
+
+    private fun item(id: String) = ImageCarouselItem(
+        id = id,
+        images = listOf(CarouselImage(url = "https://example.com/a.jpg", alt = null)),
+    )
+
+    @Test
+    fun firstConfigureSetsHasPushedAndCurrentItemNoEmit() {
+        val host = makeHost()
+        val emitted = mutableListOf<Pair<String, WritableMap>>()
+        host.emitEvent = { name, params -> emitted.add(name to params) }
+
+        host.configure(item("A"))
+
+        assertEquals("A", host.currentItemId)
+        assertTrue(host.hasPushedInitialProps)
+        assertTrue("first mount must not emit", emitted.isEmpty())
+    }
+
+    @Test
+    fun sameItemConfigureIsNoOpAfterFirstMount() {
+        val host = makeHost()
+        host.configure(item("A"))
+        val emitted = mutableListOf<Pair<String, WritableMap>>()
+        host.emitEvent = { name, params -> emitted.add(name to params) }
+
+        host.configure(item("A"))
+
+        assertEquals("A", host.currentItemId)
+        assertTrue("same item must not emit", emitted.isEmpty())
+    }
+
+    @Test
+    fun differentItemEmitsCarouselItemChanged() {
+        val host = makeHost()
+        host.configure(item("A"))
+        val emitted = mutableListOf<Pair<String, WritableMap>>()
+        host.emitEvent = { name, params -> emitted.add(name to params) }
+
+        host.configure(item("B"))
+
+        assertEquals("B", host.currentItemId)
+        assertEquals(1, emitted.size)
+        assertEquals("onCarouselItemChanged", emitted[0].first)
+        val params = emitted[0].second
+        assertEquals(host.surfaceId, params.getString("surfaceId"))
+        assertFalse(params.getBoolean("isActive"))
+        assertEquals(0, params.getInt("activeImageIndex"))
+        // `item` is a JSON string of the ImageCarouselItem; assert it contains
+        // the new id. Payload-shape correctness is covered by the cross-platform
+        // JS subscriber's destructuring, not asserted here.
+        val itemJson = params.getString("item")
+        assertTrue(
+            "item JSON should contain id=B but was: $itemJson",
+            itemJson?.contains("\"id\":\"B\"") == true,
+        )
+    }
+}

package/android/src/test/java/com/shortkit/reactnative/ReactOverlayHostDragTest.kt

@@ -0,0 +1,45 @@
+package com.shortkit.reactnative
+
+import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertFalse
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Tests SHO-9 drag-phase field on ReactOverlayHost.
+ * The full state-machine wiring (flow → field, emissions gated, full
+ * state on settle) is verified via the manual / instrumented test in
+ * the spec test plan. This test verifies the field's existence and
+ * resettability via configure().
+ */
+@RunWith(RobolectricTestRunner::class)
+class ReactOverlayHostDragTest {
+
+    private fun makeHost() = ReactOverlayHost(
+        ApplicationProvider.getApplicationContext()
+    )
+
+    @Test
+    fun isDraggingDefaultsFalse() {
+        val host = makeHost()
+        assertFalse(host.isDragging)
+    }
+
+    @Test
+    fun configureResetsIsDragging() {
+        val host = makeHost()
+        host.isDraggingForTest = true
+        host.configure(makeContentItem("A"))
+        assertFalse(host.isDragging)
+    }
+
+    private fun makeContentItem(id: String) = com.shortkit.sdk.model.ContentItem(
+        id = id,
+        title = "t",
+        duration = 5.0,
+        streamingUrl = "https://example.com/$id.m3u8",
+        thumbnailUrl = "https://example.com/$id.jpg",
+        captionTracks = emptyList(),
+    )
+}

package/android/src/test/java/com/shortkit/reactnative/ReactVideoCarouselOverlayHostDragTest.kt

@@ -0,0 +1,69 @@
+package com.shortkit.reactnative
+
+import androidx.test.core.app.ApplicationProvider
+import com.facebook.react.bridge.JavaOnlyMap
+import com.shortkit.sdk.model.VideoCarouselItem
+import org.junit.Assert.assertFalse
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Tests SHO-9 drag-phase field on ReactVideoCarouselOverlayHost.
+ * The full state-machine wiring requires a ShortKitPlayer instance with
+ * controllable flows; verified via manual / instrumented testing per the
+ * spec test plan. This test verifies the field's existence and reset
+ * behavior on configure().
+ *
+ * configure() always calls emitItemChanged(), so the createMap and
+ * createSurface seams must be injected here too (same as the emit test).
+ */
+@RunWith(RobolectricTestRunner::class)
+class ReactVideoCarouselOverlayHostDragTest {
+
+    private fun makeHost(): ReactVideoCarouselOverlayHost {
+        val host = ReactVideoCarouselOverlayHost(ApplicationProvider.getApplicationContext())
+        host.createMap = { JavaOnlyMap() }
+        // Stub surface so hasPushedInitialProps can flip and configure()
+        // doesn't retry on every call due to null surface.
+        host.createSurface = { _, _ ->
+            // Re-use the same stub shape from the emit test — no-arg style.
+            object : com.facebook.react.interfaces.fabric.ReactSurface {
+                override val surfaceID: Int = 0
+                override val moduleName: String = "StubSurface"
+                override val isRunning: Boolean = false
+                override val view: android.view.ViewGroup? = null
+                override val context: android.content.Context
+                    get() = ApplicationProvider.getApplicationContext()
+                override fun prerender() = object : com.facebook.react.interfaces.TaskInterface<Void> {
+                    override fun waitForCompletion() = Unit
+                    override fun waitForCompletion(d: Long, u: java.util.concurrent.TimeUnit) = true
+                    override fun getResult(): Void? = null
+                    override fun getError(): Exception? = null
+                    override fun isCompleted() = true
+                    override fun isCancelled() = false
+                    override fun isFaulted() = false
+                }
+                override fun start() = prerender()
+                override fun stop() = prerender()
+                override fun clear() = Unit
+                override fun detach() = Unit
+            }
+        }
+        return host
+    }
+
+    @Test
+    fun isDraggingDefaultsFalse() {
+        val host = makeHost()
+        assertFalse(host.isDragging)
+    }
+
+    @Test
+    fun configureResetsIsDragging() {
+        val host = makeHost()
+        host.isDraggingForTest = true
+        host.configure(VideoCarouselItem(id = "A", videos = emptyList()))
+        assertFalse(host.isDragging)
+    }
+}