noibu-react-native 0.2.27 → 0.2.29

package/android/src/legacy/java/com/noibu/sessionreplay/reactnative/NoibuSessionReplayModule.kt

@@ -8,6 +8,7 @@ import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.facebook.react.bridge.ReactMethod
 
 // Update the import statements to point to the KMP shared module's package
+// Import from published artifact when building outside monorepo; otherwise same package
 import com.noibu.mobile.android.sessionreplay.Noibu
 import com.noibu.mobile.android.sessionreplay.NoibuConfig
 
@@ -23,12 +24,20 @@ class NoibuSessionReplayModule(reactContext: ReactApplicationContext) :
     }
 
     private fun sendEvent(eventName: String, params: WritableMap?) {
-        reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit(eventName, params)
+        try {
+            reactContext?.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)?.emit(eventName, params)
+        } catch (t: Throwable) {
+            Log.e(NAME, "Failed to emit $eventName", t)
+        }
     }
 
     @ReactMethod
     fun initialize( promise: Promise ) {
-        val context = currentActivity?.applicationContext ?: reactContext?.applicationContext ?: return
+        val context = currentActivity?.applicationContext ?: reactContext?.applicationContext
+        if (context == null) {
+            promise.reject("E_INIT", IllegalStateException("No application context"))
+            return
+        }
         val config = NoibuConfig(
             sessionReplayEnabled = true,
             maskAllTextInputs = false,

package/android/src/newarch/java/com/noibu/sessionreplay/reactnative/NoibuSessionRecorderModule.kt

@@ -7,15 +7,18 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.turbomodule.core.interfaces.TurboModule
 import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.noibu.mobile.android.sessionreplay.Noibu
 import com.noibu.mobile.android.sessionreplay.NoibuConfig
+import java.util.concurrent.ConcurrentLinkedQueue
 
 class NoibuSessionRecorderModule(val reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext), TurboModule {
     companion object {
         private const val TAG = "NoibuSessionRecorder"
+        private const val MAX_BATCH = 100
     }
 
+    private val eventQueue: ConcurrentLinkedQueue<String> = ConcurrentLinkedQueue()
+
     init {
         Log.i(TAG, "[new-arch] Module constructed")
     }
@@ -32,10 +35,8 @@ class NoibuSessionRecorderModule(val reactContext: ReactApplicationContext) : Re
                 maskAllTextInputs = false,
             )
             Noibu.setup(context, config) { param ->
-                val map = Arguments.createMap()
-                map.putString("message", param)
-                reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                    .emit("noibuRecordingEvent", map)
+                // Enqueue raw mobile event JSON for JS to consume via TurboModule polling
+                eventQueue.add(param)
                 true
             }
             promise.resolve(true)
@@ -44,4 +45,22 @@ class NoibuSessionRecorderModule(val reactContext: ReactApplicationContext) : Re
             promise.reject("E_INIT", t)
         }
     }
+
+    @ReactMethod
+    fun consumeEvents(promise: Promise) {
+        try {
+            val array = Arguments.createArray()
+            var count = 0
+            var item = eventQueue.poll()
+            while (item != null && count < MAX_BATCH) {
+                array.pushString(item)
+                count += 1
+                item = eventQueue.poll()
+            }
+            promise.resolve(array)
+        } catch (t: Throwable) {
+            Log.e(TAG, "consumeEvents() failed", t)
+            promise.reject("E_CONSUME", t)
+        }
+    }
 }

package/dist/constants.js

