@luciq/react-native 18.0.0

package/dist/modules/NetworkLogger.d.ts

@@ -0,0 +1,52 @@
+import type { RequestHandler } from '@apollo/client';
+import { NetworkData, ProgressCallback } from '../utils/XhrNetworkInterceptor';
+import { NetworkListenerType } from '../native/NativeNetworkLogger';
+export type { NetworkData };
+export type NetworkDataObfuscationHandler = (data: NetworkData) => Promise<NetworkData>;
+/**
+ * Sets whether network logs should be sent with bug reports.
+ * It is enabled by default.
+ * @param isEnabled
+ */
+export declare const setEnabled: (isEnabled: boolean) => void;
+/**
+ * @internal
+ * Sets whether enabling or disabling native network interception.
+ * It is disabled by default.
+ * @param isEnabled
+ */
+export declare const setNativeInterceptionEnabled: (isEnabled: boolean) => void;
+export declare const getNetworkDataObfuscationHandler: () => NetworkDataObfuscationHandler | null | undefined;
+export declare const getRequestFilterExpression: () => string;
+export declare const hasRequestFilterExpression: () => boolean;
+/**
+ * Obfuscates any response data.
+ * @param handler
+ */
+export declare const setNetworkDataObfuscationHandler: (handler?: NetworkDataObfuscationHandler | null | undefined) => void;
+/**
+ * Omit requests from being logged based on either their request or response details
+ * @param expression
+ */
+export declare const setRequestFilterExpression: (expression: string) => void;
+/**
+ * Returns progress in terms of totalBytesSent and totalBytesExpectedToSend a network request.
+ * @param handler
+ */
+export declare const setProgressHandlerForRequest: (handler: ProgressCallback) => void;
+export declare const apolloLinkRequestHandler: RequestHandler;
+/**
+ * Sets whether network body logs will be captured or not.
+ * @param isEnabled
+ */
+export declare const setNetworkLogBodyEnabled: (isEnabled: boolean) => void;
+/**
+ * @internal
+ * Exported for internal/testing purposes only.
+ */
+export declare const resetNetworkListener: () => void;
+/**
+ * @internal
+ * Exported for internal/testing purposes only.
+ */
+export declare const registerNetworkLogsListener: (type: NetworkListenerType, handler?: ((networkSnapshot: NetworkData) => void) | undefined) => void;

package/dist/modules/NetworkLogger.js

