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

package/src/native/specs/NativeBugReporting.ts

@@ -0,0 +1,53 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+  show(type: string, options: string[]): void;
+
+  setInvocationEvents(events: string[]): void;
+  setOptions(options: string[]): void;
+  setExtendedBugReportMode(mode: string): void;
+  setReportTypes(types: string[]): void;
+  setDisclaimerText(text: string): void;
+  setCommentMinimumCharacterCount(limit: number, reportTypes: string[]): void;
+  setFloatingButtonEdge(edge: string, offset: number): void;
+  setVideoRecordingFloatingButtonPosition(buttonPosition: string): void;
+  setEnabledAttachmentTypes(
+    screenshot: boolean,
+    extraScreenshot: boolean,
+    galleryImage: boolean,
+    screenRecording: boolean,
+  ): void;
+
+  setAutoScreenRecordingEnabled(isEnabled: boolean): void;
+  setAutoScreenRecordingDuration(maxDuration: number): void;
+  setViewHierarchyEnabled(isEnabled: boolean): void;
+
+  setShakingThresholdForiPhone(threshold: number): void;
+  setShakingThresholdForiPad(threshold: number): void;
+  setShakingThresholdForAndroid(threshold: number): void;
+
+  setOnInvokeHandler(): void;
+  setDidSelectPromptOptionHandler(): void;
+  setOnSDKDismissedHandler(): void;
+
+  addUserConsent(
+    key: string,
+    description: string,
+    mandatory: boolean,
+    checked: boolean,
+    actionType: string | null,
+  ): void;
+
+  setProactiveReportingConfigurations(
+    enabled: boolean,
+    gapBetweenModals: number,
+    modalDelayAfterDetection: number,
+  ): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQBugReporting');

package/src/native/specs/NativeCrashReporting.ts

@@ -0,0 +1,23 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+
+  sendJSCrash(data: UnsafeObject): Promise<void>;
+
+  sendHandledJSCrash(
+    data: UnsafeObject,
+    userAttributes: UnsafeObject | null,
+    fingerprint: string | null,
+    nonFatalExceptionLevel: string | null,
+  ): Promise<void>;
+
+  setNDKCrashesEnabled(isEnabled: boolean): Promise<void>;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQCrashReporting');

package/src/native/specs/NativeFeatureRequests.ts

@@ -0,0 +1,10 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+  show(): void;
+  setEmailFieldRequiredForFeatureRequests(isEmailFieldRequired: boolean, types: string[]): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQFeatureRequests');

package/src/native/specs/NativeLuciq.ts

