react-native-newinstance-chat 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 lawrence
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NewinstanceChat.podspec

@@ -0,0 +1,23 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "NewinstanceChat"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/talktothelaw/react-native-newinstance-chat.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+
+  # Native chat SDK we wrap, published on CocoaPods Trunk.
+  s.dependency "LiveAndAiChat", "~> 0.1"
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,106 @@
+# react-native-newinstance-chat
+
+React Native bindings for [LiveAndAiChat](https://newinstance.cloud) — drops a
+complete AI + live-agent chat experience into your iOS and Android RN app
+via native module bridges.
+
+The chat UI, transport, attachments, image cache, typing indicators, and
+silent gap-fill resync all come from the native iOS / Android SDKs. This
+package is a thin TurboModule surface over them — your React Native code
+stays small.
+
+## Requirements
+
+- React Native 0.74+ (TurboModule support — recommended 0.85+)
+- iOS 15.1+
+- Android API 24+, JDK 17
+
+## Installation
+
+```sh
+npm install react-native-newinstance-chat
+# or
+yarn add react-native-newinstance-chat
+```
+
+### iOS
+
+```sh
+cd ios && pod install
+```
+
+Autolink pulls the `NewinstanceChat` podspec, which transitively depends
+on `LiveAndAiChat` (the native SDK pod, published on CocoaPods Trunk).
+
+### Android
+
+Autolink registers `NewinstanceChatPackage`. The underlying
+`cloud.newinstance:liveandaichat` AAR is resolved from Maven Central —
+ensure `mavenCentral()` is in `settings.gradle.kts`.
+
+## Quick start
+
+```tsx
+import { NewinstanceChat } from 'react-native-newinstance-chat';
+
+const sdk = new NewinstanceChat({
+  apiKey: 'sk_live_…',
+});
+
+sdk.setUser({
+  customerName: 'Ada Lovelace',
+  customerEmail: 'ada@example.com',
+});
+
+await sdk.initialize();
+
+// Later, in response to a host button tap:
+sdk.openChat();
+```
+
+The chat screen renders natively — there is no React component to mount.
+Your RN UI is whatever button / banner / FAB triggers `openChat()`.
+
+### Subscribing to events
+
+```ts
+const unsub = sdk.addListener('messageReceived', (m) => {
+  console.log('rx <-', m.content);
+});
+// Later:
+unsub();
+```
+
+Event names: `messageReceived`, `messageSent`, `agentTypingChanged`,
+`connectionStateChanged`, `unreadCountChanged`, `error`. See `src/types.ts`
+for payload shapes.
+
+### Sending messages programmatically
+
+```ts
+sdk.sendMessage('Hi, I have a question.');
+sdk.attachFile({ uri: 'file:///…', name: 'screenshot.png', mimeType: 'image/png' });
+sdk.retryMessage(failedMessageId);
+```
+
+Handoff to a live agent and typing indicators are driven automatically
+by the native chat screen — there's nothing to wire up from the host.
+
+### Tear-down
+
+```ts
+sdk.destroy();
+```
+
+Call this when your host component unmounts. After `destroy()` the
+instance is unusable — construct a new one if you need to chat again.
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT

package/android/build.gradle

@@ -0,0 +1,79 @@
+buildscript {
+  ext.NewinstanceChat = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return NewinstanceChat[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.newinstancechat"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lint {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+  // Dev fallback: pick up `cloud.newinstance:liveandaichat:0.1.0` from
+  // ~/.m2/repository if the developer ran `./gradlew :sdk:publishToMavenLocal`
+  // in liveAndAiChat-android/ but the Maven Central publish hasn't
+  // landed yet. Remove this once the SDK is live on Maven Central.
+  mavenLocal()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  // Native chat SDK the bridge wraps. Published under cloud.newinstance.
+  implementation "cloud.newinstance:liveandaichat:0.1.0"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/com/newinstancechat/NewinstanceChatModule.kt

@@ -0,0 +1,200 @@
+package com.newinstancechat
+
+import cloud.newinstance.liveandaichat.ConnectionState
+import cloud.newinstance.liveandaichat.LiveAndAiChat
+import cloud.newinstance.liveandaichat.LiveAndAiChatConfig
+import cloud.newinstance.liveandaichat.LiveAndAiChatError
+import cloud.newinstance.liveandaichat.ChatUser
+import cloud.newinstance.liveandaichat.model.ChatMessage
+import cloud.newinstance.liveandaichat.model.TransportMode
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+
+/**
+ * React Native ↔ LiveAndAiChat Android SDK bridge (TurboModule).
+ *
+ * Holds a single underlying `LiveAndAiChat` instance built lazily on
+ * `configure(...)`. Repeated `configure(...)` calls tear down and
+ * rebuild — hosts almost never want concurrent chat sessions.
+ *
+ * Events emitted to JS via `RCTDeviceEventEmitter`:
+ *   - `messageReceived`           (ChatMessage map)
+ *   - `messageSent`               (ChatMessage map)
+ *   - `agentTypingChanged`        (Boolean)
+ *   - `connectionStateChanged`    (lowercased connection state name)
+ *   - `unreadCountChanged`        (Int)
+ *   - `error`                     ({type, message, recoverable})
+ */
+class NewinstanceChatModule(reactContext: ReactApplicationContext) :
+  NativeNewinstanceChatSpec(reactContext), LiveAndAiChat.Listener {
+
+  private var sdk: LiveAndAiChat? = null
+  private var pendingUser: ChatUser? = null
+
+  override fun getName(): String = NAME
+
+  private fun emit(event: String, body: Any?) {
+    reactApplicationContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(event, body)
+  }
+
+  // MARK: - configure / setUser / initialize
+
+  override fun configure(config: ReadableMap, promise: Promise) {
+    val apiKey = config.getString("apiKey")
+    if (apiKey.isNullOrBlank()) {
+      promise.reject("E_CONFIG", "apiKey is required")
+      return
+    }
+    val baseUrl = if (config.hasKey("baseUrl")) config.getString("baseUrl") else null
+    val initialMessage =
+      if (config.hasKey("initialMessage")) config.getString("initialMessage") else null
+    val transport: TransportMode? = if (config.hasKey("transport")) {
+      when (config.getString("transport")) {
+        "sse" -> TransportMode.SSE
+        "ws"  -> TransportMode.WS
+        else  -> null
+      }
+    } else null
+
+    try {
+      val cfg = LiveAndAiChatConfig(
+        apiKey = apiKey,
+        baseUrl = baseUrl ?: LiveAndAiChatConfig.DEFAULT_BASE_URL,
+        transport = transport,
+        initialMessage = initialMessage,
+      )
+      sdk?.destroy()
+      val builder = LiveAndAiChat.Builder(reactApplicationContext).config(cfg)
+      pendingUser?.let { builder.user(it) }
+      val instance = builder.build()
+      instance.addListener(this)
+      sdk = instance
+      pendingUser = null
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("E_BUILD", e.message, e)
+    }
+  }
+
+  override fun setUser(user: ReadableMap) {
+    val name = user.getString("customerName") ?: return
+    if (name.isBlank()) return
+    val chatUser = ChatUser(
+      customerName = name,
+      customerId = if (user.hasKey("customerId")) user.getString("customerId") else null,
+      customerEmail = if (user.hasKey("customerEmail")) user.getString("customerEmail") else null,
+    )
+    val current = sdk
+    if (current != null) {
+      current.setUser(chatUser)
+    } else {
+      pendingUser = chatUser
+    }
+  }
+
+  override fun initialize(promise: Promise) {
+    val current = sdk
+    if (current == null) {
+      promise.reject("E_NOT_CONFIGURED", "configure() must be called before initialize()")
+      return
+    }
+    current.initialize()
+    promise.resolve(null)
+  }
+
+  // MARK: - Native chat presentation
+
+  override fun openChat()  { sdk?.openChat() }
+  override fun closeChat() { sdk?.closeChat() }
+
+  // MARK: - Programmatic actions
+
+  override fun sendMessage(text: String)       { sdk?.sendMessage(text) }
+  override fun retryMessage(messageId: String) { sdk?.retryMessage(messageId) }
+
+  override fun attachFile(opts: ReadableMap, promise: Promise) {
+    val current = sdk
+    if (current == null) {
+      promise.reject("E_NOT_CONFIGURED", "configure() must be called first")
+      return
+    }
+    val uri = opts.getString("uri")
+    val name = opts.getString("name")
+    val mimeType = opts.getString("mimeType")
+    if (uri == null || name == null || mimeType == null) {
+      promise.reject("E_ARGS", "uri, name, mimeType are required")
+      return
+    }
+    try {
+      val bytes = reactApplicationContext.contentResolver
+        .openInputStream(android.net.Uri.parse(uri))?.use { it.readBytes() }
+        ?: throw java.io.IOException("Could not open content URI: $uri")
+      current.attachFile(bytes, name, mimeType, uri)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("E_READ", e.message, e)
+    }
+  }
+
+  override fun destroy() {
+    sdk?.destroy()
+    sdk = null
+    pendingUser = null
+  }
+
+  // RN NativeEventEmitter listener tracking — required by Codegen even
+  // though the actual emit path is RCTDeviceEventEmitter (above).
+  override fun addListener(eventName: String) { /* no-op */ }
+  override fun removeListeners(count: Double) { /* no-op */ }
+
+  // MARK: - LiveAndAiChat.Listener
+
+  override fun onMessageReceived(message: ChatMessage) {
+    emit("messageReceived", chatMessageToMap(message))
+  }
+  override fun onMessageSent(message: ChatMessage) {
+    emit("messageSent", chatMessageToMap(message))
+  }
+  override fun onTyping(isTyping: Boolean) {
+    emit("agentTypingChanged", isTyping)
+  }
+  override fun onConnectionChange(state: ConnectionState) {
+    emit("connectionStateChanged", state.name.lowercase())
+  }
+  override fun onUnreadCountChange(count: Int) {
+    emit("unreadCountChanged", count)
+  }
+  override fun onError(error: LiveAndAiChatError) {
+    val map = Arguments.createMap()
+    map.putString("type", error.type.name.lowercase())
+    map.putString("message", error.message)
+    map.putBoolean("recoverable", error.recoverable)
+    emit("error", map)
+  }
+
+  // MARK: - Helpers
+
+  private fun chatMessageToMap(m: ChatMessage): WritableMap {
+    val map = Arguments.createMap()
+    map.putString("id", m.id)
+    map.putString("clientId", m.clientId)
+    map.putString("conversationId", m.conversationId)
+    map.putString("content", m.content)
+    map.putString("type", m.type.name.lowercase())
+    map.putString("status", m.status.name.lowercase())
+    m.seq?.let { map.putDouble("seq", it.toDouble()) }
+    m.sentAt?.let { map.putString("sentAt", it) }
+    m.totalMessages?.let { map.putInt("totalMessages", it) }
+    return map
+  }
+
+  companion object {
+    const val NAME = NativeNewinstanceChatSpec.NAME
+  }
+}

package/android/src/main/java/com/newinstancechat/NewinstanceChatPackage.kt

@@ -0,0 +1,31 @@
+package com.newinstancechat
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class NewinstanceChatPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == NewinstanceChatModule.NAME) {
+      NewinstanceChatModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      NewinstanceChatModule.NAME to ReactModuleInfo(
+        name = NewinstanceChatModule.NAME,
+        className = NewinstanceChatModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+    )
+  }
+}

package/ios/NewinstanceChat.h

@@ -0,0 +1,12 @@
+#import <NewinstanceChatSpec/NewinstanceChatSpec.h>
+
+@class NewinstanceChatImpl;
+
+@interface NewinstanceChat : NSObject <NativeNewinstanceChatSpec>
+
+/// Emit a JS-side `RCTDeviceEventEmitter` event. Called by
+/// NewinstanceChatImpl (Swift) when the underlying LiveAndAiChat SDK
+/// surfaces a delegate callback.
+- (void)emitEvent:(NSString *)name body:(id)body;
+
+@end

package/ios/NewinstanceChat.mm

@@ -0,0 +1,103 @@
+#import "NewinstanceChat.h"
+#import <React/RCTBridge.h>
+#import <React/RCTEventDispatcherProtocol.h>
+
+// Auto-generated Swift bridging header for this pod (created at build
+// time by Xcode/CocoaPods when the pod mixes Obj-C and Swift). The pod
+// name is `NewinstanceChat`, hence the header name.
+#import "NewinstanceChat-Swift.h"
+
+// Declare conformance to NewinstanceChatEmitter (defined in
+// NewinstanceChatImpl.swift) so the Swift impl can hold a typed weak
+// reference to us. The auto-generated NewinstanceChat-Swift.h imported
+// above provides the protocol declaration.
+@interface NewinstanceChat () <NewinstanceChatEmitter>
+@property (nonatomic, strong) NewinstanceChatImpl *impl;
+@end
+
+@implementation NewinstanceChat
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE()
+
+- (instancetype)init
+{
+  if ((self = [super init])) {
+    _impl = [[NewinstanceChatImpl alloc] init];
+    _impl.emitter = self;
+  }
+  return self;
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+// MARK: - Spec methods (delegated to Swift)
+
+- (void)configure:(NSDictionary *)config
+          resolve:(RCTPromiseResolveBlock)resolve
+           reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl configure:config resolver:resolve rejecter:reject];
+}
+
+- (void)setUser:(NSDictionary *)user
+{
+  [_impl setUser:user];
+}
+
+- (void)initialize:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl initializeWithResolver:resolve rejecter:reject];
+}
+
+- (void)openChat  { [_impl openChat]; }
+- (void)closeChat { [_impl closeChat]; }
+- (void)destroy   { [_impl destroy]; }
+
+- (void)sendMessage:(NSString *)text       { [_impl sendMessage:text]; }
+- (void)retryMessage:(NSString *)messageId { [_impl retryMessage:messageId]; }
+
+- (void)attachFile:(NSDictionary *)opts
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl attachFile:opts resolver:resolve rejecter:reject];
+}
+
+// NativeEventEmitter wires these so it can track subscriber counts. The
+// actual event payloads flow through RCTDeviceEventEmitter, so these are
+// intentional no-ops.
+- (void)addListener:(NSString *)eventName { }
+- (void)removeListeners:(double)count     { }
+
+// MARK: - Event emission helper (called from Swift)
+
+- (void)emitEvent:(NSString *)name body:(id)body
+{
+  // RCTDeviceEventEmitter is registered on every RN bridge instance.
+  // `enqueueJSCall:method:args:completion:` works in both bridge mode
+  // and bridgeless mode (the new arch shims it). The `bridge` property
+  // is synthesised by RCT_EXPORT_MODULE; nil in unusual bridgeless
+  // setups where the module is constructed without an attached bridge.
+  if (!self.bridge) return;
+  id payload = body ?: [NSNull null];
+  [self.bridge enqueueJSCall:@"RCTDeviceEventEmitter"
+                      method:@"emit"
+                        args:@[name, payload]
+                  completion:NULL];
+}
+
+// MARK: - TurboModule registration
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeNewinstanceChatSpecJSI>(params);
+}
+
+@end