@luciq/react-native 18.0.0

package/dist/utils/XhrNetworkInterceptor.js

@@ -0,0 +1,253 @@
+import LuciqConstants from './LuciqConstants';
+import { stringifyIfNotString, generateW3CHeader } from './LuciqUtils';
+import { FeatureFlags } from '../utils/FeatureFlags';
+const XMLHttpRequest = global.XMLHttpRequest;
+let originalXHROpen = XMLHttpRequest.prototype.open;
+let originalXHRSend = XMLHttpRequest.prototype.send;
+let originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+let onProgressCallback;
+let onDoneCallback;
+let isInterceptorEnabled = false;
+let network;
+const _reset = () => {
+    network = {
+        id: '',
+        url: '',
+        method: '',
+        requestBody: '',
+        requestBodySize: 0,
+        responseBody: '',
+        responseBodySize: 0,
+        responseCode: 0,
+        requestHeaders: {},
+        responseHeaders: {},
+        contentType: '',
+        errorDomain: '',
+        errorCode: 0,
+        startTime: 0,
+        duration: 0,
+        gqlQueryName: '',
+        serverErrorMessage: '',
+        requestContentType: '',
+        isW3cHeaderFound: null,
+        partialId: null,
+        networkStartTimeInSeconds: null,
+        w3cGeneratedHeader: null,
+        w3cCaughtHeader: null,
+    };
+};
+const getTraceparentHeader = async (networkData) => {
+    const [isW3cExternalTraceIDEnabled, isW3cExternalGeneratedHeaderEnabled, isW3cCaughtHeaderEnabled,] = await Promise.all([
+        FeatureFlags.isW3ExternalTraceID(),
+        FeatureFlags.isW3ExternalGeneratedHeader(),
+        FeatureFlags.isW3CaughtHeader(),
+    ]);
+    return injectHeaders(networkData, {
+        isW3cExternalTraceIDEnabled,
+        isW3cExternalGeneratedHeaderEnabled,
+        isW3cCaughtHeaderEnabled,
+    });
+};
+export const injectHeaders = (networkData, featureFlags) => {
+    const { isW3cExternalTraceIDEnabled, isW3cExternalGeneratedHeaderEnabled, isW3cCaughtHeaderEnabled, } = featureFlags;
+    if (!isW3cExternalTraceIDEnabled) {
+        return;
+    }
+    const isHeaderFound = networkData.requestHeaders.traceparent != null;
+    networkData.isW3cHeaderFound = isHeaderFound;
+    const injectionMethodology = isHeaderFound
+        ? identifyCaughtHeader(networkData, isW3cCaughtHeaderEnabled)
+        : injectGeneratedData(networkData, isW3cExternalGeneratedHeaderEnabled);
+    return injectionMethodology;
+};
+const identifyCaughtHeader = (networkData, isW3cCaughtHeaderEnabled) => {
+    if (isW3cCaughtHeaderEnabled) {
+        networkData.w3cCaughtHeader = networkData.requestHeaders.traceparent;
+        return networkData.requestHeaders.traceparent;
+    }
+    return;
+};
+const injectGeneratedData = (networkData, isW3cExternalGeneratedHeaderEnabled) => {
+    const { timestampInSeconds, partialId, w3cHeader } = generateW3CHeader(networkData.startTime);
+    networkData.partialId = partialId;
+    networkData.networkStartTimeInSeconds = timestampInSeconds;
+    if (isW3cExternalGeneratedHeaderEnabled) {
+        networkData.w3cGeneratedHeader = w3cHeader;
+        return w3cHeader;
+    }
+    return;
+};
+export default {
+    setOnDoneCallback(callback) {
+        onDoneCallback = callback;
+    },
+    setOnProgressCallback(callback) {
+        onProgressCallback = callback;
+    },
+    enableInterception() {
+        // Prevents infinite calls to XMLHttpRequest.open when enabling interception multiple times
+        if (isInterceptorEnabled) {
+            return;
+        }
+        originalXHROpen = XMLHttpRequest.prototype.open;
+        originalXHRSend = XMLHttpRequest.prototype.send;
+        originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
+        // An error code that signifies an issue with the RN client.
+        const clientErrorCode = 9876;
+        XMLHttpRequest.prototype.open = function (method, url, ...args) {
+            _reset();
+            network.url = url;
+            network.method = method;
+            originalXHROpen.apply(this, [method, url, ...args]);
+        };
+        XMLHttpRequest.prototype.setRequestHeader = function (header, value) {
+            // According to the HTTP RFC, headers are case-insensitive, so we convert
+            // them to lower-case to make accessing headers predictable.
+            // This avoid issues like failing to get the Content-Type header for a request
+            // because the header is set as 'Content-Type' instead of 'content-type'.
+            const key = header.toLowerCase();
+            network.requestHeaders[key] = stringifyIfNotString(value);
+            originalXHRSetRequestHeader.apply(this, [header, value]);
+        };
+        XMLHttpRequest.prototype.send = async function (data) {
+            const cloneNetwork = JSON.parse(JSON.stringify(network));
+            cloneNetwork.requestBody = data ? data : '';
+            if (typeof cloneNetwork.requestBody !== 'string') {
+                cloneNetwork.requestBody = JSON.stringify(cloneNetwork.requestBody);
+            }
+            if (this.addEventListener) {
+                this.addEventListener('readystatechange', async () => {
+                    if (!isInterceptorEnabled) {
+                        return;
+                    }
+                    if (this.readyState === this.HEADERS_RECEIVED) {
+                        const contentTypeString = this.getResponseHeader('Content-Type');
+                        if (contentTypeString) {
+                            cloneNetwork.contentType = contentTypeString.split(';')[0];
+                        }
+                        const responseBodySizeString = this.getResponseHeader('Content-Length');
+                        if (responseBodySizeString) {
+                            const responseBodySizeNumber = Number(responseBodySizeString);
+                            if (!isNaN(responseBodySizeNumber)) {
+                                cloneNetwork.responseBodySize = responseBodySizeNumber;
+                            }
+                        }
+                        if (this.getAllResponseHeaders()) {
+                            const responseHeaders = this.getAllResponseHeaders().split('\r\n');
+                            const responseHeadersDictionary = {};
+                            responseHeaders.forEach((element) => {
+                                const key = element.split(/:(.+)/)[0];
+                                const value = element.split(/:(.+)/)[1];
+                                responseHeadersDictionary[key] = value;
+                            });
+                            cloneNetwork.responseHeaders = responseHeadersDictionary;
+                        }
+                        if (cloneNetwork.requestHeaders['content-type']) {
+                            cloneNetwork.requestContentType =
+                                cloneNetwork.requestHeaders['content-type'].split(';')[0];
+                        }
+                    }
+                    if (this.readyState === this.DONE) {
+                        cloneNetwork.duration = Date.now() - cloneNetwork.startTime;
+                        if (this.status == null) {
+                            cloneNetwork.responseCode = 0;
+                        }
+                        else {
+                            cloneNetwork.responseCode = this.status;
+                        }
+                        // @ts-ignore
+                        if (this._hasError) {
+                            cloneNetwork.errorCode = clientErrorCode;
+                            cloneNetwork.errorDomain = 'ClientError';
+                            // @ts-ignore
+                            const _response = this._response;
+                            cloneNetwork.requestBody =
+                                typeof _response === 'string' ? _response : JSON.stringify(_response);
+                            cloneNetwork.responseBody = '';
+                            // Detect a more descriptive error message.
+                            if (typeof _response === 'string' && _response.length > 0) {
+                                cloneNetwork.errorDomain = _response;
+                            }
+                            // @ts-ignore
+                        }
+                        else if (this._timedOut) {
+                            cloneNetwork.errorCode = clientErrorCode;
+                            cloneNetwork.errorDomain = 'TimeOutError';
+                        }
+                        if (this.response) {
+                            if (this.responseType === 'blob') {
+                                const responseText = await new Response(this.response).text();
+                                cloneNetwork.responseBody = responseText;
+                            }
+                            else if (['text', '', 'json'].includes(this.responseType)) {
+                                cloneNetwork.responseBody = JSON.stringify(this.response);
+                            }
+                        }
+                        else {
+                            cloneNetwork.responseBody = '';
+                            cloneNetwork.contentType = 'text/plain';
+                        }
+                        cloneNetwork.requestBodySize = cloneNetwork.requestBody.length;
+                        if (cloneNetwork.responseBodySize === 0 && cloneNetwork.responseBody) {
+                            cloneNetwork.responseBodySize = cloneNetwork.responseBody.length;
+                        }
+                        if (cloneNetwork.requestHeaders[LuciqConstants.GRAPHQL_HEADER]) {
+                            cloneNetwork.gqlQueryName =
+                                cloneNetwork.requestHeaders[LuciqConstants.GRAPHQL_HEADER];
+                            delete cloneNetwork.requestHeaders[LuciqConstants.GRAPHQL_HEADER];
+                            if (cloneNetwork.gqlQueryName === 'null') {
+                                cloneNetwork.gqlQueryName = '';
+                            }
+                            if (cloneNetwork.responseBody) {
+                                const responseObj = JSON.parse(cloneNetwork.responseBody);
+                                if (responseObj.errors) {
+                                    cloneNetwork.serverErrorMessage = 'GraphQLError';
+                                }
+                                else {
+                                    cloneNetwork.serverErrorMessage = '';
+                                }
+                            }
+                        }
+                        else {
+                            delete cloneNetwork.gqlQueryName;
+                        }
+                        if (onDoneCallback) {
+                            onDoneCallback(cloneNetwork);
+                        }
+                    }
+                });
+                const downloadUploadProgressCallback = (event) => {
+                    if (!isInterceptorEnabled) {
+                        return;
+                    }
+                    // check if will be able to compute progress
+                    if (event.lengthComputable && onProgressCallback) {
+                        const totalBytesSent = event.loaded;
+                        const totalBytesExpectedToSend = event.total - event.loaded;
+                        onProgressCallback(totalBytesSent, totalBytesExpectedToSend);
+                    }
+                };
+                this.addEventListener('progress', downloadUploadProgressCallback);
+                this.upload.addEventListener('progress', downloadUploadProgressCallback);
+            }
+            cloneNetwork.startTime = Date.now();
+            const traceparent = await getTraceparentHeader(cloneNetwork);
+            if (traceparent) {
+                this.setRequestHeader('Traceparent', traceparent);
+            }
+            if (this.readyState === this.UNSENT) {
+                return; // Prevent sending the request if not opened
+            }
+            originalXHRSend.apply(this, [data]);
+        };
+        isInterceptorEnabled = true;
+    },
+    disableInterception() {
+        isInterceptorEnabled = false;
+        XMLHttpRequest.prototype.send = originalXHRSend;
+        XMLHttpRequest.prototype.open = originalXHROpen;
+        XMLHttpRequest.prototype.setRequestHeader = originalXHRSetRequestHeader;
+        onDoneCallback = null;
+        onProgressCallback = null;
+    },
+};

