@scribeup/react-native-scribeup 0.5.0 → 0.6.1

package/README.md

@@ -15,11 +15,13 @@ The package is a thin wrapper around the native [iOS](https://github.com/ScribeU
    1. [ScribeUp (Full Screen)](#scribeup-full-screen)
    2. [ScribeUpWidget (Embeddable)](#scribeupwidget-embeddable)
 4. [API Reference](#api-reference)
-5. [Example Projects](#example-projects)
-6. [Troubleshooting](#troubleshooting)
-7. [Author](#author)
-8. [License](#license)
+5. [Migration Note (0.3.x → 0.6.0)](#migration-note-03x--060)
+6. [Example Projects](#example-projects)
+7. [Troubleshooting](#troubleshooting)
+8. [Author](#author)
+9. [License](#license)
 
+---
 
 ## Installation
 
@@ -56,11 +58,15 @@ export default function App() {
 
   const authenticatedUrl = "https://example.com/subscriptions?token=YOUR_JWT"; // Obtain from your backend (see docs)
 
-  const handleExit = (data?: { message?: string; code?: number }) => {
-    console.log("ScribeUp finished", data);
+  const handleExit = (error: { code?: number; message?: string } | null, data: Record<string, any> | null) => {
+    console.log("ScribeUp exited", { error, data });
     setVisible(false);
   };
 
+  const handleEvent = (data: Record<string, any>) => {
+    console.log("ScribeUp event", data);
+  };
+
   return (
     <SafeAreaView style={{ flex: 1, justifyContent: "center", alignItems: "center" }}>
       <Button title="Manage my subscriptions" onPress={() => setVisible(true)} />
@@ -71,6 +77,7 @@ export default function App() {
           url={authenticatedUrl}
           productName="Subscription Manager" // optional text in the nav-bar
           onExit={handleExit} // called on success or error
+          onEvent={handleEvent}
         />
       )}
     </SafeAreaView>
@@ -130,14 +137,25 @@ export default function MyComponent() {
 
 ### ScribeUp (Full Screen)
 
-```
+```tsx
 <ScribeUp
-  url: string;              // required – authenticated manage-subscriptions URL
-  productName?: string;     // optional – title shown in the navigation bar
-  onExit?: (data?) => void; // optional – called when the user exits, with optional error
-/>
+  url: string;                              // required – authenticated manage-subscriptions URL
+  productName?: string;                     // optional – title in navigation bar
+  onExit?: (error: ExitError|null, data: object|null) => void;
+  onEvent?: (data: object) => void;
+>
 ```
 
+**`onExit`**
+Called when the user exits the flow.
+Receives two arguments:
+- `error`: `{ code: number; message?: string }` or `null` on success
+- `data`: structured object with optional payload
+
+**`onEvent`**
+Emitted zero or more times during the session to notify about intermediate states or actions (e.g., UI transitions, user actions).
+
+
 ### ScribeUpWidget (Embeddable)
 
 ```
@@ -152,14 +170,12 @@ export default function MyComponent() {
 - `reload()` – reloads the current page
 - `loadURL(url: string)` – loads a new URL
 
-### Exit Callback
-
-`onExit` receives an object with two optional fields:
+---
 
-* `message` – descriptive error or informational message.
-* `code` – numeric error code (0 on success, -1 on unknown error).
+## Migration Note (0.3.x → 0.6.0)
 
-If both fields are undefined, the flow completed without errors.
+- `onExit` now receives **two parameters**: `(error, data)` instead of a single `data` object.
+- New `onEvent(data)` listener added for real-time progress updates.
 
 ---
 
@@ -204,9 +220,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/ScribeupModule.kt

@@ -41,7 +41,7 @@ class ScribeupModule(reactContext: ReactApplicationContext) :
         if (error != null) {
           val params = Arguments.createMap()
           params.putString("message", error.message)
-          params.putString("code", error.code.toString())
+          params.putInt("code", error.code)
           currentPromise?.resolve(params)
         } else {
           currentPromise?.resolve(null)
@@ -50,8 +50,8 @@ class ScribeupModule(reactContext: ReactApplicationContext) :
       }
     } catch (e: Exception) {
       val params = Arguments.createMap()
-      params.putString("message", e.message ?: "Unknown error")
-      params.putString("code", "-1")
+      params.putString("message", e.message ?: "Unexpected Error")
+      params.putInt("code", 1000)
       promise.resolve(params)
       currentPromise = null
     }

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
@@ -15,12 +16,12 @@ import java.net.URL
 
 // Error codes shared between iOS and Android
 object ErrorCodes {
-  const val UNKNOWN = -1
+  const val UNKNOWN = 1000
   const val INVALID_URL = 1001
-  const val ACTIVITY_NULL = 1002
-  const val INVALID_ACTIVITY_TYPE = 1003
-  const val NO_ROOT_VIEW_CONTROLLER = 1004
-  const val SDK_ERROR = 2001
+  const val INVALID_ENV = 1002
+  const val ACTIVITY_NULL = 1003
+  const val INVALID_ACTIVITY_TYPE = 1004
+  const val NO_ROOT_VIEW_CONTROLLER = 1005
 }
 
 class ScribeupModuleImpl(private val reactContext: ReactApplicationContext) {
@@ -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 error = SubscriptionManagerError(message = e.message ?: "Unexpected Error", code = ErrorCodes.UNKNOWN)
+      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

@@ -4,12 +4,12 @@ import React
 
 // MARK: - Error Codes (shared between iOS and Android)
 fileprivate enum ErrorCodes {
-  static let unknown = -1
-  static let invalidUrl = 1001
-  static let activityNull = 1002
-  static let invalidActivityType = 1003
-  static let noRootViewController = 1004
-  static let sdkError = 2001
+  static let UNKNOWN = 1000
+  static let INVALID_URL = 1001
+  static let INVALID_ENV = 1002
+  static let ACTIVITY_NULL = 1003
+  static let INVALID_ACTIVITY_TYPE = 1004
+  static let NO_ROOT_VIEW_CONTROLLER = 1005
 }
 
 @objc(Scribeup)
@@ -24,7 +24,7 @@ class Scribeup: RCTEventEmitter {
 
   @objc
   override func supportedEvents() -> [String] {
-    return ["ScribeupOnExit"]
+    return ["ScribeupOnExit", "ScribeupOnEvent"]
   }
 
   // MARK: - Properties
@@ -46,7 +46,7 @@ class Scribeup: RCTEventEmitter {
 
     DispatchQueue.main.async {
       guard let rootVC = UIApplication.shared.delegate?.window??.rootViewController else {
-        self.rejecter?(String(ErrorCodes.noRootViewController), "Cannot find root view controller", nil)
+        self.rejecter?(String(ErrorCodes.NO_ROOT_VIEW_CONTROLLER), "Cannot find root view controller", nil)
         return
       }
 
@@ -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.5.0",
+  "version": "0.6.1",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -52,8 +52,8 @@
   },
   "config": {
     "nativeSDKVersions": {
-      "android": "0.8.2",
-      "ios": "0.8.3"
+      "android": "0.8.5",
+      "ios": "0.8.5"
     }
   }
 }

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;
+  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.
+ * 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 ?? 1000), 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 ?? 1000), 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 ?? 1000), message: err?.message || "Unexpected 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 ?? 1000), message: err?.message || "Unexpected Error" },
+        null,
+      );
     }
   }