@repliqo/sdk-react-native 0.3.7 → 0.4.0

package/dist/snapshot/NativeScreenCapture.js

@@ -2,8 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNativeScreenCaptureAvailable = isNativeScreenCaptureAvailable;
 exports.captureNativeFrame = captureNativeFrame;
-exports.captureFullContent = captureFullContent;
-exports.scanFullContent = scanFullContent;
 const react_native_1 = require("react-native");
 const NativeModule = react_native_1.Platform.OS === 'android'
     ? react_native_1.NativeModules.ScreenCaptureModule ?? null
@@ -18,6 +16,12 @@ function isNativeScreenCaptureAvailable() {
  *
  * No permissions required. No dialog. No foreground service.
  *
+ * This is the ONLY native capture path. Full-content capture of
+ * off-screen ScrollView content is NOT possible natively (React Native
+ * doesn't render off-screen content to the GPU/view tree) — full-content
+ * heatmap backgrounds are instead built collaboratively from viewport
+ * tiles captured as the user naturally scrolls (see RepliqoScrollView).
+ *
  * @returns NativeFrameResult or null if capture failed / not available
  */
 async function captureNativeFrame() {
@@ -38,65 +42,3 @@ async function captureNativeFrame() {
         return null;
     }
 }
-/**
- * Capture the FULL content of the primary ScrollView on screen,
- * including content scrolled off-screen. Used for heatmap backgrounds.
- *
- * Falls back to a viewport capture if no ScrollView is found.
- * Max height: 5000px. JPEG quality: 60%. Width: ~500px.
- *
- * Known limitation: FlatList/SectionList use RecyclerView which only
- * renders visible items — full-content capture falls back to viewport.
- *
- * @returns FullContentResult with isFullContent flag, or null
- */
-async function captureFullContent() {
-    if (!NativeModule)
-        return null;
-    try {
-        const result = await NativeModule.captureFullContent();
-        if (!result || !result.image)
-            return null;
-        return {
-            image: result.image,
-            width: result.width,
-            height: result.height,
-            format: 'jpeg',
-            isFullContent: !!result.isFullContent,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Perform a fast programmatic scroll-scan of the main ScrollView.
- * Captures the entire content as viewport tiles in ~300-500ms.
- *
- * The scan is invisible to the user — scroll position is saved and
- * restored. Returns an array of tiles covering the full content.
- *
- * @returns Array of tiles, or null if no ScrollView or not available
- */
-async function scanFullContent() {
-    if (!NativeModule)
-        return null;
-    try {
-        const tiles = await NativeModule.scanFullContent();
-        if (!tiles || !Array.isArray(tiles) || tiles.length === 0)
-            return null;
-        return tiles
-            .filter((t) => t && t.image)
-            .map((t) => ({
-            image: t.image,
-            width: t.width,
-            height: t.height,
-            scrollOffsetY: t.scrollOffsetY,
-            viewportHeight: t.viewportHeight,
-            contentHeight: t.contentHeight,
-        }));
-    }
-    catch {
-        return null;
-    }
-}

package/dist/snapshot/capture.d.ts

@@ -22,6 +22,13 @@ export declare class SnapshotCapture {
     private log;
     private warn;
     constructor(config: SnapshotCaptureConfig, onSnapshot: (snapshot: SnapshotPayload) => void, provider?: ScreenshotProvider, log?: LogFn, warn?: LogFn);
+    /**
+     * Generation counter. Incremented on every start()/stop() so that timer
+     * chains from a PREVIOUS generation cannot reschedule themselves. Without
+     * it, a fast stop()→start() while a tick's capture is still in flight
+     * leaves two parallel timer chains alive (double capture rate).
+     */
+    private epoch;
     start(): void;
     stop(): void;
     captureNow(): Promise<void>;

package/dist/snapshot/capture.js

@@ -14,6 +14,13 @@ class SnapshotCapture {
         this.currentScreen = 'unknown';
         this.capturing = false;
         this.running = false;
+        /**
+         * Generation counter. Incremented on every start()/stop() so that timer
+         * chains from a PREVIOUS generation cannot reschedule themselves. Without
+         * it, a fast stop()→start() while a tick's capture is still in flight
+         * leaves two parallel timer chains alive (double capture rate).
+         */
+        this.epoch = 0;
         this.config = config;
         this.onSnapshot = onSnapshot;
         this.provider = provider;
@@ -24,11 +31,13 @@ class SnapshotCapture {
         if (this.running)
             return;
         this.running = true;
+        this.epoch++;
         this.log('Snapshot capture started (interval:', this.config.captureInterval, 'ms)');
-        this.scheduleNext();
+        this.scheduleNext(this.epoch);
     }
     stop() {
         this.running = false;
+        this.epoch++;
         if (this.timeoutId !== null) {
             clearTimeout(this.timeoutId);
             this.timeoutId = null;
@@ -38,13 +47,16 @@ class SnapshotCapture {
     async captureNow() {
         await this.tick();
     }
-    scheduleNext() {
-        if (!this.running)
+    scheduleNext(epoch) {
+        if (!this.running || epoch !== this.epoch)
             return;
         this.timeoutId = setTimeout(() => {
+            // Orphan timer from a previous generation — do nothing.
+            if (epoch !== this.epoch)
+                return;
             Promise.resolve(this.tick()).finally(() => {
-                if (this.running) {
-                    this.scheduleNext();
+                if (this.running && epoch === this.epoch) {
+                    this.scheduleNext(epoch);
                 }
             });
         }, this.config.captureInterval);

package/dist/trackers/error.tracker.d.ts

@@ -5,6 +5,7 @@ export declare class ErrorTracker {
     private sessionId;
     private currentScreen;
     private originalHandler;
+    private wrapperHandler;
     private isActive;
     constructor(onCrash: CrashCallback);
     setSessionId(id: string | null): void;
@@ -16,7 +17,31 @@ export declare class ErrorTracker {
      */
     reportError(error: Error, metadata?: Record<string, any>): void;
     private setupGlobalErrorHandler;
+    /**
+     * Handle an unhandled promise rejection. Guarded on isActive because the
+     * underlying trackers can't always be unregistered.
+     */
+    private handleUnhandledRejection;
+    /**
+     * Register with the mechanisms React Native ACTUALLY uses to surface
+     * unhandled promise rejections:
+     *
+     *  1. Hermes' native promise rejection tracker (Hermes engine).
+     *  2. The `promise` polyfill's rejection-tracking module (JSC and older
+     *     RN versions).
+     *
+     * A bare global callback (the old approach) is never invoked by RN — it
+     * silently captured nothing.
+     *
+     * KNOWN LIMITATION: these trackers hold a single handler — registering
+     * REPLACES whatever was installed before (RN's dev LogBox warning, or
+     * another SDK like Sentry if it initialized first), and there is no
+     * unregister API, so after stop() an inert handler remains installed.
+     * If you run multiple error-tracking SDKs, initialize Repliqo FIRST so
+     * the other SDK's handler wins, or disable enableCrashTracking.
+     */
     private setupUnhandledRejectionHandler;
+    private teardownUnhandledRejectionHandler;
     private restoreGlobalErrorHandler;
 }
 export {};

package/dist/trackers/error.tracker.js

@@ -6,7 +6,32 @@ class ErrorTracker {
         this.sessionId = null;
         this.currentScreen = null;
         this.originalHandler = null;
+        this.wrapperHandler = null;
         this.isActive = false;
+        /**
+         * Handle an unhandled promise rejection. Guarded on isActive because the
+         * underlying trackers can't always be unregistered.
+         */
+        this.handleUnhandledRejection = (_id, error) => {
+            if (!this.isActive)
+                return;
+            try {
+                const message = error instanceof Error ? error.message : String(error);
+                const stack = error instanceof Error ? error.stack : undefined;
+                const crash = {
+                    sessionId: this.sessionId || undefined,
+                    type: 'unhandled_rejection',
+                    message,
+                    stackTrace: stack || undefined,
+                    screenName: this.currentScreen || undefined,
+                    timestamp: new Date().toISOString(),
+                };
+                this.onCrash(crash);
+            }
+            catch (_e) {
+                // Never crash the app due to error reporting
+            }
+        };
         this.onCrash = onCrash;
     }
     setSessionId(id) {
@@ -25,8 +50,11 @@ class ErrorTracker {
     stop() {
         if (!this.isActive)
             return;
+        // Flip the flag FIRST — the rejection trackers can't always be
+        // unregistered (Hermes), so their callbacks guard on isActive.
         this.isActive = false;
         this.restoreGlobalErrorHandler();
+        this.teardownUnhandledRejectionHandler();
     }
     /**
      * Manual error reporting - allows consumers to report caught errors.
@@ -53,66 +81,115 @@ class ErrorTracker {
             const ErrorUtils = global.ErrorUtils;
             if (ErrorUtils) {
                 this.originalHandler = ErrorUtils.getGlobalHandler();
-                ErrorUtils.setGlobalHandler((error, isFatal) => {
-                    try {
-                        const crash = {
-                            sessionId: this.sessionId || undefined,
-                            type: isFatal ? 'native_crash' : 'js_error',
-                            message: error.message,
-                            stackTrace: error.stack || undefined,
-                            screenName: this.currentScreen || undefined,
-                            metadata: { isFatal },
-                            timestamp: new Date().toISOString(),
-                        };
-                        this.onCrash(crash);
-                    }
-                    catch (_e) {
-                        // Never crash the app due to error reporting
+                this.wrapperHandler = (error, isFatal) => {
+                    if (this.isActive) {
+                        try {
+                            const crash = {
+                                sessionId: this.sessionId || undefined,
+                                type: isFatal ? 'native_crash' : 'js_error',
+                                message: error.message,
+                                stackTrace: error.stack || undefined,
+                                screenName: this.currentScreen || undefined,
+                                metadata: { isFatal },
+                                timestamp: new Date().toISOString(),
+                            };
+                            this.onCrash(crash);
+                        }
+                        catch (_e) {
+                            // Never crash the app due to error reporting
+                        }
                     }
                     // Always call original handler so RN can handle the error
                     if (this.originalHandler) {
                         this.originalHandler(error, isFatal);
                     }
-                });
+                };
+                ErrorUtils.setGlobalHandler(this.wrapperHandler);
             }
         }
         catch (_e) {
             // Never crash the app due to error handler setup
         }
     }
+    /**
+     * Register with the mechanisms React Native ACTUALLY uses to surface
+     * unhandled promise rejections:
+     *
+     *  1. Hermes' native promise rejection tracker (Hermes engine).
+     *  2. The `promise` polyfill's rejection-tracking module (JSC and older
+     *     RN versions).
+     *
+     * A bare global callback (the old approach) is never invoked by RN — it
+     * silently captured nothing.
+     *
+     * KNOWN LIMITATION: these trackers hold a single handler — registering
+     * REPLACES whatever was installed before (RN's dev LogBox warning, or
+     * another SDK like Sentry if it initialized first), and there is no
+     * unregister API, so after stop() an inert handler remains installed.
+     * If you run multiple error-tracking SDKs, initialize Repliqo FIRST so
+     * the other SDK's handler wins, or disable enableCrashTracking.
+     */
     setupUnhandledRejectionHandler() {
+        // Kept for manual invocation / test hooks.
         try {
-            if (typeof global !== 'undefined') {
-                global.__analyticsUnhandledRejection = (_id, error) => {
-                    try {
-                        const message = error instanceof Error ? error.message : String(error);
-                        const stack = error instanceof Error ? error.stack : undefined;
-                        const crash = {
-                            sessionId: this.sessionId || undefined,
-                            type: 'unhandled_rejection',
-                            message,
-                            stackTrace: stack || undefined,
-                            screenName: this.currentScreen || undefined,
-                            timestamp: new Date().toISOString(),
-                        };
-                        this.onCrash(crash);
-                    }
-                    catch (_e) {
-                        // Never crash the app due to error reporting
-                    }
-                };
+            global.__analyticsUnhandledRejection =
+                this.handleUnhandledRejection;
+        }
+        catch (_e) {
+            /* ignore */
+        }
+        // Hermes: native promise rejection tracking.
+        try {
+            const hermes = global.HermesInternal;
+            if (hermes?.hasPromise?.() && hermes?.enablePromiseRejectionTracker) {
+                hermes.enablePromiseRejectionTracker({
+                    allRejections: true,
+                    onUnhandled: this.handleUnhandledRejection,
+                    onHandled: () => { },
+                });
+                return;
             }
         }
         catch (_e) {
-            // Never crash the app due to rejection handler setup
+            /* ignore — fall through to the polyfill */
+        }
+        // JSC / promise polyfill path.
+        try {
+            const rejectionTracking = require('promise/setimmediate/rejection-tracking');
+            rejectionTracking.enable({
+                allRejections: true,
+                onUnhandled: this.handleUnhandledRejection,
+                onHandled: () => { },
+            });
+        }
+        catch (_e) {
+            // Module unavailable (e.g. jest without the polyfill) — the global
+            // hook above still allows manual reporting.
+        }
+    }
+    teardownUnhandledRejectionHandler() {
+        try {
+            delete global.__analyticsUnhandledRejection;
+        }
+        catch (_e) {
+            /* ignore */
         }
+        // Hermes offers no unregister API and disabling the polyfill tracker
+        // could clobber another library's handler — the isActive guard in
+        // handleUnhandledRejection makes lingering registrations inert.
     }
     restoreGlobalErrorHandler() {
         try {
             const ErrorUtils = global.ErrorUtils;
             if (ErrorUtils && this.originalHandler) {
-                ErrorUtils.setGlobalHandler(this.originalHandler);
+                // Only restore if WE are still the installed handler — another
+                // library may have wrapped us after start(), and restoring would
+                // clobber its handler.
+                if (ErrorUtils.getGlobalHandler() === this.wrapperHandler) {
+                    ErrorUtils.setGlobalHandler(this.originalHandler);
+                }
                 this.originalHandler = null;
+                this.wrapperHandler = null;
             }
         }
         catch (_e) {

package/dist/trackers/navigation.tracker.js

@@ -57,6 +57,17 @@ function useNavigationTracker() {
                 // AppAnalytics not initialized, silently ignore
             }
         }
+        else if (currentRouteName && !previousRouteName) {
+            // First route seen without onReady having fired (some apps only wire
+            // onStateChange). Without this, currentScreen stays null until the
+            // SECOND navigation and early touches/visits go unattributed.
+            try {
+                client_1.AppAnalytics.getInstance().onScreenEnter(currentRouteName);
+            }
+            catch {
+                // AppAnalytics not initialized, silently ignore
+            }
+        }
         routeNameRef.current = currentRouteName;
     }, []);
     return {

package/dist/transport/api.client.d.ts

@@ -11,10 +11,39 @@ export declare class ApiClient {
     private logger;
     constructor(baseUrl: string, apiKey: string, logger: Logger);
     private getHeaders;
+    /**
+     * fetch with a hard timeout. Without it, a single stalled request keeps
+     * the BatchQueue's in-flight lock held indefinitely — no flush can run,
+     * the buffer fills up and starts evicting events (silent data loss).
+     */
+    private fetchWithTimeout;
+    /**
+     * Classify a non-ok batch response. Permanent PAYLOAD errors (the batch
+     * itself will never be accepted: 400 malformed, 413 too large, 422
+     * unprocessable, 404 gone) surface as NonRetryableFlushError so the
+     * queue drops the poison batch instead of retrying it forever.
+     *
+     * 401/403 are NOT the payload's fault — they mean the API key is wrong
+     * or was rotated. Treat them as transient (retry with backoff) so a key
+     * rotation doesn't silently destroy every live SDK's buffered data.
+     * 408/429 are transient by definition.
+     */
+    private batchError;
+    /**
+     * Parse a 2xx response body, tolerating malformed JSON. The server
+     * already accepted the data — throwing here would make the queue retry
+     * an already-persisted batch and create duplicates.
+     */
+    private safeJson;
     startSession(deviceId: string, deviceInfo?: DeviceInfo): Promise<{
         id: string;
     }>;
     endSession(sessionId: string): Promise<void>;
+    /**
+     * Attach the host app's user identity to a session.
+     * Fire-and-forget: errors are logged but never thrown.
+     */
+    identifySession(sessionId: string, userId: string, traits?: Record<string, unknown>): Promise<void>;
     sendEventsBatch(sessionId: string, events: AnalyticsEvent[]): Promise<{
         count: number;
     }>;
@@ -22,7 +51,11 @@ export declare class ApiClient {
     sendSnapshotsBatch(snapshots: SnapshotPayload[]): Promise<{
         count: number;
     }>;
-    sendCrashReport(crash: CrashReport): Promise<void>;
+    /**
+     * Send a single crash report. Never throws; returns true when the
+     * server accepted it (used to clear the persisted pending copy).
+     */
+    sendCrashReport(crash: CrashReport): Promise<boolean>;
     sendCrashesBatch(crashes: CrashReport[]): Promise<{
         count: number;
     }>;