@@ -0,0 +1,208 @@
+import LuciqConstants from '../utils/LuciqConstants';
+import xhr from '../utils/XhrNetworkInterceptor';
+import { LuciqRNConfig } from '../utils/config';
+import { Logger } from '../utils/logger';
+import { NativeLuciq } from '../native/NativeLuciq';
+import { isContentTypeNotAllowed, registerFilteringAndObfuscationListener, registerFilteringListener, registerObfuscationListener, reportNetworkLog, } from '../utils/LuciqUtils';
+import { NativeNetworkLogger, NativeNetworkLoggerEvent, NetworkListenerType, NetworkLoggerEmitter, } from '../native/NativeNetworkLogger';
+import { Platform } from 'react-native';
+let _networkDataObfuscationHandler;
+let _requestFilterExpression = 'false';
+let _isNativeInterceptionEnabled = false;
+let _networkListener = null;
+let hasFilterExpression = false;
+function getPortFromUrl(url) {
+    const portMatch = url.match(/:(\d+)(?=\/|$)/);
+    return portMatch ? portMatch[1] : null;
+}
+/**
+ * Sets whether network logs should be sent with bug reports.
+ * It is enabled by default.
+ * @param isEnabled
+ */
+export const setEnabled = (isEnabled) => {
+    if (isEnabled) {
+        xhr.enableInterception();
+        xhr.setOnDoneCallback(async (network) => {
+            // eslint-disable-next-line no-new-func
+            const predicate = Function('network', 'return ' + _requestFilterExpression);
+            if (!predicate(network)) {
+                const MAX_NETWORK_BODY_SIZE_IN_BYTES = await NativeLuciq.getNetworkBodyMaxSize();
+                try {
+                    if (_networkDataObfuscationHandler) {
+                        network = await _networkDataObfuscationHandler(network);
+                    }
+                    if (__DEV__) {
+                        const urlPort = getPortFromUrl(network.url);
+                        if (urlPort === LuciqRNConfig.metroDevServerPort) {
+                            return;
+                        }
+                    }
+                    if (network.requestBodySize > MAX_NETWORK_BODY_SIZE_IN_BYTES) {
+                        network.requestBody = `${LuciqConstants.MAX_REQUEST_BODY_SIZE_EXCEEDED_MESSAGE}${MAX_NETWORK_BODY_SIZE_IN_BYTES / 1024} Kb`;
+                        Logger.warn('LCQ-RN:', `${LuciqConstants.MAX_REQUEST_BODY_SIZE_EXCEEDED_MESSAGE}${MAX_NETWORK_BODY_SIZE_IN_BYTES / 1024} Kb`);
+                    }
+                    if (network.responseBodySize > MAX_NETWORK_BODY_SIZE_IN_BYTES) {
+                        network.responseBody = `${LuciqConstants.MAX_RESPONSE_BODY_SIZE_EXCEEDED_MESSAGE}${MAX_NETWORK_BODY_SIZE_IN_BYTES / 1024} Kb`;
+                        Logger.warn('LCQ-RN:', `${LuciqConstants.MAX_RESPONSE_BODY_SIZE_EXCEEDED_MESSAGE}${MAX_NETWORK_BODY_SIZE_IN_BYTES / 1024} Kb`);
+                    }
+                    if (network.requestBody && isContentTypeNotAllowed(network.requestContentType)) {
+                        network.requestBody = `Body is omitted because content type ${network.requestContentType} isn't supported`;
+                        Logger.warn(`LCQ-RN: The request body for the network request with URL ${network.url} has been omitted because the content type ${network.requestContentType} isn't supported.`);
+                    }
+                    if (network.responseBody && isContentTypeNotAllowed(network.contentType)) {
+                        network.responseBody = `Body is omitted because content type ${network.contentType} isn't supported`;
+                        Logger.warn(`LCQ-RN: The response body for the network request with URL ${network.url} has been omitted because the content type ${network.contentType} isn't supported.`);
+                    }
+                    reportNetworkLog(network);
+                }
+                catch (e) {
+                    Logger.error(e);
+                }
+            }
+        });
+    }
+    else {
+        xhr.disableInterception();
+    }
+};
+/**
+ * @internal
+ * Sets whether enabling or disabling native network interception.
+ * It is disabled by default.
+ * @param isEnabled
+ */
+export const setNativeInterceptionEnabled = (isEnabled) => {
+    _isNativeInterceptionEnabled = isEnabled;
+};
+export const getNetworkDataObfuscationHandler = () => _networkDataObfuscationHandler;
+export const getRequestFilterExpression = () => _requestFilterExpression;
+export const hasRequestFilterExpression = () => hasFilterExpression;
+/**
+ * Obfuscates any response data.
+ * @param handler
+ */
+export const setNetworkDataObfuscationHandler = (handler) => {
+    _networkDataObfuscationHandler = handler;
+    if (_isNativeInterceptionEnabled && Platform.OS === 'ios') {
+        if (hasFilterExpression) {
+            registerFilteringAndObfuscationListener(_requestFilterExpression);
+        }
+        else {
+            registerObfuscationListener();
+        }
+    }
+};
+/**
+ * Omit requests from being logged based on either their request or response details
+ * @param expression
+ */
+export const setRequestFilterExpression = (expression) => {
+    _requestFilterExpression = expression;
+    hasFilterExpression = true;
+    if (_isNativeInterceptionEnabled && Platform.OS === 'ios') {
+        if (_networkDataObfuscationHandler) {
+            registerFilteringAndObfuscationListener(_requestFilterExpression);
+        }
+        else {
+            registerFilteringListener(_requestFilterExpression);
+        }
+    }
+};
+/**
+ * Returns progress in terms of totalBytesSent and totalBytesExpectedToSend a network request.
+ * @param handler
+ */
+export const setProgressHandlerForRequest = (handler) => {
+    xhr.setOnProgressCallback(handler);
+};
+export const apolloLinkRequestHandler = (operation, forward) => {
+    try {
+        operation.setContext((context) => {
+            const newHeaders = context.headers ?? {};
+            newHeaders[LuciqConstants.GRAPHQL_HEADER] = operation.operationName;
+            return { headers: newHeaders };
+        });
+    }
+    catch (e) {
+        Logger.error(e);
+    }
+    return forward(operation);
+};
+/**
+ * Sets whether network body logs will be captured or not.
+ * @param isEnabled
+ */
+export const setNetworkLogBodyEnabled = (isEnabled) => {
+    NativeLuciq.setNetworkLogBodyEnabled(isEnabled);
+};
+/**
+ * @internal
+ * Exported for internal/testing purposes only.
+ */
+export const resetNetworkListener = () => {
+    if (process.env.NODE_ENV === 'test') {
+        _networkListener = null;
+        NativeNetworkLogger.resetNetworkLogsListener();
+    }
+    else {
+        Logger.error(`${LuciqConstants.LCQ_APM_TAG}: The \`resetNetworkListener()\` method is intended solely for testing purposes.`);
+    }
+};
+/**
+ * @internal
+ * Exported for internal/testing purposes only.
+ */
+export const registerNetworkLogsListener = (type, handler) => {
+    if (Platform.OS === 'ios') {
+        // remove old listeners
+        if (NetworkLoggerEmitter.listenerCount(NativeNetworkLoggerEvent.NETWORK_LOGGER_HANDLER) > 0) {
+            NetworkLoggerEmitter.removeAllListeners(NativeNetworkLoggerEvent.NETWORK_LOGGER_HANDLER);
+        }
+        if (_networkListener == null) {
+            // set new listener.
+            _networkListener = type;
+        }
+        else {
+            // attach a new listener to the existing one.
+            _networkListener = NetworkListenerType.both;
+        }
+    }
+    NetworkLoggerEmitter.addListener(NativeNetworkLoggerEvent.NETWORK_LOGGER_HANDLER, (networkSnapshot) => {
+        // Mapping the data [Native -> React-Native].
+        const { id, url, requestHeader, requestBody, responseHeader, response, responseCode } = networkSnapshot;
+        const networkSnapshotObj = {
+            id: id,
+            url: url,
+            requestBody: requestBody,
+            requestHeaders: requestHeader,
+            method: '',
+            responseBody: response,
+            responseCode: responseCode,
+            responseHeaders: responseHeader,
+            contentType: '',
+            duration: 0,
+            requestBodySize: 0,
+            responseBodySize: 0,
+            errorDomain: '',
+            errorCode: 0,
+            startTime: 0,
+            serverErrorMessage: '',
+            requestContentType: '',
+            isW3cHeaderFound: true,
+            networkStartTimeInSeconds: 0,
+            partialId: 0,
+            w3cCaughtHeader: '',
+            w3cGeneratedHeader: '',
+        };
+        if (handler) {
+            handler(networkSnapshotObj);
+        }
+    });
+    if (Platform.OS === 'ios') {
+        NativeNetworkLogger.registerNetworkLogsListener(_networkListener ?? NetworkListenerType.both);
+    }
+    else {
+        NativeNetworkLogger.registerNetworkLogsListener();
+    }
+};