@@ -24,7 +24,7 @@ const CONTENT_TYPE = 'content-type';
  * Gets the script id from the cookie object, returns default if cannot be found
  */
 function GET_SCRIPT_ID() {
-    return "1.0.104-rn-sdk-0.2.27" ;
+    return "1.0.104-rn-sdk-0.2.29" ;
 }
 /**
  * Gets the max metro recon number

package/dist/native/NativeNoibuSessionRecorder.d.ts

@@ -1,6 +1,7 @@
 import type { TurboModule } from 'react-native';
 export interface Spec extends TurboModule {
     initialize(): Promise<boolean>;
+    consumeEvents?(): Promise<string[]>;
 }
-declare const _default: Spec;
-export default _default;
+declare let moduleRef: Spec | null;
+export default moduleRef;

package/dist/native/NativeNoibuSessionRecorder.js

@@ -1,6 +1,25 @@
+// Ensure the Codegen parser sees Spec usage with TurboModuleRegistry.get<Spec>(..)
+// This block is never executed at runtime but allows codegen to infer the module name.
+// eslint-disable-next-line no-constant-condition, @typescript-eslint/no-unused-expressions
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { TurboModuleRegistry: TurboModuleRegistryUntyped } = require('react-native');
-const TurboModuleRegistry = TurboModuleRegistryUntyped;
-var TurboNativeSessionRecorder = TurboModuleRegistry.getEnforcing('NoibuSessionRecorder');
+let moduleRef = null;
+try {
+    // Note: We've already destructured the TurboModuleRegistry object into TurboModuleRegistryUntyped
+    const tmr = TurboModuleRegistryUntyped;
+    // Prefer non-throwing get() if available
+    const maybe = (tmr === null || tmr === void 0 ? void 0 : tmr.get) ? tmr.get('NoibuSessionRecorder') : undefined;
+    if (maybe) {
+        moduleRef = maybe;
+    }
+    else if (tmr === null || tmr === void 0 ? void 0 : tmr.getEnforcing) {
+        // getEnforcing may throw on legacy; catch and fall back to null
+        moduleRef = tmr.getEnforcing('NoibuSessionRecorder');
+    }
+}
+catch (_e) {
+    moduleRef = null;
+}
+var TurboNativeSessionRecorder = moduleRef;
 
 export { TurboNativeSessionRecorder as default };

package/dist/sessionRecorder/nativeSessionRecorderSubscription.js

@@ -1,14 +1,17 @@
-import { __rest } from 'tslib';
+import { __awaiter, __rest } from 'tslib';
 import { NativeModules, Platform, NativeEventEmitter } from 'react-native';
 import TurboNativeSessionRecorder from '../native/NativeNoibuSessionRecorder.js';
 import { noibuLog } from '../utils/log.js';
 import { transformToWeb } from '../mobileTransformer/mobile-replay/index.js';
 
+var _a;
 const LINKING_ERROR = `The package 'noibu-session-replay' doesn't seem to be linked. Make sure: \n\n` +
     '- You rebuilt the app after installing the package\n' +
     '- You are not using Expo Go\n';
-const { NativeSessionRecorder: LegacyNativeSessionRecorder, NoibuSessionRecorder } = NativeModules;
-const NativeSessionRecorder = TurboNativeSessionRecorder !== null && TurboNativeSessionRecorder !== void 0 ? TurboNativeSessionRecorder : LegacyNativeSessionRecorder;
+const RNModule = (_a = NativeModules.NoibuSessionRecorder) !== null && _a !== void 0 ? _a : NativeModules.NativeSessionRecorder;
+const NativeSessionRecorder = TurboNativeSessionRecorder !== null && TurboNativeSessionRecorder !== void 0 ? TurboNativeSessionRecorder : RNModule;
+// Consider new-arch if the resolved module exposes the polling method
+const isNewArchAndroid = Platform.OS === 'android' && typeof (NativeSessionRecorder === null || NativeSessionRecorder === void 0 ? void 0 : NativeSessionRecorder.consumeEvents) === 'function';
 let nativeModuleEmitter;
 const SupportedPlatforms = ['android', 'ios'];
 /** The level of logging to show in the device logcat stream. */
