@shortkitsdk/react-native 0.2.32 → 0.2.34

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

@@ -59,6 +59,8 @@ class ShortKitBridge(
     clientAppVersion: String?,
     customDimensionsJSON: String?,
     debugPanel: Boolean,
+    serverTracingEnabled: Boolean,
+    consoleTracingEnabled: Boolean,
     private val emitEvent: (String, WritableMap) -> Unit
 ) {
 
@@ -516,7 +518,9 @@ class ShortKitBridge(
             clientAppName = clientAppName,
             clientAppVersion = clientAppVersion,
             customDimensions = dims,
-            debugPanelEnabled = debugPanel
+            debugPanelEnabled = debugPanel,
+            serverTracingEnabled = serverTracingEnabled,
+            consoleTracingEnabled = consoleTracingEnabled
         )
         this.shortKit = sdk
         shared = this
@@ -778,22 +782,22 @@ class ShortKitBridge(
     // Custom feed operations
     // ------------------------------------------------------------------
 
-    fun setFeedItems(feedId: String, itemsJSON: String) {
+    fun setFeedItems(feedId: String, itemsJSON: String, startAtId: String?) {
         val fragment = feedFragment(feedId)
         if (fragment != null) {
             val parsed = parseFeedInputs(itemsJSON) ?: return
             Handler(Looper.getMainLooper()).post {
-                fragment.setFeedItems(parsed)
+                fragment.setFeedItems(parsed, startAtId)
             }
         } else {
             synchronized(pendingOpsLock) {
                 pendingOps.getOrPut(feedId) { mutableListOf() }.add { frag ->
                     val parsed = parseFeedInputs(itemsJSON) ?: return@add
                     if (Looper.myLooper() == Looper.getMainLooper()) {
-                        frag.setFeedItems(parsed)
+                        frag.setFeedItems(parsed, startAtId)
                     } else {
                         Handler(Looper.getMainLooper()).post {
-                            frag.setFeedItems(parsed)
+                            frag.setFeedItems(parsed, startAtId)
                         }
                     }
                 }
@@ -801,6 +805,23 @@ class ShortKitBridge(
         }
     }
 
+    fun scrollFeedToItem(feedId: String, id: String, animated: Boolean) {
+        val fragment = feedFragment(feedId)
+        if (fragment != null) {
+            Handler(Looper.getMainLooper()).post {
+                fragment.scrollToItem(id, animated)
+            }
+        } else {
+            synchronized(pendingOpsLock) {
+                pendingOps.getOrPut(feedId) { mutableListOf() }.add { frag ->
+                    Handler(Looper.getMainLooper()).post {
+                        frag.scrollToItem(id, animated)
+                    }
+                }
+            }
+        }
+    }
+
     fun appendFeedItems(feedId: String, itemsJSON: String) {
         val fragment = feedFragment(feedId)
         if (fragment != null) {

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

@@ -72,7 +72,9 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
         clientAppName: String?,
         clientAppVersion: String?,
         customDimensions: String?,
-        debugPanel: Boolean?
+        debugPanel: Boolean?,
+        serverTracingEnabled: Boolean?,
+        consoleTracingEnabled: Boolean?
     ) {
         bridge?.teardown()
         bridge = null
@@ -88,6 +90,8 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
                 clientAppVersion = clientAppVersion,
                 customDimensionsJSON = customDimensions,
                 debugPanel = debugPanel ?: false,
+                serverTracingEnabled = serverTracingEnabled ?: false,
+                consoleTracingEnabled = consoleTracingEnabled ?: false,
                 emitEvent = { name, body -> sendEvent(name, body) }
             )
 
@@ -191,12 +195,22 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
     // -----------------------------------------------------------------
 
     @ReactMethod
-    override fun setFeedItems(feedId: String, items: String) {
+    override fun setFeedItems(feedId: String, items: String, startAtId: String?) {
         val b = bridge
         if (b != null) {
-            b.setFeedItems(feedId, items)
+            b.setFeedItems(feedId, items, startAtId)
         } else {
-            bufferOp { bridge?.setFeedItems(feedId, items) }
+            bufferOp { bridge?.setFeedItems(feedId, items, startAtId) }
+        }
+    }
+
+    @ReactMethod
+    override fun scrollFeedToItem(feedId: String, id: String, animated: Boolean) {
+        val b = bridge
+        if (b != null) {
+            b.scrollFeedToItem(feedId, id, animated)
+        } else {
+            bufferOp { bridge?.scrollFeedToItem(feedId, id, animated) }
         }
     }
 
@@ -274,7 +288,7 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
     // -----------------------------------------------------------------
 
     @ReactMethod
-    override fun downloadVideo(itemId: String, mode: String, promise: Promise) {
+    override fun downloadVideo(itemId: String, mode: String, overlayMode: String, promise: Promise) {
         // TODO: PR 2 — wire to ShortKit.activeInstance.get().downloadVideo
         promise.reject("UNSUPPORTED", "downloadVideo not yet implemented on Android")
     }

package/ios/FeedMaskHostView.swift

@@ -0,0 +1,190 @@
+import UIKit
+import ShortKitSDK
+
+/// `UIView` that conforms to `FeedMask` and bridges to a host-supplied
+/// React component. Acts as the integration point between the SDK's
+/// UIKit `FeedMask` API and the RN component tree.
+///
+/// **Architecture: native feed region + RN-rendered chrome container.**
+/// Mirrors the layout of `swift_sdk/.../DailyMailFeedMask` exactly:
+///
+///   ┌──────────────────────────────┐
+///   │                              │
+///   │    `feedRegion` (native)     │  ← SDK embeds the feed VC here.
+///   │                              │
+///   ├──────────────────────────────┤
+///   │   `chromeContainer` (RN)     │  ← Host's JS mask renders here.
+///   └──────────────────────────────┘
+///
+/// `feedRegion` is a plain `UIView` instance property pinned to the
+/// top of the mask. The SDK's `FeedMaskContainerViewController.embedFeed`
+/// adds the feed VC's view to it via AutoLayout, identical to the
+/// native DM demo. Nothing covers the feed, so SDK touch routing,
+/// pull-to-dismiss, and the seamless modal-zoom transition all work
+/// out of the box.
+///
+/// `chromeContainer` is the lower sibling. We mount an
+/// `SKFabricSurfaceWrapper`-backed RN root inside it rendering the JS
+/// surface module `ShortKitFeedMask_<name>`. The host's component
+/// renders into chromeContainer's bounds — pure JS, no native bridge
+/// needed beyond this file.
+@objc public class FeedMaskHostView: UIView, @unchecked Sendable, FeedMask {
+
+    // MARK: - FeedMask conformance — public
+
+    /// Native UIView the SDK embeds the feed VC into. Pinned to the
+    /// top of the mask above `chromeContainer`.
+    public let feedRegion = UIView()
+
+    public func attach(player: ShortKitPlayer) {
+        self.attachedPlayer = player
+    }
+
+    public func configure(with item: ContentItem) {
+        pendingItem = item
+        guard let surf = surface, let json = Self.serializeItem(item) else { return }
+        surf.setProperties(["item": json])
+    }
+
+    public func activatePlayback() {
+        // v1: stub. Reserved for a future "playback active" event prop
+        // pushed to the JS surface if a host wires something up to it.
+    }
+
+    // MARK: - Configuration (set by the bridge factory closure)
+
+    /// Surface presenter for instantiating `RCTFabricSurface`.
+    var surfacePresenter: AnyObject?
+
+    /// JS module name for the Fabric surface, e.g.
+    /// `ShortKitFeedMask_viewStory`. The JS side's
+    /// `ShortKitFeedMaskSurface` registers under this name on
+    /// `<ShortKitPlayer>`/`<ShortKitWidget>` mount.
+    var feedMaskModuleName: String = "ShortKitFeedMask"
+
+    /// Height of the chrome container in points. v1: fixed default of
+    /// 96pt (matches the DM "View Story" pill demo). Future: expose as
+    /// part of the JS `feedMask` config so hosts can override per-mask.
+    var chromeHeight: CGFloat = 96
+
+    // MARK: - Internal state
+
+    private var surface: SKFabricSurfaceWrapper?
+    private var surfaceView: UIView?
+    private var pendingItem: ContentItem?
+    private weak var attachedPlayer: ShortKitPlayer?
+
+    /// Native chrome container — sibling of `feedRegion`, pinned to
+    /// the bottom of the mask. The RN root mounts INSIDE this
+    /// container, full-bleed within the chrome strip only.
+    private let chromeContainer: UIView = {
+        let v = UIView()
+        v.translatesAutoresizingMaskIntoConstraints = false
+        v.backgroundColor = .black
+        return v
+    }()
+
+    // MARK: - Init
+
+    public override init(frame: CGRect) {
+        super.init(frame: frame)
+        backgroundColor = .black
+
+        feedRegion.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(feedRegion)
+        addSubview(chromeContainer)
+
+        NSLayoutConstraint.activate([
+            feedRegion.topAnchor.constraint(equalTo: topAnchor),
+            feedRegion.leadingAnchor.constraint(equalTo: leadingAnchor),
+            feedRegion.trailingAnchor.constraint(equalTo: trailingAnchor),
+            feedRegion.bottomAnchor.constraint(equalTo: chromeContainer.topAnchor),
+
+            chromeContainer.leadingAnchor.constraint(equalTo: leadingAnchor),
+            chromeContainer.trailingAnchor.constraint(equalTo: trailingAnchor),
+            chromeContainer.bottomAnchor.constraint(equalTo: bottomAnchor),
+            chromeContainer.heightAnchor.constraint(equalToConstant: chromeHeight),
+        ])
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) { fatalError("init(coder:) is not supported") }
+
+    deinit {
+        surface?.stop()
+    }
+
+    // MARK: - Lifecycle
+
+    public override func didMoveToWindow() {
+        super.didMoveToWindow()
+        if window != nil, surface == nil {
+            installSurface()
+        }
+    }
+
+    private func installSurface() {
+        guard let presenter = surfacePresenter else { return }
+
+        let initialProps: [String: Any]
+        if let item = pendingItem, let json = Self.serializeItem(item) {
+            initialProps = ["item": json]
+        } else {
+            initialProps = [:]
+        }
+
+        guard let surf = SKFabricSurfaceWrapper(
+            presenter: presenter,
+            moduleName: feedMaskModuleName,
+            initialProperties: initialProps
+        ) else { return }
+        surf.start()
+
+        let view = surf.view
+        view.translatesAutoresizingMaskIntoConstraints = false
+        chromeContainer.addSubview(view)
+        NSLayoutConstraint.activate([
+            view.topAnchor.constraint(equalTo: chromeContainer.topAnchor),
+            view.leadingAnchor.constraint(equalTo: chromeContainer.leadingAnchor),
+            view.trailingAnchor.constraint(equalTo: chromeContainer.trailingAnchor),
+            view.bottomAnchor.constraint(equalTo: chromeContainer.bottomAnchor),
+        ])
+        surfaceView = view
+        surface = surf
+
+        let size = CGSize(width: bounds.width, height: chromeHeight)
+        if size.width > 0, size.height > 0 {
+            surf.setMinimumSize(size)
+        }
+    }
+
+    public override func layoutSubviews() {
+        super.layoutSubviews()
+        let size = CGSize(width: bounds.width, height: chromeHeight)
+        guard size.width > 0, size.height > 0 else { return }
+        surface?.setMinimumSize(size)
+    }
+
+    // MARK: - Helpers
+
+    /// JSON-serialize a `ContentItem` for the JS surface's `item` prop.
+    /// Mirrors the JS-side `deserializeContentItem` shape.
+    private static func serializeItem(_ item: ContentItem) -> String? {
+        var dict: [String: Any] = [
+            "id": item.id,
+            "title": item.title,
+            "duration": item.duration,
+            "streamingUrl": item.streamingUrl,
+            "thumbnailUrl": item.thumbnailUrl,
+            "captionTracks": [],
+        ]
+        if let pid = item.playbackId { dict["playbackId"] = pid }
+        if let desc = item.description { dict["description"] = desc }
+        if let author = item.author { dict["author"] = author }
+        if let articleUrl = item.articleUrl { dict["articleUrl"] = articleUrl }
+        if let fallbackUrl = item.fallbackUrl { dict["fallbackUrl"] = fallbackUrl }
+        guard let data = try? JSONSerialization.data(withJSONObject: dict),
+              let json = String(data: data, encoding: .utf8) else { return nil }
+        return json
+    }
+}

package/ios/ShortKitBridge.swift

@@ -903,6 +903,40 @@ import ShortKitSDK
         )
     }
 
+    /// Parse a double-stringified feed-mask JSON value into a
+    /// `FeedMaskMode`. The JS side serializes `config.feedMask` as
+    /// either `"\"none\""` or `{"type":"custom","name":"<name>"}` —
+    /// both shapes get a JSON-encoded string layer because they're
+    /// embedded inside the larger config string.
+    ///
+    /// On `.custom`, returns a factory closure that constructs a fresh
+    /// `FeedMaskHostView` per invocation. The host then wires up its
+    /// surface presenter + module name from the shared `ShortKitBridge`.
+    /// Multiple expansions create independent mask instances —
+    /// matches `ReactOverlayHost`'s closure pattern.
+    static func parseFeedMask(_ json: String?) -> FeedMaskMode {
+        guard let json,
+              let data = json.data(using: .utf8),
+              let parsed = try? JSONSerialization.jsonObject(with: data) else {
+            return .none
+        }
+        if let str = parsed as? String, str == "none" {
+            return .none
+        }
+        if let obj = parsed as? [String: Any],
+           let type = obj["type"] as? String,
+           type == "custom" {
+            let name = obj["name"] as? String ?? "Default"
+            return .custom { @Sendable @MainActor in
+                let host = FeedMaskHostView()
+                host.surfacePresenter = ShortKitBridge.shared?.surfacePresenter
+                host.feedMaskModuleName = "ShortKitFeedMask_\(name)"
+                return host
+            }
+        }
+        return .none
+    }
+
     /// Parse a double-stringified overlay JSON into a `VideoOverlayMode`.
     ///
     /// Examples:

package/ios/ShortKitPlayerNativeView.swift

@@ -32,10 +32,22 @@ import ShortKitSDK
         }
     }
 
+    /// JSON-serialized `FeedInput[]` used to seed the expanded feed when
+    /// the user taps and `clickAction == .feed`. See `ShortKitPlayerProps.feedItems`
+    /// in the JS layer for full semantics. The parsed list is forwarded
+    /// to the SDK via `ShortKitPlayerViewController.setFeedItems(_:)`.
+    @objc public var feedItems: String? {
+        didSet {
+            guard feedItems != oldValue else { return }
+            applyFeedItems()
+        }
+    }
+
     // MARK: - Child VC
 
     private var playerVC: ShortKitPlayerViewController?
     private var parsedConfig: PlayerConfig?
+    private var parsedFeedItems: [FeedInput] = []
 
     // MARK: - Lifecycle
 
@@ -93,6 +105,13 @@ import ShortKitSDK
             vc.configure(with: item)
         }
 
+        // Forward the host-provided expanded-feed seed list, if any.
+        // Set before the view loads so it's available the first time
+        // `openFeed()` runs — same ordering rationale as `configure(with:)`.
+        if !parsedFeedItems.isEmpty {
+            vc.setFeedItems(parsedFeedItems)
+        }
+
         parentVC.addChild(vc)
         vc.view.frame = bounds
         vc.view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
@@ -145,6 +164,18 @@ import ShortKitSDK
         playerVC?.configure(with: item)
     }
 
+    private func applyFeedItems() {
+        // Empty / nil JSON ⇒ clear the host seed.
+        guard let json = feedItems,
+              let items = ShortKitBridge.parseFeedInputs(json) else {
+            parsedFeedItems = []
+            playerVC?.setFeedItems([])
+            return
+        }
+        parsedFeedItems = items
+        playerVC?.setFeedItems(items)
+    }
+
     private func applyActive() {
         guard let vc = playerVC else { return }
         if active {

package/ios/ShortKitPlayerNativeViewManager.mm

@@ -24,5 +24,6 @@ RCT_EXPORT_MODULE(ShortKitPlayerView)
 RCT_EXPORT_VIEW_PROPERTY(config, NSString)
 RCT_EXPORT_VIEW_PROPERTY(contentItem, NSString)
 RCT_EXPORT_VIEW_PROPERTY(active, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(feedItems, NSString)
 
 @end

package/ios/ShortKitSDK.xcframework/ios-arm64/ShortKitSDK.framework/Info.plist

@@ -11,9 +11,9 @@
     <key>CFBundlePackageType</key>
     <string>FMWK</string>
     <key>CFBundleVersion</key>
-    <string>0.2.32</string>
+    <string>0.2.34</string>
     <key>CFBundleShortVersionString</key>
-    <string>0.2.32</string>
+    <string>0.2.34</string>
     <key>MinimumOSVersion</key>
     <string>16.0</string>
 </dict>