package/dist/modules/Replies.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Enables and disables everything related to receiving replies.
+ * @param isEnabled
+ */
+export declare const setEnabled: (isEnabled: boolean) => void;
+/**
+ * Tells whether the user has chats already or not.
+ */
+export declare const hasChats: () => Promise<boolean>;
+/**
+ * Manual invocation for replies.
+ */
+export declare const show: () => void;
+/**
+ * Sets a block of code that gets executed when a new message is received.
+ * @param handler A callback that gets executed when a new message is received.
+ */
+export declare const setOnNewReplyReceivedHandler: (handler: () => void) => void;
+/**
+ * Returns the number of unread messages the user currently has.
+ * Use this method to get the number of unread messages the user
+ * has, then possibly notify them about it with your own UI.
+ * Notifications count, or -1 in case the SDK has not been initialized.
+ */
+export declare const getUnreadRepliesCount: () => Promise<number>;
+/**
+ * Enables/disables showing in-app notifications when the user receives a
+ * new message.
+ * @param isEnabled A boolean to set whether
+ * notifications are enabled or disabled.
+ */
+export declare const setInAppNotificationsEnabled: (isEnabled: boolean) => void;
+/**
+ * Set whether new in app notification received will play a small sound notification
+ * or not (Default is {@code false})
+ * @android
+ *
+ * @param isEnabled desired state of conversation sounds
+ */
+export declare const setInAppNotificationSound: (isEnabled: boolean) => void;
+/**
+ * Enables/disables the use of push notifications in the SDK.
+ * Defaults to YES.
+ * @param isEnabled A boolean to indicate whether push notifications are enabled or disabled.
+ */
+export declare const setPushNotificationsEnabled: (isEnabled: boolean) => void;
+/**
+ * Set the GCM registration token to Luciq
+ *
+ * @param token the GCM registration token
+ */
+export declare const setPushNotificationRegistrationTokenAndroid: (token: string) => void;
+/**
+ * Show in-app Messaging's notifications
+ *
+ * @param data the data bundle related to Luciq
+ */
+export declare const showNotificationAndroid: (data: Record<string, string>) => void;
+/**
+ * Set the push notification's icon that will be shown with Luciq notifications
+ *
+ * @param resourceId the notification icon resource ID
+ */
+export declare const setNotificationIconAndroid: (resourceId: number) => void;
+/**
+ * Set a notification channel id to a notification channel that notifications
+ * can be posted to.
+ *
+ * @param id an id to a notification channel that notifications
+ */
+export declare const setPushNotificationChannelIdAndroid: (id: string) => void;
+/**
+ * Set whether new system notification received will play the default sound from
+ * RingtoneManager or not (Default is {@code false})
+ *
+ * @param isEnabled desired state of conversation sounds
+ */
+export declare const setSystemReplyNotificationSoundEnabledAndroid: (isEnabled: boolean) => void;

