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

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

@@ -1,3 +1,5 @@
+
+
 #import "LuciqAPMBridge.h"
 #import <LuciqSDK/LCQAPM.h>
 #import <asl.h>
@@ -7,13 +9,6 @@
 #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 {
@@ -31,91 +26,86 @@
 
 RCT_EXPORT_MODULE(LCQAPM)
 
-- (id)init
+- (id) init
 {
     self = [super init];
     return self;
 }
 
-RCT_EXPORT_METHOD(lcqSleep) {
+// Pauses the current thread for 3 seconds.
+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;
 }
 
-RCT_EXPORT_METHOD(startFlow:(NSString *)name) {
+// 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) {
     [LCQAPM startFlowWithName:name];
 }
 
-RCT_EXPORT_METHOD(endFlow:(NSString *)name) {
+// Ends a flow with the specified `name`.
+RCT_EXPORT_METHOD(endFlow: (NSString *)name) {
     [LCQAPM endFlowWithName:name];
 }
 
-RCT_EXPORT_METHOD(setFlowAttribute:(NSString *)name
-                  key:(NSString *)key
-                  value:(NSString * _Nullable)value) {
+
+// Sets a user defined attribute for the currently active flow.
+RCT_EXPORT_METHOD(setFlowAttribute:(NSString *)name :(NSString *)key :(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;
 }
 
-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.
-}
-
+// Syncs a custom span to the native SDK (currently logs only)
 RCT_EXPORT_METHOD(syncCustomSpan:(NSString *)name
                   startTimestamp:(double)startTimestamp
                   endTimestamp:(double)endTimestamp
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject)
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(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];
@@ -123,14 +113,17 @@ 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
-                  reject:(RCTPromiseRejectBlock)reject) {
+                  rejecter:(RCTPromiseRejectBlock)reject) {
     @try {
         BOOL enabled = LCQAPM.customSpansEnabled;
         resolve(@(enabled));
@@ -140,8 +133,9 @@ RCT_EXPORT_METHOD(isCustomSpanEnabled:(RCTPromiseResolveBlock)resolve
     }
 }
 
+// Checks if APM is enabled
 RCT_EXPORT_METHOD(isAPMEnabled:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject) {
+                  rejecter:(RCTPromiseRejectBlock)reject) {
     @try {
         BOOL enabled = LCQAPM.enabled;
         resolve(@(enabled));
@@ -151,16 +145,13 @@ 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:(NSString *)edge offset:(double)offset;
+- (void)setFloatingButtonEdge:(CGRectEdge)floatingButtonEdge withTopOffset:(double)floatingButtonOffsetFromTop;
 
-- (void)setOnInvokeHandler;
+- (void)setOnInvokeHandler:(RCTResponseSenderBlock)callBack;
 
-- (void)setOnSDKDismissedHandler;
+- (void)setOnSDKDismissedHandler:(RCTResponseSenderBlock)callBack;
 
 - (void)setShakingThresholdForiPhone:(double)iPhoneShakingThreshold;
 
 - (void)setShakingThresholdForiPad:(double)iPadShakingThreshold;
 
-- (void)setExtendedBugReportMode:(NSString *)mode;
+- (void)setExtendedBugReportMode:(LCQExtendedBugReportMode)extendedBugReportMode;
 
 - (void)setReportTypes:(NSArray *)types;
 
-- (void)show:(NSString *)type options:(NSArray *)options;
+- (void)show:(LCQBugReportingReportType)type options:(NSArray *)options;
 
 - (void)setAutoScreenRecordingEnabled:(BOOL)enabled;
 
@@ -57,6 +57,6 @@
                       checked:(BOOL)checked
                    actionType:(id)actionType;
 
-- (void)setProactiveReportingConfigurations:(BOOL)enabled gapBetweenModals:(double)gapBetweenModals modalDelayAfterDetection:(double)modalDelayAfterDetection;
+- (void)setProactiveReportingConfigurations:(BOOL)enabled gap:(NSNumber* )gap model:(NSNumber* )modal;
 
 @end

package/ios/RNLuciq/LuciqBugReportingBridge.m

@@ -0,0 +1,249 @@
+//
+//  LuciqBugReportingBridge.m
+//  RNLuciq
+//
+//  Created by Salma Ali on 7/30/19.
+//  Copyright © 2019 luciq. All rights reserved.
+//
+
+#import "LuciqBugReportingBridge.h"
+#import <LuciqSDK/LCQBugReporting.h>
+#import <asl.h>
+#import <React/RCTLog.h>
+#import <os/log.h>
+#import <React/RCTUIManager.h>
+
+@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:(CGFloat)duration) {
+    LCQBugReporting.autoScreenRecordingDuration = duration;
+}
+
+RCT_EXPORT_METHOD(setOnInvokeHandler:(RCTResponseSenderBlock)callBack) {
+    if (callBack != nil) {
+        LCQBugReporting.willInvokeHandler = ^{
+            [self sendEventWithName:@"LCQpreInvocationHandler" body:nil];
+        };
+    } else {
+        LCQBugReporting.willInvokeHandler = nil;
+    }
+}
+
+RCT_EXPORT_METHOD(setOnSDKDismissedHandler:(RCTResponseSenderBlock)callBack) {
+    if (callBack != nil) {
+        LCQBugReporting.didDismissHandler = ^(LCQDismissType dismissType, LCQReportCategory reportType) {
+
+            //parse dismiss type enum
+            NSString* dismissTypeString;
+            if (dismissType == LCQDismissTypeCancel) {
+                dismissTypeString = @"CANCEL";
+            } else if (dismissType == LCQDismissTypeSubmit) {
+                dismissTypeString = @"SUBMIT";
+            } else if (dismissType == LCQDismissTypeAddAttachment) {
+                dismissTypeString = @"ADD_ATTACHMENT";
+            }
+
+            //parse report type enum
+            NSString* reportTypeString;
+            if (reportType == LCQReportCategoryBug) {
+                reportTypeString = @"bug";
+            } else if (reportType == LCQReportCategoryFeedback) {
+                reportTypeString = @"feedback";
+            } else {
+                reportTypeString = @"other";
+            }
+            NSDictionary *result = @{ @"dismissType": dismissTypeString,
+                                      @"reportType": reportTypeString};
+            [self sendEventWithName:@"LCQpostInvocationHandler" body: result];
+        };
+    } else {
+        LCQBugReporting.didDismissHandler = nil;
+    }
+}
+
+RCT_EXPORT_METHOD(setDidSelectPromptOptionHandler:(RCTResponseSenderBlock)callBack) {
+    if (callBack != nil) {
+
+        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";
+            }
+
+            [self sendEventWithName:@"LCQDidSelectPromptOptionHandler" body:@{
+                                                                              @"promptOption": promptOptionString
+                                                                              }];
+        };
+    } else {
+        LCQBugReporting.didSelectPromptOptionHandler = nil;
+    }
+}
+
+RCT_EXPORT_METHOD(setInvocationEvents:(NSArray*)invocationEventsArray) {
+    LCQInvocationEvent invocationEvents = 0;
+    for (NSNumber *boxedValue in invocationEventsArray) {
+        invocationEvents |= [boxedValue intValue];
+    }
+    LCQBugReporting.invocationEvents = invocationEvents;
+}
+
+RCT_EXPORT_METHOD(setOptions:(NSArray*)invocationOptionsArray) {
+    LCQBugReportingOption invocationOptions = 0;
+
+    for (NSNumber *boxedValue in invocationOptionsArray) {
+        invocationOptions |= [boxedValue intValue];
+    }
+
+    LCQBugReporting.bugReportingOptions = invocationOptions;
+}
+
+RCT_EXPORT_METHOD(setFloatingButtonEdge:(CGRectEdge)floatingButtonEdge withTopOffset:(double)floatingButtonOffsetFromTop) {
+    LCQBugReporting.floatingButtonEdge = floatingButtonEdge;
+    LCQBugReporting.floatingButtonTopOffset = floatingButtonOffsetFromTop;
+}
+
+RCT_EXPORT_METHOD(setExtendedBugReportMode:(LCQExtendedBugReportMode)extendedBugReportMode) {
+    LCQBugReporting.extendedBugReportMode = extendedBugReportMode;
+}
+
+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)viewHirearchyEnabled) {
+    LCQBugReporting.shouldCaptureViewHierarchy = viewHirearchyEnabled;
+}
+
+RCT_EXPORT_METHOD(setVideoRecordingFloatingButtonPosition:(LCQPosition)position) {
+    LCQBugReporting.videoRecordingFloatingButtonPosition = position;
+}
+
+RCT_EXPORT_METHOD(setReportTypes:(NSArray*) types ) {
+    LCQBugReportingReportType reportTypes = 0;
+    for (NSNumber *boxedValue in types) {
+        reportTypes |= [boxedValue intValue];
+    }
+    [LCQBugReporting setPromptOptionsEnabledReportTypes: reportTypes];
+}
+
+RCT_EXPORT_METHOD(show:(LCQBugReportingReportType)type options:(NSArray*) options) {
+    LCQBugReportingOption parsedOptions = 0;
+    for (NSNumber *boxedValue in options) {
+        parsedOptions |= [boxedValue intValue];
+    }
+    NSArray* args = @[@(type), @(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:(nonnull NSNumber *)limit reportTypes:(NSArray *)reportTypes) {
+    LCQBugReportingType parsedReportTypes = 0;
+    if (![reportTypes count]) {
+        parsedReportTypes = @(LCQBugReportingTypeBug).integerValue | @(LCQBugReportingTypeFeedback).integerValue | @(LCQBugReportingTypeQuestion).integerValue;
+    }
+    else {
+        for (NSNumber *reportType in reportTypes) {
+            parsedReportTypes |= [reportType intValue];
+        }
+    }
+   [LCQBugReporting setCommentMinimumCharacterCount:[limit integerValue] forBugReportType:parsedReportTypes];
+}
+
+RCT_EXPORT_METHOD(addUserConsent:(NSString *)key
+                  description:(NSString *)description
+                  mandatory:(BOOL)mandatory
+                  checked:(BOOL)checked
+                  actionType:(id)actionType) {
+    LCQConsentAction mappedActionType = (LCQConsentAction)[actionType integerValue];
+
+    [LCQBugReporting addUserConsentWithKey:key
+                               description:description
+                                 mandatory:mandatory
+                                   checked:checked
+                                actionType:mappedActionType];
+}
+
+RCT_EXPORT_METHOD(setProactiveReportingConfigurations:(BOOL)enabled gap:(nonnull NSNumber* )gap model:(nonnull NSNumber* )modal) {
+    LCQProactiveReportingConfigurations *configurations = [[LCQProactiveReportingConfigurations alloc] init];
+    configurations.enabled = enabled; //Enable/disable
+    configurations.gapBetweenModals = gap; // Time in seconds
+    configurations.modalDelayAfterDetection = modal; // Time in seconds
+   [LCQBugReporting setProactiveReportingConfigurations:configurations];
+}
+
+
+@synthesize description;
+
+@synthesize hash;
+
+@synthesize superclass;
+
+@end

package/ios/RNLuciq/LuciqCrashReportingBridge.h

@@ -9,21 +9,10 @@
 
 @interface LuciqCrashReportingBridge : RCTEventEmitter <RCTBridgeModule>
 
-- (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;
+- (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;
 
 @end

package/ios/RNLuciq/LuciqCrashReportingBridge.m

@@ -0,0 +1,68 @@
+#import "LuciqCrashReportingBridge.h"
+#import "Util/LCQCrashReporting+CP.h"
+
+
+@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 *)stackTrace
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0ul);
+    dispatch_async(queue, ^{
+        [LCQCrashReporting cp_reportFatalCrashWithStackTrace:stackTrace];
+        resolve([NSNull null]);
+    });
+}
+
+RCT_EXPORT_METHOD(sendHandledJSCrash: (NSDictionary *)stackTrace
+                  userAttributes:(nullable NSDictionary *)userAttributes fingerprint:(nullable NSString *)fingerprint nonFatalExceptionLevel:(LCQNonFatalLevel)nonFatalExceptionLevel
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+
+    if([fingerprint isKindOfClass:NSNull.class]){
+        fingerprint = nil;
+    }
+
+    if([userAttributes isKindOfClass:NSNull.class]){
+        userAttributes = nil;
+    }
+    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0ul);
+    dispatch_async(queue, ^{
+        [LCQCrashReporting cp_reportNonFatalCrashWithStackTrace:stackTrace level:nonFatalExceptionLevel groupingString:fingerprint userAttributes:userAttributes];
+
+        resolve([NSNull null]);
+    });
+
+}
+@synthesize description;
+
+@synthesize hash;
+
+@synthesize superclass;
+
+@end
+
+

