@kindly-ai/react-native 0.1.0

package/ios/KindlyReactNativeImpl.swift

@@ -0,0 +1,410 @@
+// Swift implementation of the Kindly RN bridge — receives forwarded calls
+// from `KindlyReactNative.mm` and delegates to the public Kindly iOS SDK
+// (`import Kindly`, then `KindlyChatClient.start(...)` etc.).
+//
+// The bridge between this Swift class and the codegen-generated Obj-C++
+// TurboModule is the auto-generated `KindlyReactNative-Swift.h` header
+// (filename derives from the pod's `s.module_name`/`s.name`).
+//
+// Symmetric with `flutter-sdk/ios/Classes/KindlyPlugin.swift`. The biggest
+// difference: RN can't make synchronous calls JS→native→JS→native, so the
+// blocking-bool callbacks (`shouldHandleLink`, `shouldHandleNotification`)
+// use a request-id round-trip — we put a `CompletableDeferred`-equivalent
+// (`DispatchSemaphore` + locked dictionary) keyed by UUID, fire the request
+// event, JS replies via `respondToShouldHandle(requestId, value)`, native
+// signals the semaphore. 5-second timeout, defaults to `true`. Same
+// semantics as the Flutter pattern.
+
+import Combine
+import Foundation
+import Kindly
+import React
+import UIKit
+
+@objc public class KindlyReactNativeImpl: NSObject {
+
+  // The `RCTEventEmitter`-typed Obj-C class instance. Held weakly so we
+  // don't extend its lifetime past RN's bridge teardown.
+  private weak var emitter: KindlyReactNative?
+
+  // State publisher cache so `isChatDisplayed` can answer synchronously.
+  private var stateSubscription: AnyCancellable?
+  private var lastIsChatDisplayed: Bool = false
+
+  // Pending request maps for the sync round-trips. Each entry pairs a
+  // request UUID with a (semaphore, answer) tuple. Native blocks on the
+  // semaphore (5s); JS replies via respondToAuthToken / respondToShouldHandle
+  // which signals the semaphore.
+  private var authPending: [String: PendingAuth] = [:]
+  private var shouldHandlePending: [String: PendingBool] = [:]
+  private let pendingLock = NSLock()
+
+  private struct PendingAuth {
+    let semaphore: DispatchSemaphore
+    var token: String?
+  }
+  private struct PendingBool {
+    let semaphore: DispatchSemaphore
+    var value: Bool = true
+  }
+
+  // KindlyChatClientDelegate bridge — set as the delegate when at least one
+  // delegate flag is on. The bridge calls back into this class's helpers.
+  private var delegateBridge: KindlyDelegateBridge?
+
+  @objc public init(emitter: KindlyReactNative) {
+    self.emitter = emitter
+    super.init()
+    // Subscribe to the SDK's state publisher so isChatDisplayed is sync.
+    self.stateSubscription = KindlyChatClient.state.sink { [weak self] state in
+      self?.lastIsChatDisplayed = state.isChatDisplayed
+    }
+  }
+
+  // MARK: - Lifecycle
+
+  @objc public func start(botKey: String,
+                          languageCode: String?,
+                          hasAuthCallback: Bool) {
+    let lang = languageCode ?? "en"
+
+    let authCallback: AuthTokenCallback? = hasAuthCallback ? { [weak self] _, promise in
+      // Build a UUID-keyed pending entry, fire the JS event, block native
+      // for up to 5s waiting for `respondToAuthToken(requestId:token:)`.
+      guard let self = self else {
+        promise.reject(NSError(domain: "KindlyReactNative",
+                               code: -1,
+                               userInfo: [NSLocalizedDescriptionKey: "self deallocated"]))
+        return
+      }
+      let requestId = UUID().uuidString
+      let semaphore = DispatchSemaphore(value: 0)
+
+      self.pendingLock.lock()
+      self.authPending[requestId] = PendingAuth(semaphore: semaphore, token: nil)
+      self.pendingLock.unlock()
+
+      self.emit(name: "KindlyGetAuthToken", body: ["requestId": requestId])
+
+      // Wait off the calling thread (KindlyChatClient invokes the auth
+      // callback on a background queue; blocking is OK there).
+      DispatchQueue.global().async {
+        _ = semaphore.wait(timeout: .now() + 30.0)
+        self.pendingLock.lock()
+        let entry = self.authPending.removeValue(forKey: requestId)
+        self.pendingLock.unlock()
+        if let token = entry?.token {
+          promise.fulfill(token)
+        } else {
+          promise.reject(NSError(domain: "KindlyReactNative",
+                                 code: -1,
+                                 userInfo: [NSLocalizedDescriptionKey: "Auth token not provided"]))
+        }
+      }
+    } : nil
+
+    KindlyChatClient.start(botKey: botKey, languageCode: lang, authTokenCallback: authCallback)
+  }
+
+  @objc public func displayChat(languageCode: String?, triggerDialogueId: String?) {
+    KindlyChatClient.displayChat(languageCode: languageCode, triggerDialogueId: triggerDialogueId)
+  }
+
+  @objc public func launchChat(triggerDialogueId: String?) {
+    KindlyChatClient.displayChat(languageCode: nil, triggerDialogueId: triggerDialogueId)
+  }
+
+  @objc public func closeChat() {
+    KindlyChatClient.closeChat()
+  }
+
+  @objc public func endChat(resolve: @escaping RCTPromiseResolveBlock,
+                            reject: @escaping RCTPromiseRejectBlock) {
+    KindlyChatClient.endChat().then { _ in
+      resolve(NSNull())
+    }.catch { error in
+      reject("END_CHAT_FAILED", error.localizedDescription, error)
+    }
+  }
+
+  @objc public func kill(resolve: @escaping RCTPromiseResolveBlock,
+                         reject: @escaping RCTPromiseRejectBlock) {
+    KindlyChatClient.kill().then { _ in
+      resolve(NSNull())
+    }.catch { error in
+      reject("KILL_FAILED", error.localizedDescription, error)
+    }
+  }
+
+  @objc public func setLanguage(code: String,
+                                resolve: @escaping RCTPromiseResolveBlock,
+                                reject: @escaping RCTPromiseRejectBlock) {
+    KindlyChatClient.setLanguage(code).then { _ in
+      resolve(NSNull())
+    }.catch { error in
+      reject("SET_LANGUAGE_FAILED", error.localizedDescription, error)
+    }
+  }
+
+  // MARK: - Messaging
+
+  @objc public func sendMessage(text: String,
+                                newContext: [String: String]?,
+                                resolve: @escaping RCTPromiseResolveBlock,
+                                reject: @escaping RCTPromiseRejectBlock) {
+    KindlyChatClient.sendMessage(text, newContext: newContext).then { reconciled in
+      resolve(serializeChatMessage(reconciled))
+    }.catch { error in
+      reject("SEND_MESSAGE_FAILED", error.localizedDescription, error)
+    }
+  }
+
+  @objc public func setNewContext(_ context: [String: String]) {
+    KindlyChatClient.setNewContext(context)
+  }
+
+  @objc public func clearNewContext() {
+    KindlyChatClient.clearNewContext()
+  }
+
+  @objc public func triggerDialogue(_ dialogueId: String) {
+    KindlyChatClient.triggerDialogue(id: dialogueId)
+  }
+
+  @objc public func handleUrl(_ urlString: String) -> Bool {
+    guard let url = URL(string: urlString) else { return false }
+    return KindlyChatClient.handleURL(url)
+  }
+
+  // MARK: - Theme
+
+  @objc public func setCustomTheme(_ colors: [String: Any]) {
+    func color(_ key: String) -> UIColor? {
+      guard let raw = colors[key] as? Int else { return nil }
+      return UIColor(argb: raw)
+    }
+    KindlyChatClient.setCustomTheme(
+      background: color("background"),
+      botMessageBackground: color("botMessageBackground"),
+      botMessageText: color("botMessageText"),
+      buttonBackground: color("buttonBackground"),
+      buttonOutline: color("buttonOutline"),
+      buttonSelectedBackground: color("buttonSelectedBackground"),
+      buttonText: color("buttonText"),
+      defaultShadow: color("defaultShadow"),
+      inputBackground: color("inputBackground"),
+      inputCursor: color("inputCursor"),
+      inputText: color("inputText"),
+      navBarBackground: color("navBarBackground"),
+      navBarText: color("navBarText"),
+      userMessageBackground: color("userMessageBackground"),
+      userMessageText: color("userMessageText")
+    )
+  }
+
+  @objc public func clearCustomTheme() {
+    KindlyChatClient.clearCustomTheme()
+  }
+
+  // MARK: - Push
+
+  @objc public func setAPNSDeviceToken(_ token: String) {
+    KindlyChatClient.setAPNSDeviceToken(token)
+  }
+
+  @objc public func handleNotification(_ data: [AnyHashable: Any]) {
+    KindlyChatClient.notificationReceived(data)
+  }
+
+  @objc public func isKindlyNotification(_ data: [AnyHashable: Any]) -> Bool {
+    return KindlyChatClient.isKindlyNotification(data)
+  }
+
+  // MARK: - State / settings
+
+  @objc public func saveAuthToken(_ token: String) -> Bool {
+    return KindlyChatClient.saveAuthToken(token)
+  }
+
+  @objc public func isChatDisplayed() -> Bool {
+    return lastIsChatDisplayed
+  }
+
+  @objc public func setVerboseLogging(_ enabled: Bool) {
+    KindlyChatClient.verboseLogging = enabled
+  }
+
+  @objc public func setCrashReporting(_ enabled: Bool) {
+    KindlyChatClient.enableCrashReporting = enabled
+  }
+
+  // MARK: - Round-trip responders (called by JS)
+
+  @objc public func respondToAuthToken(_ requestId: String, token: String?) {
+    pendingLock.lock()
+    defer { pendingLock.unlock() }
+    guard var entry = authPending[requestId] else { return }
+    entry.token = token
+    authPending[requestId] = entry
+    entry.semaphore.signal()
+  }
+
+  @objc public func respondToShouldHandle(_ requestId: String, value: Bool) {
+    pendingLock.lock()
+    defer { pendingLock.unlock() }
+    guard var entry = shouldHandlePending[requestId] else { return }
+    entry.value = value
+    shouldHandlePending[requestId] = entry
+    entry.semaphore.signal()
+  }
+
+  // MARK: - Delegate gating
+
+  @objc public func setDelegate(buttonPressed: Bool,
+                                shouldHandleLink: Bool,
+                                shouldHandleNotification: Bool,
+                                onHandover: Bool) {
+    let bridge = delegateBridge ?? KindlyDelegateBridge(impl: self)
+    bridge.hasButtonPressed = buttonPressed
+    bridge.hasShouldHandleLink = shouldHandleLink
+    bridge.hasShouldHandleNotification = shouldHandleNotification
+    delegateBridge = bridge
+
+    let anySet = buttonPressed || shouldHandleLink || shouldHandleNotification
+    KindlyChatClient.delegate = anySet ? bridge : nil
+  }
+
+  // MARK: - Internal helpers used by the bridge
+
+  fileprivate func emit(name: String, body: Any?) {
+    emitter?.emitEvent(name, body: body)
+  }
+
+  /// Block native for up to 5s while JS computes a Bool answer. Default
+  /// `true` on timeout / no-listener — never hang the chat UI.
+  fileprivate func blockingShouldHandle(eventName: String, payload: [String: Any]) -> Bool {
+    let requestId = UUID().uuidString
+    let semaphore = DispatchSemaphore(value: 0)
+
+    pendingLock.lock()
+    shouldHandlePending[requestId] = PendingBool(semaphore: semaphore, value: true)
+    pendingLock.unlock()
+
+    var body = payload
+    body["requestId"] = requestId
+    DispatchQueue.main.async { [weak self] in
+      self?.emit(name: eventName, body: body)
+    }
+
+    _ = semaphore.wait(timeout: .now() + 5.0)
+
+    pendingLock.lock()
+    let entry = shouldHandlePending.removeValue(forKey: requestId)
+    pendingLock.unlock()
+    return entry?.value ?? true
+  }
+
+  fileprivate func emitButtonPressed(button: ExternalChatButton, chatLog: [ExternalChatMessage]) {
+    let payload: [String: Any] = [
+      "button": serializeExternalChatButton(button),
+      "chatLog": chatLog.map { serializeChatMessage($0) },
+    ]
+    DispatchQueue.main.async { [weak self] in
+      self?.emit(name: "KindlyOnButtonPressed", body: payload)
+    }
+  }
+}
+
+// MARK: - KindlyChatClientDelegate bridge
+
+/// Bridges the iOS SDK's `KindlyChatClientDelegate` protocol to the JS-side
+/// callbacks registered via `KindlySDK.setDelegate(...)`. Symmetric with the
+/// Flutter SDK's bridge — fire-and-forget for didPressButton, blocking-bool
+/// (5s timeout, default true) for shouldHandleLink / shouldHandleNotification.
+private final class KindlyDelegateBridge: NSObject, KindlyChatClientDelegate {
+  weak var impl: KindlyReactNativeImpl?
+  init(impl: KindlyReactNativeImpl) { self.impl = impl; super.init() }
+
+  var hasButtonPressed: Bool = false
+  var hasShouldHandleLink: Bool = false
+  var hasShouldHandleNotification: Bool = false
+
+  func didPressButton(chatButton: ExternalChatButton, chatLog: [ExternalChatMessage]) {
+    guard hasButtonPressed else { return }
+    impl?.emitButtonPressed(button: chatButton, chatLog: chatLog)
+  }
+
+  func shouldHandleLink(url: URL) -> Bool {
+    guard hasShouldHandleLink, let impl = impl else { return true }
+    return impl.blockingShouldHandle(
+      eventName: "KindlyShouldHandleLink",
+      payload: ["url": url.absoluteString]
+    )
+  }
+
+  func shouldHandleNotification(notification: ExternalNotification) -> Bool {
+    guard hasShouldHandleNotification, let impl = impl else { return true }
+    let payload: [String: Any] = [
+      "notification": [
+        "id": notification.id,
+        "title": notification.title,
+        "body": notification.body,
+        "data": stringifyUserInfo(notification.userInfo),
+      ],
+    ]
+    return impl.blockingShouldHandle(
+      eventName: "KindlyShouldHandleNotification",
+      payload: payload
+    )
+  }
+}
+
+// MARK: - Serialization helpers (file-private)
+
+private func serializeChatMessage(_ message: ExternalChatMessage) -> [String: Any] {
+  var dict = message.toDictionary()
+  if let created = dict["created"] as? Date {
+    dict["created"] = ISO8601DateFormatter().string(from: created)
+  }
+  return dict
+}
+
+/// `ExternalChatButton`'s fields are package-internal — reflect at runtime.
+private func serializeExternalChatButton(_ button: ExternalChatButton) -> [String: Any] {
+  var dict: [String: Any] = [:]
+  for child in Mirror(reflecting: button).children {
+    guard let label = child.label else { continue }
+    let value = child.value
+    let valueMirror = Mirror(reflecting: value)
+    if valueMirror.displayStyle == .optional {
+      if let unwrapped = valueMirror.children.first?.value {
+        dict[label] = unwrapped
+      }
+    } else {
+      dict[label] = value
+    }
+  }
+  return dict
+}
+
+private func stringifyUserInfo(_ userInfo: [AnyHashable: Any]) -> [String: String] {
+  var out: [String: String] = [:]
+  for (k, v) in userInfo {
+    if let key = k as? String {
+      out[key] = String(describing: v)
+    }
+  }
+  return out
+}
+
+extension UIColor {
+  /// Initialise from a 32-bit ARGB integer (Flutter `Color.value` convention).
+  fileprivate convenience init(argb: Int) {
+    self.init(
+      red: CGFloat((argb >> 16) & 0xFF) / 255.0,
+      green: CGFloat((argb >> 8) & 0xFF) / 255.0,
+      blue: CGFloat(argb & 0xFF) / 255.0,
+      alpha: CGFloat((argb >> 24) & 0xFF) / 255.0
+    )
+  }
+}