package/dist/utils/config.d.ts

@@ -0,0 +1,5 @@
+import { LogLevel } from './Enums';
+export declare const LuciqRNConfig: {
+    metroDevServerPort: string;
+    debugLogsLevel: LogLevel;
+};

package/dist/utils/config.js

@@ -0,0 +1,6 @@
+import LuciqConstants from './LuciqConstants';
+import { LogLevel } from './Enums';
+export const LuciqRNConfig = {
+    metroDevServerPort: LuciqConstants.DEFAULT_METRO_PORT,
+    debugLogsLevel: LogLevel.error,
+};

package/dist/utils/logger.d.ts

@@ -0,0 +1,10 @@
+export declare class Logger {
+    private static shouldLog;
+    private static logMessage;
+    static error(message?: any, ...optionalParams: any[]): void;
+    static info(message?: any, ...optionalParams: any[]): void;
+    static log(message?: any, ...optionalParams: any[]): void;
+    static warn(message?: any, ...optionalParams: any[]): void;
+    static trace(message?: any, ...optionalParams: any[]): void;
+    static debug(message?: any, ...optionalParams: any[]): void;
+}

package/dist/utils/logger.js

@@ -0,0 +1,39 @@
+import { LuciqRNConfig } from './config';
+import { LogLevel } from './Enums';
+export class Logger {
+    static shouldLog(level) {
+        const currentLevel = LuciqRNConfig.debugLogsLevel;
+        // Return true if the current log level is equal to or more verbose than the requested level
+        const logLevelHierarchy = {
+            [LogLevel.verbose]: 3,
+            [LogLevel.debug]: 2,
+            [LogLevel.error]: 1,
+            [LogLevel.none]: 0,
+        };
+        return logLevelHierarchy[currentLevel] >= logLevelHierarchy[level];
+    }
+    // General logging method that takes a logging function as an argument
+    static logMessage(level, logMethod, message, ...optionalParams) {
+        if (this.shouldLog(level)) {
+            logMethod(message, ...optionalParams);
+        }
+    }
+    static error(message, ...optionalParams) {
+        this.logMessage(LogLevel.error, console.error, message, ...optionalParams); // Pass console.error for errors
+    }
+    static info(message, ...optionalParams) {
+        this.logMessage(LogLevel.verbose, console.info, message, ...optionalParams); // Pass console.info for info
+    }
+    static log(message, ...optionalParams) {
+        this.logMessage(LogLevel.verbose, console.log, message, ...optionalParams); // Default log method
+    }
+    static warn(message, ...optionalParams) {
+        this.logMessage(LogLevel.debug, console.warn, message, ...optionalParams); // Use console.warn for debug
+    }
+    static trace(message, ...optionalParams) {
+        this.logMessage(LogLevel.debug, console.trace, message, ...optionalParams); // Use console.trace for debugging
+    }
+    static debug(message, ...optionalParams) {
+        this.logMessage(LogLevel.debug, console.debug, message, ...optionalParams); // Use console.debug for debug logs
+    }
+}

