@sellwild/react-native-sdk 1.3.3 → 1.3.6

package/{ios/SellwildSDK-RN.podspec → SellwildSDK-RN.podspec}

@@ -1,15 +1,17 @@
 require 'json'
 
-package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
 
 Pod::Spec.new do |s|
   s.name             = 'SellwildSDK-RN'
   s.version          = package['version']
   s.summary          = 'React Native bridge for the Sellwild iOS SDK'
   s.description      = <<-DESC
-    Bridges <SellwildBanner> from @sellwild/react-native-sdk to the
-    native iOS SellwildAdView (Prebid Mobile + AdManagerBannerView).
-    There is no WebView in the ad path.
+    Bridges the @sellwild/react-native-sdk components to native iOS:
+      - <SellwildBanner> → SellwildAdView (Prebid Mobile + AdManagerBannerView)
+      - <SellwildFeed>   → SellwildFeedView (all-in-one COL1-scheduled
+                           feed of native listing cards + native ads)
+    There is no WebView in either path.
   DESC
 
   s.homepage         = 'https://github.com/Antengo/sellwild-sdk'
@@ -20,12 +22,12 @@ Pod::Spec.new do |s|
   s.platforms        = { :ios => '13.0' }
   s.swift_version    = '5.5'
 
-  s.source_files     = '*.{swift,m,h}'
+  s.source_files     = 'ios/*.{swift,m,h}'
   s.requires_arc     = true
 
   # The host app must already pull in SellwildSDK (the iOS SDK pod). We
   # depend on it explicitly so `pod install` resolves both with one
   # declaration in the host Podfile.
-  s.dependency 'SellwildSDK', '>= 1.3.0'
+  s.dependency 'SellwildSDK', '>= 1.3.5'
   s.dependency 'React-Core'
 end

package/android/build.gradle

@@ -64,5 +64,5 @@ dependencies {
     // The native SDK that owns SellwildAdView, SellwildPrebidMobile, etc.
     // Resolves to the published AAR off https://maven.sellwild.com/releases
     // for npm consumers, or to mavenLocal in the SDK monorepo dev workflow.
-    implementation "com.sellwild:sdk:1.3.2"
+    implementation "com.sellwild:sdk:1.3.5"
 }

package/android/src/main/java/com/sellwild/rnsdk/SellwildFeedViewManager.kt