@@ -0,0 +1,137 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  getAllConstants(): UnsafeObject;
+  setEnabled(isEnabled: boolean): void;
+  isBuilt(): Promise<boolean>;
+  init(
+    token: string,
+    invocationEvents: string[],
+    debugLogsLevel: string,
+    useNativeNetworkInterception: boolean,
+    codePushVersion: string | null,
+    appVariant: string | null,
+    options: UnsafeObject | null,
+    overAirVersion: UnsafeObject | null,
+  ): void;
+  show(): void;
+
+  setCodePushVersion(version: string): void;
+  setOverAirVersion(OTAserviceVersion: UnsafeObject): void;
+  setAppVariant(appVariant: string): void;
+  setLCQLogPrintsToConsole(printsToConsole: boolean): void;
+  setSessionProfilerEnabled(isEnabled: boolean): void;
+
+  setLocale(sdkLocale: string): void;
+  setColorTheme(sdkTheme: string): void;
+  setPrimaryColor(color: number | null): void;
+  setString(string: string, key: string): void;
+
+  networkLogAndroid(
+    url: string,
+    requestBody: string,
+    responseBody: string | null,
+    method: string,
+    responseCode: number,
+    requestHeaders: string,
+    responseHeaders: string,
+    duration: number,
+  ): void;
+
+  networkLogIOS(
+    url: string,
+    method: string,
+    requestBody: string | null,
+    requestBodySize: number,
+    responseBody: string | null,
+    responseBodySize: number,
+    responseCode: number,
+    requestHeaders: UnsafeObject,
+    responseHeaders: UnsafeObject,
+    contentType: string,
+    errorDomain: string,
+    errorCode: number,
+    startTime: number,
+    duration: number,
+    gqlQueryName: string | null,
+    serverErrorMessage: string | null,
+    w3cExternalTraceAttributes: UnsafeObject,
+  ): void;
+
+  setNetworkLoggingEnabled(isEnabled: boolean): void;
+  setNetworkLogBodyEnabled(isEnabled: boolean): void;
+
+  setReproStepsConfig(bugMode: string, crashMode: string, sessionReplay: string): void;
+  setTrackUserSteps(isEnabled: boolean): void;
+  reportScreenChange(firstScreen: string): void;
+  reportCurrentViewChange(screenName: string): void;
+  addPrivateView(nativeTag: number | null): void;
+  removePrivateView(nativeTag: number | null): void;
+
+  logVerbose(message: string): void;
+  logInfo(message: string): void;
+  logDebug(message: string): void;
+  logError(message: string): void;
+  logWarn(message: string): void;
+  clearLogs(): void;
+
+  identifyUser(email: string, name: string, id: string | null): void;
+  logOut(): void;
+  logUserEvent(name: string): void;
+  setUserData(data: string): void;
+
+  setUserAttribute(key: string, value: string): void;
+  getUserAttribute(key: string): Promise<string>;
+  removeUserAttribute(key: string): void;
+  getAllUserAttributes(): Promise<UnsafeObject>;
+  clearAllUserAttributes(): void;
+
+  showWelcomeMessageWithMode(mode: string): void;
+  setWelcomeMessageMode(mode: string): void;
+
+  appendTags(tags: string[]): void;
+  resetTags(): void;
+  getTags(): Promise<string[]>;
+
+  addFeatureFlags(featureFlags: UnsafeObject): void;
+  removeFeatureFlags(featureFlags: string[]): void;
+  removeAllFeatureFlags(): void;
+
+  setFileAttachment(filePath: string, fileName: string | null): void;
+
+  setPreSendingHandler(): void;
+  appendTagToReport(tag: string): void;
+  appendConsoleLogToReport(consoleLog: string): void;
+  setUserAttributeToReport(key: string, value: string): void;
+  logDebugToReport(log: string): void;
+  logVerboseToReport(log: string): void;
+  logWarnToReport(log: string): void;
+  logErrorToReport(log: string): void;
+  logInfoToReport(log: string): void;
+  addFileAttachmentWithURLToReport(url: string, filename: string | null): void;
+  addFileAttachmentWithDataToReport(data: string, filename: string | null): void;
+  willRedirectToStore(): void;
+
+  isW3ExternalTraceIDEnabled(): Promise<boolean>;
+  isW3ExternalGeneratedHeaderEnabled(): Promise<boolean>;
+  isW3CaughtHeaderEnabled(): Promise<boolean>;
+
+  registerFeatureFlagsChangeListener(): void;
+  setOnFeaturesUpdatedListener(): void;
+  enableAutoMasking(autoMaskingTypes: string[]): void;
+  getNetworkBodyMaxSize(): Promise<number>;
+
+  setTheme(theme: UnsafeObject): void;
+  setFullscreen(isEnabled: boolean): void;
+
+  setWebViewMonitoringEnabled(isEnabled: boolean): void;
+  setWebViewNetworkTrackingEnabled(isEnabled: boolean): void;
+  setWebViewUserInteractionsTrackingEnabled(isEnabled: boolean): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Luciq');

package/src/native/specs/NativeNetworkLogger.ts

@@ -0,0 +1,31 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  isNativeInterceptionEnabled(): boolean;
+
+  registerNetworkLogsListener(type: string | null): void;
+
+  updateNetworkLogSnapshot(
+    url: string,
+    callbackID: string,
+    requestBody: string | null,
+    responseBody: string | null,
+    responseCode: number,
+    requestHeaders: UnsafeObject,
+    responseHeaders: UnsafeObject,
+  ): void;
+
+  hasAPMNetworkPlugin(): Promise<boolean>;
+  resetNetworkLogsListener(): void;
+
+  setNetworkLoggingRequestFilterPredicateIOS(id: string, value: boolean): void;
+  forceStartNetworkLoggingIOS(): void;
+  forceStopNetworkLoggingIOS(): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQNetworkLogger');

package/src/native/specs/NativeReplies.ts

