react-native-hubspot-wrapper 0.3.0 → 0.4.1

package/README.md

@@ -12,7 +12,7 @@ Early release (`0.x`). The public API may evolve before `1.0`.
 Currently supported:
 
 - `initialize()`
-- `openChat(chatflow)`
+- `openChat(chatflow, options?)`
 - `setIdentity({ identityToken, email? })`
 - `setProperties(properties)`
 - `clearUserData()`
@@ -61,14 +61,39 @@ await HubspotWrapper.setProperties([{ name: 'plan', value: 'pro' }]);
 await HubspotWrapper.openChat('support');
 ```
 
+By default, `openChat` hides HubSpot's "back to inbox" / conversations-list
+button inside the chat widget. This wrapper is opinionated toward single-chat
+support flows, but you can preserve HubSpot's stock UI per chat:
+
+```ts
+await HubspotWrapper.openChat('support', {
+  hideBackToInboxButton: false,
+});
+```
+
 ## API
 
 - `initialize(): Promise<void>`
-- `openChat(chatflow: string): Promise<void>`
+- `openChat(chatflow: string, options?: { hideBackToInboxButton?: boolean }): Promise<void>`
 - `setIdentity({ identityToken, email? }): Promise<void>`
 - `setProperties(properties): Promise<void>`
 - `clearUserData(): Promise<void>`
 
+### `openChat(chatflow, options?)`
+
+Opens the HubSpot chat UI for the provided chatflow.
+
+- `hideBackToInboxButton` defaults to `true`.
+- Set `hideBackToInboxButton: false` to keep HubSpot's default conversations
+  navigation visible.
+
+### `clearUserData()`
+
+Clears the native SDK's current user/session state and waits for HubSpot chat
+visitor cookies/data cleanup to finish before resolving. This is intended for
+logout or account-switch flows so the next chat session does not reuse the
+previous visitor identity.
+
 ## iOS SDK source strategy
 
 This package vendors HubSpot iOS SDK source files under `ios/HubspotMobileSDK`.

package/android/src/main/java/com/reactnativehubspotwrapper/HubspotBackButtonHider.kt

@@ -0,0 +1,279 @@
+package com.marcinolek.reactnativehubspotwrapper
+
+import android.app.Activity
+import android.app.Application
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.View
+import android.view.ViewGroup
+import android.webkit.WebView
+import java.util.WeakHashMap
+
+/**
+ * Hides the HubSpot chat widget's "back to inbox" / conversations-list navigation
+ * inside [HubspotWebActivity] (which lives in HubSpot's compiled `.aar` and which
+ * we therefore can't modify directly).
+ *
+ * Approach:
+ *
+ * 1. We register a single [Application.ActivityLifecycleCallbacks] from the wrapper
+ *    module's init.
+ * 2. Each time `com.hubspot.mobilesdk.HubspotWebActivity` resumes, we depth-first
+ *    walk its decor view to find the `WebView`.
+ * 3. We `evaluateJavascript` a heuristic-based hider that walks all same-origin
+ *    sub-frames (the chat UI itself lives in an iframe on `app-na2.hubspot.com`)
+ *    and hides any `<button>`/`<a>`/`role="button"` whose accessible label,
+ *    `data-test-id`, title, id, class or short visible text normalizes (camelCase
+ *    -> spaces, `_-` -> spaces, lowercase) to something matching
+ *    `\b(back|inbox|previous|conversations)\b`. A `MutationObserver` is then
+ *    attached so late-mounted buttons get hidden too.
+ * 4. We re-fire `evaluateJavascript` periodically for a few seconds so the iframe
+ *    walk catches the chat iframe as soon as it mounts (it's loaded asynchronously
+ *    by HubSpot's `project.js` bundle after the activity opens).
+ *
+ * The implementation is intentionally identical in spirit to the iOS hider in
+ * `HubspotWrapperImpl.swift` so the same JS works on both platforms.
+ */
+internal object HubspotBackButtonHider {
+  private const val TAG = "HubspotWrapper"
+
+  const val EXTRA_HIDE_BACK_TO_INBOX_BUTTON =
+    "com.marcinolek.reactnativehubspotwrapper.HIDE_BACK_TO_INBOX_BUTTON"
+
+  /**
+   * The fully-qualified name of HubSpot's chat activity in the AAR. Matched by
+   * string so we don't have to import / depend on it for compile-time resolution.
+   */
+  private const val WEB_ACTIVITY_NAME = "com.hubspot.mobilesdk.HubspotWebActivity"
+
+  /** How often we re-fire `evaluateJavascript` to catch late-loaded iframes. */
+  private const val RESCAN_INTERVAL_MS = 250L
+
+  /**
+   * Total time we keep re-firing after the activity resumes. The chat iframe
+   * normally appears within ~2s; we give a generous margin and then stop to
+   * avoid burning CPU forever if the user leaves the chat open for a long time.
+   */
+  private const val MAX_SCAN_DURATION_MS = 10_000L
+
+  @Volatile
+  private var installed = false
+
+  private val handler = Handler(Looper.getMainLooper())
+  private val scheduledInjections = WeakHashMap<WebView, Runnable>()
+
+  @Synchronized
+  fun installOnce(app: Application) {
+    if (installed) return
+    installed = true
+
+    app.registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {
+      override fun onActivityResumed(activity: Activity) {
+        if (activity.javaClass.name != WEB_ACTIVITY_NAME) return
+        if (!activity.intent.getBooleanExtra(EXTRA_HIDE_BACK_TO_INBOX_BUTTON, true)) {
+          cancelHiderInjection(findWebView(activity.window.decorView))
+          return
+        }
+        val webView = findWebView(activity.window.decorView)
+        if (webView == null) {
+          Log.w(TAG, "installBackButtonHider: WebView not found in $WEB_ACTIVITY_NAME view tree")
+          return
+        }
+        Log.i(TAG, "installBackButtonHider: scheduling JS injection on $webView")
+        scheduleHiderInjection(webView)
+      }
+
+      override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
+      override fun onActivityStarted(activity: Activity) {}
+      override fun onActivityPaused(activity: Activity) {
+        if (activity.javaClass.name == WEB_ACTIVITY_NAME) {
+          cancelHiderInjection(findWebView(activity.window.decorView))
+        }
+      }
+      override fun onActivityStopped(activity: Activity) {}
+      override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
+      override fun onActivityDestroyed(activity: Activity) {
+        if (activity.javaClass.name == WEB_ACTIVITY_NAME) {
+          cancelHiderInjection(findWebView(activity.window.decorView))
+        }
+      }
+    })
+  }
+
+  private fun findWebView(view: View?): WebView? {
+    if (view is WebView) return view
+    if (view is ViewGroup) {
+      for (i in 0 until view.childCount) {
+        val found = findWebView(view.getChildAt(i))
+        if (found != null) return found
+      }
+    }
+    return null
+  }
+
+  private fun scheduleHiderInjection(webView: WebView) {
+    cancelHiderInjection(webView)
+
+    val start = System.currentTimeMillis()
+    val runnable = object : Runnable {
+      override fun run() {
+        try {
+          webView.evaluateJavascript(BACK_BUTTON_HIDER_JS, null)
+        } catch (error: Exception) {
+          Log.w(TAG, "evaluateJavascript failed", error)
+        }
+        if (System.currentTimeMillis() - start < MAX_SCAN_DURATION_MS) {
+          handler.postDelayed(this, RESCAN_INTERVAL_MS)
+        } else {
+          scheduledInjections.remove(webView)
+        }
+      }
+    }
+    scheduledInjections[webView] = runnable
+    handler.post(runnable)
+  }
+
+  private fun cancelHiderInjection(webView: WebView?) {
+    if (webView == null) return
+    val runnable = scheduledInjections.remove(webView) ?: return
+    handler.removeCallbacks(runnable)
+  }
+
+  /**
+   * Heuristic-based hider for the chat widget's back/inbox button. Identical in
+   * shape to the iOS version in `HubspotWrapperImpl.swift`. Designed to be safe
+   * to invoke many times: a `__rnHubspotHiderInstalled` per-document flag short-
+   * circuits re-installation, while the periodic re-fire from
+   * [scheduleHiderInjection] still allows newly-mounted iframes to be picked up.
+   */
+  private const val BACK_BUTTON_HIDER_JS = """
+    (function() {
+      function bootstrap(win) {
+        var doc;
+        try { doc = win.document; } catch (_) { return; }
+        if (!doc || doc.__rnHubspotHiderInstalled) return;
+        doc.__rnHubspotHiderInstalled = true;
+
+        var BACK_PATTERN = /\b(back|inbox|previous|conversations)\b/i;
+
+        function normalize(s) {
+          if (!s) return '';
+          return String(s)
+            .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+            .replace(/[_-]+/g, ' ')
+            .toLowerCase();
+        }
+
+        function looksLikeBackControl(el) {
+          if (!el || el.nodeType !== 1) return false;
+          if (el.getAttribute('data-rn-hubspot-wrapper-hidden') === '1') return false;
+          var tag = el.tagName;
+          if (tag !== 'BUTTON' && tag !== 'A' && el.getAttribute('role') !== 'button') return false;
+          var attrs = [
+            el.getAttribute('aria-label'),
+            el.getAttribute('data-test-id'),
+            el.getAttribute('data-test'),
+            el.getAttribute('title'),
+            el.getAttribute('id'),
+            el.getAttribute('class')
+          ];
+          for (var i = 0; i < attrs.length; i++) {
+            if (attrs[i] && BACK_PATTERN.test(normalize(attrs[i]))) return true;
+          }
+          var text = (el.textContent || '').trim();
+          if (text && text.length <= 32 && BACK_PATTERN.test(normalize(text))) return true;
+          return false;
+        }
+
+        function hide(el) {
+          try {
+            el.setAttribute('data-rn-hubspot-wrapper-hidden', '1');
+            el.style.setProperty('display', 'none', 'important');
+            el.style.setProperty('visibility', 'hidden', 'important');
+            el.style.setProperty('pointer-events', 'none', 'important');
+          } catch (_) {}
+        }
+
+        // Hide `el`, then walk up to a few ancestors and also hide any wrapper
+        // that becomes empty (no remaining unhidden element children) as a
+        // result. HubSpot's chat header has a back-button slot whose padding
+        // / min-width / flex-basis stays around even when the inner button is
+        // `display:none`, which shows up as the avatar shifting right after the
+        // first message is sent. Capping at depth 3 keeps us inside the header.
+        function hideUpwards(el) {
+          hide(el);
+          var current = el;
+          for (var depth = 0; depth < 3; depth++) {
+            var parent = current.parentElement;
+            if (!parent) break;
+            if (parent === doc.documentElement || parent === doc.body) break;
+            var visibleCount = 0;
+            var children = parent.children;
+            for (var i = 0; i < children.length; i++) {
+              if (children[i].getAttribute('data-rn-hubspot-wrapper-hidden') !== '1') {
+                visibleCount++;
+              }
+            }
+            if (visibleCount > 0) break;
+            hide(parent);
+            current = parent;
+          }
+        }
+
+        var observed = new WeakSet();
+        function scanRoot(root) {
+          if (!root) return;
+          try {
+            var nodes = root.querySelectorAll('button, a, [role="button"]');
+            for (var i = 0; i < nodes.length; i++) {
+              if (looksLikeBackControl(nodes[i])) hideUpwards(nodes[i]);
+            }
+            var all = root.querySelectorAll('*');
+            for (var j = 0; j < all.length; j++) {
+              var sr = all[j].shadowRoot;
+              if (sr) {
+                scanRoot(sr);
+                attachObserver(sr);
+              }
+            }
+          } catch (_) {}
+        }
+
+        function attachObserver(root) {
+          if (!root || observed.has(root)) return;
+          observed.add(root);
+          try {
+            var mo = new MutationObserver(function() { scanRoot(root); });
+            mo.observe(root, { childList: true, subtree: true, attributes: true, attributeFilter: ['aria-label', 'data-test-id', 'data-test', 'title', 'class'] });
+          } catch (_) {}
+        }
+
+        function go() {
+          scanRoot(doc);
+          attachObserver(doc.documentElement || doc);
+        }
+
+        if (doc.readyState === 'loading') {
+          doc.addEventListener('DOMContentLoaded', go, { once: true });
+        } else {
+          go();
+        }
+      }
+
+      function walkAllFrames(win) {
+        if (!win) return;
+        bootstrap(win);
+        try {
+          for (var i = 0; i < win.frames.length; i++) {
+            walkAllFrames(win.frames[i]);
+          }
+        } catch (_) {}
+      }
+
+      walkAllFrames(window);
+    })();
+  """
+}

package/android/src/main/java/com/reactnativehubspotwrapper/HubspotWrapperModule.kt

@@ -1,5 +1,6 @@
 package com.marcinolek.reactnativehubspotwrapper
 
+import android.app.Application
 import android.content.Intent
 import android.util.Log
 import android.webkit.CookieManager
@@ -20,6 +21,14 @@ class HubspotWrapperModule(reactContext: ReactApplicationContext) :
   private val appContext = reactContext.applicationContext
   private lateinit var hubspotManager: HubspotManager
 
+  init {
+    // Install the chat back-button hider as soon as the wrapper module is created.
+    // The hider only does work when `HubspotWebActivity` actually resumes, so this
+    // is a cheap one-time `Application.ActivityLifecycleCallbacks` registration.
+    // See `HubspotBackButtonHider` for why this lives outside the activity itself.
+    (appContext as? Application)?.let { HubspotBackButtonHider.installOnce(it) }
+  }
+
   override fun getName(): String = NAME
 
   override fun initialize(promise: Promise) {
@@ -33,11 +42,12 @@ class HubspotWrapperModule(reactContext: ReactApplicationContext) :
     }
   }
 
-  override fun openChat(chatflow: String, promise: Promise) {
+  override fun openChat(chatflow: String, hideBackToInboxButton: Boolean, promise: Promise) {
     try {
       val intent = Intent(appContext, HubspotWebActivity::class.java)
       intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
       intent.putExtra("chatflow", chatflow)
+      intent.putExtra(HubspotBackButtonHider.EXTRA_HIDE_BACK_TO_INBOX_BUTTON, hideBackToInboxButton)
       appContext.startActivity(intent)
       promise.resolve(null)
     } catch (error: Exception) {

package/ios/HubspotMobileSDK/Views/ChatView/HubspotChatView.swift

@@ -349,6 +349,9 @@ struct HubspotChatWebView: UIViewRepresentable {
 
             contentController.addUserScript(WKUserScript(source: js, injectionTime: .atDocumentEnd, forMainFrameOnly: false))
 
+            // [react-native-hubspot-wrapper] hide chat "back to inbox" button - see HubspotWrapperImpl
+            HubspotWrapperImpl.installBackButtonHider(on: contentController)
+
             // create script that triggers on hubspot event, and calls our message handler
 
             let configCallbacksJS = """

package/ios/HubspotWrapperImpl.swift

@@ -1,9 +1,31 @@
 import Foundation
 import SwiftUI
 import UIKit
+import WebKit
 
 @objcMembers
 public class HubspotWrapperImpl: NSObject {
+  private static var shouldHideBackToInboxButton = true
+
+  /// Substrings used to match `WKWebsiteDataRecord.displayName` (which is the host /
+  /// eTLD+1, e.g. `hubspot.com`, `hs-banner.com`, `hsadspixel.net`) for the various
+  /// domains the chat widget loads from. Anything matching is wiped on `clearUserData`.
+  ///
+  /// We deliberately use substrings rather than exact hosts because the widget pulls
+  /// resources from a long tail of HubSpot CDNs - `js.hs-banner.com`, `js.hubspot.com`,
+  /// `static.hsappstatic.net`, `app-na2.hubspot.com`, `*.hubspotqa.com`, etc. - and any
+  /// of those can hold cookies / localStorage / IndexedDB that re-attach a returning
+  /// visitor or surface the unsent draft message on the next open.
+  private static let chatDataDomainMatches: [String] = [
+    "hubspot",
+    "hsforms",
+    "hs-banner",
+    "hs-scripts",
+    "hsadspixel",
+    "hsappstatic",
+    "usemessages",
+  ]
+
   public func initialize(_ outError: NSErrorPointer) -> Bool {
     let semaphore = DispatchSemaphore(value: 0)
     var configureError: NSError?
@@ -26,7 +48,7 @@ public class HubspotWrapperImpl: NSObject {
     return true
   }
 
-  public func openChat(_ chatflow: String, error outError: NSErrorPointer) -> Bool {
+  public func openChat(_ chatflow: String, hideBackToInboxButton: Bool, error outError: NSErrorPointer) -> Bool {
     var didSucceed = false
     let presentBlock = {
       guard let rootVC = Self.topViewController() else {
@@ -38,6 +60,7 @@ public class HubspotWrapperImpl: NSObject {
         return
       }
 
+      Self.shouldHideBackToInboxButton = hideBackToInboxButton
       let chatView = HubspotChatView(chatFlow: chatflow)
       let hostingController = UIHostingController(rootView: chatView)
       rootVC.present(hostingController, animated: true)
@@ -80,12 +103,218 @@ public class HubspotWrapperImpl: NSObject {
     }
   }
 
-  public func clearUserData() {
-    Task {
-      await HubspotManager.shared.clearUserData()
+  /// Clear the SDK's in-memory identity/property state and synchronously wait for ALL
+  /// HubSpot website data (cookies, localStorage, sessionStorage, IndexedDB, service
+  /// workers, etc.) to be removed from the shared `WKWebsiteDataStore` before invoking
+  /// `completion`.
+  ///
+  /// Why we do our own clearing instead of relying on the SDK:
+  ///
+  /// 1. `HubspotManager.clearUserData()` is synchronous, but the cookie removal it
+  ///    performs is dispatched into a fire-and-forget `Task { ... }` that we have no
+  ///    handle to. JS code doing
+  ///    `await HubspotWrapper.clearUserData(); await HubspotWrapper.openChat(...)`
+  ///    races the still-in-flight cookie deletion, so the next chat session re-uses
+  ///    the previous visitor identity.
+  ///
+  /// 2. Even when the SDK's cookie deletion *does* finish, it only removes the two
+  ///    visitor-identity cookies (`hubspotutk`, `messagesUtk`). The chat widget also
+  ///    persists the unsent draft message and other state in `localStorage` /
+  ///    `sessionStorage` / `IndexedDB`. Cookie-only clearing leaves the draft visible
+  ///    on the next open, which is exactly the bug we kept seeing.
+  ///
+  /// We therefore enumerate `WKWebsiteDataStore` records, filter to records whose
+  /// host matches a HubSpot domain (see `chatDataDomainMatches`) and remove ALL data
+  /// types for those records. We only resolve the JS promise once that's complete.
+  public func clearUserData(_ completion: @escaping () -> Void) {
+    Task { @MainActor in
+      HubspotManager.shared.clearUserData()
+      await Self.deleteAllChatWebsiteData()
+      completion()
+    }
+  }
+
+  private static func deleteAllChatWebsiteData() async {
+    let store = WKWebsiteDataStore.default()
+    let allTypes = WKWebsiteDataStore.allWebsiteDataTypes()
+    let records = await store.dataRecords(ofTypes: allTypes)
+    let matching = records.filter { record in
+      let host = record.displayName.lowercased()
+      return chatDataDomainMatches.contains(where: host.contains)
     }
+    guard !matching.isEmpty else { return }
+    await store.removeData(ofTypes: allTypes, for: matching)
+  }
+
+  /// Install a `WKUserScript` on `controller` that hides any "back to inbox" /
+  /// conversations-list navigation rendered by the HubSpot chat widget.
+  ///
+  /// Called from the patched `HubspotChatWebView.WebviewCoordinator.setupScripts()`
+  /// (see `update-hubspot-ios-sdk.sh` for the patch that re-applies that hook on
+  /// every SDK sync). The actual heuristic-based hide JS lives here in our own
+  /// non-vendored file so SDK updates don't churn the implementation.
+  ///
+  /// We can't rely on a single CSS selector because:
+  ///   - HubSpot's widget uses minified/hashed class names that change across
+  ///     releases.
+  ///   - Parts of the widget render inside shadow roots, which a top-level
+  ///     `<style>` doesn't pierce.
+  ///   - The button can mount after first paint as the widget hydrates.
+  ///
+  /// The injected script installs a `MutationObserver` that walks the full tree
+  /// (recursing into open shadow roots) and hides anything that *behaves* like a
+  /// back button - matched on `aria-label`, `data-test-id`, `title`, `id`, `class`,
+  /// and visible text. Re-scans periodically for the first few seconds to cover
+  /// late-mounted shadow roots. Injected at document start in every frame.
+  @objc public static func installBackButtonHider(on controller: WKUserContentController) {
+    guard shouldHideBackToInboxButton else { return }
+
+    let script = WKUserScript(
+      source: backButtonHiderJS,
+      injectionTime: .atDocumentStart,
+      forMainFrameOnly: false
+    )
+    controller.addUserScript(script)
   }
 
+  /// Heuristic-based hider for the chat widget's back/inbox button. Designed to
+  /// work both as a `WKUserScript` (per-frame at `.atDocumentStart`) and as a
+  /// one-shot `evaluateJavascript` payload from the Android side - hence the
+  /// `walkAllFrames` / `bootstrap` split with the per-document install guard.
+  /// Keep this string in lockstep with `HubspotBackButtonHider.BACK_BUTTON_HIDER_JS`
+  /// in the Android wrapper. Insert spaces at camelCase boundaries and collapse
+  /// underscores/dashes to spaces so word-boundary matching catches class names
+  /// like `ConversationView__BackButton`. (In JS regex, `_` is a word char, so
+  /// without this `\\bback\\b` would fail against `..._back_...`.)
+  private static let backButtonHiderJS: String = """
+    (function() {
+      function bootstrap(win) {
+        var doc;
+        try { doc = win.document; } catch (_) { return; }
+        if (!doc || doc.__rnHubspotHiderInstalled) return;
+        doc.__rnHubspotHiderInstalled = true;
+
+        var BACK_PATTERN = /\\b(back|inbox|previous|conversations)\\b/i;
+
+        function normalize(s) {
+          if (!s) return '';
+          return String(s)
+            .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+            .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+            .replace(/[_-]+/g, ' ')
+            .toLowerCase();
+        }
+
+        function looksLikeBackControl(el) {
+          if (!el || el.nodeType !== 1) return false;
+          if (el.getAttribute('data-rn-hubspot-wrapper-hidden') === '1') return false;
+          var tag = el.tagName;
+          if (tag !== 'BUTTON' && tag !== 'A' && el.getAttribute('role') !== 'button') return false;
+          var attrs = [
+            el.getAttribute('aria-label'),
+            el.getAttribute('data-test-id'),
+            el.getAttribute('data-test'),
+            el.getAttribute('title'),
+            el.getAttribute('id'),
+            el.getAttribute('class')
+          ];
+          for (var i = 0; i < attrs.length; i++) {
+            if (attrs[i] && BACK_PATTERN.test(normalize(attrs[i]))) return true;
+          }
+          var text = (el.textContent || '').trim();
+          if (text && text.length <= 32 && BACK_PATTERN.test(normalize(text))) return true;
+          return false;
+        }
+
+        function hide(el) {
+          try {
+            el.setAttribute('data-rn-hubspot-wrapper-hidden', '1');
+            el.style.setProperty('display', 'none', 'important');
+            el.style.setProperty('visibility', 'hidden', 'important');
+            el.style.setProperty('pointer-events', 'none', 'important');
+          } catch (_) {}
+        }
+
+        // Hide `el`, then walk up to a few ancestors and also hide any wrapper
+        // that becomes empty (no remaining unhidden element children) as a
+        // result. HubSpot's chat header has a back-button slot whose padding
+        // / min-width / flex-basis stays around even when the inner button is
+        // `display:none`, which shows up as the avatar shifting right after the
+        // first message is sent. Capping at depth 3 keeps us inside the header.
+        function hideUpwards(el) {
+          hide(el);
+          var current = el;
+          for (var depth = 0; depth < 3; depth++) {
+            var parent = current.parentElement;
+            if (!parent) break;
+            if (parent === doc.documentElement || parent === doc.body) break;
+            var visibleCount = 0;
+            var children = parent.children;
+            for (var i = 0; i < children.length; i++) {
+              if (children[i].getAttribute('data-rn-hubspot-wrapper-hidden') !== '1') {
+                visibleCount++;
+              }
+            }
+            if (visibleCount > 0) break;
+            hide(parent);
+            current = parent;
+          }
+        }
+
+        var observed = new WeakSet();
+        function scanRoot(root) {
+          if (!root) return;
+          try {
+            var nodes = root.querySelectorAll('button, a, [role="button"]');
+            for (var i = 0; i < nodes.length; i++) {
+              if (looksLikeBackControl(nodes[i])) hideUpwards(nodes[i]);
+            }
+            var all = root.querySelectorAll('*');
+            for (var j = 0; j < all.length; j++) {
+              var sr = all[j].shadowRoot;
+              if (sr) {
+                scanRoot(sr);
+                attachObserver(sr);
+              }
+            }
+          } catch (_) {}
+        }
+
+        function attachObserver(root) {
+          if (!root || observed.has(root)) return;
+          observed.add(root);
+          try {
+            var mo = new MutationObserver(function() { scanRoot(root); });
+            mo.observe(root, { childList: true, subtree: true, attributes: true, attributeFilter: ['aria-label', 'data-test-id', 'data-test', 'title', 'class'] });
+          } catch (_) {}
+        }
+
+        function go() {
+          scanRoot(doc);
+          attachObserver(doc.documentElement || doc);
+        }
+
+        if (doc.readyState === 'loading') {
+          doc.addEventListener('DOMContentLoaded', go, { once: true });
+        } else {
+          go();
+        }
+      }
+
+      function walkAllFrames(win) {
+        if (!win) return;
+        bootstrap(win);
+        try {
+          for (var i = 0; i < win.frames.length; i++) {
+            walkAllFrames(win.frames[i]);
+          }
+        } catch (_) {}
+      }
+
+      walkAllFrames(window);
+    })();
+    """
+
   private static func topViewController(
     base: UIViewController? = UIApplication.shared.connectedScenes
       .compactMap { $0 as? UIWindowScene }

package/ios/RNHubspotWrapper.mm

@@ -34,10 +34,10 @@ RCT_EXPORT_MODULE(NativeHubspotWrapper)
   reject(@"INIT_ERROR", @"Failed to initialize HubSpot SDK", error);
 }
 
-- (void)openChat:(NSString *)chatflow resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+- (void)openChat:(NSString *)chatflow hideBackToInboxButton:(BOOL)hideBackToInboxButton resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
 {
   NSError *error = nil;
-  BOOL didOpen = [_impl openChat:chatflow error:&error];
+  BOOL didOpen = [_impl openChat:chatflow hideBackToInboxButton:hideBackToInboxButton error:&error];
   if (didOpen) {
     resolve(nil);
     return;
@@ -59,8 +59,13 @@ RCT_EXPORT_MODULE(NativeHubspotWrapper)
 
 - (void)clearUserData:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
 {
-  [_impl clearUserData];
-  resolve(nil);
+  // Important: do not resolve until the impl reports completion. The impl awaits the
+  // actual chat-identity cookie deletion before invoking this block. Resolving sooner
+  // creates a race where JS-level `await clearUserData()` returns before HubSpot's
+  // visitor cookies are gone, and the next `openChat` re-uses the previous identity.
+  [_impl clearUserData:^{
+    resolve(nil);
+  }];
 }
 
 @end

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "react-native-hubspot-wrapper",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "TurboModule wrapper for HubSpot mobile chat SDK",
   "main": "src/index.ts",
   "types": "src/index.ts",
   "files": [
     "src",
-    "android",
+    "android/build.gradle",
+    "android/src",
     "ios",
     "ReactNativeHubspotWrapper.podspec",
     "react-native.config.js",

package/scripts/update-hubspot-ios-sdk.sh

@@ -75,6 +75,31 @@ extension Bundle {
 if old_block not in content:
     raise RuntimeError("Expected Image extension block was not found in HubspotManager.swift")
 hubspot_manager.write_text(content.replace(old_block, new_block, 1))
+
+# 4) Hook our back-button hider into HubspotChatWebView's WKUserContentController.
+#    The actual hider implementation lives in our own non-vendored
+#    HubspotWrapperImpl.swift; this patch just inserts a one-line call so the
+#    hider runs whenever the SDK builds its content controller. We open chat as
+#    a single fresh conversation per session and never want users navigating
+#    into prior threads.
+chat_view = target_dir / "Views/ChatView/HubspotChatView.swift"
+chat_content = chat_view.read_text()
+anchor = (
+    'contentController.addUserScript(WKUserScript(source: js, '
+    'injectionTime: .atDocumentEnd, forMainFrameOnly: false))'
+)
+hook_block = (
+    "\n\n"
+    "            // [react-native-hubspot-wrapper] hide chat \"back to inbox\" button - see HubspotWrapperImpl\n"
+    "            HubspotWrapperImpl.installBackButtonHider(on: contentController)"
+)
+if anchor not in chat_content:
+    raise RuntimeError("Expected setupScripts anchor not found in HubspotChatView.swift")
+if "HubspotWrapperImpl.installBackButtonHider" in chat_content:
+    # Already patched.
+    pass
+else:
+    chat_view.write_text(chat_content.replace(anchor, anchor + hook_block, 1))
 PY
 }
 

package/src/index.ts

@@ -7,6 +7,10 @@ export type SetIdentityParams = {
   email?: string | null;
 };
 
+export type OpenChatOptions = {
+  hideBackToInboxButton?: boolean;
+};
+
 function ensureNonEmpty(value: string, fieldName: string): void {
   if (!value || !value.trim()) {
     throw new Error(`\`${fieldName}\` must be a non-empty string.`);
@@ -18,9 +22,9 @@ const HubspotWrapper = {
     return NativeHubspotWrapper.initialize();
   },
 
-  openChat(chatflow: string): Promise<void> {
+  openChat(chatflow: string, options: OpenChatOptions = {}): Promise<void> {
     ensureNonEmpty(chatflow, 'chatflow');
-    return NativeHubspotWrapper.openChat(chatflow);
+    return NativeHubspotWrapper.openChat(chatflow, options.hideBackToInboxButton ?? true);
   },
 
   setIdentity(params: SetIdentityParams): Promise<void> {

package/src/specs/NativeHubspotWrapper.ts

@@ -8,7 +8,7 @@ export type HubspotProperty = {
 
 export interface Spec extends TurboModule {
   initialize(): Promise<void>;
-  openChat(chatflow: string): Promise<void>;
+  openChat(chatflow: string, hideBackToInboxButton: boolean): Promise<void>;
   setIdentity(identityToken: string, email: string | null): Promise<void>;
   setProperties(properties: ReadonlyArray<HubspotProperty>): Promise<void>;
   clearUserData(): Promise<void>;

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -1,2 +0,0 @@
-#Tue Apr 28 11:02:36 CEST 2026
-gradle.version=8.13