package/expo.d.ts

@@ -0,0 +1 @@
+export * from './plugin/build';

package/expo.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/build');

package/ios/RNLuciq/ArgsRegistry.h

@@ -0,0 +1,32 @@
+#import <Foundation/Foundation.h>
+#import <LuciqSDK/LCQTypes.h>
+#import <LuciqSDK/LuciqSDK.h>
+
+typedef NSDictionary<NSString*, NSNumber*> ArgsDictionary;
+
+@interface ArgsRegistry : NSObject
+
++ (NSMutableDictionary *) getAll;
+
++ (ArgsDictionary *) sdkLogLevels;
++ (ArgsDictionary *) invocationEvents;
++ (ArgsDictionary *) invocationOptions;
++ (ArgsDictionary *) colorThemes;
++ (ArgsDictionary *) floatingButtonEdges;
++ (ArgsDictionary *) recordButtonPositions;
++ (ArgsDictionary *) welcomeMessageStates;
++ (ArgsDictionary *) reportTypes;
++ (ArgsDictionary *) dismissTypes;
++ (ArgsDictionary *) actionTypes;
++ (ArgsDictionary *) extendedBugReportStates;
++ (ArgsDictionary *) reproStates;
++ (ArgsDictionary *) locales;
++ (ArgsDictionary *)nonFatalExceptionLevel;
++ (ArgsDictionary *) launchType;
++ (ArgsDictionary *) overAirServices;
++ (ArgsDictionary *) userConsentActionTypes;
+
++ (NSDictionary<NSString *, NSString *> *) placeholders;
++ (ArgsDictionary *)autoMaskingTypes;
+
+@end