@@ -0,0 +1,27 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+  show(): void;
+  hasChats(): Promise<boolean>;
+  getUnreadRepliesCount(): Promise<number>;
+
+  setOnNewReplyReceivedHandler(): void;
+
+  setPushNotificationsEnabled(isEnabled: boolean): void;
+  setInAppNotificationEnabled(isEnabled: boolean): void;
+
+  setInAppNotificationSound(isEnabled: boolean): void;
+  setPushNotificationRegistrationToken(token: string): void;
+  showNotification(data: UnsafeObject): void;
+  setNotificationIcon(resourceId: number): void;
+  setPushNotificationChannelId(id: string): void;
+  setSystemReplyNotificationSoundEnabled(isEnabled: boolean): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQReplies');

package/src/native/specs/NativeSessionReplay.ts

@@ -0,0 +1,20 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+  setNetworkLogsEnabled(isEnabled: boolean): void;
+  setLuciqLogsEnabled(isEnabled: boolean): void;
+  setUserStepsEnabled(isEnabled: boolean): void;
+  getSessionReplayLink(): Promise<string>;
+  setSyncCallback(): Promise<void>;
+  evaluateSync(shouldSync: boolean): void;
+  setCapturingMode(mode: string): void;
+  setScreenshotQuality(quality: string): void;
+  setScreenshotCaptureInterval(intervalMs: number): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQSessionReplay');

package/src/native/specs/NativeSurveys.ts

@@ -0,0 +1,23 @@
+import type { TurboModule } from 'react-native';
+import type { UnsafeObject } from 'react-native/Libraries/Types/CodegenTypes';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  setEnabled(isEnabled: boolean): void;
+  setAutoShowingEnabled(autoShowingSurveysEnabled: boolean): void;
+  showSurvey(surveyToken: string): void;
+  showSurveysIfAvailable(): void;
+  getAvailableSurveys(): Promise<UnsafeObject[]>;
+  hasRespondedToSurvey(surveyToken: string): Promise<boolean>;
+
+  setShouldShowWelcomeScreen(shouldShowWelcomeScreen: boolean): void;
+  setAppStoreURL(appStoreURL: string): void;
+
+  setOnShowHandler(): void;
+  setOnDismissHandler(): void;
+
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('LCQSurveys');

package/src/utils/Enums.ts

@@ -1,6 +1,9 @@
 import { NativeLuciq } from '../native/NativeLuciq';
 