package/dist/modules/Replies.js

@@ -0,0 +1,121 @@
+import { Platform } from 'react-native';
+import { NativeEvents, NativeReplies, emitter } from '../native/NativeReplies';
+/**
+ * Enables and disables everything related to receiving replies.
+ * @param isEnabled
+ */
+export const setEnabled = (isEnabled) => {
+    NativeReplies.setEnabled(isEnabled);
+};
+/**
+ * Tells whether the user has chats already or not.
+ */
+export const hasChats = async () => {
+    const result = await NativeReplies.hasChats();
+    return result;
+};
+/**
+ * Manual invocation for replies.
+ */
+export const show = () => {
+    NativeReplies.show();
+};
+/**
+ * Sets a block of code that gets executed when a new message is received.
+ * @param handler A callback that gets executed when a new message is received.
+ */
+export const setOnNewReplyReceivedHandler = (handler) => {
+    emitter.addListener(NativeEvents.ON_REPLY_RECEIVED_HANDLER, handler);
+    NativeReplies.setOnNewReplyReceivedHandler(handler);
+};
+/**
+ * Returns the number of unread messages the user currently has.
+ * Use this method to get the number of unread messages the user
+ * has, then possibly notify them about it with your own UI.
+ * Notifications count, or -1 in case the SDK has not been initialized.
+ */
+export const getUnreadRepliesCount = async () => {
+    const count = await NativeReplies.getUnreadRepliesCount();
+    return count;
+};
+/**
+ * Enables/disables showing in-app notifications when the user receives a
+ * new message.
+ * @param isEnabled A boolean to set whether
+ * notifications are enabled or disabled.
+ */
+export const setInAppNotificationsEnabled = (isEnabled) => {
+    NativeReplies.setInAppNotificationEnabled(isEnabled);
+};
+/**
+ * Set whether new in app notification received will play a small sound notification
+ * or not (Default is {@code false})
+ * @android
+ *
+ * @param isEnabled desired state of conversation sounds
+ */
+export const setInAppNotificationSound = (isEnabled) => {
+    if (Platform.OS === 'android') {
+        NativeReplies.setInAppNotificationSound(isEnabled);
+    }
+};
+/**
+ * Enables/disables the use of push notifications in the SDK.
+ * Defaults to YES.
+ * @param isEnabled A boolean to indicate whether push notifications are enabled or disabled.
+ */
+export const setPushNotificationsEnabled = (isEnabled) => {
+    NativeReplies.setPushNotificationsEnabled(isEnabled);
+};
+/**
+ * Set the GCM registration token to Luciq
+ *
+ * @param token the GCM registration token
+ */
+export const setPushNotificationRegistrationTokenAndroid = (token) => {
+    if (Platform.OS === 'android') {
+        NativeReplies.setPushNotificationRegistrationToken(token);
+    }
+};
+/**
+ * Show in-app Messaging's notifications
+ *
+ * @param data the data bundle related to Luciq
+ */
+export const showNotificationAndroid = (data) => {
+    if (Platform.OS === 'android') {
+        NativeReplies.showNotification(data);
+    }
+};
+/**
+ * Set the push notification's icon that will be shown with Luciq notifications
+ *
+ * @param resourceId the notification icon resource ID
+ */
+export const setNotificationIconAndroid = (resourceId) => {
+    if (Platform.OS === 'android') {
+        NativeReplies.setNotificationIcon(resourceId);
+    }
+};
+/**
+ * Set a notification channel id to a notification channel that notifications
+ * can be posted to.
+ *
+ * @param id an id to a notification channel that notifications
+ */
+export const setPushNotificationChannelIdAndroid = (id) => {
+    if (Platform.OS === 'android') {
+        NativeReplies.setPushNotificationChannelId(id);
+    }
+};
+/**
+ * Set whether new system notification received will play the default sound from
+ * RingtoneManager or not (Default is {@code false})
+ *
+ * @param isEnabled desired state of conversation sounds
+ */
+export const setSystemReplyNotificationSoundEnabledAndroid = (isEnabled) => {
+    if (Platform.OS === 'android') {
+        NativeReplies.setSystemReplyNotificationSoundEnabled(isEnabled);
+    }
+};

