noibu-react-native 0.2.33-rc.1 → 0.2.33-rc.2

package/android/build.gradle

@@ -64,15 +64,7 @@ repositories {
 def kotlin_version = getExtOrDefault("kotlinVersion")
 
 dependencies {
-  implementation "com.facebook.react:react-native:+"
-  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-  implementation "com.noibu:sessionreplay-recorder:1.0.4"
-}
-
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "NoibuSessionRecorder"
-    codegenJavaPackageName = "com.noibu.sessionreplay.reactnative"
-  }
+    implementation "com.facebook.react:react-native:+"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation "com.noibu:sessionreplay-recorder:1.0.5-rc.1"
 }

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

@@ -11,7 +11,7 @@ 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 {
+class NoibuSessionRecorderModule(val reactContext: ReactApplicationContext) : NativeSessionRecorderSpec(reactContext) {
     companion object {
         private const val TAG = "NoibuSessionRecorder"
         private const val MAX_BATCH = 100
@@ -25,11 +25,10 @@ class NoibuSessionRecorderModule(val reactContext: ReactApplicationContext) : Re
 
     override fun getName(): String = "NoibuSessionRecorder"
 
-    @ReactMethod
-    fun initialize(promise: Promise) {
+    override fun initialize(promise: Promise) {
         Log.i(TAG, "[new-arch] initialize() called")
         try {
-            val context = currentActivity?.applicationContext ?: reactApplicationContext.applicationContext
+            val context = reactContext.currentActivity?.applicationContext ?: reactApplicationContext.applicationContext
             val config = NoibuConfig(
                 sessionReplayEnabled = true,
                 maskAllTextInputs = false,
@@ -46,8 +45,7 @@ class NoibuSessionRecorderModule(val reactContext: ReactApplicationContext) : Re
         }
     }
 
-    @ReactMethod
-    fun consumeEvents(promise: Promise) {
+    override fun consumeEvents(promise: Promise) {
         try {
             val array = Arguments.createArray()
             var count = 0

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

@@ -1,28 +1,27 @@
 package com.noibu.sessionreplay.reactnative
 
-import com.facebook.react.TurboReactPackage
+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
 
-class NoibuSessionReplayPackage : TurboReactPackage() {
+class NoibuSessionReplayPackage : BaseReactPackage() {
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == "NoibuSessionRecorder") {
+    return if (name == NativeSessionRecorderSpec.NAME) {
       NoibuSessionRecorderModule(reactContext)
     } else null
   }
 
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
     mapOf(
-      "NoibuSessionRecorder" to ReactModuleInfo(
-        /* name */ "NoibuSessionRecorder",
-        /* className */ "com.noibu.sessionreplay.reactnative.NoibuSessionRecorderModule",
-        /* canOverrideExistingModule */ false,
-        /* needsEagerInit */ false,
-        /* hasConstants */ false,
-        /* isCxxModule */ false,
-        /* isTurboModule */ true
+      NativeSessionRecorderSpec.NAME to ReactModuleInfo(/* name */
+        name = NativeSessionRecorderSpec.NAME,
+        className = NativeSessionRecorderSpec.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
       )
     )
   }

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.33-rc.1" ;
+    return "1.0.104-rn-sdk-0.2.33-rc.2" ;
 }
 /**
  * Gets the max metro recon number

package/dist/sessionRecorder/nativeSessionRecorderSubscription.js

@@ -11,7 +11,9 @@ const LINKING_ERROR = `The package 'noibu-session-replay' doesn't seem to be lin
 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';
+const isNewArch = typeof (NativeSessionRecorder === null || NativeSessionRecorder === void 0 ? void 0 : NativeSessionRecorder.consumeEvents) === 'function';
+const isNewArchAndroid = Platform.OS === 'android' && isNewArch;
+const isNewArchIOS = Platform.OS === 'ios' && isNewArch;
 let nativeModuleEmitter;
 const SupportedPlatforms = ['android', 'ios'];
 /** The level of logging to show in the device logcat stream. */
@@ -30,6 +32,10 @@ var LogLevel;
  */
 function initialize() {
     if (Platform.OS === 'ios') {
+        // In new architecture, initialize native module to start capturing
+        if (isNewArchIOS) {
+            NativeSessionRecorder.initialize();
+        }
         return;
     }
     if (!SupportedPlatforms.includes(Platform.OS)) {
@@ -69,84 +75,95 @@ 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
+    noibuLog('will subscribe to NativeEvent');
+    // Shared new-architecture polling (Android/iOS)
+    const startNewArchPump = () => {
+        let cancelled = false;
+        const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+        (function pump() {
+            return __awaiter(this, void 0, void 0, function* () {
+                while (!cancelled) {
+                    try {
+                        const batch = yield NativeSessionRecorder.consumeEvents();
+                        if (Array.isArray(batch) && batch.length > 0) {
+                            noibuLog("Actual batch: ", batch);
+                            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');
-        }
-        // 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 })]);
-            // Emit pre-serialized JSON strings to minimize JS heap during batching
-            transformedEvents.forEach(e => callback({ message: JSON.stringify(e) }));
-        });
-        // return () => subscription.remove();
-    }
-    if (Platform.OS === 'ios') {
+                    catch (_err) {
+                        // Swallow errors and continue polling
+                    }
+                    yield sleep(50);
+                }
+            });
+        })();
+        return () => {
+            cancelled = true;
+        };
+    };
+    // Shared legacy-architecture event listener (Android/iOS)
+    const addLegacyListener = () => {
+        var _a;
         if (!nativeModuleEmitter) {
-            nativeModuleEmitter = new NativeEventEmitter(RNModule);
-            noibuLog('nativeModuleEmitter', nativeModuleEmitter);
+            const moduleForEmitter = RNModule !== null && RNModule !== void 0 ? RNModule : NativeSessionRecorder;
+            if (!moduleForEmitter) {
+                throw new Error('You have to initialize Noibu Session Recorder first');
+            }
+            nativeModuleEmitter = new NativeEventEmitter(moduleForEmitter);
         }
-        nativeModuleEmitter.addListener('iOSEvent', (event) => {
+        const handleLegacyPayload = (event) => {
             var _a;
+            noibuLog('handleLegacyPayload', event);
             try {
-                const mobileEvents = event.mobileEvents;
-                const webEvents = transformToWeb(mobileEvents);
-                // Emit pre-serialized JSON strings to minimize JS heap during batching
-                for (const webEvent of webEvents) {
-                    callback({ message: JSON.stringify(webEvent) });
+                let mobileEvents = [];
+                if (event && Array.isArray(event.mobileEvents)) {
+                    // iOS legacy format
+                    mobileEvents = event.mobileEvents;
+                }
+                else if (event && typeof event.message === 'string') {
+                    // Android legacy format: single JSON string containing one mobile event
+                    const _b = JSON.parse(event.message), { data } = _b, rest = __rest(_b, ["data"]);
+                    mobileEvents = [Object.assign(Object.assign({}, rest), { data })];
+                }
+                else if (typeof event === 'string') {
+                    // Fallback: raw string message
+                    const _c = JSON.parse(event), { data } = _c, rest = __rest(_c, ["data"]);
+                    mobileEvents = [Object.assign(Object.assign({}, rest), { data })];
+                }
+                if (mobileEvents.length > 0) {
+                    const webEvents = transformToWeb(mobileEvents);
+                    for (const webEvent of webEvents) {
+                        callback({ message: JSON.stringify(webEvent) });
+                    }
                 }
             }
             catch (err) {
-                noibuLog(`[Error] iOS transformToWeb failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                noibuLog(`[Error] Legacy transformToWeb failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
             }
-        });
-        if (!isIOSInitialized) {
+        };
+        nativeModuleEmitter.addListener('noibuRecordingEvent', handleLegacyPayload);
+        if (Platform.OS === 'ios' && !isIOSInitialized) {
             (_a = RNModule === null || RNModule === void 0 ? void 0 : RNModule.startIOS) === null || _a === void 0 ? void 0 : _a.call(RNModule);
             isIOSInitialized = true;
         }
-        // return () => subscription.remove();
+        // return () => subscription?.remove();
+        return () => { };
+    };
+    if (isNewArch) {
+        return startNewArchPump();
     }
-    return () => { };
+    return addLegacyListener();
 }
 
 export { LogLevel, initialize, subscribeToNativeEvent };

package/ios/IOSPocEmitter.swift

@@ -16,7 +16,7 @@ class NoibuSessionRecorder: RCTEventEmitter {
   }
 
   override func supportedEvents() -> [String]! {
-    return ["iOSEvent"]
+    return ["noibuRecordingEvent"]
   }
 
   override func startObserving() {
@@ -36,7 +36,7 @@ class NoibuSessionRecorder: RCTEventEmitter {
 
     config.onReactNativeCallback = { [weak self] mobileEvents in
         guard let self = self, self.bridge != nil else { return }
-        self.sendEvent(withName: "iOSEvent", body: ["mobileEvents": mobileEvents])
+        self.sendEvent(withName: "noibuRecordingEvent", body: ["mobileEvents": mobileEvents])
     }
     NoibuSDKManager.shared.setup(config)
   }

package/ios/RCTNoibuSessionRecorder.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+// Public header must not pull in C++/JSI.
+@interface RCTNoibuSessionRecorder : NSObject <RCTBridgeModule>
+@end

package/ios/RCTNoibuSessionRecorder.mm

@@ -0,0 +1,112 @@
+// Must be Obj-C++
+#import "RCTNoibuSessionRecorder.h"
+
+#import <ReactCommon/RCTTurboModule.h>
+// Import the generated header (TurboModule spec)
+#import <NoibuSessionRecorder/NoibuSessionRecorder.h>
+// Import Noibu SDK Swift interfaces exposed to ObjC
+#if __has_include(<NoibuSDK/NoibuSDK-Swift.h>)
+#import <NoibuSDK/NoibuSDK-Swift.h>
+#elif __has_include("NoibuSDK-Swift.h")
+#import "NoibuSDK-Swift.h"
+#endif
+
+@interface RCTNoibuSessionRecorder () <NativeSessionRecorderSpec>
+@end
+
+@implementation RCTNoibuSessionRecorder
+
+RCT_EXPORT_MODULE(NoibuSessionRecorder)
+
++ (BOOL)requiresMainQueueSetup { return NO; }
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeSessionRecorderSpecJSI>(params);
+}
+
+static const NSInteger kMaxBatch = 100;
+
+// Simple thread-safe queue of JSON strings
+static dispatch_queue_t noibu_queue_lock;
+static NSMutableArray<NSString *> *noibu_queue_storage;
+
+static void ensure_queue_initialized(void) {
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    noibu_queue_lock = dispatch_queue_create("com.noibu.sessionreplay.queue", DISPATCH_QUEUE_SERIAL);
+    noibu_queue_storage = [NSMutableArray array];
+  });
+}
+
+static void enqueue_json_string(NSString *item) {
+  ensure_queue_initialized();
+  if (item.length == 0) { return; }
+  dispatch_sync(noibu_queue_lock, ^{
+    [noibu_queue_storage addObject:item];
+  });
+}
+
+static NSArray<NSString *> *drain_queue(NSUInteger maxCount) {
+  ensure_queue_initialized();
+  __block NSArray<NSString *> *result = @[];
+  dispatch_sync(noibu_queue_lock, ^{
+    if (noibu_queue_storage.count == 0) { return; }
+    NSUInteger count = MIN(MAX(1, maxCount), (NSUInteger)noibu_queue_storage.count);
+    result = [noibu_queue_storage subarrayWithRange:NSMakeRange(0, count)];
+    [noibu_queue_storage removeObjectsInRange:NSMakeRange(0, count)];
+  });
+  return result ?: @[];
+}
+
+- (void)initialize:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  @try {
+    ensure_queue_initialized();
+
+    // Construct Noibu SDK configuration (placeholder values)
+    NSString *apiKey = @"NOIBU_API_KEY";
+    NSString *host = @"https://noibu.com/";
+
+#if __has_include(<NoibuSDK/NoibuSDK-Swift.h>) || __has_include("NoibuSDK-Swift.h")
+    NoibuConfig *config = [[NoibuConfig alloc] apiKey:apiKey host:host];
+    // Enable session replay by default, leave other options as defaults
+    // Bridge callback to enqueue raw mobile events for JS polling
+
+    config.onReactNativeCallback = ^(NSArray<NSDictionary *> *mobileEvents) {
+      for (id item in mobileEvents) {
+        if ([item isKindOfClass:[NSString class]]) {
+          enqueue_json_string((NSString *)item);
+        } else if ([NSJSONSerialization isValidJSONObject:item]) {
+          NSError *error = nil;
+          NSData *data = [NSJSONSerialization dataWithJSONObject:item options:0 error:&error];
+          if (data && !error) {
+            NSString *json = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+            if (json.length > 0) { enqueue_json_string(json); }
+          }
+        }
+      }
+    };
+
+    [[NoibuSDKManager shared] setup:config];
+#endif
+    resolve(@(YES));
+  } @catch (NSException *exception) {
+    reject(@"E_INIT", exception.reason ?: @"initialize() failed", nil);
+  }
+}
+
+- (void)consumeEvents:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject
+{
+  @try {
+    NSArray<NSString *> *batch = drain_queue((NSUInteger)kMaxBatch);
+    resolve(batch ?: @[]);
+  } @catch (NSException *exception) {
+    reject(@"E_CONSUME", exception.reason ?: @"consumeEvents() failed", nil);
+  }
+}
+
+@end

package/noibu-react-native.podspec

@@ -15,9 +15,20 @@ Pod::Spec.new do |s|
   #s.source       = { :git => "https://www.github.com/aleguia.git", :tag => "#{s.version}" }
   s.source = { :path => "." }
 
-  # Include source files
-
-  s.source_files = "ios/**/*.{h,m,mm,swift}"
+  # Include source files per-architecture (legacy vs new-arch)
+  if ENV['RCT_NEW_ARCH_ENABLED'] == '1'
+    # New Architecture: TurboModule implementation only (Objective-C++)
+    s.source_files = [
+      "ios/RCTNoibuSessionRecorder.h",
+      "ios/RCTNoibuSessionRecorder.mm",
+    ]
+  else
+    # Legacy Architecture: RCTEventEmitter implementation only
+    s.source_files = [
+      "ios/IOSPocEmitter.m",
+      "ios/IOSPocEmitter.swift",
+    ]
+  end
   s.swift_version = '5.0'
 
   # Build as static framework to avoid new-arch linking issues

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "noibu-react-native",
-  "version": "0.2.33-rc.1",
+  "version": "0.2.33-rc.2",
   "targetNjsVersion": "1.0.104",
   "description": "React-Native SDK for NoibuJS to collect errors in React-Native applications",
   "main": "dist/entry/index.js",
@@ -8,16 +8,20 @@
   "codegenConfig": {
     "name": "NoibuSessionRecorder",
     "type": "modules",
-    "jsSrcsDir": "src",
+    "jsSrcsDir": "specs",
     "android": {
       "javaPackageName": "com.noibu.sessionreplay.reactnative"
+    },
+    "ios": {
+      "modulesProvider": {
+        "NoibuSessionRecorder": "RCTNoibuSessionRecorder"
+      }
     }
   },
   "files": [
     "android",
-    "android/settings.gradle",
     "dist/*",
-    "src/native/NativeNoibuSessionRecorder.ts",
+    "specs/*",
     "README.md",
     "CHANGELOG.md",
     "ios",

package/specs/NativeSessionRecorder.ts

@@ -0,0 +1,10 @@
+import type {TurboModule} from 'react-native';
+import {TurboModuleRegistry} from 'react-native';
+
+export interface Spec extends TurboModule {
+  initialize(): Promise<boolean>;
+  // Returns an array of raw mobile event JSON strings and clears native queue
+  consumeEvents?(): Promise<string[]>;
+}
+
+export default TurboModuleRegistry.get<Spec>('NoibuSessionRecorder');

package/src/native/NativeNoibuSessionRecorder.ts

@@ -1,52 +0,0 @@
-// @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');
-}
-
-// Safely access TurboModuleRegistry without throwing on legacy arch
-type TurboModuleRegistryType = {
-  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;
-};
-
-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 moduleRef;