package/ios/RNLuciq/LuciqFeatureRequestsBridge.h

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

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

@@ -1,3 +1,11 @@
+//
+//  LuciqFeatureRequestsBridge.m
+//  RNLuciq
+//
+//  Created by Salma Ali on 7/30/19.
+//  Copyright © 2019 luciq. All rights reserved.
+//
+
 #import "LuciqFeatureRequestsBridge.h"
 #import <LuciqSDK/LCQFeatureRequests.h>
 #import <asl.h>
@@ -6,13 +14,6 @@
 #import <LuciqSDK/LCQTypes.h>
 #import <React/RCTUIManager.h>
 
-#ifdef RCT_NEW_ARCH_ENABLED
-#import <RNLuciqSpec/RNLuciqSpec.h>
-
-@interface LuciqFeatureRequestsBridge () <NativeFeatureRequestsSpec>
-@end
-#endif
-
 @implementation LuciqFeatureRequestsBridge
 
 - (dispatch_queue_t)methodQueue {
@@ -35,32 +36,26 @@ RCT_EXPORT_METHOD(show) {
 }
 
 RCT_EXPORT_METHOD(setEmailFieldRequiredForFeatureRequests:(BOOL)isEmailFieldRequired
-                  types:(NSArray *)actionTypesArray) {
+                  forAction:(NSArray *)actionTypesArray) {
     LCQAction actionTypes = 0;
 
-    for (id value in actionTypesArray) {
-        if ([value isKindOfClass:[NSNumber class]] || [value isKindOfClass:[NSString class]]) {
-            actionTypes |= [value intValue];
-        }
+    for (NSNumber *boxedValue in actionTypesArray) {
+        actionTypes |= [boxedValue intValue];
     }
 
     [LCQFeatureRequests setEmailFieldRequired:isEmailFieldRequired forAction:actionTypes];
 }
 
-RCT_EXPORT_METHOD(setEnabled:(BOOL)isEnabled) {
+RCT_EXPORT_METHOD(setEnabled: (BOOL) isEnabled) {
     LCQFeatureRequests.enabled = isEnabled;
 }
 
-#ifdef RCT_NEW_ARCH_ENABLED
-- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
-    (const facebook::react::ObjCTurboModule::InitParams &)params
-{
-    return std::make_shared<facebook::react::NativeFeatureRequestsSpecJSI>(params);
-}
-#endif
-
 @synthesize description;
+
 @synthesize hash;
+
 @synthesize superclass;
 
 @end
+
+

package/ios/RNLuciq/LuciqNetworkLoggerBridge.h

@@ -2,9 +2,15 @@
 #import <React/RCTEventEmitter.h>
 #import <LuciqSDK/LCQTypes.h>
 
-typedef void (^LCQURLRequestAsyncObfuscationCompletedHandler)(NSURLRequest * _Nonnull request);
+typedef void (^ LCQURLRequestAsyncObfuscationCompletedHandler)(NSURLRequest * _Nonnull request);
 typedef void (^LCQURLRequestResponseAsyncFilteringCompletedHandler)(BOOL keep);
 
+typedef NS_ENUM(NSInteger, NetworkListenerType) {
+    NetworkListenerTypeFiltering,
+    NetworkListenerTypeObfuscation,
+    NetworkListenerTypeBoth
+};
+
 @interface LuciqNetworkLoggerBridge : RCTEventEmitter <RCTBridgeModule>
 
 @property NSMutableDictionary<NSString *, LCQURLRequestAsyncObfuscationCompletedHandler> * _Nonnull requestObfuscationCompletionDictionary;
@@ -12,4 +18,27 @@ typedef void (^LCQURLRequestResponseAsyncFilteringCompletedHandler)(BOOL keep);
 @property NSMutableDictionary<NSString *, LCQURLRequestResponseAsyncFilteringCompletedHandler> * _Nonnull requestFilteringCompletionDictionary;
 @property NSMutableDictionary<NSString *, LCQURLRequestResponseAsyncFilteringCompletedHandler> * _Nonnull responseFilteringCompletionDictionary;
 
+/*
+ +------------------------------------------------------------------------+
+ |                            NetworkLogger Module                        |
+ +------------------------------------------------------------------------+
+ */
+
+- (BOOL)isNativeInterceptionEnabled;
+
+- (void) registerNetworkLogsListener:(NetworkListenerType)listenerType;
+
+- (void)updateNetworkLogSnapshot:(NSString * _Nonnull)url
+                        callbackID:(NSString * _Nonnull)callbackID
+                        requestBody:(NSString * _Nullable)requestBody
+                        responseBody:(NSString * _Nullable)responseBody
+                        responseCode:(double)responseCode
+                        requestHeaders:(NSDictionary * _Nullable)requestHeaders
+                        responseHeaders:(NSDictionary * _Nullable)responseHeaders;
+
+- (void) setNetworkLoggingRequestFilterPredicateIOS:(NSString * _Nonnull) callbackID : (BOOL)value;
+
+- (void)forceStartNetworkLoggingIOS;
+
+- (void)forceStopNetworkLoggingIOS;
 @end