@sellwild/react-native-sdk 1.7.3 → 1.8.0

package/README.md

@@ -5,7 +5,7 @@ Sellwild mobile advertising SDK for React Native. Server-side header bidding thr
 ## Install
 
 ```bash
-npm install @sellwild/react-native-sdk react-native-webview
+npm install @sellwild/react-native-sdk
 cd ios && pod install && cd ..
 ```
 
@@ -67,7 +67,7 @@ export default function App() {
 ## Components
 
 - **`SellwildBanner`** — Display ad (300x250, 320x50, 728x90)
-- **`SellwildWidget`** — Full marketplace widget with listings and ads
+- **`SellwildFeed`** — All-in-one native feed: listings interleaved with native ads
 - **`SellwildListingCard`** — Individual listing card component
 - **`useSellwildListings`** — Hook for fetching listings data
 

package/SellwildSDK-RN.podspec

@@ -28,6 +28,8 @@ Pod::Spec.new do |s|
   # 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.4.0'
+  # Floor tracks this package's version (lockstep releases): the bridge uses
+  # SellwildGeo / SellwildEid / prewarm, which older SellwildSDK pods lack.
+  s.dependency 'SellwildSDK', ">= #{package['version']}"
   s.dependency 'React-Core'
 end

package/android/build.gradle

@@ -76,7 +76,9 @@ 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.4.1"
+    // Keep in lockstep with the SDK release version: the bridge uses APIs
+    // (SellwildGeo, SellwildEid, SellwildSDK.prewarm) that older AARs lack.
+    implementation "com.sellwild:sdk:1.8.0"
 }
 
 // Force kotlin-stdlib down to the bridge's declared Kotlin version. The

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

@@ -1,5 +1,7 @@
 package com.sellwild.rnsdk
 
+import android.content.Context
+import android.view.View
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.common.MapBuilder
@@ -15,6 +17,32 @@ import com.sellwild.sdk.SellwildGrowthCodeConfig
 import com.sellwild.sdk.SellwildLocalizedListingsConfig
 import org.json.JSONObject
 