@@ -26,20 +29,28 @@ var LogLevel;
  * Initializes the Noibu - Session recording SDK if the API level is supported.
  */
 function initialize() {
-    var _a;
     if (Platform.OS === 'ios') {
         return;
     }
-    nativeModuleEmitter = new NativeEventEmitter((_a = NativeModules.NativeSessionRecorder) !== null && _a !== void 0 ? _a : NativeSessionRecorder);
     if (!SupportedPlatforms.includes(Platform.OS)) {
         noibuLog(`Noibu - Session recording supports ${SupportedPlatforms.join(', ')} only for now.`);
         return;
     }
-    if (NativeSessionRecorder === null) {
+    if (!NativeSessionRecorder) {
         noibuLog('Noibu - Session recording did not initialize properly.', LINKING_ERROR);
         return;
     }
+    // For legacy Android, set up the event emitter; for new-arch Android, we poll via TurboModule
+    if (!isNewArchAndroid) {
+        const moduleForEmitter = RNModule !== null && RNModule !== void 0 ? RNModule : NativeSessionRecorder;
+        if (!moduleForEmitter) {
+            noibuLog('NativeSessionRecorder module missing for legacy Android.');
+            return;
+        }
+        nativeModuleEmitter = new NativeEventEmitter(moduleForEmitter);
+    }
     NativeSessionRecorder.initialize();
+    noibuLog("Session recorder initialized.");
 }
 let isIOSInitialized = false;
 /**
@@ -58,26 +69,61 @@ let isIOSInitialized = false;
  * @throws {Error} If the Noibu Session Recorder is not initialized before calling this function.
  */
 function subscribeToNativeEvent(callback) {
+    var _a;
+    noibuLog("will subscribe to NativeEvent");
     if (Platform.OS === 'android') {
+        if (isNewArchAndroid) {
+            noibuLog("is new architecture");
+            const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+            (function pump() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    while (true) {
+                        try {
+                            const batch = yield NativeSessionRecorder.consumeEvents();
+                            noibuLog("this is the recording array: ", batch);
+                            if (Array.isArray(batch) && batch.length > 0) {
+                                for (const message of batch) {
+                                    try {
+                                        const _a = JSON.parse(message), { data } = _a, rest = __rest(_a, ["data"]);
+                                        const transformedEvents = transformToWeb([Object.assign(Object.assign({}, rest), { data })]);
+                                        for (const e of transformedEvents) {
+                                            callback({ message: JSON.stringify(e) });
+                                        }
+                                    }
+                                    catch (e) {
+                                        // Skip malformed items
+                                    }
+                                }
+                            }
+                        }
+                        catch (err) {
+                            // Swallow errors and continue polling
+                        }
+                        yield sleep(50);
+                    }
+                });
+            })();
+            // Keep polling indefinitely; do not expose a canceller in new-arch path
+            return () => { };
+        }
+        noibuLog("is NOT new architecture");
         if (!nativeModuleEmitter) {
             throw new Error('You have to initialize Noibu Session Recorder first');
         }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        // const subscription = nativeModuleEmitter.addListener('noibuRecordingEvent', callback);
