@scribeup/react-native-scribeup 0.4.0 → 0.6.0

package/README.md

@@ -204,9 +204,9 @@ The first execution may take a while – the scripts:
 
 ## Troubleshooting
 
-1. **iOS: `The package '@scribeup/react-native-scribeup' doesn't seem to be linked`.**  
+1. **iOS: `The package '@scribeup/react-native-scribeup' doesn't seem to be linked`.**
    Make sure you ran `pod install` after installing the package and rebuilt the app.
-2. **Expo Go crashes when opening the manager.**  
+2. **Expo Go crashes when opening the manager.**
    Expo Go does not include native code. Use a dev-client or production build.
 3. Still stuck? Reach us at **dev@scribeup.io** or open an issue.
 

package/android/src/main/java/com/rnscribeupsdk/ScribeupModuleImpl.kt

@@ -5,6 +5,7 @@ import android.util.Log
 import androidx.fragment.app.FragmentActivity
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import io.scribeup.scribeupsdk.SubscriptionManager
@@ -38,7 +39,13 @@ class ScribeupModuleImpl(private val reactContext: ReactApplicationContext) {
     if (activity == null) {
       Log.e("Scribeup", "Activity is null")
       val error = SubscriptionManagerError(message = "Activity is null", code = ErrorCodes.ACTIVITY_NULL)
-      exitCallback?.invoke(error)
+      val params = Arguments.createMap().apply {
+        putMap("error", Arguments.createMap().apply {
+          putInt("code", error.code)
+          putString("message", error.message)
+        })
+      }
+      sendEvent("ScribeupOnExit", params)
       return
     }
 
@@ -46,7 +53,13 @@ class ScribeupModuleImpl(private val reactContext: ReactApplicationContext) {
     if (activity !is FragmentActivity) {
       Log.e("Scribeup", "Activity is not a FragmentActivity")
       val error = SubscriptionManagerError(message = "Activity is not a FragmentActivity", code = ErrorCodes.INVALID_ACTIVITY_TYPE)
-      exitCallback?.invoke(error)
+      val params = Arguments.createMap().apply {
+        putMap("error", Arguments.createMap().apply {
+          putInt("code", error.code)
+          putString("message", error.message)
+        })
+      }
+      sendEvent("ScribeupOnExit", params)
       return
     }
 
@@ -54,7 +67,13 @@ class ScribeupModuleImpl(private val reactContext: ReactApplicationContext) {
     if (!isValidUrl(url)) {
       Log.e("Scribeup", "Invalid URL: $url")
       val error = SubscriptionManagerError(message = "Invalid URL: $url", code = ErrorCodes.INVALID_URL)
-      exitCallback?.invoke(error)
+      val params = Arguments.createMap().apply {
+        putMap("error", Arguments.createMap().apply {
+          putInt("code", error.code)
+          putString("message", error.message)
+        })
+      }
+      sendEvent("ScribeupOnExit", params)
       return
     }
 
@@ -64,22 +83,41 @@ class ScribeupModuleImpl(private val reactContext: ReactApplicationContext) {
         url = url,
         productName = productName,
         listener = object : SubscriptionManagerListener {
-          override fun onExit(error: SubscriptionManagerError?) {
+          override fun onExit(error: SubscriptionManagerError?, data: Map<String, Any?>?) {
             val params = Arguments.createMap()
 
             if (error != null) {
-              params.putString("message", error.message)
-              params.putInt("code", error.code)
+              params.putMap("error", Arguments.createMap().apply {
+                putInt("code", error.code)
+                putString("message", error.message)
+              })
             }
 
-            exitCallback?.invoke(error)
+            if (data != null) {
+              params.putMap("data", toWritableMap(data))
+            }
+
+            sendEvent("ScribeupOnExit", params)
+          }
+
+          override fun onEvent(data: Map<String, Any?>) {
+            val params = Arguments.createMap().apply {
+              putMap("data", toWritableMap(data))
+            }
+            sendEvent("ScribeupOnEvent", params)
           }
         }
       )
     } catch (e: Exception) {
       Log.e("Scribeup", "Error presenting subscription manager: ${e.message}")
       val error = SubscriptionManagerError(message = e.message ?: "Unknown error", code = ErrorCodes.UNKNOWN)
-      exitCallback?.invoke(error)
+      val params = Arguments.createMap().apply {
+        putMap("error", Arguments.createMap().apply {
+          putInt("code", error.code)
+          putString("message", error.message)
+        })
+      }
+      sendEvent("ScribeupOnExit", params)
     }
   }
 
@@ -97,21 +135,56 @@ class ScribeupModuleImpl(private val reactContext: ReactApplicationContext) {
     reactContext.runOnUiQueueThread {
       try {
         val eventEmitter = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        eventEmitter.emit(eventName, params ?: Arguments.createMap())
+      } catch (e: Exception) {
+        Log.e("Scribeup", "Error emitting event: ${e.message}")
+      }
+    }
+  }
 
-        val newParams = Arguments.createMap()
-        if (params != null) {
-          if (params.hasKey("message")) {
-            newParams.putString("message", params.getString("message"))
-          }
-          if (params.hasKey("code")) {
-            newParams.putString("code", params.getString("code"))
-          }
+  // -------------------- Converters: Map/List -> Writable* --------------------
+
+  @Suppress("UNCHECKED_CAST")
+  private fun toWritableMap(map: Map<String, Any?>): WritableMap {
+    val out = Arguments.createMap()
+    for ((kAny, v) in map) {
+      val key = kAny as String
+      when (v) {
+        null -> out.putNull(key)
+        is String -> out.putString(key, v)
+        is Int -> out.putInt(key, v)
+        is Long -> {
+          if (v in Int.MIN_VALUE..Int.MAX_VALUE) out.putInt(key, v.toInt()) else out.putDouble(key, v.toDouble())
         }
+        is Float -> out.putDouble(key, v.toDouble())
+        is Double -> out.putDouble(key, v)
+        is Boolean -> out.putBoolean(key, v)
+        is Map<*, *> -> out.putMap(key, toWritableMap(v as Map<String, Any?>))
+        is List<*> -> out.putArray(key, toWritableArray(v))
+        else -> out.putString(key, v.toString())
+      }
+    }
+    return out
+  }
 
-        eventEmitter.emit("ScribeupExitSignal", newParams)
-      } catch (e: Exception) {
-        Log.e("Scribeup", "Error emitting event: ${e.message}")
+  private fun toWritableArray(list: List<*>): WritableArray {
+    val out = Arguments.createArray()
+    for (v in list) {
+      when (v) {
+        null -> out.pushNull()
+        is String -> out.pushString(v)
+        is Int -> out.pushInt(v)
+        is Long -> {
+          if (v in Int.MIN_VALUE..Int.MAX_VALUE) out.pushInt(v.toInt()) else out.pushDouble(v.toDouble())
+        }
+        is Float -> out.pushDouble(v.toDouble())
+        is Double -> out.pushDouble(v)
+        is Boolean -> out.pushBoolean(v)
+        is Map<*, *> -> out.pushMap(toWritableMap(v as Map<String, Any?>))
+        is List<*> -> out.pushArray(toWritableArray(v))
+        else -> out.pushString(v.toString())
       }
     }
+    return out
   }
 }

package/ios/ScribeupModule.swift

@@ -24,7 +24,7 @@ class Scribeup: RCTEventEmitter {
 
   @objc
   override func supportedEvents() -> [String] {
-    return ["ScribeupOnExit"]
+    return ["ScribeupOnExit", "ScribeupOnEvent"]
   }
 
   // MARK: - Properties
@@ -60,18 +60,27 @@ class Scribeup: RCTEventEmitter {
     }
   }
 
-  func sendExitEvent(error: SubscriptionManagerError?) {
+  func sendExitEvent(error: SubscriptionManagerError?, data: [String: Any]?) {
     if self.hasListeners {
       var body: [String: Any] = [:]
 
       if let error = error {
-        body["error"] = ["code": ErrorCodes.sdkError, "message": error.message]
+        body["error"] = ["code": error.code, "message": error.message]
+      }
+      if let data = data {
+        body["data"] = data
       }
 
       self.sendEvent(withName: "ScribeupOnExit", body: body)
     }
   }
 
+  func sendOnEvent(data: [String: Any]) {
+    if self.hasListeners {
+      self.sendEvent(withName: "ScribeupOnEvent", body: ["data": data])
+    }
+  }
+
   override func startObserving() {
     self.hasListeners = true
   }
@@ -88,18 +97,24 @@ class ScribeupSubscriptionListener: NSObject, SubscriptionManagerListener {
         self.delegate = delegate
     }
 
-    func onExit(_ error: SubscriptionManagerError?) {
+    func onExit(_ error: SubscriptionManagerError?, _ data: [String: Any]?) {
         if let delegate = self.delegate {
             if let error = error {
                 delegate.rejecter?(String(error.code), error.message, nil)
             } else {
-                delegate.resolver?(nil)
+                var payload: [String: Any] = [:]
+                if let data = data { payload["data"] = data }
+                delegate.resolver?(payload)
             }
 
             delegate.resolver = nil
             delegate.rejecter = nil
         }
 
-        self.delegate?.sendExitEvent(error: error)
+        self.delegate?.sendExitEvent(error: error, data: data)
+    }
+
+    func onEvent(_ data: [String: Any]) {
+        self.delegate?.sendOnEvent(data: data)
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scribeup/react-native-scribeup",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -52,8 +52,8 @@
   },
   "config": {
     "nativeSDKVersions": {
-      "android": "0.8.0",
-      "ios": "0.8.0"
+      "android": "0.8.2",
+      "ios": "0.8.3"
     }
   }
 }

package/src/ScribeUp.d.ts

@@ -1,30 +1,46 @@
 import React from "react";
-/**
- * Data type returned when the SDK process ends
- */
-export type ExitData = {
-    message?: string;
-    code?: number;
-};
+
+/** JSON value types allowed inside data payloads */
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonObject
+  | JsonValue[];
+
+export interface JsonObject {
+  [key: string]: JsonValue;
+}
+
+/** Error returned when the SDK process ends with failure */
+export interface ExitError {
+  code: number;
+  message?: string;
+}
+
 /**
  * ScribeUp component properties
  */
 export interface ScribeUpProps {
-    url: string;
-    productName: string;
-    onExit: (data?: ExitData) => void;
+  url: string;
+  productName?: string;
+  onExit: (error: ExitError | null, data: JsonObject | null) => void;
+  onEvent?: (data: JsonObject) => void;
 }
+
 /**
  * ScribeUp Component
  *
  * React component that displays the ScribeUp SDK interface when
- * mounted and invokes the onExit callback when the user completes or
- * cancels the process.
+ * mounted and invokes the callbacks as the user interacts with or
+ * exits the flow.
  */
 declare class ScribeUp extends React.Component<ScribeUpProps> {
-    constructor(props: ScribeUpProps);
-    componentDidMount(): void;
-    private present;
-    render(): any;
+  constructor(props: ScribeUpProps);
+  componentDidMount(): void;
+  private present;
+  render(): any;
 }
+
 export default ScribeUp;

package/src/ScribeUp.tsx

@@ -1,5 +1,10 @@
 import React from "react";
-import { NativeModules, Platform } from "react-native";
+import {
+  NativeModules,
+  Platform,
+  NativeEventEmitter,
+  EmitterSubscription,
+} from "react-native";
 
 const LINKING_ERROR =
   `The package 'scribeup-react-native-scribeup' doesn't seem to be linked. Make sure: \n\n` +
@@ -20,65 +25,152 @@ const Scribeup = NativeModules.Scribeup
       },
     );
 
-/**
- * Data type returned when the SDK process ends
- */
-export type ExitData = {
+const EXIT_EVENT = "ScribeupOnExit";
+const EVENT_NAME = "ScribeupOnEvent";
+
+/** JSON value types allowed inside data payloads */
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonObject
+  | JsonValue[];
+
+export interface JsonObject {
+  [key: string]: JsonValue;
+}
+
+export type ExitError = {
+  code: number;
   message?: string;
-  code?: number;
 };
 
+type ExitPayload = { error?: ExitError; data?: JsonObject };
+type EventPayload = { data?: JsonObject };
+
 /**
  * ScribeUp component properties
  */
 export interface ScribeUpProps {
   url: string;
   productName: string;
-  onExit: (data?: ExitData) => void;
+  onExit?: (error: ExitError | null, data: JsonObject | null) => void;
+  onEvent?: (data: JsonObject) => void;
 }
 
 /**
  * ScribeUp Component
  *
- * React component that displays the ScribeUp SDK interface when
- * mounted and invokes the onExit callback when the user completes or
- * cancels the process.
+ * Presents the native UI on mount and wires callbacks via device events.
+ * Safe against modules that don't implement addListener/removeListeners.
  */
 class ScribeUp extends React.Component<ScribeUpProps> {
-  constructor(props: ScribeUpProps) {
-    super(props);
-  }
+  private emitter?: NativeEventEmitter;
+  private exitSub?: EmitterSubscription;
+  private eventSub?: EmitterSubscription;
+  private didExit = false;
 
   componentDidMount() {
-    const { url, productName, onExit } = this.props;
-    this.present(url, productName, onExit);
+    const { url, productName } = this.props;
+
+    // Use module-backed emitter only if it implements the listener API.
+    const canAttach =
+      Scribeup &&
+      typeof (Scribeup as any).addListener === "function" &&
+      typeof (Scribeup as any).removeListeners === "function";
+
+    this.emitter = new NativeEventEmitter(canAttach ? (Scribeup as any) : undefined);
+
+    // Subscribe to onExit
+    this.exitSub = this.emitter.addListener(
+      EXIT_EVENT,
+      (payload?: ExitPayload) => {
+        if (this.didExit) return;
+        this.didExit = true;
+
+        const error: ExitError | null = payload?.error
+          ? { code: Number(payload.error.code ?? -1), message: payload.error.message }
+          : null;
+
+        const data: JsonObject | null =
+          payload?.data && typeof payload.data === "object"
+            ? (payload.data as JsonObject)
+            : null;
+
+        this.props.onExit?.(error, data);
+      },
+    );
+
+    // Subscribe to onEvent
+    this.eventSub = this.emitter.addListener(
+      EVENT_NAME,
+      (payload?: EventPayload) => {
+        const data =
+          payload?.data && typeof payload.data === "object"
+            ? (payload.data as JsonObject)
+            : null;
+        if (data) this.props.onEvent?.(data);
+      },
+    );
+
+    // Present the native UI. Support both promise- and event-based native APIs.
+    this.present(url, productName);
   }
 
-  private present(
-    url: string,
-    productName: string,
-    onExit: (data?: ExitData) => void,
-  ) {
-    if (Scribeup && typeof Scribeup.presentWithUrl === "function") {
-      try {
-        Scribeup.presentWithUrl(url, productName)
+  componentWillUnmount() {
+    try {
+      this.exitSub?.remove();
+      this.eventSub?.remove();
+    } finally {
+      this.exitSub = undefined;
+      this.eventSub = undefined;
+      this.emitter = undefined;
+    }
+  }
+
+  private present(url: string, productName: string) {
+    if (!(Scribeup && typeof (Scribeup as any).presentWithUrl === "function")) {
+      throw new Error(`ScribeUp: Native module not found for ${Platform.OS}`);
+    }
+
+    try {
+      const ret = (Scribeup as any).presentWithUrl(url, productName);
+
+      // If native returns a Promise, also resolve to onExit (guarded to avoid duplicate calls).
+      if (ret && typeof ret.then === "function") {
+        ret
           .then((result: any) => {
-            onExit(result || {});
+            if (this.didExit) return; // event already handled exit
+            this.didExit = true;
+
+            const error: ExitError | null = result?.error
+              ? { code: Number(result.error.code ?? -1), message: result.error.message }
+              : null;
+
+            const data: JsonObject | null =
+              result && result.data && typeof result.data === "object"
+                ? (result.data as JsonObject)
+                : null;
+
+            this.props.onExit?.(error, data);
           })
-          .catch((error: any) => {
-            onExit({
-              message: error?.message || "Unknown error",
-              code: error?.code || -1,
-            });
+          .catch((err: any) => {
+            if (this.didExit) return;
+            this.didExit = true;
+            this.props.onExit?.(
+              { code: Number(err?.code ?? -1), message: err?.message || "Unknown error" },
+              null,
+            );
           });
-      } catch (error: any) {
-        onExit({
-          message: error?.message || "Unknown error",
-          code: error?.code || -1,
-        });
       }
-    } else {
-      throw new Error(`ScribeUp: Native module not found for ${Platform.OS}`);
+    } catch (err: any) {
+      if (this.didExit) return;
+      this.didExit = true;
+      this.props.onExit?.(
+        { code: Number(err?.code ?? -1), message: err?.message || "Unknown error" },
+        null,
+      );
     }
   }