package/dist/modules/SessionReplay.d.ts

@@ -0,0 +1,78 @@
+import type { SessionMetadata } from '../models/SessionMetadata';
+/**
+ * Enables or disables Session Replay for your Luciq integration.
+ *
+ * By default, Session Replay is enabled if it is available in your current plan
+ *
+ * @param isEnabled
+ *
+ * @example
+ * ```ts
+ * SessionReplay.setEnabled(true);
+ * ```
+ */
+export declare const setEnabled: (isEnabled: boolean) => void;
+/**
+ * Enables or disables network logs for Session Replay.
+ *
+ * By default, network logs are enabled.
+ *
+ * @param isEnabled
+ *
+ * @example
+ * ```ts
+ * SessionReplay.setNetworkLogsEnabled(true);
+ * ```
+ */
+export declare const setNetworkLogsEnabled: (isEnabled: boolean) => void;
+/**
+ * Enables or disables Luciq logs for Session Replay.
+ *
+ * By default, Luciq logs are enabled.
+ *
+ * @param isEnabled
+ *
+ * @example
+ * ```ts
+ * SessionReplay.setLuciqLogsEnabled(true);
+ * ```
+ */
+export declare const setLuciqLogsEnabled: (isEnabled: boolean) => void;
+/**
+ * Enables or disables capturing of user steps  for Session Replay.
+ *
+ * By default, user steps are enabled.
+ *
+ * @param isEnabled
+ *
+ * @example
+ * ```ts
+ * SessionReplay.setUserStepsEnabled(true);
+ * ```
+ */
+export declare const setUserStepsEnabled: (isEnabled: boolean) => void;
+/**
+ * Retrieves current session's replay link.
+ *
+ * @example
+ * ```ts
+ * SessionReplay.getSessionReplayLink();
+ * ```
+ */
+export declare const getSessionReplayLink: () => Promise<string>;
+/**
+ * Set a callback for whether this session should sync
+ *
+ * @param handler
+
+ * @example
+ * ```ts
+ * SessionReplay.setSyncCallback((metadata) => {
+ *    return metadata.device == "Xiaomi M2007J3SY" &&
+ *         metadata.os == "OS Level 33" &&
+ *         metadata.appVersion == "3.1.4 (4)" ||
+ *         metadata.sessionDurationInSeconds > 20;
+ * });
+ * ```
+ */
+export declare const setSyncCallback: (handler: (payload: SessionMetadata) => boolean) => Promise<void>;

