@luciq/react-native 19.3.0 → 19.4.0-44237-SNAPSHOT

package/dist/utils/Enums.js

@@ -1,5 +1,7 @@
 import { NativeLuciq } from '../native/NativeLuciq';
-const constants = NativeLuciq.getConstants();
+const constants = typeof NativeLuciq.getConstants === 'function'
+    ? NativeLuciq.getConstants()
+    : NativeLuciq.getAllConstants();
 /**
  * Verbosity level of the SDK debug logs. This has nothing to do with `Luciq.log`,
  * and only affect the logs used to debug the SDK itself.

package/dist/utils/LuciqUtils.d.ts

@@ -28,7 +28,7 @@ export declare const stringifyIfNotString: (input: unknown) => string;
  * `sendCrashReport(error, NativeCrashReporting.sendJSCrash);`
  *
  */
-export declare function sendCrashReport(error: ExtendedError, remoteSenderCallback: (json: CrashData | string) => Promise<void>): Promise<void>;
+export declare function sendCrashReport(error: ExtendedError, remoteSenderCallback: (json: CrashData) => Promise<void>): Promise<void>;
 /**
  * Generate random 32 bit unsigned integer Hexadecimal (8 chars) lower case letters
  * Should not return all zeros

package/dist/utils/LuciqUtils.js

@@ -128,9 +128,6 @@ export const stringifyIfNotString = (input) => {
  */
 export async function sendCrashReport(error, remoteSenderCallback) {
     const jsonObject = getCrashDataFromError(error);
-    if (Platform.OS === 'android') {
-        return remoteSenderCallback(JSON.stringify(jsonObject));
-    }
     return remoteSenderCallback(jsonObject);
 }
 /**

package/ios/RNLuciq/LuciqAPMBridge.h

@@ -17,7 +17,7 @@
 - (void)setAutoUITraceEnabled:(BOOL)isEnabled;
 - (void)startFlow:(NSString *)name;
 - (void)endFlow:(NSString *)name;
-- (void)setFlowAttribute:(NSString *)name :(NSString *)key :(NSString *_Nullable)value;
+- (void)setFlowAttribute:(NSString *)name key:(NSString *)key value:(NSString *_Nullable)value;
 - (void)startUITrace:(NSString *)name;
 - (void)endUITrace;
 
@@ -27,13 +27,13 @@
 - (void)syncCustomSpan:(NSString *)name
         startTimestamp:(double)startTimestamp
           endTimestamp:(double)endTimestamp
-              resolver:(RCTPromiseResolveBlock)resolve
-              rejecter:(RCTPromiseRejectBlock)reject;
+               resolve:(RCTPromiseResolveBlock)resolve
+                reject:(RCTPromiseRejectBlock)reject;
 
 - (void)isCustomSpanEnabled:(RCTPromiseResolveBlock)resolve
-                   rejecter:(RCTPromiseRejectBlock)reject;
+                     reject:(RCTPromiseRejectBlock)reject;
 
 - (void)isAPMEnabled:(RCTPromiseResolveBlock)resolve
-            rejecter:(RCTPromiseRejectBlock)reject;
+              reject:(RCTPromiseRejectBlock)reject;
 
 @end

package/ios/RNLuciq/{LuciqAPMBridge.m → LuciqAPMBridge.mm}

@@ -1,5 +1,3 @@
-
-
 #import "LuciqAPMBridge.h"
 #import <LuciqSDK/LCQAPM.h>
 #import <asl.h>
@@ -9,6 +7,13 @@
 #import <React/RCTUIManager.h>
 #import "Util/LCQAPM+PrivateAPIs.h"
 
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNLuciqSpec/RNLuciqSpec.h>
+
+@interface LuciqAPMBridge () <NativeAPMSpec>
+@end
+#endif
+
 @implementation LuciqAPMBridge
 
 - (dispatch_queue_t)methodQueue {
@@ -26,86 +31,91 @@
 
 RCT_EXPORT_MODULE(LCQAPM)
 
-- (id) init
+- (id)init
 {
     self = [super init];
     return self;
 }
 
-// Pauses the current thread for 3 seconds.
-RCT_EXPORT_METHOD(LCQSleep) {
+RCT_EXPORT_METHOD(lcqSleep) {
     [NSThread sleepForTimeInterval:3.0f];
 }
 
-// Enables or disables APM.
 RCT_EXPORT_METHOD(setEnabled:(BOOL)isEnabled) {
     LCQAPM.enabled = isEnabled;
 }
 
-// Determines either coldAppLaunch is enabled or not.
 RCT_EXPORT_METHOD(setAppLaunchEnabled:(BOOL)isEnabled) {
     LCQAPM.coldAppLaunchEnabled = isEnabled;
 }
 
-// This method is used to signal the end of the app launch process.
 RCT_EXPORT_METHOD(endAppLaunch) {
     [LCQAPM endAppLaunch];
 }
 
-// Controls whether automatic tracing of UI interactions is enabled or disabled within the SDK.
 RCT_EXPORT_METHOD(setAutoUITraceEnabled:(BOOL)isEnabled) {
     LCQAPM.autoUITraceEnabled = isEnabled;
 }
 
-// Starts a flow trace with the specified `name`,
-// allowing the SDK to capture and analyze the flow of execution within the application.
-RCT_EXPORT_METHOD(startFlow: (NSString *)name) {
+RCT_EXPORT_METHOD(startFlow:(NSString *)name) {
     [LCQAPM startFlowWithName:name];
 }
 
-// Ends a flow with the specified `name`.
-RCT_EXPORT_METHOD(endFlow: (NSString *)name) {
+RCT_EXPORT_METHOD(endFlow:(NSString *)name) {
     [LCQAPM endFlowWithName:name];
 }
 
-
-// Sets a user defined attribute for the currently active flow.
-RCT_EXPORT_METHOD(setFlowAttribute:(NSString *)name :(NSString *)key :(NSString *_Nullable)value) {
+RCT_EXPORT_METHOD(setFlowAttribute:(NSString *)name
+                  key:(NSString *)key
+                  value:(NSString * _Nullable)value) {
     [LCQAPM setAttributeForFlowWithName:name key:key value:value];
 }
 
-// Starts a new `UITrace` with the provided `name` parameter,
-// allowing the SDK to capture and analyze the UI components within the application.
 RCT_EXPORT_METHOD(startUITrace:(NSString *)name) {
     [LCQAPM startUITraceWithName:name];
 }
 
-// Terminates the currently active UI trace.
 RCT_EXPORT_METHOD(endUITrace) {
     [LCQAPM endUITrace];
 }
 
-// Enables or disables screen render.
 RCT_EXPORT_METHOD(setScreenRenderingEnabled:(BOOL)isEnabled) {
     LCQAPM.screenRenderingEnabled = isEnabled;
 }
 
-// Syncs a custom span to the native SDK (currently logs only)
+RCT_EXPORT_METHOD(networkLogAndroid:(double)requestStartTime
+                  requestDuration:(double)requestDuration
+                  requestHeaders:(NSString *)requestHeaders
+                  requestBody:(NSString *)requestBody
+                  requestBodySize:(double)requestBodySize
+                  requestMethod:(NSString *)requestMethod
+                  requestUrl:(NSString *)requestUrl
+                  requestContentType:(NSString *)requestContentType
+                  responseHeaders:(NSString *)responseHeaders
+                  responseBody:(NSString * _Nullable)responseBody
+                  responseBodySize:(double)responseBodySize
+                  statusCode:(double)statusCode
+                  responseContentType:(NSString *)responseContentType
+                  errorDomain:(NSString *)errorDomain
+                  w3cExternalTraceAttributes:(NSDictionary *)w3cExternalTraceAttributes
+                  gqlQueryName:(NSString * _Nullable)gqlQueryName
+                  serverErrorMessage:(NSString * _Nullable)serverErrorMessage) {
+    // Android-only; iOS no-op to satisfy unified spec.
+}
+
 RCT_EXPORT_METHOD(syncCustomSpan:(NSString *)name
                   startTimestamp:(double)startTimestamp
                   endTimestamp:(double)endTimestamp
-                  resolver:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
 {
     @try {
-        // Convert microseconds → seconds (NSDate uses seconds)
         NSTimeInterval startSeconds = startTimestamp / 1e6;
         NSTimeInterval endSeconds   = endTimestamp / 1e6;
 
         NSDate *startDate = [NSDate dateWithTimeIntervalSince1970:startSeconds];
         NSDate *endDate   = [NSDate dateWithTimeIntervalSince1970:endSeconds];
 
-        // Add completed span to APM
         [LCQAPM addCompletedCustomSpanWithName:name
                                      startDate:startDate
                                        endDate:endDate];
@@ -113,17 +123,14 @@ RCT_EXPORT_METHOD(syncCustomSpan:(NSString *)name
         resolve(@YES);
     }
     @catch (NSException *exception) {
-        reject(
-            @"SYNC_CUSTOM_SPAN_ERROR",
-            exception.reason ?: @"Failed to sync custom span",
-            nil
-        );
+        reject(@"SYNC_CUSTOM_SPAN_ERROR",
+               exception.reason ?: @"Failed to sync custom span",
+               nil);
     }
 }
 
-// Checks if custom spans feature is enabled
 RCT_EXPORT_METHOD(isCustomSpanEnabled:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject) {
+                  reject:(RCTPromiseRejectBlock)reject) {
     @try {
         BOOL enabled = LCQAPM.customSpansEnabled;
         resolve(@(enabled));
@@ -133,9 +140,8 @@ RCT_EXPORT_METHOD(isCustomSpanEnabled:(RCTPromiseResolveBlock)resolve
     }
 }
 
-// Checks if APM is enabled
 RCT_EXPORT_METHOD(isAPMEnabled:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject) {
+                  reject:(RCTPromiseRejectBlock)reject) {
     @try {
         BOOL enabled = LCQAPM.enabled;
         resolve(@(enabled));
@@ -145,13 +151,16 @@ RCT_EXPORT_METHOD(isAPMEnabled:(RCTPromiseResolveBlock)resolve
     }
 }
 
-
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeAPMSpecJSI>(params);
+}
+#endif
 
 @synthesize description;
-
 @synthesize hash;
-
 @synthesize superclass;
 
 @end
-

package/ios/RNLuciq/LuciqBugReportingBridge.h

@@ -25,21 +25,21 @@
 
 - (void)setOptions:(NSArray *)optionsArray;
 
-- (void)setFloatingButtonEdge:(CGRectEdge)floatingButtonEdge withTopOffset:(double)floatingButtonOffsetFromTop;
+- (void)setFloatingButtonEdge:(NSString *)edge offset:(double)offset;
 
-- (void)setOnInvokeHandler:(RCTResponseSenderBlock)callBack;
+- (void)setOnInvokeHandler;
 
-- (void)setOnSDKDismissedHandler:(RCTResponseSenderBlock)callBack;
+- (void)setOnSDKDismissedHandler;
 
 - (void)setShakingThresholdForiPhone:(double)iPhoneShakingThreshold;
 
 - (void)setShakingThresholdForiPad:(double)iPadShakingThreshold;
 
-- (void)setExtendedBugReportMode:(LCQExtendedBugReportMode)extendedBugReportMode;
+- (void)setExtendedBugReportMode:(NSString *)mode;
 
 - (void)setReportTypes:(NSArray *)types;
 
-- (void)show:(LCQBugReportingReportType)type options:(NSArray *)options;
+- (void)show:(NSString *)type options:(NSArray *)options;
 
 - (void)setAutoScreenRecordingEnabled:(BOOL)enabled;
 
@@ -57,6 +57,6 @@
                       checked:(BOOL)checked
                    actionType:(id)actionType;
 
-- (void)setProactiveReportingConfigurations:(BOOL)enabled gap:(NSNumber* )gap model:(NSNumber* )modal;
+- (void)setProactiveReportingConfigurations:(BOOL)enabled gapBetweenModals:(double)gapBetweenModals modalDelayAfterDetection:(double)modalDelayAfterDetection;
 
 @end

package/ios/RNLuciq/LuciqBugReportingBridge.mm

@@ -0,0 +1,234 @@
+#import "LuciqBugReportingBridge.h"
+#import <LuciqSDK/LCQBugReporting.h>
+#import <asl.h>
+#import <React/RCTLog.h>
+#import <os/log.h>
+#import <React/RCTUIManager.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNLuciqSpec/RNLuciqSpec.h>
+
+@interface LuciqBugReportingBridge () <NativeBugReportingSpec>
+@end
+#endif
+
+@implementation LuciqBugReportingBridge
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[
+        @"LCQpreInvocationHandler",
+        @"LCQpostInvocationHandler",
+        @"LCQDidSelectPromptOptionHandler",
+    ];
+}
+
+RCT_EXPORT_MODULE(LCQBugReporting)
+
+RCT_EXPORT_METHOD(setEnabled:(BOOL)isEnabled) {
+    LCQBugReporting.enabled = isEnabled;
+}
+
+RCT_EXPORT_METHOD(setAutoScreenRecordingEnabled:(BOOL)enabled) {
+    LCQBugReporting.autoScreenRecordingEnabled = enabled;
+}
+
+RCT_EXPORT_METHOD(setAutoScreenRecordingDuration:(double)duration) {
+    LCQBugReporting.autoScreenRecordingDuration = duration;
+}
+
+RCT_EXPORT_METHOD(setOnInvokeHandler) {
+    __weak LuciqBugReportingBridge *weakSelf = self;
+    LCQBugReporting.willInvokeHandler = ^{
+        [weakSelf sendEventWithName:@"LCQpreInvocationHandler" body:nil];
+    };
+}
+
+RCT_EXPORT_METHOD(setOnSDKDismissedHandler) {
+    __weak LuciqBugReportingBridge *weakSelf = self;
+    LCQBugReporting.didDismissHandler = ^(LCQDismissType dismissType, LCQReportCategory reportType) {
+        NSString *dismissTypeString;
+        if (dismissType == LCQDismissTypeCancel) {
+            dismissTypeString = @"CANCEL";
+        } else if (dismissType == LCQDismissTypeSubmit) {
+            dismissTypeString = @"SUBMIT";
+        } else if (dismissType == LCQDismissTypeAddAttachment) {
+            dismissTypeString = @"ADD_ATTACHMENT";
+        }
+
+        NSString *reportTypeString;
+        if (reportType == LCQReportCategoryBug) {
+            reportTypeString = @"bug";
+        } else if (reportType == LCQReportCategoryFeedback) {
+            reportTypeString = @"feedback";
+        } else {
+            reportTypeString = @"other";
+        }
+        NSDictionary *result = @{ @"dismissType": dismissTypeString,
+                                  @"reportType": reportTypeString };
+        [weakSelf sendEventWithName:@"LCQpostInvocationHandler" body:result];
+    };
+}
+
+RCT_EXPORT_METHOD(setDidSelectPromptOptionHandler) {
+    __weak LuciqBugReportingBridge *weakSelf = self;
+    LCQBugReporting.didSelectPromptOptionHandler = ^(LCQPromptOption promptOption) {
+        NSString *promptOptionString;
+        if (promptOption == LCQPromptOptionBug) {
+            promptOptionString = @"bug";
+        } else if (promptOption == LCQBugReportingTypeFeedback) {
+            promptOptionString = @"feedback";
+        } else if (promptOption == LCQPromptOptionChat) {
+            promptOptionString = @"chat";
+        } else {
+            promptOptionString = @"none";
+        }
+        [weakSelf sendEventWithName:@"LCQDidSelectPromptOptionHandler"
+                               body:@{@"promptOption": promptOptionString}];
+    };
+}
+
+RCT_EXPORT_METHOD(setInvocationEvents:(NSArray *)invocationEventsArray) {
+    LCQInvocationEvent invocationEvents = 0;
+    for (id value in invocationEventsArray) {
+        invocationEvents |= [value intValue];
+    }
+    LCQBugReporting.invocationEvents = invocationEvents;
+}
+
+RCT_EXPORT_METHOD(setOptions:(NSArray *)invocationOptionsArray) {
+    LCQBugReportingOption invocationOptions = 0;
+    for (id value in invocationOptionsArray) {
+        invocationOptions |= [value intValue];
+    }
+    LCQBugReporting.bugReportingOptions = invocationOptions;
+}
+
+RCT_EXPORT_METHOD(setFloatingButtonEdge:(NSString *)edge offset:(double)offset) {
+    LCQBugReporting.floatingButtonEdge = (CGRectEdge)[edge intValue];
+    LCQBugReporting.floatingButtonTopOffset = offset;
+}
+
+RCT_EXPORT_METHOD(setExtendedBugReportMode:(NSString *)mode) {
+    LCQBugReporting.extendedBugReportMode = (LCQExtendedBugReportMode)[mode intValue];
+}
+
+RCT_EXPORT_METHOD(setEnabledAttachmentTypes:(BOOL)screenshot
+                  extraScreenshot:(BOOL)extraScreenshot
+                  galleryImage:(BOOL)galleryImage
+                  screenRecording:(BOOL)screenRecording) {
+    LCQAttachmentType attachmentTypes = 0;
+    if (screenshot) attachmentTypes = LCQAttachmentTypeScreenShot;
+    if (extraScreenshot) attachmentTypes |= LCQAttachmentTypeExtraScreenShot;
+    if (galleryImage) attachmentTypes |= LCQAttachmentTypeGalleryImage;
+    if (screenRecording) attachmentTypes |= LCQAttachmentTypeScreenRecording;
+
+    LCQBugReporting.enabledAttachmentTypes = attachmentTypes;
+}
+
+RCT_EXPORT_METHOD(setViewHierarchyEnabled:(BOOL)viewHierarchyEnabled) {
+    LCQBugReporting.shouldCaptureViewHierarchy = viewHierarchyEnabled;
+}
+
+RCT_EXPORT_METHOD(setVideoRecordingFloatingButtonPosition:(NSString *)position) {
+    LCQBugReporting.videoRecordingFloatingButtonPosition = (LCQPosition)[position intValue];
+}
+
+RCT_EXPORT_METHOD(setReportTypes:(NSArray *)types) {
+    LCQBugReportingReportType reportTypes = 0;
+    for (id value in types) {
+        reportTypes |= [value intValue];
+    }
+    [LCQBugReporting setPromptOptionsEnabledReportTypes:reportTypes];
+}
+
+RCT_EXPORT_METHOD(show:(NSString *)type options:(NSArray *)options) {
+    LCQBugReportingOption parsedOptions = 0;
+    for (id value in options) {
+        parsedOptions |= [value intValue];
+    }
+    NSArray *args = @[@([type intValue]), @(parsedOptions)];
+    [[NSRunLoop mainRunLoop] performSelector:@selector(showBugReportingWithReportTypeAndOptionsHelper:)
+                                     target:self
+                                   argument:args
+                                      order:0
+                                      modes:@[NSDefaultRunLoopMode]];
+}
+
+- (void)showBugReportingWithReportTypeAndOptionsHelper:(NSArray *)args {
+    LCQBugReportingReportType parsedReportType = [args[0] intValue];
+    LCQBugReportingOption parsedOptions = [args[1] intValue];
+    [LCQBugReporting showWithReportType:parsedReportType options:parsedOptions];
+}
+
+RCT_EXPORT_METHOD(setShakingThresholdForiPhone:(double)iPhoneShakingThreshold) {
+    LCQBugReporting.shakingThresholdForiPhone = iPhoneShakingThreshold;
+}
+
+RCT_EXPORT_METHOD(setShakingThresholdForiPad:(double)iPadShakingThreshold) {
+    LCQBugReporting.shakingThresholdForiPad = iPadShakingThreshold;
+}
+
+RCT_EXPORT_METHOD(setDisclaimerText:(NSString *)text) {
+    [LCQBugReporting setDisclaimerText:text];
+}
+
+RCT_EXPORT_METHOD(setCommentMinimumCharacterCount:(double)limit reportTypes:(NSArray *)reportTypes) {
+    LCQBugReportingType parsedReportTypes = 0;
+    if (![reportTypes count]) {
+        parsedReportTypes = LCQBugReportingTypeBug | LCQBugReportingTypeFeedback | LCQBugReportingTypeQuestion;
+    } else {
+        for (id value in reportTypes) {
+            parsedReportTypes |= [value intValue];
+        }
+    }
+    [LCQBugReporting setCommentMinimumCharacterCount:(NSInteger)limit forBugReportType:parsedReportTypes];
+}
+
+RCT_EXPORT_METHOD(addUserConsent:(NSString *)key
+                  description:(NSString *)description
+                  mandatory:(BOOL)mandatory
+                  checked:(BOOL)checked
+                  actionType:(NSString * _Nullable)actionType) {
+    LCQConsentAction mappedActionType = (LCQConsentAction)[actionType integerValue];
+    [LCQBugReporting addUserConsentWithKey:key
+                               description:description
+                                 mandatory:mandatory
+                                   checked:checked
+                                actionType:mappedActionType];
+}
+
+RCT_EXPORT_METHOD(setProactiveReportingConfigurations:(BOOL)enabled
+                  gapBetweenModals:(double)gapBetweenModals
+                  modalDelayAfterDetection:(double)modalDelayAfterDetection) {
+    LCQProactiveReportingConfigurations *configurations = [[LCQProactiveReportingConfigurations alloc] init];
+    configurations.enabled = enabled;
+    configurations.gapBetweenModals = @(gapBetweenModals);
+    configurations.modalDelayAfterDetection = @(modalDelayAfterDetection);
+    [LCQBugReporting setProactiveReportingConfigurations:configurations];
+}
+
+// Android-only method — iOS no-op.
+RCT_EXPORT_METHOD(setShakingThresholdForAndroid:(double)threshold) { }
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeBugReportingSpecJSI>(params);
+}
+#endif
+
+@synthesize description;
+@synthesize hash;
+@synthesize superclass;
+
+@end

package/ios/RNLuciq/LuciqCrashReportingBridge.h

@@ -9,10 +9,21 @@
 
 @interface LuciqCrashReportingBridge : RCTEventEmitter <RCTBridgeModule>
 
-- (void)setEnabled:(BOOL) isEnabled;
-- (void)sendJSCrash:(NSDictionary *_Nonnull )stackTrace resolver:(RCTPromiseResolveBlock _Nullable )resolve
-           rejecter:(RCTPromiseRejectBlock _Nullable )reject;
-- (void)sendHandledJSCrash:(NSDictionary *_Nonnull)stackTrace userAttributes:(nullable NSDictionary *)userAttributes fingerprint:(nullable NSString *)fingerprint nonFatalExceptionLevel:(LCQNonFatalLevel) nonFatalExceptionLevel resolver:(RCTPromiseResolveBlock _Nullable )resolve
-                  rejecter:(RCTPromiseRejectBlock _Nullable )reject;
+- (void)setEnabled:(BOOL)isEnabled;
+
+- (void)sendJSCrash:(NSDictionary * _Nonnull)data
+            resolve:(RCTPromiseResolveBlock _Nullable)resolve
+             reject:(RCTPromiseRejectBlock _Nullable)reject;
+
+- (void)sendHandledJSCrash:(NSDictionary * _Nonnull)data
+            userAttributes:(NSDictionary * _Nullable)userAttributes
+               fingerprint:(NSString * _Nullable)fingerprint
+    nonFatalExceptionLevel:(NSString * _Nullable)nonFatalExceptionLevel
+                   resolve:(RCTPromiseResolveBlock _Nullable)resolve
+                    reject:(RCTPromiseRejectBlock _Nullable)reject;
+
+- (void)setNDKCrashesEnabled:(BOOL)isEnabled
+                     resolve:(RCTPromiseResolveBlock _Nullable)resolve
+                      reject:(RCTPromiseRejectBlock _Nullable)reject;
 
 @end

package/ios/RNLuciq/LuciqCrashReportingBridge.mm

@@ -0,0 +1,91 @@
+#import "LuciqCrashReportingBridge.h"
+#import "Util/LCQCrashReporting+CP.h"
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import <RNLuciqSpec/RNLuciqSpec.h>
+
+@interface LuciqCrashReportingBridge () <NativeCrashReportingSpec>
+@end
+#endif
+
+@implementation LuciqCrashReportingBridge
+
+- (dispatch_queue_t)methodQueue {
+    return dispatch_get_main_queue();
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+    return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents {
+    return @[
+        @"LCQSendHandledJSCrash",
+        @"LCQSendUnhandledJSCrash",
+    ];
+}
+
+RCT_EXPORT_MODULE(LCQCrashReporting)
+
+RCT_EXPORT_METHOD(setEnabled:(BOOL)isEnabled) {
+    LCQCrashReporting.enabled = isEnabled;
+}
+
+RCT_EXPORT_METHOD(sendJSCrash:(NSDictionary *)data
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0ul);
+    dispatch_async(queue, ^{
+        [LCQCrashReporting cp_reportFatalCrashWithStackTrace:data];
+        resolve([NSNull null]);
+    });
+}
+
+RCT_EXPORT_METHOD(sendHandledJSCrash:(NSDictionary *)data
+                  userAttributes:(nullable NSDictionary *)userAttributes
+                  fingerprint:(nullable NSString *)fingerprint
+                  nonFatalExceptionLevel:(nullable NSString *)nonFatalExceptionLevel
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    if ([fingerprint isKindOfClass:NSNull.class]) {
+        fingerprint = nil;
+    }
+    if ([userAttributes isKindOfClass:NSNull.class]) {
+        userAttributes = nil;
+    }
+
+    LCQNonFatalLevel level = LCQNonFatalLevelError;
+    if (nonFatalExceptionLevel != nil && ![nonFatalExceptionLevel isKindOfClass:NSNull.class]) {
+        level = (LCQNonFatalLevel)[nonFatalExceptionLevel intValue];
+    }
+
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0ul);
+    dispatch_async(queue, ^{
+        [LCQCrashReporting cp_reportNonFatalCrashWithStackTrace:data
+                                                          level:level
+                                                 groupingString:fingerprint
+                                                 userAttributes:userAttributes];
+        resolve([NSNull null]);
+    });
+}
+
+RCT_EXPORT_METHOD(setNDKCrashesEnabled:(BOOL)isEnabled
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+    resolve([NSNull null]);
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeCrashReportingSpecJSI>(params);
+}
+#endif
+
+@synthesize description;
+@synthesize hash;
+@synthesize superclass;
+
+@end

package/ios/RNLuciq/LuciqFeatureRequestsBridge.h

@@ -18,7 +18,7 @@
  +------------------------------------------------------------------------+
  */
 
-- (void)setEmailFieldRequiredForFeatureRequests:(BOOL)isEmailFieldRequired forAction:(NSArray *)actionTypesArray;
+- (void)setEmailFieldRequiredForFeatureRequests:(BOOL)isEmailFieldRequired types:(NSArray *)actionTypesArray;
 
 - (void)show;