@@ -0,0 +1,183 @@
+package com.sellwild.rnsdk
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.sellwild.sdk.SellwildConfig
+import com.sellwild.sdk.SellwildFeedView
+import com.sellwild.sdk.SellwildListing
+import com.sellwild.sdk.SellwildSDK
+import org.json.JSONObject
+
+/**
+ * Bridges the JS <SellwildFeed> component to the native
+ * com.sellwild.sdk.SellwildFeedView (all-in-one native feed: COL1-scheduled
+ * listing cards + Prebid + GAM ads, no WebView).
+ *
+ * Props (set from JS):
+ *   - config: object — the resolved SellwildConfig (from configure()).
+ *     The bridge re-runs the CDN decoder against `config.remote` so
+ *     feed-specific fields (COL1, bgColor, mobileZids, listingsUrl, …)
+ *     are populated identically to a native [SellwildSDK.configure] call.
+ *
+ * Events emitted to JS:
+ *   - onFeedLoaded
+ *   - onListingTap   { listing }
+ *   - onAdImpression { zoneId }
+ *   - onAdClicked    { zoneId }
+ *   - onFeedError    { message }
+ */
+class SellwildFeedViewManager : SimpleViewManager<SellwildFeedView>() {
+
+    override fun getName(): String = REACT_CLASS
+
+    /**
+     * Per-view scratch state. SellwildFeedView.setup() kicks off a network
+     * fetch + auctions for every COL1 ad slot, so we defer it to
+     * onAfterUpdateTransaction and skip re-applying on JS re-renders.
+     */
+    private val pending = java.util.WeakHashMap<SellwildFeedView, PendingProps>()
+
+    private data class PendingProps(
+        var config: ReadableMap? = null,
+        var lastAppliedKey: String? = null,
+    )
+
+    override fun createViewInstance(reactContext: ThemedReactContext): SellwildFeedView {
+        val view = SellwildFeedView(reactContext)
+        pending[view] = PendingProps()
+        view.listener = object : SellwildFeedView.Listener {
+            override fun onListingTap(listing: SellwildListing): Boolean {
+                val payload = Arguments.createMap().apply {
+                    putMap("listing", listingPayload(listing))
+                }
+                emit(reactContext, view, "onListingTap", payload)
+                // SDK still owns navigation (Custom Tabs); JS just observes.
+                return false
+            }
+
+            override fun onAdImpression(zoneId: String) {
+                val payload = Arguments.createMap().apply { putString("zoneId", zoneId) }
+                emit(reactContext, view, "onAdImpression", payload)
+            }
+
+            override fun onAdClicked(zoneId: String) {
+                val payload = Arguments.createMap().apply { putString("zoneId", zoneId) }
+                emit(reactContext, view, "onAdClicked", payload)
+            }
+
+            override fun onLoad() {
+                emit(reactContext, view, "onFeedLoaded", null)
+            }
+
+            override fun onError(message: String) {
+                val payload = Arguments.createMap().apply { putString("message", message) }
+                emit(reactContext, view, "onFeedError", payload)
+            }
+        }
+        return view
+    }
+
+    @ReactProp(name = "config")
+    fun setConfig(view: SellwildFeedView, value: ReadableMap?) {
+        pendingFor(view).config = value
+    }
+
+    override fun onAfterUpdateTransaction(view: SellwildFeedView) {
+        super.onAfterUpdateTransaction(view)
+
+        val p = pending[view] ?: return
+        val configMap = p.config ?: return
+
+        val key = "${configMap.hashCode()}"
+        if (p.lastAppliedKey == key) return
+        p.lastAppliedKey = key
+
+        val config = configFromMap(configMap)
+        view.setup(config)
+        view.load()
+    }
+
+    override fun onDropViewInstance(view: SellwildFeedView) {
+        pending.remove(view)
+        super.onDropViewInstance(view)
+    }
+
+    private fun pendingFor(view: SellwildFeedView): PendingProps =
+        pending.getOrPut(view) { PendingProps() }
+
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> {
+        return MapBuilder.builder<String, Any>()
+            .put("onFeedLoaded", MapBuilder.of("registrationName", "onFeedLoaded"))
+            .put("onListingTap", MapBuilder.of("registrationName", "onListingTap"))
+            .put("onAdImpression", MapBuilder.of("registrationName", "onAdImpression"))
+            .put("onAdClicked", MapBuilder.of("registrationName", "onAdClicked"))
+            .put("onFeedError", MapBuilder.of("registrationName", "onFeedError"))
+            .build()
+    }
+
+    private fun emit(
+        context: ReactContext,
+        view: SellwildFeedView,
+        name: String,
+        payload: WritableMap?,
+    ) {
+        context.getJSModule(RCTEventEmitter::class.java)
+            .receiveEvent(view.id, name, payload)
+    }
+
+    companion object {
+        const val REACT_CLASS = "SellwildFeedView"
+
+        /**
+         * Build a full SellwildConfig from a JS map. The JS side passes the
+         * resolved CDN payload under `remote`; we re-run the canonical CDN
+         * decoder ([SellwildSDK.apply]) against it so feed-specific fields
+         * (COL1, bgColor, mobileZids, listingsUrl, …) land identically to a
+         * native [SellwildSDK.configure] call. Explicit JS overrides
+         * (e.g. appBundleId from the host app) win.
+         */
+        internal fun configFromMap(map: ReadableMap): SellwildConfig {
+            val partnerCode = if (map.hasKey("partnerCode")) map.getString("partnerCode") ?: "" else ""
+
+            var config = SellwildConfig(partnerCode = partnerCode)
+
+            // Apply the raw CDN payload first.
+            if (map.hasKey("remote") && !map.isNull("remote")) {
+                val remoteMap = map.getMap("remote")!!.toHashMap()
+                val remoteJson = JSONObject(remoteMap)
+                config = SellwildSDK.apply(remoteJson, config).copy(
+                    remoteJson = remoteJson.toString()
+                )
+            }
+
+            // JS-side overrides.
+            if (map.hasKey("appBundleId")) config = config.copy(appBundleId = map.getString("appBundleId"))
+            if (map.hasKey("appStoreUrl")) config = config.copy(appStoreUrl = map.getString("appStoreUrl"))
+            if (map.hasKey("gamTag")) config = config.copy(gamTag = map.getString("gamTag"))
+            if (map.hasKey("debug")) config = config.copy(debug = map.getBoolean("debug"))
+            if (map.hasKey("adRefreshMax")) config = config.copy(adRefreshMax = map.getInt("adRefreshMax"))
+            if (map.hasKey("adRefreshMaxMobile")) config = config.copy(adRefreshMaxMobile = map.getInt("adRefreshMaxMobile"))
+            if (map.hasKey("adRefreshIntervalMs")) config = config.copy(adRefreshIntervalMs = map.getDouble("adRefreshIntervalMs").toLong())
+
+            return config
+        }
+
+        /** Surface the listing payload to JS. Mirrors `SellwildListing` in @sellwild/sdk-core. */
+        internal fun listingPayload(listing: SellwildListing): WritableMap = Arguments.createMap().apply {
+            putString("id", listing.id)
+            putString("title", listing.title)
+            listing.url?.let { putString("url", it) }
+            listing.currency?.let { putString("currency", it) }
+            listing.price?.let { putString("price", it) }
+            listing.remoteUrl?.let { putString("remoteUrl", it) }
+            listing.primaryPhotoUrl?.let { putString("photoUrl", it) }
+        }
+    }
+}