package/dist/modules/SessionReplay.js

@@ -0,0 +1,98 @@
+import { NativeSessionReplay, NativeEvents, emitter } from '../native/NativeSessionReplay';
+/**
+ * Enables or disables Session Replay for your Luciq integration.
+ *
+ * By default, Session Replay is enabled if it is available in your current plan
+ *
+ * @param isEnabled
+ *
+ * @example
+ * ```ts
+ * SessionReplay.setEnabled(true);
+ * ```
+ */
+export const setEnabled = (isEnabled) => {
+    NativeSessionReplay.setEnabled(isEnabled);
+};
+/**
+ * Enables or disables network logs for Session Replay.
+ *
+ * By default, network logs are enabled.
+ *
+ * @param isEnabled
+ *
+ * @example
+ * ```ts
+ * SessionReplay.setNetworkLogsEnabled(true);
+ * ```
+ */
+export const setNetworkLogsEnabled = (isEnabled) => {
+    NativeSessionReplay.setNetworkLogsEnabled(isEnabled);
+};
+/**
+ * Enables or disables Luciq logs for Session Replay.
+ *
+ * By default, Luciq logs are enabled.
+ *
+ * @param isEnabled
+ *
+ * @example
+ * ```ts
+ * SessionReplay.setLuciqLogsEnabled(true);
+ * ```
+ */
+export const setLuciqLogsEnabled = (isEnabled) => {
+    NativeSessionReplay.setLuciqLogsEnabled(isEnabled);
+};
+/**
+ * Enables or disables capturing of user steps  for Session Replay.
+ *
+ * By default, user steps are enabled.
+ *
+ * @param isEnabled
+ *
+ * @example
+ * ```ts
+ * SessionReplay.setUserStepsEnabled(true);
+ * ```
+ */
+export const setUserStepsEnabled = (isEnabled) => {
+    NativeSessionReplay.setUserStepsEnabled(isEnabled);
+};
+/**
+ * Retrieves current session's replay link.
+ *
+ * @example
+ * ```ts
+ * SessionReplay.getSessionReplayLink();
+ * ```
+ */
+export const getSessionReplayLink = async () => {
+    return NativeSessionReplay.getSessionReplayLink();
+};
+/**
+ * Set a callback for whether this session should sync
+ *
+ * @param handler
+
+ * @example
+ * ```ts
+ * SessionReplay.setSyncCallback((metadata) => {
+ *    return metadata.device == "Xiaomi M2007J3SY" &&
+ *         metadata.os == "OS Level 33" &&
+ *         metadata.appVersion == "3.1.4 (4)" ||
+ *         metadata.sessionDurationInSeconds > 20;
+ * });
+ * ```
+ */
+export const setSyncCallback = async (handler) => {
+    emitter.addListener(NativeEvents.SESSION_REPLAY_ON_SYNC_CALLBACK_INVOCATION, (payload) => {
+        const result = handler(payload);
+        const shouldSync = Boolean(result);
+        if (typeof result !== 'boolean') {
+            console.warn(`LCQ-RN: The callback passed to SessionReplay.setSyncCallback was expected to return a boolean but returned "${result}". The value has been cast to boolean, proceeding with ${shouldSync}.`);
+        }
+        NativeSessionReplay.evaluateSync(shouldSync);
+    });
+    return NativeSessionReplay.setSyncCallback();
+};