+        // Legacy bridge path with DeviceEventManagerModule
         nativeModuleEmitter.addListener('noibuRecordingEvent', event => {
             const message = event.message;
             const _a = JSON.parse(message), { data } = _a, rest = __rest(_a, ["data"]);
             noibuLog('New noibu recording event', rest);
             const transformedEvents = transformToWeb([Object.assign(Object.assign({}, rest), { data })]);
-            noibuLog('after transformation: ', transformedEvents);
             // Emit pre-serialized JSON strings to minimize JS heap during batching
-            transformedEvents.forEach((e) => callback({ message: JSON.stringify(e) }));
+            transformedEvents.forEach(e => callback({ message: JSON.stringify(e) }));
         });
         // return () => subscription.remove();
     }
     if (Platform.OS === 'ios') {
         if (!nativeModuleEmitter) {
-            nativeModuleEmitter = new NativeEventEmitter(NoibuSessionRecorder);
+            nativeModuleEmitter = new NativeEventEmitter(RNModule);
             noibuLog('nativeModuleEmitter', nativeModuleEmitter);
         }
         nativeModuleEmitter.addListener('iOSEvent', (event) => {
@@ -95,7 +141,7 @@ function subscribeToNativeEvent(callback) {
             }
         });
         if (!isIOSInitialized) {
-            NoibuSessionRecorder.startIOS();
+            (_a = RNModule === null || RNModule === void 0 ? void 0 : RNModule.startIOS) === null || _a === void 0 ? void 0 : _a.call(RNModule);
             isIOSInitialized = true;
         }
         // return () => subscription.remove();

package/noibu-react-native.podspec

@@ -26,7 +26,7 @@ Pod::Spec.new do |s|
   #s.vendored_frameworks = "ios/SessionRecorder.xcframework"
   #s.vendored_frameworks = "ios/Noibu.xcframework"
 
-  s.dependency 'NoibuSDK', '0.0.9'
+  s.dependency 'NoibuSDK', '0.0.8'
   s.pod_target_xcconfig = {
     "HEADER_SEARCH_PATHS" => "\"$(PODS_ROOT)/noibu-react-native/ios/**\""
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noibu-react-native",
-  "version": "0.2.27",
+  "version": "0.2.29",
   "targetNjsVersion": "1.0.104",
   "description": "React-Native SDK for NoibuJS to collect errors in React-Native applications",
   "main": "dist/entry/index.js",

package/src/native/NativeNoibuSessionRecorder.ts

@@ -1,20 +1,52 @@
 // @ts-ignore - Using type from newer React Native versions when building locally
 import type { TurboModule } from 'react-native';
+// Provide a type-only ambient declaration so TS doesn't require a real export
+// This is used only for RN Codegen parsing inside a dead code branch below
+declare const TurboModuleRegistry: {
+  get?<T>(name: string): T | null | undefined;
+  getEnforcing?<T>(name: string): T;
+};
 
 export interface Spec extends TurboModule {
   initialize(): Promise<boolean>;
+  // Returns an array of raw mobile event JSON strings and clears native queue
+  consumeEvents?(): Promise<string[]>;
+}
+
+// Ensure the Codegen parser sees Spec usage with TurboModuleRegistry.get<Spec>(..)
+// This block is never executed at runtime but allows codegen to infer the module name.
+// eslint-disable-next-line no-constant-condition, @typescript-eslint/no-unused-expressions
+if (false) {
+  // The string must match the native module name
+    // @ts-ignore
+  TurboModuleRegistry.get<Spec>('NoibuSessionRecorder');
 }
 
-// Create a typed facade for TurboModuleRegistry so we can use generics
+// Safely access TurboModuleRegistry without throwing on legacy arch
 type TurboModuleRegistryType = {
-  getEnforcing<T>(name: string): T;
+  get?<T>(name: string): T | null | undefined;
+  getEnforcing?<T>(name: string): T;
 };
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { TurboModuleRegistry: TurboModuleRegistryUntyped } = require('react-native') as {
-  TurboModuleRegistry: TurboModuleRegistryType;
+  TurboModuleRegistry?: TurboModuleRegistryType;
 };
 
-const TurboModuleRegistry: TurboModuleRegistryType = TurboModuleRegistryUntyped;
+let moduleRef: Spec | null = null;
+try {
+  // Note: We've already destructured the TurboModuleRegistry object into TurboModuleRegistryUntyped
+  const tmr = TurboModuleRegistryUntyped as TurboModuleRegistryType | undefined;
+  // Prefer non-throwing get() if available
+  const maybe = tmr?.get ? tmr.get<Spec>('NoibuSessionRecorder') : undefined;
+  if (maybe) {
+    moduleRef = maybe;
+  } else if (tmr?.getEnforcing) {
+    // getEnforcing may throw on legacy; catch and fall back to null
+    moduleRef = tmr.getEnforcing<Spec>('NoibuSessionRecorder');
+  }
+} catch (_e) {
+  moduleRef = null;
+}
 
-export default TurboModuleRegistry.getEnforcing<Spec>('NoibuSessionRecorder');
+export default moduleRef;