+/**
+ * React Native (Paper) only lays out views in its own shadow tree; the child
+ * views a native component adds itself — here the GAM/Prebid banner and the
+ * WebView the viewability tracker watches — are never measured or laid out, so
+ * they render 0-size and fail the impression viewability check
+ * (getWidth()>0 / getGlobalVisibleRect), which means NO viewable impression and
+ * NO burl fires. Re-run measure + layout on our RN-assigned bounds whenever a
+ * child requests layout (e.g. when the ad renders asynchronously). This is the
+ * standard RN native-view fix (react-native-webview/maps/video do the same).
+ * Not needed on iOS RN, which lays subviews out via Auto Layout constraints.
+ */
+internal class RnSellwildAdView(context: Context) : SellwildAdView(context) {
+    private val measureAndLayout = Runnable {
+        measure(
+            View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
+            View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY),
+        )
+        layout(left, top, right, bottom)
+    }
+
+    override fun requestLayout() {
+        super.requestLayout()
+        post(measureAndLayout)
+    }
+}
+
 /**
  * Bridges the JS <SellwildBanner> component to the native
  * com.sellwild.sdk.SellwildAdView.
@@ -62,10 +90,13 @@ class SellwildBannerViewManager : SimpleViewManager<SellwildAdView>() {
         // only call setup() + load() once per identity tuple. Refresh of
         // the rendered ad is driven by the SDK's internal timer.
         var lastAppliedKey: String? = null,
+        // Last applied config, compared by value. A hashCode() in the key is
+        // only a probabilistic match (collisions ⇒ a real change is skipped).
+        var lastAppliedConfig: Map<String, Any?>? = null,
     )
 
     override fun createViewInstance(reactContext: ThemedReactContext): SellwildAdView {
-        val view = SellwildAdView(reactContext)
+        val view = RnSellwildAdView(reactContext)
         pending[view] = PendingProps()
         view.listener = object : SellwildAdView.Listener {
             override fun onAdLoaded(adView: SellwildAdView) {
@@ -90,6 +121,13 @@ class SellwildBannerViewManager : SimpleViewManager<SellwildAdView>() {
                 emit(reactContext, adView, "onAdClicked", null)
             }
 
+            override fun onAdBlocked(adView: SellwildAdView, zoneId: String) {
+                val payload = com.facebook.react.bridge.Arguments.createMap().apply {
+                    putString("zoneId", zoneId)
+                }
+                emit(reactContext, adView, "onAdBlocked", payload)
+            }
+
             override fun onAdFailed(adView: SellwildAdView, message: String) {
                 val payload = com.facebook.react.bridge.Arguments.createMap().apply {
                     putString("message", message)
@@ -139,9 +177,11 @@ class SellwildBannerViewManager : SimpleViewManager<SellwildAdView>() {
         val adSize = adSizeFromLabel(sizeLabel) ?: return
 
         // Skip if the props identity hasn't changed since last apply.
-        val key = "$sizeLabel|$zoneId|${p.adStack}|${configMap.hashCode()}"
-        if (p.lastAppliedKey == key) return
+        val key = "$sizeLabel|$zoneId|${p.adStack}"
+        val configValue = configMap.toHashMap()
+        if (p.lastAppliedKey == key && p.lastAppliedConfig == configValue) return
         p.lastAppliedKey = key
+        p.lastAppliedConfig = configValue
 
         val config = configFromMap(configMap)
         // JS resolves the stack from config and passes it as the override so
@@ -171,6 +211,7 @@ class SellwildBannerViewManager : SimpleViewManager<SellwildAdView>() {
             .put("onAdClicked", MapBuilder.of("registrationName", "onAdClicked"))
             .put("onAdFailed", MapBuilder.of("registrationName", "onAdFailed"))
             .put("onAdResize", MapBuilder.of("registrationName", "onAdResize"))
+            .put("onAdBlocked", MapBuilder.of("registrationName", "onAdBlocked"))
             .build()
     }
 

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

@@ -1,8 +1,11 @@
 package com.sellwild.rnsdk
 
+import android.content.Context
+import android.view.View
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.common.MapBuilder
 import com.facebook.react.uimanager.SimpleViewManager
@@ -17,6 +20,29 @@ import com.sellwild.sdk.SellwildLocalizedListingsConfig
 import com.sellwild.sdk.SellwildSDK
 import org.json.JSONObject
 
+/**
+ * React Native (Paper) only lays out its own shadow-tree views; children a
+ * native component adds itself (the feed's RecyclerView + ad WebViews) are never
+ * measured/laid out, so they render 0-size and fail the impression viewability
+ * check — no viewable impression, no burl. Re-run measure + layout on our
+ * RN-assigned bounds whenever a child requests layout. Standard RN native-view
+ * fix; not needed on iOS RN (Auto Layout constraints handle it).
+ */
+internal class RnSellwildFeedView(context: Context) : SellwildFeedView(context) {
+    private val measureAndLayout = Runnable {
+        measure(
+            View.MeasureSpec.makeMeasureSpec(width, View.MeasureSpec.EXACTLY),
+            View.MeasureSpec.makeMeasureSpec(height, View.MeasureSpec.EXACTLY),
+        )
+        layout(left, top, right, bottom)
+    }
+
+    override fun requestLayout() {
+        super.requestLayout()
+        post(measureAndLayout)
+    }
+}
+
 /**
  * Bridges the JS <SellwildFeed> component to the native
  * com.sellwild.sdk.SellwildFeedView (all-in-one native feed: COL1-scheduled
@@ -27,6 +53,9 @@ import org.json.JSONObject
  *     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.
+ *   - scrollEnabled: bool — disable internal scrolling for embedding.
+ *   - consumeListingTaps: bool — when true the host owns listing taps; the
+ *     SDK does not open Custom Tabs.
  *
  * Events emitted to JS:
  *   - onFeedLoaded
@@ -48,11 +77,16 @@ class SellwildFeedViewManager : SimpleViewManager<SellwildFeedView>() {
 
     private data class PendingProps(
         var config: ReadableMap? = null,
-        var lastAppliedKey: String? = null,
+        // When true, listing taps are only forwarded to JS and the SDK does
+        // not open Custom Tabs. Read at tap time, so it applies live.
+        var consumeListingTaps: Boolean = false,
+        // Last applied config, compared by value. A hashCode() key is only a
+        // probabilistic match (collisions ⇒ a real config change is skipped).
+        var lastAppliedConfig: Map<String, Any?>? = null,
     )
 
     override fun createViewInstance(reactContext: ThemedReactContext): SellwildFeedView {
-        val view = SellwildFeedView(reactContext)
+        val view = RnSellwildFeedView(reactContext)
         pending[view] = PendingProps()
         view.listener = object : SellwildFeedView.Listener {
             override fun onListingTap(listing: SellwildListing): Boolean {
@@ -60,8 +94,10 @@ class SellwildFeedViewManager : SimpleViewManager<SellwildFeedView>() {
                     putMap("listing", listingPayload(listing))
                 }
                 emit(reactContext, view, "onListingTap", payload)
-                // SDK still owns navigation (Custom Tabs); JS just observes.
-                return false
+                // JS can't return a value through an (async) RN event, so the
+                // `consumeListingTaps` prop decides whether the SDK opens
+                // Custom Tabs (false, default) or leaves navigation to the host.
+                return pending[view]?.consumeListingTaps ?: false
             }
 
             override fun onAdImpression(zoneId: String) {
@@ -111,15 +147,20 @@ class SellwildFeedViewManager : SimpleViewManager<SellwildFeedView>() {
         view.scrollEnabled = value
     }
 
+    @ReactProp(name = "consumeListingTaps", defaultBoolean = false)
+    fun setConsumeListingTaps(view: SellwildFeedView, value: Boolean) {
+        pendingFor(view).consumeListingTaps = 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 configValue = configMap.toHashMap()
+        if (p.lastAppliedConfig == configValue) return
+        p.lastAppliedConfig = configValue
 
         val config = configFromMap(configMap)
         view.setup(config)
@@ -128,6 +169,9 @@ class SellwildFeedViewManager : SimpleViewManager<SellwildFeedView>() {
 
     override fun onDropViewInstance(view: SellwildFeedView) {
         pending.remove(view)
+        // RN unmounted the feed for good: stop its ad rows' refresh and release
+        // the Activity (detach alone doesn't when MOBILE_PAUSE_REFRESH_DETACHED=false).
+        view.destroy()
         super.onDropViewInstance(view)
     }
 
@@ -160,6 +204,23 @@ class SellwildFeedViewManager : SimpleViewManager<SellwildFeedView>() {
     companion object {
         const val REACT_CLASS = "SellwildFeedView"
 
+        /**
+         * A zone id from JS: a string, or a number (core config's default is
+         * `0`, meaning unset). `getString` throws on a number, so read either
+         * type. Returns null for missing, empty, or `0`.
+         */
+        internal fun zoneIdOrNull(map: ReadableMap, key: String): String? {
+            if (!map.hasKey(key) || map.isNull(key)) return null
+            val s = when (map.getType(key)) {
+                ReadableType.String -> map.getString(key)
+                ReadableType.Number -> map.getDouble(key).let { d ->
+                    if (d % 1.0 == 0.0) d.toLong().toString() else d.toString()
+                }
+                else -> null
+            }?.trim()
+            return s?.takeIf { it.isNotEmpty() && it != "0" }
+        }
+
         /**
          * Build a full SellwildConfig from a JS map. The JS side passes the
          * resolved CDN payload under `remote`; we re-run the canonical CDN
@@ -199,13 +260,13 @@ class SellwildFeedViewManager : SimpleViewManager<SellwildFeedView>() {
             if (map.hasKey("slug")) config = config.copy(slug = map.getString("slug") ?: config.slug)
             if (map.hasKey("listingsUrl")) config = config.copy(listingsUrl = map.getString("listingsUrl"))
             if (map.hasKey("priceColor")) config = config.copy(priceColor = map.getString("priceColor") ?: config.priceColor)
-            if (map.hasKey("bannerZid")) config = config.copy(bannerZid = map.getString("bannerZid"))
-            if (map.hasKey("bottomBannerZid")) config = config.copy(bottomBannerZid = map.getString("bottomBannerZid"))
+            zoneIdOrNull(map, "bannerZid")?.let { config = config.copy(bannerZid = it) }
+            zoneIdOrNull(map, "bottomBannerZid")?.let { config = config.copy(bottomBannerZid = it) }
             // mobileZids / mobileBannerZid are OS-suffix-resolved by SellwildSDK.apply
             // when `remote` is present; only fall back to the flat (OS-agnostic) JS
             // values when there was no remote payload to resolve from (parity w/ iOS).
             if (!map.hasKey("remote") || map.isNull("remote")) {
-                if (map.hasKey("mobileBannerZid")) config = config.copy(mobileBannerZid = map.getString("mobileBannerZid"))
+                zoneIdOrNull(map, "mobileBannerZid")?.let { config = config.copy(mobileBannerZid = it) }
                 if (map.hasKey("mobileZids") && !map.isNull("mobileZids")) {
                     val arr = map.getArray("mobileZids")
                     if (arr != null) config = config.copy(mobileZids = (0 until arr.size()).mapNotNull { arr.getString(it) })

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

@@ -5,9 +5,11 @@ import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.UiThreadUtil
 import com.sellwild.sdk.SellwildEid
 import com.sellwild.sdk.SellwildEidUid
 import com.sellwild.sdk.SellwildPrebidMobile
+import com.sellwild.sdk.SellwildSDK
 
 /**
  * React Native method module for the native Sellwild SDK's runtime setters.
@@ -42,6 +44,22 @@ class SellwildModule(reactContext: ReactApplicationContext) :
         SellwildPrebidMobile.setExternalUserIds(toEids(eids))
     }
 
+    /**
+     * JS: `SellwildRNModule.prewarm(nativeConfig)`. Pre-initializes the native ad
+     * stack (Prebid + ad server SDK) before the first ad view mounts, so the
+     * first impression doesn't incur cold-start init latency. Mirrors the native
+     * Android-only [SellwildSDK.prewarm]; idempotent. Runs on the main thread —
+     * the ad-SDK inits expect it. Reuses the banner manager's config mapping so
+     * the payload shape matches `<SellwildBanner config=...>`.
+     */
+    @ReactMethod
+    fun prewarm(config: ReadableMap?) {
+        if (config == null) return
+        val ctx = reactApplicationContext
+        val cfg = SellwildBannerViewManager.configFromMap(config)
+        UiThreadUtil.runOnUiThread { SellwildSDK.prewarm(ctx, cfg) }
+    }
+
     private fun toEids(arr: ReadableArray?): List<SellwildEid> {
         if (arr == null) return emptyList()
         val out = ArrayList<SellwildEid>()

package/ios/SellwildBannerViewManager.m

@@ -23,5 +23,6 @@ RCT_EXPORT_VIEW_PROPERTY(onHouseAdImpression, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onAdClicked, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onAdFailed, RCTDirectEventBlock)
 RCT_EXPORT_VIEW_PROPERTY(onAdResize, RCTDirectEventBlock)
+RCT_EXPORT_VIEW_PROPERTY(onAdBlocked, RCTDirectEventBlock)
 
 @end

package/ios/SellwildBannerViewManager.swift

@@ -53,11 +53,18 @@ final class SellwildBannerHostView: UIView, SellwildAdViewDelegate {
     @objc var onAdFailed: RCTDirectEventBlock?
     /// Emitted with the rendered creative size so JS can resize the slot.
     @objc var onAdResize: RCTDirectEventBlock?
+    /// Boltive blocked the rendered creative (MOBILE_BOLTIVE_ENABLED only).
+    @objc var onAdBlocked: RCTDirectEventBlock?
 
     // MARK: Internals
 
     private var adView: SellwildAdView?
     private var lastAppliedKey: String?
+    /// Last applied `config` map, compared by value (`isEqual:` ⇒
+    /// `isEqualToDictionary:`, deep). NOT `NSDictionary.hash` — that is
+    /// just the entry count, so a partnerCode / slug / geo / remote change
+    /// with the same key count would be silently ignored.
+    private var lastAppliedConfig: NSDictionary?
     private var needsApply: Bool = false
 
     override init(frame: CGRect) {
@@ -87,9 +94,10 @@ final class SellwildBannerHostView: UIView, SellwildAdViewDelegate {
         // refresh of the rendered ad is driven by the SDK's internal
         // timer, not by JS re-renders.
         let stackStr = (adStack as String?) ?? ""
-        let key = "\(sizeStr)|\(zid)|\(stackStr)|\(cfgMap.hash)"
-        if lastAppliedKey == key { return }
+        let key = "\(sizeStr)|\(zid)|\(stackStr)"
+        if lastAppliedKey == key, lastAppliedConfig?.isEqual(cfgMap) == true { return }
         lastAppliedKey = key
+        lastAppliedConfig = cfgMap.copy() as? NSDictionary
 
         let sellwildConfig = Self.configFromMap(cfgMap)
 
@@ -138,6 +146,10 @@ final class SellwildBannerHostView: UIView, SellwildAdViewDelegate {
         onAdFailed?(["message": error.localizedDescription])
     }
 
+    func sellwildAdView(_ adView: SellwildAdView, didBlockAdForZoneId zoneId: String) {
+        onAdBlocked?(["zoneId": zoneId])
+    }
+
     func sellwildAdView(_ adView: SellwildAdView, didRenderWithSize size: CGSize) {
         onAdResize?(["width": size.width, "height": size.height])
     }

package/ios/SellwildFeedViewManager.m

@@ -13,6 +13,7 @@
 // SellwildFeedHostView.
 RCT_EXPORT_VIEW_PROPERTY(config, NSDictionary)
 RCT_EXPORT_VIEW_PROPERTY(scrollEnabled, BOOL)
+RCT_EXPORT_VIEW_PROPERTY(consumeListingTaps, BOOL)
 
 // Direct events emitted to JS callbacks.
 RCT_EXPORT_VIEW_PROPERTY(onFeedLoaded, RCTDirectEventBlock)

package/ios/SellwildFeedViewManager.swift

@@ -13,6 +13,9 @@ import UIKit
 ///       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.
+///   - scrollEnabled: bool — disable internal scrolling for embedding.
+///   - consumeListingTaps: bool — when true the host owns listing taps;
+///       the SDK does not open SFSafariViewController.
 ///
 /// Events emitted to JS:
 ///   - onFeedLoaded
@@ -41,6 +44,10 @@ final class SellwildFeedHostView: UIView, SellwildFeedViewDelegate {
     /// Disable the feed's internal scrolling so it can be embedded inside a
     /// parent scroll view. Applied live and on feed creation.
     @objc var scrollEnabled: Bool = true { didSet { feedView?.scrollEnabled = scrollEnabled } }
+    /// When true, listing taps are only forwarded to JS (`onListingTap`) and
+    /// the SDK does NOT open SFSafariViewController. Read at tap time, so it
+    /// applies live without rebuilding the feed. Default false = SDK opens.
+    @objc var consumeListingTaps: Bool = false
 
     // MARK: RN events
 
@@ -61,7 +68,11 @@ final class SellwildFeedHostView: UIView, SellwildFeedViewDelegate {
     // MARK: Internals
 
     private var feedView: SellwildFeedView?
-    private var lastAppliedKey: String?
+    /// Last applied `config` map, compared by value (`isEqual:` ⇒
+    /// `isEqualToDictionary:`, deep). NOT `NSDictionary.hash` — that is
+    /// just the entry count, so a partnerCode / slug / geo / remote change
+    /// with the same key count would be silently ignored.
+    private var lastAppliedConfig: NSDictionary?
     private var needsApply: Bool = false
 
     override init(frame: CGRect) {
@@ -82,9 +93,8 @@ final class SellwildFeedHostView: UIView, SellwildFeedViewDelegate {
         // 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
+        if lastAppliedConfig?.isEqual(cfgMap) == true { return }
+        lastAppliedConfig = cfgMap.copy() as? NSDictionary
 
         let sellwildConfig = Self.configFromMap(cfgMap)
 
@@ -119,15 +129,12 @@ final class SellwildFeedHostView: UIView, SellwildFeedViewDelegate {
 
     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.
+        // can't return a value back through a direct event block (events
+        // are async), so whether the SDK opens SFSafariViewController is
+        // decided here from the `consumeListingTaps` prop instead.
         let payload = Self.listingPayload(listing)
         onListingTap?(["listing": payload])
-        return false
+        return consumeListingTaps
     }
 
     func sellwildFeed(_ feed: SellwildFeedView, didRecordAdImpressionForZoneId zoneId: String) {

package/ios/SellwildRNModule.m

@@ -6,5 +6,6 @@
 
 RCT_EXTERN_METHOD(setGeo:(NSDictionary *)geo)
 RCT_EXTERN_METHOD(setExternalUserIds:(NSArray *)eids)
+RCT_EXTERN_METHOD(prewarm:(NSDictionary *)config)
 
 @end

package/ios/SellwildRNModule.swift

@@ -39,4 +39,18 @@ final class SellwildRNModule: NSObject {
         }
         SellwildPrebidMobile.setExternalUserIds(mapped)
     }
+
+    /// JS: `SellwildRNModule.prewarm(nativeConfig)`. Pre-initializes the native ad
+    /// stack before the first ad view mounts so the first impression doesn't incur
+    /// cold-start init latency. Idempotent. Reuses the banner manager's config
+    /// mapping so the payload matches `<SellwildBanner config=...>`. iOS bootstraps
+    /// inside `configure()` too; this is the explicit early opt-in for parity with
+    /// Android's `SellwildSDK.prewarm`.
+    @objc(prewarm:)
+    func prewarm(_ config: NSDictionary) {
+        let cfg = SellwildBannerHostView.configFromMap(config)
+        DispatchQueue.main.async {
+            _ = SellwildPrebidMobile.bootstrap(with: cfg)
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellwild/react-native-sdk",
-  "version": "1.7.3",
+  "version": "1.8.0",
   "description": "Sellwild mobile advertising SDK for React Native",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -18,16 +18,14 @@
     "advertising",
     "ads",
     "sellwild",
-    "marketplace",
-    "widget"
+    "marketplace"
   ],
   "peerDependencies": {
     "react": ">=17.0.0",
-    "react-native": ">=0.70.0",
-    "react-native-webview": ">=11.0.0"
+    "react-native": ">=0.70.0"
   },
   "dependencies": {
-    "@sellwild/sdk-core": "^1.3.0"
+    "@sellwild/sdk-core": "^1.8.0"
   },
   "devDependencies": {
     "@types/react": "^18.0.0",

package/src/SellwildBanner.tsx

@@ -1,7 +1,7 @@
 import React from 'react'
-import { Platform, requireNativeComponent, UIManager, ViewStyle, View, Text, StyleSheet, NativeSyntheticEvent } from 'react-native'
+import { Platform, requireNativeComponent, UIManager, StyleProp, ViewStyle, View, Text, StyleSheet, NativeSyntheticEvent } from 'react-native'
 import { resolveAdStack, type SellwildConfig, type AdSize } from '@sellwild/sdk-core'
-import { resolveAppIdentity } from './appIdentity'
+import { toNativeConfig } from './nativeConfig'
 
 // Standard IAB mobile ad sizes — used to lock the host View dimensions.
 // The actual ad size is also propagated to native as the `size` prop label.
@@ -60,13 +60,14 @@ interface NativeBannerProps {
    * everything else (bidders, GAM tag, etc.).
    */
   adStack: string
-  style?: ViewStyle
+  style?: StyleProp<ViewStyle>
   onAdLoaded?: (e: NativeSyntheticEvent<{}>) => void
   onAdImpression?: (e: NativeSyntheticEvent<{ zoneId: string }>) => void
   onHouseAdImpression?: (e: NativeSyntheticEvent<{ zoneId: string }>) => void
   onAdClicked?: (e: NativeSyntheticEvent<{}>) => void
   onAdFailed?: (e: NativeSyntheticEvent<{ message: string }>) => void
   onAdResize?: (e: NativeSyntheticEvent<{ width: number; height: number }>) => void
+  onAdBlocked?: (e: NativeSyntheticEvent<{ zoneId: string }>) => void
 }
 
 const NativeBanner = (() => {
@@ -95,6 +96,12 @@ export interface SellwildBannerProps {
   onHouseImpression?: (zoneId: string) => void
   onClick?: () => void
   onError?: (error: Error) => void
+  /**
+   * Fired when Boltive blocks the rendered creative (only with
+   * `MOBILE_BOLTIVE_ENABLED` on). The SDK already swaps in the house ad and
+   * re-auctions; this is for reporting.
+   */
+  onBlocked?: (zoneId: string) => void
 }
 
 export function SellwildBanner({
@@ -106,6 +113,7 @@ export function SellwildBanner({
   onHouseImpression,
   onClick,
   onError,
+  onBlocked,
 }: SellwildBannerProps) {
   const dim = AD_DIMENSIONS[size]
 
@@ -159,31 +167,9 @@ export function SellwildBanner({
     )
   }
 
-  // Pass only the fields the native banner path actually reads. The rest
-  // of SellwildConfig is ignored on the native side. Note: TS core uses
-  // `adRefreshInterval` (millis); the native side reads it as
-  // `adRefreshIntervalMs`. The bridge translates.
-  // App identity is resolved per-platform here (iOS vs Android) from the raw
-  // CDN payload on `config.remote`; the native banner path reads these fields.
-  const { appBundleId, appStoreUrl } = resolveAppIdentity(config)
-  const nativeConfig = {
-    partnerCode: config.partnerCode,
-    appBundleId,
-    appStoreUrl,
-    geo: config.geo,
-    gamTag: config.gamTag,
-    debug: config.debug,
-    pbsDebug: config.pbsDebug,
-    adRefreshMax: config.adRefreshMax,
-    adRefreshMaxMobile: config.adRefreshMaxMobile,
-    adRefreshIntervalMs: config.adRefreshInterval,
-    prebidServer: config.prebidServer,
-    // Local GrowthCode overrides (remote GROWTHCODE_* keys ride `remote`).
-    growthCode: config.growthCode,
-    // Local localized-listings overrides (remote LOCALIZED_LISTINGS rides `remote`).
-    localizedListings: config.localizedListings,
-    remote: config.remote,
-  }
+  // The fields the native banner path reads. Built via the shared helper so
+  // <SellwildBanner> and prewarm() stay in sync (single source of truth).
+  const nativeConfig = toNativeConfig(config)
 
   return (
     <NativeBanner
@@ -198,6 +184,7 @@ export function SellwildBanner({
       onAdImpression={() => onImpression?.()}
       onHouseAdImpression={(e: NativeSyntheticEvent<{ zoneId: string }>) => onHouseImpression?.(e.nativeEvent?.zoneId)}
       onAdClicked={() => onClick?.()}
+      onAdBlocked={(e: NativeSyntheticEvent<{ zoneId: string }>) => onBlocked?.(e.nativeEvent?.zoneId)}
       onAdFailed={(e: NativeSyntheticEvent<{ message: string }>) => {
         const msg = e.nativeEvent?.message ?? 'Ad failed'
         onError?.(new Error(msg))