package/lib/module/NativeKindlyReactNative.js

@@ -0,0 +1,22 @@
+"use strict";
+
+// TurboModule spec for the @kindly-ai/react-native package.
+//
+// Codegen INPUT — `react-native` reads this at build time and generates the
+// abstract Spec class on iOS (Obj-C++ header) and Android (Kotlin abstract
+// class). The native module classes extend those.
+//
+// Convention used here: every method takes flat primitive parameters and
+// returns either a primitive or a Promise. We deliberately avoid nested
+// struct args (`(args: { ... })`) because codegen generates JS::Native*Args
+// C++ structs for those, which add fragility without buying anything for
+// our use case. This matches the scaffolded `multiply()` example pattern.
+//
+// Filename MUST match `Native<ModuleName>.ts`. ModuleName here is
+// `KindlyReactNative` — this becomes the native module name returned by
+// `getName()` and the registry key. Customer-facing imports come from the
+// package, not the module name.
+
+import { TurboModuleRegistry } from 'react-native';
+export default TurboModuleRegistry.getEnforcing('KindlyReactNative');
+//# sourceMappingURL=NativeKindlyReactNative.js.map

package/lib/module/NativeKindlyReactNative.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","getEnforcing"],"sourceRoot":"../../src","sources":["NativeKindlyReactNative.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,mBAAmB,QAAQ,cAAc;AA8DlD,eAAeA,mBAAmB,CAACC,YAAY,CAAO,mBAAmB,CAAC","ignoreList":[]}