@sellwild/react-native-sdk 1.7.4 → 1.8.1

package/src/SellwildFeed.tsx

@@ -23,14 +23,15 @@ import { resolveAppIdentity } from './appIdentity'
 // 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.
+// This is the one-component marketplace surface for React Native (the
+// WebView-based <SellwildWidget> has been removed).
 
 const NATIVE_NAME = 'SellwildFeedView'
 
 interface NativeFeedProps {
   config: object
   scrollEnabled?: boolean
+  consumeListingTaps?: boolean
   style?: StyleProp<ViewStyle>
   onFeedLoaded?: (e: NativeSyntheticEvent<{}>) => void
   onFeedReady?: (e: NativeSyntheticEvent<{ listingCount: number }>) => void
@@ -95,9 +96,23 @@ export interface SellwildFeedProps {
   onFeedReady?: (listingCount: number) => 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).
+   * When `true`, listing taps are fully handled by the host app: the SDK does
+   * NOT open the listing in the in-app browser (Custom Tabs /
+   * SFSafariViewController) and only fires `onListingTap`. Use this to route
+   * listings through your own navigation. Defaults to `false` (the SDK opens
+   * the listing URL), so existing integrations are unaffected.
+   */
+  consumeListingTaps?: boolean
+
+  /**
+   * Fired when a listing card is tapped. This is a notification only: the
+   * return value is ignored, because React Native events are delivered to JS
+   * asynchronously — after the native side has already decided whether to
+   * open the browser. To handle navigation yourself, set
+   * `consumeListingTaps` instead.
+   *
+   * The `boolean` return type is kept only so existing handlers still compile;
+   * it is deprecated and has no effect.
    */
   onListingTap?: (listing: SellwildListing) => boolean | void
 
@@ -117,10 +132,22 @@ export interface SellwildFeedProps {
   onError?: (error: Error) => void
 }
 
+/**
+ * Zone ids are `number | string` in core config, defaulting to `0` (unset).
+ * Both native bridges read them as strings, so send a string, or nothing when
+ * unset: Android threw on a number and iOS silently dropped it.
+ */
+function zoneIdProp(v: number | string | null | undefined): string | undefined {
+  if (v === null || v === undefined) return undefined
+  const s = String(v).trim()
+  return s === '' || s === '0' ? undefined : s
+}
+
 export function SellwildFeed({
   config,
   style,
   scrollEnabled = true,
+  consumeListingTaps = false,
   onContentSizeChange,
   onLoad,
   onFeedReady,
@@ -134,6 +161,8 @@ export function SellwildFeed({
   // scrolling, so we size our own container from the native-reported content
   // height rather than filling with flex:1.
   const [contentHeight, setContentHeight] = React.useState<number | null>(null)
+  // Dev-only: warn once per feed about the ignored `return true`, not on every tap.
+  const warnedReturnTrue = React.useRef(false)
   const embedded = scrollEnabled === false
   const containerStyle: StyleProp<ViewStyle> = embedded
     ? [contentHeight != null ? { height: contentHeight } : undefined, style]
@@ -186,9 +215,9 @@ export function SellwildFeed({
     remote: config.remote,
     listingsUrl: config.listingsUrl,
     priceColor: config.priceColor,
-    bannerZid: config.bannerZid,
-    bottomBannerZid: config.bottomBannerZid,
-    mobileBannerZid: config.mobileBannerZid,
+    bannerZid: zoneIdProp(config.bannerZid),
+    bottomBannerZid: zoneIdProp(config.bottomBannerZid),
+    mobileBannerZid: zoneIdProp(config.mobileBannerZid),
     mobileZids: config.mobileZids,
   }
 
@@ -197,6 +226,7 @@ export function SellwildFeed({
       style={containerStyle}
       config={nativeConfig}
       scrollEnabled={scrollEnabled}
+      consumeListingTaps={consumeListingTaps}
       onContentSizeChange={(e: NativeSyntheticEvent<{ width?: number; height: number }>) => {
         const { width, height } = e.nativeEvent ?? { height: 0 }
         // Only size our own container when embedded; a scrolling feed fills
@@ -209,7 +239,15 @@ export function SellwildFeed({
         onFeedReady?.(e.nativeEvent.listingCount)
       }}
       onListingTap={(e: NativeSyntheticEvent<{ listing: SellwildListing }>) => {
-        onListingTap?.(e.nativeEvent.listing)
+        const result = onListingTap?.(e.nativeEvent.listing)
+        if (__DEV__ && result === true && !consumeListingTaps && !warnedReturnTrue.current) {
+          warnedReturnTrue.current = true
+          console.warn(
+            '[Sellwild] onListingTap returned true, but the return value is ignored ' +
+              '(RN events are async). Set consumeListingTaps on <SellwildFeed> to ' +
+              'stop the SDK from opening the listing.',
+          )
+        }
       }}
       onAdImpression={(e: NativeSyntheticEvent<{ zoneId: string }>) => {
         onAdImpression?.(e.nativeEvent.zoneId)

package/src/appIdentity.ts

@@ -10,14 +10,13 @@ import type { SellwildConfig } from '@sellwild/sdk-core'
  * (OS-agnostic) keys onto `appBundleId`/`appStoreUrl` and stashes the raw
  * payload on `config.remote`; the platform is only known here on the device,
  * so we resolve the OS-specific value at the bridge boundary — the RN analog
- * of the native `SellwildSDK.apply()` (iOS/Android) and Flutter `dart:io`
- * resolution.
+ * of the native `SellwildSDK.apply()` (iOS/Android) resolution.
  *
  * Both native bridges (feed + banner) consume `config.appBundleId` /
  * `config.appStoreUrl`, so resolving once here makes both correct without any
  * Kotlin/Swift bridge change.
  *
- * Precedence (matches iOS/Android `apply()` and Flutter): the per-platform CDN
+ * Precedence (matches iOS/Android `apply()`): the per-platform CDN
  * value, else the shared `appBundleId`/`appStoreUrl` (which already carries any
  * host override). Backward compatible: no suffixed key = today's behavior.
  */

package/src/commands.ts

@@ -1,5 +1,7 @@
 import { NativeModules } from 'react-native'
-import type { SellwildEid, SellwildGeo } from '@sellwild/sdk-core'
+import { configure as coreConfigure } from '@sellwild/sdk-core'
+import type { SellwildConfig, SellwildEid, SellwildGeo } from '@sellwild/sdk-core'
+import { toNativeConfig } from './nativeConfig'
 
 // Imperative bridge to the native Sellwild method module. The ad surface is
 // otherwise view-manager-only (config flows as a prop on <SellwildBanner> /
@@ -8,6 +10,7 @@ const SellwildRNModule = NativeModules.SellwildRNModule as
   | {
       setGeo?: (geo: Record<string, unknown>) => void
       setExternalUserIds?: (eids: SellwildEid[]) => void
+      prewarm?: (config: Record<string, unknown>) => void
     }
   | undefined
 
@@ -35,3 +38,29 @@ export function setGeo(geo: SellwildGeo | null): void {
 export function setExternalUserIds(eids: SellwildEid[]): void {
   SellwildRNModule?.setExternalUserIds?.(eids ?? [])
 }
+
+/**
+ * Pre-initialize the native ad stack (Prebid + ad server SDK) before the first
+ * `<SellwildBanner>`/`<SellwildFeed>` mounts, so the first impression doesn't
+ * incur cold-start init latency and fall back to server-only demand.
+ *
+ * Since 1.8.0 `configure()` calls this automatically, so it's only needed for
+ * configs built another way (e.g. `buildConfig`). Idempotent, and a no-op if the
+ * native module isn't linked.
+ */
+export function prewarm(config: SellwildConfig): void {
+  SellwildRNModule?.prewarm?.(toNativeConfig(config))
+}
+
+/**
+ * Fetch the partner's CDN config (see core `configure`) and pre-warm the native
+ * ad stack with it, so the first ad view doesn't pay SDK init latency. Matches
+ * native iOS / Android `configure()`, which pre-warm too.
+ */
+export async function configure(
+  ...args: Parameters<typeof coreConfigure>
+): Promise<SellwildConfig> {
+  const config = await coreConfigure(...args)
+  prewarm(config)
+  return config
+}

package/src/index.ts

@@ -1,6 +1,3 @@
-export { SellwildWidget } from './SellwildWidget'
-export type { SellwildWidgetProps } from './SellwildWidget'
-
 export { SellwildBanner } from './SellwildBanner'
 export type { SellwildBannerProps } from './SellwildBanner'
 
@@ -14,7 +11,7 @@ export { useSellwildListings } from './useSellwildListings'
 export type { UseSellwildListingsResult } from './useSellwildListings'
 
 // Imperative native setters (runtime, session-scoped).
-export { setGeo, setExternalUserIds } from './commands'
+export { setGeo, setExternalUserIds, prewarm, configure } from './commands'
 
 // Re-export core types for convenience
 export type {
@@ -34,7 +31,6 @@ export type {
 } from '@sellwild/sdk-core'
 
 export {
-  configure,
   buildConfig,
   buildConfigWithRemote,
   currencyToSymbol,
@@ -43,3 +39,9 @@ export {
 } from '@sellwild/sdk-core'
 
 export type { ConfigureOptions } from '@sellwild/sdk-core'
+
+// Stamp every analytics event with the host platform. Runs once on module load
+// so any code path that reaches the shared core `eventQueue` is attributed to
+// react-native (merged into `attributes.platform` alongside `sdkVersion`).
+import { eventQueue } from '@sellwild/sdk-core'
+eventQueue.setPlatform('react-native')

package/src/nativeConfig.ts

@@ -0,0 +1,34 @@
+import type { SellwildConfig } from '@sellwild/sdk-core'
+import { resolveAppIdentity } from './appIdentity'
+
+/**
+ * Build the native config payload the auction/ad path reads, from a core
+ * SellwildConfig. This is the single source of truth for the fields the native
+ * banner path + `prewarm` consume — keep `<SellwildBanner>` and `prewarm()` in
+ * sync by both going through here.
+ *
+ * Notes:
+ *  - App identity is resolved per-platform (iOS vs Android) from `config.remote`.
+ *  - TS core uses `adRefreshInterval` (millis); the native side reads it as
+ *    `adRefreshIntervalMs`. The bridge translates.
+ *  - The raw CDN payload rides on `remote` for the auction passthrough.
+ */
+export function toNativeConfig(config: SellwildConfig): Record<string, unknown> {
+  const { appBundleId, appStoreUrl } = resolveAppIdentity(config)
+  return {
+    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,
+    growthCode: config.growthCode,
+    localizedListings: config.localizedListings,
+    remote: config.remote,
+  }
+}

package/src/SellwildWidget.tsx

@@ -1,145 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import {
-  View,
-  StyleSheet,
-  ActivityIndicator,
-  ViewStyle,
-} from 'react-native'
-import { WebView } from 'react-native-webview'
-import type { WebViewMessageEvent } from 'react-native-webview'
-import type { SellwildConfig, SellwildListing } from '@sellwild/sdk-core'
-import { buildConfig, WIDGET_BASE_URL } from '@sellwild/sdk-core'
-import type { PartialSellwildConfig } from '@sellwild/sdk-core'
-import { buildWidgetHtml } from './htmlBuilder'
-
-export interface SellwildWidgetProps {
-  config: PartialSellwildConfig
-  style?: ViewStyle
-  onListingPress?: (listing: SellwildListing) => void
-  onAdImpression?: (zoneId: string | number) => void
-  onError?: (error: Error) => void
-  onLoad?: () => void
-}
-
-// The web widget intercepts window.open() and sends the listing URL.
-// A full SellwildListing object is not available from the WebView boundary —
-// the listing field will be absent; url contains the Sellwild product page URL.
-type WebViewMessage =
-  | { type: 'LISTING_CLICK'; listing?: SellwildListing; url?: string }
-  | { type: 'AD_IMPRESSION'; zoneId: string | number }
-  | { type: 'WIDGET_LOADED' }
-  | { type: 'ERROR'; message: string }
-
-export function SellwildWidget({
-  config: configProp,
-  style,
-  onListingPress,
-  onAdImpression,
-  onError,
-  onLoad,
-}: SellwildWidgetProps) {
-  // Memoize so that parent re-renders don't change `source.html`, which
-  // would force react-native-webview to reload and lose ad session state.
-  const config = useMemo(() => buildConfig(configProp), [
-    configProp.partnerCode,
-    configProp.listingsUrl,
-    configProp.gamTag,
-    configProp.gptProxyUrl,
-    configProp.bannerZid,
-    configProp.debug,
-  ])
-  const [loading, setLoading] = useState(true)
-  const webViewRef = useRef<WebView>(null)
-
-  const html = useMemo(() => buildWidgetHtml(config), [config])
-
-  const handleMessage = useCallback(
-    (event: WebViewMessageEvent) => {
-      try {
-        const msg: WebViewMessage = JSON.parse(event.nativeEvent.data)
-        switch (msg.type) {
-          case 'LISTING_CLICK':
-            // The web widget sends a URL via window.open() interception.
-            // A full listing object is not available at the WebView boundary.
-            // Pass the listing if somehow present (future compatibility),
-            // otherwise construct a minimal stub so callers can navigate.
-            if (msg.listing) {
-              onListingPress?.(msg.listing)
-            } else if (msg.url && onListingPress) {
-              const stub: SellwildListing = {
-                id: '', status: 'active', title: '',
-                text: '', url: msg.url, categoryId: '', categoryGroupId: '',
-                currency: 'USD', price: '', strikePrice: '',
-                has_photo: false, photo_count: 0, photos: [],
-                createdDate: '', videoUrl: '', shippable: '',
-                listingType: '', dataSourceId: '',
-                user: { id: '', firstName: '', lastName: '', username: '',
-                        membershipType: '', trustLevel: '', has_photo: '',
-                        photos: [], isPhoneVerified: false },
-              }
-              onListingPress(stub)
-            }
-            break
-          case 'AD_IMPRESSION':
-            onAdImpression?.(msg.zoneId)
-            break
-          case 'WIDGET_LOADED':
-            setLoading(false)
-            onLoad?.()
-            break
-          case 'ERROR':
-            onError?.(new Error(msg.message))
-            break
-        }
-      } catch {
-        // Non-SDK message, ignore
-      }
-    },
-    [onListingPress, onAdImpression, onError, onLoad]
-  )
-
-  return (
-    <View style={[styles.container, style]}>
-      {loading && (
-        <View style={styles.loader}>
-          <ActivityIndicator size="large" />
-        </View>
-      )}
-      <WebView
-        ref={webViewRef}
-        source={{ html, baseUrl: 'https://widget.sellwild.com/' }}
-        style={styles.webView}
-        onMessage={handleMessage}
-        javaScriptEnabled
-        domStorageEnabled
-        thirdPartyCookiesEnabled
-        allowsInlineMediaPlayback
-        mediaPlaybackRequiresUserAction={false}
-        mixedContentMode="compatibility"
-        originWhitelist={['*']}
-        onError={syntheticEvent => {
-          const { nativeEvent } = syntheticEvent
-          onError?.(new Error(nativeEvent.description))
-        }}
-      />
-    </View>
-  )
-}
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-    minHeight: 300,
-  },
-  webView: {
-    flex: 1,
-    backgroundColor: 'transparent',
-  },
-  loader: {
-    ...StyleSheet.absoluteFillObject,
-    justifyContent: 'center',
-    alignItems: 'center',
-    backgroundColor: '#f5f5f5',
-    zIndex: 1,
-  },
-})