package/android/src/main/java/com/sellwild/rnsdk/SellwildSdkPackage.kt

@@ -14,5 +14,6 @@ class SellwildSdkPackage : ReactPackage {
         reactContext: ReactApplicationContext,
     ): List<ViewManager<out View, out ReactShadowNode<*>>> = listOf(
         SellwildBannerViewManager(),
+        SellwildFeedViewManager(),
     )
 }

package/ios/SellwildFeedViewManager.m

@@ -0,0 +1,23 @@
+#import <React/RCTViewManager.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTBridgeModule.h>
+
+// Register the view manager class with React Native. We export it under
+// the JS name "SellwildFeedView" to match the Android side
+// (com.sellwild.rnsdk.SellwildFeedViewManager.REACT_CLASS).
+@interface RCT_EXTERN_REMAP_MODULE(SellwildFeedView,
+                                   SellwildFeedViewManager,
+                                   RCTViewManager)
+
+// Props set from JS — these forward to @objc properties on
+// SellwildFeedHostView.
+RCT_EXPORT_VIEW_PROPERTY(config, NSDictionary)
+
+// Direct events emitted to JS callbacks.
+RCT_EXPORT_VIEW_PROPERTY(onFeedLoaded, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onListingTap, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onAdImpression, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onAdClicked, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onFeedError, RCTDirectEventBlock)
+
+@end

package/ios/SellwildFeedViewManager.swift