package/ios/RNLuciq/ArgsRegistry.m

@@ -0,0 +1,276 @@
+#import "ArgsRegistry.h"
+
+@implementation ArgsRegistry
+
++ (NSMutableDictionary *) getAll {
+    NSMutableDictionary *all = [[NSMutableDictionary alloc] init];
+
+    [all addEntriesFromDictionary:ArgsRegistry.sdkLogLevels];
+    [all addEntriesFromDictionary:ArgsRegistry.invocationEvents];
+    [all addEntriesFromDictionary:ArgsRegistry.invocationOptions];
+    [all addEntriesFromDictionary:ArgsRegistry.colorThemes];
+    [all addEntriesFromDictionary:ArgsRegistry.floatingButtonEdges];
+    [all addEntriesFromDictionary:ArgsRegistry.recordButtonPositions];
+    [all addEntriesFromDictionary:ArgsRegistry.welcomeMessageStates];
+    [all addEntriesFromDictionary:ArgsRegistry.reportTypes];
+    [all addEntriesFromDictionary:ArgsRegistry.dismissTypes];
+    [all addEntriesFromDictionary:ArgsRegistry.actionTypes];
+    [all addEntriesFromDictionary:ArgsRegistry.extendedBugReportStates];
+    [all addEntriesFromDictionary:ArgsRegistry.reproStates];
+    [all addEntriesFromDictionary:ArgsRegistry.locales];
+    [all addEntriesFromDictionary:ArgsRegistry.nonFatalExceptionLevel];
+    [all addEntriesFromDictionary:ArgsRegistry.placeholders];
+    [all addEntriesFromDictionary:ArgsRegistry.launchType];
+    [all addEntriesFromDictionary:ArgsRegistry.overAirServices];
+
+    [all addEntriesFromDictionary:ArgsRegistry.autoMaskingTypes];
+    [all addEntriesFromDictionary:ArgsRegistry.userConsentActionTypes];
+
+    return all;
+}
+
++ (ArgsDictionary *) sdkLogLevels {
+    return @{
+        @"sdkDebugLogsLevelVerbose": @(LCQSDKDebugLogsLevelVerbose),
+        @"sdkDebugLogsLevelDebug": @(LCQSDKDebugLogsLevelDebug),
+        @"sdkDebugLogsLevelError": @(LCQSDKDebugLogsLevelError),
+        @"sdkDebugLogsLevelNone": @(LCQSDKDebugLogsLevelNone),
+    };
+}
+
++ (ArgsDictionary *) invocationEvents {
+    return@{
+        @"invocationEventNone": @(LCQInvocationEventNone),
+        @"invocationEventShake": @(LCQInvocationEventShake),
+        @"invocationEventScreenshot": @(LCQInvocationEventScreenshot),
+        @"invocationEventTwoFingersSwipeLeft": @(LCQInvocationEventTwoFingersSwipeLeft),
+        @"invocationEventRightEdgePan": @(LCQInvocationEventRightEdgePan),
+        @"invocationEventFloatingButton": @(LCQInvocationEventFloatingButton)
+    };
+}
+
++ (ArgsDictionary *) invocationOptions {
+    return @{
+        @"optionEmailFieldHidden": @(LCQBugReportingOptionEmailFieldHidden),
+        @"optionEmailFieldOptional": @(LCQBugReportingOptionEmailFieldOptional),
+        @"optionCommentFieldRequired": @(LCQBugReportingOptionCommentFieldRequired),
+        @"optionDisablePostSendingDialog": @(LCQBugReportingOptionDisablePostSendingDialog),
+    };
+}
+
++ (ArgsDictionary *) colorThemes {
+    return @{
+        @"colorThemeLight": @(LCQColorThemeLight),
+        @"colorThemeDark": @(LCQColorThemeDark),
+    };
+}
+
++ (ArgsDictionary *) floatingButtonEdges {
+    return @{
+        @"rectMinXEdge": @(CGRectMinXEdge),
+        @"rectMinYEdge": @(CGRectMinYEdge),
+        @"rectMaxXEdge": @(CGRectMaxXEdge),
+        @"rectMaxYEdge": @(CGRectMaxYEdge),
+    };
+}
+
++ (ArgsDictionary *) recordButtonPositions {
+    return @{
+        @"topLeft": @(LCQPositionTopLeft),
+        @"topRight": @(LCQPositionTopRight),
+        @"bottomLeft": @(LCQPositionBottomLeft),
+        @"bottomRight": @(LCQPositionBottomRight),
+    };
+}
+
++ (ArgsDictionary *) welcomeMessageStates {
+    return @{
+        @"welcomeMessageModeLive": @(LCQWelcomeMessageModeLive),
+        @"welcomeMessageModeBeta": @(LCQWelcomeMessageModeBeta),
+        @"welcomeMessageModeDisabled": @(LCQWelcomeMessageModeDisabled),
+    };
+}
+
++ (ArgsDictionary *) reportTypes {
+    return @{
+        @"bugReportingReportTypeBug": @(LCQBugReportingReportTypeBug),
+        @"bugReportingReportTypeFeedback": @(LCQBugReportingReportTypeFeedback),
+        @"bugReportingReportTypeQuestion": @(LCQBugReportingReportTypeQuestion),
+    };
+}
+
++ (ArgsDictionary *) dismissTypes {
+    return @{
+        @"dismissTypeSubmit": @(LCQDismissTypeSubmit),
+        @"dismissTypeCancel": @(LCQDismissTypeCancel),
+        @"dismissTypeAddAttachment": @(LCQDismissTypeAddAttachment),
+    };
+}
+
++ (ArgsDictionary *) actionTypes {
+    return @{
+        @"allActions": @(LCQActionAllActions),
+        @"requestNewFeature": @(LCQActionRequestNewFeature),
+        @"addCommentToFeature": @(LCQActionAddCommentToFeature),
+    };
+}
++ (ArgsDictionary *) userConsentActionTypes {
+    return @{
+        @"dropAutoCapturedMedia": @(LCQConsentActionDropAutoCapturedMedia),
+        @"dropLogs": @(LCQConsentActionDropLogs),
+        @"noChat": @(LCQConsentActionNoChat)
+    };
+}
++ (ArgsDictionary *) extendedBugReportStates {
+    return @{
+        @"enabledWithRequiredFields": @(LCQExtendedBugReportModeEnabledWithRequiredFields),
+        @"enabledWithOptionalFields": @(LCQExtendedBugReportModeEnabledWithOptionalFields),
+        @"disabled": @(LCQExtendedBugReportModeDisabled),
+    };
+}
+
++ (ArgsDictionary *) reproStates {
+    return @{
+        @"reproStepsEnabled": @(LCQUserStepsModeEnable),
+        @"reproStepsDisabled": @(LCQUserStepsModeDisable),
+        @"reproStepsEnabledWithNoScreenshots": @(LCQUserStepsModeEnabledWithNoScreenshots),
+    };
+}
+
++ (ArgsDictionary *) locales {
+    return @{
+        @"localeArabic": @(LCQLocaleArabic),
+        @"localeAzerbaijani": @(LCQLocaleAzerbaijani),
+        @"localeChineseSimplified": @(LCQLocaleChineseSimplified),
+        @"localeChineseTraditional": @(LCQLocaleChineseTraditional),
+        @"localeCzech": @(LCQLocaleCzech),
+        @"localeDanish": @(LCQLocaleDanish),
+        @"localeDutch": @(LCQLocaleDutch),
+        @"localeEnglish": @(LCQLocaleEnglish),
+        @"localeFrench": @(LCQLocaleFrench),
+        @"localeGerman": @(LCQLocaleGerman),
+        @"localeItalian": @(LCQLocaleItalian),
+        @"localeJapanese": @(LCQLocaleJapanese),
+        @"localeKorean": @(LCQLocaleKorean),
+        @"localePolish": @(LCQLocalePolish),
+        @"localePortugueseBrazil": @(LCQLocalePortugueseBrazil),
+        @"localeRomanian": @(LCQLocaleRomanian),
+        @"localeRussian": @(LCQLocaleRussian),
+        @"localeSpanish": @(LCQLocaleSpanish),
+        @"localeSwedish": @(LCQLocaleSwedish),
+        @"localeTurkish": @(LCQLocaleTurkish),
+    };
+}
+
++ (ArgsDictionary *)nonFatalExceptionLevel {
+    return @{
+        @"nonFatalErrorLevelInfo" : @(LCQNonFatalLevelInfo),
+        @"nonFatalErrorLevelError" : @(LCQNonFatalLevelError),
+        @"nonFatalErrorLevelWarning" : @(LCQNonFatalLevelWarning),
+        @"nonFatalErrorLevelCritical" : @(LCQNonFatalLevelCritical)
+
+
+    };
+}
+
++ (NSDictionary<NSString *, NSString *> *) placeholders {
+    return @{
+        @"shakeHint": kLCQShakeStartAlertTextStringName,
+        @"swipeHint": kLCQTwoFingerSwipeStartAlertTextStringName,
+        @"edgeSwipeStartHint": kLCQEdgeSwipeStartAlertTextStringName,
+        @"startAlertText": kLCQStartAlertTextStringName,
+        @"invalidEmailMessage": kLCQInvalidEmailMessageStringName,
+        @"invalidEmailTitle": kLCQInvalidEmailTitleStringName,
+
+        @"invocationHeader": kLCQInvocationTitleStringName,
+        @"reportQuestion": kLCQAskAQuestionStringName,
+        @"reportBug": kLCQReportBugStringName,
+        @"reportFeedback": kLCQReportFeedbackStringName,
+        @"emailFieldHint": kLCQEmailFieldPlaceholderStringName,
+        @"commentFieldHintForBugReport": kLCQCommentFieldPlaceholderForBugReportStringName,
+        @"commentFieldHintForFeedback": kLCQCommentFieldPlaceholderForFeedbackStringName,
+        @"commentFieldHintForQuestion": kLCQCommentFieldPlaceholderForQuestionStringName,
+        @"addVideoMessage": kLCQAddScreenRecordingMessageStringName,
+        @"addVoiceMessage": kLCQAddVoiceMessageStringName,
+        @"addImageFromGallery": kLCQAddImageFromGalleryStringName,
+        @"addExtraScreenshot": kLCQAddExtraScreenshotStringName,
+        @"audioRecordingPermissionDeniedTitle": kLCQAudioRecordingPermissionDeniedTitleStringName,
+        @"audioRecordingPermissionDeniedMessage": kLCQAudioRecordingPermissionDeniedMessageStringName,
+        @"microphonePermissionAlertSettingsButtonTitle": kLCQMicrophonePermissionAlertSettingsButtonTitleStringName,
+        @"conversationsHeaderTitle": kLCQChatsTitleStringName,
+        @"chatsHeaderTitle": kLCQChatsTitleStringName,
+        @"team": kLCQTeamStringName,
+        @"recordingMessageToHoldText": kLCQRecordingMessageToHoldTextStringName,
+        @"recordingMessageToReleaseText": kLCQRecordingMessageToReleaseTextStringName,
+        @"messagesNotification": kLCQMessagesNotificationTitleSingleMessageStringName,
+        @"messagesNotificationAndOthers": kLCQMessagesNotificationTitleMultipleMessagesStringName,
+        @"screenshotHeaderTitle": kLCQScreenshotTitleStringName,
+        @"okButtonTitle": kLCQOkButtonTitleStringName,
+        @"cancelButtonTitle": kLCQCancelButtonTitleStringName,
+        @"thankYouText": kLCQThankYouAlertTitleStringName,
+        @"audio": kLCQAudioStringName,
+        @"screenRecording": kLCQScreenRecordingStringName,
+        @"image": kLCQImageStringName,
+        @"surveyEnterYourAnswer": kLCQSurveyEnterYourAnswerTextPlaceholder,
+        @"videoPressRecord": kLCQVideoPressRecordTitle,
+        @"collectingDataText": kLCQCollectingDataText,
+        @"thankYouAlertText": kLCQThankYouAlertMessageStringName,
+
+        @"welcomeMessageBetaWelcomeStepTitle": kLCQBetaWelcomeMessageWelcomeStepTitle,
+        @"welcomeMessageBetaWelcomeStepContent": kLCQBetaWelcomeMessageWelcomeStepContent,
+        @"welcomeMessageBetaHowToReportStepTitle": kLCQBetaWelcomeMessageHowToReportStepTitle,
+        @"welcomeMessageBetaHowToReportStepContent": kLCQBetaWelcomeMessageHowToReportStepContent,
+        @"welcomeMessageBetaFinishStepTitle": kLCQBetaWelcomeMessageFinishStepTitle,
+        @"welcomeMessageBetaFinishStepContent": kLCQBetaWelcomeMessageFinishStepContent,
+        @"welcomeMessageLiveWelcomeStepTitle": kLCQLiveWelcomeMessageTitle,
+        @"welcomeMessageLiveWelcomeStepContent": kLCQLiveWelcomeMessageContent,
+
+        @"surveysStoreRatingThanksTitle": kLCQStoreRatingThankYouTitleText,
+        @"surveysStoreRatingThanksSubtitle": kLCQStoreRatingThankYouDescriptionText,
+
+        @"reportBugDescription": kLCQReportBugDescriptionStringName,
+        @"reportFeedbackDescription": kLCQReportFeedbackDescriptionStringName,
+        @"reportQuestionDescription": kLCQReportQuestionDescriptionStringName,
+        @"requestFeatureDescription": kLCQRequestFeatureDescriptionStringName,
+
+        @"discardAlertTitle": kLCQDiscardAlertTitle,
+        @"discardAlertMessage": kLCQDiscardAlertMessage,
+        @"discardAlertDiscard": kLCQDiscardAlertCancel,
+        @"discardAlertStay": kLCQDiscardAlertAction,
+        @"addAttachmentButtonTitleStringName": kLCQAddAttachmentButtonTitleStringName,
+
+        @"reportReproStepsDisclaimerBody": kLCQReproStepsDisclaimerBody,
+        @"reportReproStepsDisclaimerLink": kLCQReproStepsDisclaimerLink,
+        @"reproStepsProgressDialogBody": kLCQProgressViewTitle,
+        @"reproStepsListHeader": kLCQReproStepsListTitle,
+        @"reproStepsListDescription": kLCQReproStepsListHeader,
+        @"reproStepsListEmptyStateDescription": kLCQReproStepsListEmptyStateLabel,
+        @"reproStepsListItemNumberingTitle": kLCQReproStepsListItemName,
+        @"conversationTextFieldHint": kLCQChatReplyFieldPlaceholderStringName,
+        @"insufficientContentTitle" : kLCQInsufficientContentTitleStringName,
+        @"insufficientContentMessage" : kLCQInsufficientContentMessageStringName,
+    };
+}
+
++ (ArgsDictionary *) launchType {
+    return @{
+        @"cold": @(LaunchTypeCold),
+        @"unknown":@(LaunchTypeUnknown)
+    };
+}
++ (ArgsDictionary *) overAirServices {
+    return @{
+        @"expo":@(LCQOverAirTypeExpo) ,
+        @"codePush":@(LCQOverAirTypeCodePush),
+    };
+}
+
++ (ArgsDictionary *)autoMaskingTypes {
+    return @{
+        @"labels" : @(LCQAutoMaskScreenshotOptionLabels),
+        @"textInputs" : @(LCQAutoMaskScreenshotOptionTextInputs),
+        @"media" : @(LCQAutoMaskScreenshotOptionMedia),
+        @"none" : @(LCQAutoMaskScreenshotOptionMaskNothing)
+    };
+}
+@end

package/ios/RNLuciq/LuciqAPMBridge.h

@@ -0,0 +1,26 @@
+
+#import <Foundation/Foundation.h>
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <LuciqSDK/LCQTypes.h>
+
+@interface LuciqAPMBridge : RCTEventEmitter <RCTBridgeModule>
+/*
+ +------------------------------------------------------------------------+
+ |                             APM Module                                 |
+ +------------------------------------------------------------------------+
+ */
+
+- (void)setEnabled:(BOOL)isEnabled;
+- (void)setAppLaunchEnabled:(BOOL)isEnabled;
+- (void)endAppLaunch;
+- (void)setAutoUITraceEnabled:(BOOL)isEnabled;
+- (void)startFlow:(NSString *)name;
+- (void)endFlow:(NSString *)name;
+- (void)setFlowAttribute:(NSString *)name :(NSString *)key :(NSString *_Nullable)value;
+- (void)startUITrace:(NSString *)name;
+- (void)endUITrace;
+
+extern NSMutableDictionary *traces;
+
+@end