-const constants = NativeLuciq.getConstants();
+const constants =
+  typeof NativeLuciq.getConstants === 'function'
+    ? NativeLuciq.getConstants()
+    : (NativeLuciq as any).getAllConstants();
 
 /**
  * Verbosity level of the SDK debug logs. This has nothing to do with `Luciq.log`,

package/src/utils/FeatureFlags.ts

@@ -1,40 +1,5 @@
 import { NativeLuciq } from '../native/NativeLuciq';
 import { _registerFeatureFlagsChangeListener } from '../modules/Luciq';
-import { Logger } from './logger';
-
-const TAG = 'LCQ-RN-NET:';
-
-let cachedW3cFlags = {
-  isW3cExternalTraceIDEnabled: false,
-  isW3cExternalGeneratedHeaderEnabled: false,
-  isW3cCaughtHeaderEnabled: false,
-};
-
-export async function initFeatureFlagsCache() {
-  Logger.debug(TAG, '[FeatureFlags] Initializing W3C feature flags cache from native bridge...');
-  try {
-    const [traceID, generatedHeader, caughtHeader] = await Promise.all([
-      NativeLuciq.isW3ExternalTraceIDEnabled(),
-      NativeLuciq.isW3ExternalGeneratedHeaderEnabled(),
-      NativeLuciq.isW3CaughtHeaderEnabled(),
-    ]);
-    cachedW3cFlags = {
-      isW3cExternalTraceIDEnabled: traceID,
-      isW3cExternalGeneratedHeaderEnabled: generatedHeader,
-      isW3cCaughtHeaderEnabled: caughtHeader,
-    };
-    Logger.debug(
-      TAG,
-      `[FeatureFlags] Cache initialized: traceID=${traceID}, generatedHeader=${generatedHeader}, caughtHeader=${caughtHeader}`,
-    );
-  } catch (e) {
-    Logger.debug(TAG, '[FeatureFlags] Failed to initialize cache, using defaults (all false):', e);
-  }
-}
-
-export function getCachedW3cFlags() {
-  return cachedW3cFlags;
-}
 
 export const FeatureFlags = {
   isW3ExternalTraceID: () => NativeLuciq.isW3ExternalTraceIDEnabled(),
@@ -51,15 +16,6 @@ export const registerFeatureFlagsListener = () => {
       isW3CaughtHeaderEnabled: boolean;
       networkBodyLimit: number;
     }) => {
-      Logger.debug(
-        TAG,
-        `[FeatureFlags] Flags updated from native listener: traceID=${res.isW3ExternalTraceIDEnabled}, generatedHeader=${res.isW3ExternalGeneratedHeaderEnabled}, caughtHeader=${res.isW3CaughtHeaderEnabled}, bodyLimit=${res.networkBodyLimit}`,
-      );
-      cachedW3cFlags = {
-        isW3cExternalTraceIDEnabled: res.isW3ExternalTraceIDEnabled,
-        isW3cExternalGeneratedHeaderEnabled: res.isW3ExternalGeneratedHeaderEnabled,
-        isW3cCaughtHeaderEnabled: res.isW3CaughtHeaderEnabled,
-      };
       FeatureFlags.isW3ExternalTraceID = async () => {
         return res.isW3ExternalTraceIDEnabled;
       };

package/src/utils/LuciqUtils.ts

@@ -12,7 +12,6 @@ import { NativeCrashReporting } from '../native/NativeCrashReporting';
 import type { NetworkData } from './XhrNetworkInterceptor';
 import { NativeLuciq } from '../native/NativeLuciq';
 import { NativeAPM } from '../native/NativeAPM';
-import { Logger } from './logger';
 import * as NetworkLogger from '../modules/NetworkLogger';
 import {
   NativeNetworkLogger,
@@ -165,14 +164,9 @@ export const stringifyIfNotString = (input: unknown) => {
  */
 export async function sendCrashReport(
   error: ExtendedError,
-  remoteSenderCallback: (json: CrashData | string) => Promise<void>,
+  remoteSenderCallback: (json: CrashData) => Promise<void>,
 ) {
   const jsonObject = getCrashDataFromError(error);
-
-  if (Platform.OS === 'android') {
-    return remoteSenderCallback(JSON.stringify(jsonObject));
-  }
-
   return remoteSenderCallback(jsonObject);
 }
 /**
@@ -232,11 +226,6 @@ export const reportNetworkLog = (network: NetworkData) => {
     const requestHeaders = JSON.stringify(network.requestHeaders);
     const responseHeaders = JSON.stringify(network.responseHeaders);
 
-    Logger.debug(
-      'LCQ-RN-NET:',
-      `[reportNetworkLog] Sending to NativeLuciq.networkLogAndroid: ${network.method} ${network.url}, status=${network.responseCode}, duration=${network.duration}ms, error=${network.errorDomain || 'none'}`,
-    );
-
     NativeLuciq.networkLogAndroid(
       network.url,
       network.requestBody,
@@ -252,10 +241,6 @@ export const reportNetworkLog = (network: NetworkData) => {
       !apmFlags.hasAPMNetworkPlugin ||
       !apmFlags.shouldEnableNativeInterception
     ) {
-      Logger.debug(
-        'LCQ-RN-NET:',
-        `[reportNetworkLog] Also sending to NativeAPM.networkLogAndroid (native interception disabled): ${network.method} ${network.url}`,
-      );
       NativeAPM.networkLogAndroid(
         network.startTime,
         network.duration,
@@ -281,11 +266,6 @@ export const reportNetworkLog = (network: NetworkData) => {
         network.gqlQueryName,
         network.serverErrorMessage,
       );
-    } else {
-      Logger.debug(
-        'LCQ-RN-NET:',
-        `[reportNetworkLog] Skipping NativeAPM.networkLogAndroid (native interception enabled): nativeFeature=${apmFlags.isNativeInterceptionFeatureEnabled}, hasPlugin=${apmFlags.hasAPMNetworkPlugin}, shouldEnable=${apmFlags.shouldEnableNativeInterception}`,
-      );
     }
   } else {
     NativeLuciq.networkLogIOS(