@@ -0,0 +1,200 @@
+import Foundation
+import React
+import SellwildSDK
+import UIKit
+
+/// Bridges the JS `<SellwildFeed>` component to the native
+/// `SellwildFeedView` (all-in-one native feed: COL1-scheduled listing
+/// cards + Prebid + GAM ads, zero WebView). Mirrors the Android
+/// `SellwildFeedViewManager` shape.
+///
+/// Props (set from JS):
+///   - config: object — the resolved SellwildConfig (from configure()).
+///       The bridge re-runs the CDN decoder against `config.remote` so
+///       feed-specific fields (COL1, bgColor, mobileZids, …) are
+///       populated even though they're not all typed on the JS side.
+///
+/// Events emitted to JS:
+///   - onFeedLoaded
+///   - onListingTap   { listing }
+///   - onAdImpression { zoneId }
+///   - onAdClicked    { zoneId }
+///   - onFeedError    { message }
+@objc(SellwildFeedViewManager)
+public final class SellwildFeedViewManager: RCTViewManager {
+
+    public override static func requiresMainQueueSetup() -> Bool { true }
+
+    public override func view() -> UIView! {
+        return SellwildFeedHostView()
+    }
+}
+
+/// Hosts a `SellwildFeedView`. We can't construct the feed until the
+/// `config` prop has arrived, so we cache it and apply on
+/// `didSetProps:` — same pattern as the banner host view.
+final class SellwildFeedHostView: UIView, SellwildFeedViewDelegate {
+
+    // MARK: RN-set props
+
+    @objc var config: NSDictionary? { didSet { needsApply = true } }
+
+    // MARK: RN events
+
+    @objc var onFeedLoaded: RCTDirectEventBlock?
+    @objc var onListingTap: RCTDirectEventBlock?
+    @objc var onAdImpression: RCTDirectEventBlock?
+    @objc var onAdClicked: RCTDirectEventBlock?
+    @objc var onFeedError: RCTDirectEventBlock?
+
+    // MARK: Internals
+
+    private var feedView: SellwildFeedView?
+    private var lastAppliedKey: String?
+    private var needsApply: Bool = false
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+    }
+
+    required init?(coder: NSCoder) { fatalError("init(coder:) not used") }
+
+    override func didSetProps(_ changedProps: [String]) {
+        guard needsApply else { return }
+        needsApply = false
+        applyIfReady()
+    }
+
+    private func applyIfReady() {
+        guard let cfgMap = config else { return }
+
+        // Skip if the props identity hasn't changed since last apply.
+        // Feed refresh is driven by user pull-to-refresh, not JS
+        // re-renders.
+        let key = "\(cfgMap.hash)"
+        if lastAppliedKey == key { return }
+        lastAppliedKey = key
+
+        let sellwildConfig = Self.configFromMap(cfgMap)
+
+        // Tear down any previous feed view; SellwildFeedView holds its
+        // own table state and we want a clean fetch on identity change.
+        feedView?.removeFromSuperview()
+
+        let view = SellwildFeedView(config: sellwildConfig)
+        view.delegate = self
+        view.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(view)
+        NSLayoutConstraint.activate([
+            view.leadingAnchor.constraint(equalTo: leadingAnchor),
+            view.trailingAnchor.constraint(equalTo: trailingAnchor),
+            view.topAnchor.constraint(equalTo: topAnchor),
+            view.bottomAnchor.constraint(equalTo: bottomAnchor),
+        ])
+        feedView = view
+        view.load()
+    }
+
+    // MARK: SellwildFeedViewDelegate
+
+    func sellwildFeedDidLoad(_ feed: SellwildFeedView) {
+        onFeedLoaded?([:])
+    }
+
+    func sellwildFeed(_ feed: SellwildFeedView, didTapListing listing: SellwildListing) -> Bool {
+        // Forward the listing payload to JS as a plain dictionary. JS
+        // can't return a value back through a direct event block, so
+        // the SDK still owns whether to open the URL in
+        // SFSafariViewController. Partners who want to fully consume
+        // the tap can subclass via `useNativeNavigation` later;
+        // current behaviour matches the WebView widget (always opens
+        // in in-app browser) so there's no regression.
+        let payload = Self.listingPayload(listing)
+        onListingTap?(["listing": payload])
+        return false
+    }
+
+    func sellwildFeed(_ feed: SellwildFeedView, didRecordAdImpressionForZoneId zoneId: String) {
+        onAdImpression?(["zoneId": zoneId])
+    }
+
+    func sellwildFeed(_ feed: SellwildFeedView, didRecordAdClickForZoneId zoneId: String) {
+        onAdClicked?(["zoneId": zoneId])
+    }
+
+    func sellwildFeed(_ feed: SellwildFeedView, didFailWithError message: String) {
+        onFeedError?(["message": message])
+    }
+
+    // MARK: Config marshalling
+
+    /// Build a full SellwildConfig from a JS dictionary. The JS side
+    /// passes the raw CDN payload under `remote`; we re-run the
+    /// canonical CDN decoder against it so feed-specific fields (COL1,
+    /// bgColor, mobileZids, listingsUrl, …) are populated identically
+    /// to a native `SellwildSDK.configure(...)` call.
+    static func configFromMap(_ map: NSDictionary) -> SellwildConfig {
+        let partnerCode = (map["partnerCode"] as? String) ?? ""
+        var cfg = SellwildConfig(partnerCode: partnerCode)
+
+        // Apply the raw CDN payload first so explicit JS overrides
+        // (e.g. appBundleId from the host app) win.
+        if let remote = map["remote"] as? [String: Any] {
+            cfg = SellwildSDK.apply(remote, to: cfg)
+            if let data = try? JSONSerialization.data(withJSONObject: remote, options: []) {
+                cfg.remoteJSON = data
+            }
+        }
+
+        if let v = map["slug"] as? String { cfg.slug = v }
+        if let v = map["appBundleId"] as? String { cfg.appBundleId = v }
+        if let v = map["appStoreUrl"] as? String { cfg.appStoreUrl = v }
+        if let v = map["gamTag"] as? String { cfg.gamTag = v }
+        if let v = map["debug"] as? Bool { cfg.debug = v }
+        if let v = map["adRefreshMax"] as? Int { cfg.adRefreshMax = v }
+        if let v = map["adRefreshMaxMobile"] as? Int { cfg.adRefreshMaxMobile = v }
+        if let v = map["listingsUrl"] as? String { cfg.listingsUrl = v }
+        if let v = map["priceColor"] as? String { cfg.priceColor = v }
+        if let v = map["bannerZid"] as? String { cfg.bannerZid = v }
+        if let v = map["bottomBannerZid"] as? String { cfg.bottomBannerZid = v }
+        if let v = map["mobileBannerZid"] as? String { cfg.mobileBannerZid = v }
+        if let v = map["mobileZids"] as? [String] { cfg.mobileZids = v }
+
+        // JS bridge passes ms; iOS API is seconds (TimeInterval).
+        if let v = map["adRefreshIntervalMs"] as? NSNumber {
+            cfg.adRefreshInterval = v.doubleValue / 1000.0
+        }
+
+        if let prebid = map["prebidServer"] as? NSDictionary,
+           let accountId = prebid["accountId"] as? String,
+           let endpoint = prebid["endpoint"] as? String {
+            let bidders = (prebid["bidders"] as? [String]) ?? []
+            let timeout = (prebid["timeout"] as? Int) ?? 1500
+            cfg.prebidServer = PrebidServerConfig(
+                accountId: accountId,
+                endpoint: endpoint,
+                bidders: bidders,
+                timeout: timeout,
+                syncEndpoint: prebid["syncEndpoint"] as? String
+            )
+        }
+
+        return cfg
+    }
+
+    /// Serialize a SellwildListing to a JS-friendly dictionary. Surfaces
+    /// the fields the JS callback is most likely to act on; the rest
+    /// can be added on demand.
+    static func listingPayload(_ listing: SellwildListing) -> [String: Any] {
+        var dict: [String: Any] = [
+            "id": listing.id,
+            "title": listing.title,
+        ]
+        if let v = listing.url { dict["url"] = v }
+        if let v = listing.currency { dict["currency"] = v }
+        if let v = listing.price { dict["price"] = v }
+        if let v = listing.remoteUrl { dict["remoteUrl"] = v }
+        if let firstPhoto = listing.photos?.first?.url { dict["photoUrl"] = firstPhoto }
+        return dict
+    }
+}

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@sellwild/react-native-sdk",
-  "version": "1.3.3",
+  "version": "1.3.6",
   "description": "Sellwild mobile advertising SDK for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",
   "files": [
     "src",
-    "android",
-    "ios"
+    "android/build.gradle",
+    "android/src/**/*",
+    "ios/*.swift",
+    "ios/*.m",
+    "ios/*.h",
+    "SellwildSDK-RN.podspec"
   ],
   "keywords": [
     "react-native",

package/src/SellwildFeed.tsx

@@ -0,0 +1,174 @@
+import React from 'react'
+import {
+  Platform,
+  requireNativeComponent,
+  StyleProp,
+  StyleSheet,
+  Text,
+  UIManager,
+  View,
+  ViewStyle,
+  NativeSyntheticEvent,
+} from 'react-native'
+import type { SellwildConfig, SellwildListing } from '@sellwild/sdk-core'
+
+// ─── Native component bridge ─────────────────────────────────────────────────
+//
+// SellwildFeed is the "all-in-one" native surface: a single-column scroll
+// of native listing cards interleaved with native Prebid + GAM ads,
+// scheduled by the CDN-published COL1 token string. There is **no
+// WebView** in this surface — every row is native on both platforms.
+//
+// iOS:     SellwildFeedView (UITableView-backed)
+// Android: com.sellwild.sdk.SellwildFeedView (RecyclerView-backed)
+//
+// This component is the drop-in native replacement for the WebView-based
+// <SellwildWidget>. Same one-component integration shape; native rails.
+
+const NATIVE_NAME = 'SellwildFeedView'
+
+interface NativeFeedProps {
+  config: object
+  style?: StyleProp<ViewStyle>
+  onFeedLoaded?: (e: NativeSyntheticEvent<{}>) => void
+  onListingTap?: (e: NativeSyntheticEvent<{ listing: SellwildListing }>) => void
+  onAdImpression?: (e: NativeSyntheticEvent<{ zoneId: string }>) => void
+  onAdClicked?: (e: NativeSyntheticEvent<{ zoneId: string }>) => void
+  onFeedError?: (e: NativeSyntheticEvent<{ message: string }>) => void
+}
+
+const NativeFeed = (() => {
+  // requireNativeComponent crashes loudly if the view manager isn't
+  // registered. Probe first so we can render a friendly fallback on
+  // platforms where the bridge isn't in this build yet.
+  const config = UIManager.getViewManagerConfig?.(NATIVE_NAME)
+  if (!config) {
+    return null
+  }
+  return requireNativeComponent<NativeFeedProps>(NATIVE_NAME)
+})()
+
+// ─── Public component ────────────────────────────────────────────────────────
+
+export interface SellwildFeedProps {
+  /**
+   * Resolved Sellwild config from `configure()`. The native feed reads
+   * the COL1 schedule, listings URL, ad zones, and theme out of this.
+   */
+  config: SellwildConfig
+
+  /** Optional style override. The feed expands to its container by default. */
+  style?: ViewStyle
+
+  /** Fired once after the initial listings fetch resolves successfully. */
+  onLoad?: () => void
+
+  /**
+   * Fired when a listing card is tapped. Return `true` to consume the
+   * event; return `false` (or omit) to let the SDK open `listing.url`
+   * in the platform in-app browser (Custom Tabs / SFSafariViewController).
+   */
+  onListingTap?: (listing: SellwildListing) => boolean | void
+
+  /** Fired when a native ad row records an impression. */
+  onAdImpression?: (zoneId: string) => void
+
+  /** Fired when a native ad row is clicked. */
+  onAdClicked?: (zoneId: string) => void
+
+  /** Fired when the listings fetch fails or a row fails to render. */
+  onError?: (error: Error) => void
+}
+
+export function SellwildFeed({
+  config,
+  style,
+  onLoad,
+  onListingTap,
+  onAdImpression,
+  onAdClicked,
+  onError,
+}: SellwildFeedProps) {
+  if (!NativeFeed) {
+    // Native module not registered. Most common cause: the host app was
+    // built before the @sellwild/react-native-sdk autolink ran, or this
+    // is being rendered in a JS-only test environment.
+    return (
+      <View style={[styles.fill, style, __DEV__ ? styles.devPlaceholder : undefined]}>
+        {__DEV__ ? (
+          <Text style={styles.devText}>
+            Sellwild native feed not available on {Platform.OS} (yet)
+          </Text>
+        ) : null}
+      </View>
+    )
+  }
+
+  // Pass the fields the native feed reads, plus the raw CDN payload
+  // under `remote`. The native bridge re-runs the CDN decoder against
+  // `remote` to populate feed-specific fields (COL1 schedule, bgColor,
+  // mobileZids, mobileBannerZid, listingsUrl), so we don't need to
+  // mirror every field as a typed property on the JS side.
+  //
+  // Note: TS core uses `adRefreshInterval` (ms); the native side
+  // reads it as `adRefreshIntervalMs`. The bridge translates.
+  const nativeConfig: Record<string, unknown> = {
+    partnerCode: config.partnerCode,
+    slug: config.slug,
+    appBundleId: config.appBundleId,
+    appStoreUrl: config.appStoreUrl,
+    gamTag: config.gamTag,
+    debug: config.debug,
+    adRefreshMax: config.adRefreshMax,
+    adRefreshMaxMobile: config.adRefreshMaxMobile,
+    adRefreshIntervalMs: config.adRefreshInterval,
+    prebidServer: config.prebidServer,
+    remote: config.remote,
+    listingsUrl: config.listingsUrl,
+    priceColor: config.priceColor,
+    bannerZid: config.bannerZid,
+    bottomBannerZid: config.bottomBannerZid,
+    mobileBannerZid: config.mobileBannerZid,
+    mobileZids: config.mobileZids,
+  }
+
+  return (
+    <NativeFeed
+      style={[styles.fill, style]}
+      config={nativeConfig}
+      onFeedLoaded={() => onLoad?.()}
+      onListingTap={(e: NativeSyntheticEvent<{ listing: SellwildListing }>) => {
+        onListingTap?.(e.nativeEvent.listing)
+      }}
+      onAdImpression={(e: NativeSyntheticEvent<{ zoneId: string }>) => {
+        onAdImpression?.(e.nativeEvent.zoneId)
+      }}
+      onAdClicked={(e: NativeSyntheticEvent<{ zoneId: string }>) => {
+        onAdClicked?.(e.nativeEvent.zoneId)
+      }}
+      onFeedError={(e: NativeSyntheticEvent<{ message: string }>) => {
+        const msg = e.nativeEvent?.message ?? 'Feed failed'
+        onError?.(new Error(msg))
+      }}
+    />
+  )
+}
+
+const styles = StyleSheet.create({
+  fill: {
+    flex: 1,
+  },
+  devPlaceholder: {
+    backgroundColor: '#FEE2E2',
+    borderWidth: 1,
+    borderColor: '#FCA5A5',
+    alignItems: 'center',
+    justifyContent: 'center',
+    padding: 12,
+  },
+  devText: {
+    color: '#991B1B',
+    fontSize: 12,
+    textAlign: 'center',
+  },
+})

package/src/index.ts

@@ -4,6 +4,9 @@ export type { SellwildWidgetProps } from './SellwildWidget'
 export { SellwildBanner } from './SellwildBanner'
 export type { SellwildBannerProps } from './SellwildBanner'
 
+export { SellwildFeed } from './SellwildFeed'
+export type { SellwildFeedProps } from './SellwildFeed'
+
 export { SellwildListingCard } from './SellwildListingCard'
 export type { SellwildListingCardProps } from './SellwildListingCard'