@repliqo/sdk-react-native 0.1.0

package/dist/snapshot/captureScreenshot.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureScreenshot = captureScreenshot;
+exports.__resetCaptureRefForTests = __resetCaptureRefForTests;
+const react_native_1 = require("react-native");
+const NativeScreenCapture_1 = require("./NativeScreenCapture");
+const TARGET_WIDTH = 390;
+const JPEG_QUALITY = 0.4;
+// --- view-shot fallback (lazy-loaded) ---
+let viewShotCaptureScreen = null;
+let viewShotResolved = false;
+function resolveViewShot() {
+    if (viewShotResolved)
+        return viewShotCaptureScreen;
+    viewShotResolved = true;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const viewShot = require('react-native-view-shot');
+        if (typeof viewShot.captureScreen === 'function') {
+            viewShotCaptureScreen = viewShot.captureScreen;
+        }
+        else if (typeof viewShot.captureRef === 'function') {
+            viewShotCaptureScreen = (opts) => viewShot.captureRef('window', opts);
+        }
+    }
+    catch {
+        // view-shot not installed - native capture only
+    }
+    return viewShotCaptureScreen;
+}
+/**
+ * Capture a JPEG screenshot using the best available method:
+ *
+ *  1. Native multi-window capture (Android) — uses View.draw() on all
+ *     app windows via WindowManagerGlobal reflection. Captures modals,
+ *     alerts, dialogs, overlays. No permissions needed.
+ *  2. react-native-view-shot fallback — captures the main RN view only
+ *     (no modals or native dialogs)
+ *  3. null — if both are unavailable
+ *
+ * Never throws. Returns null on any failure.
+ */
+async function captureScreenshot() {
+    // Strategy 1: Native multi-window capture (preferred on Android)
+    if ((0, NativeScreenCapture_1.isNativeScreenCaptureAvailable)()) {
+        const native = await (0, NativeScreenCapture_1.captureNativeFrame)();
+        if (native)
+            return { ...native, source: 'native' };
+        // If native returns null (e.g. first frame not ready), fall through
+        // to view-shot for this single frame rather than showing nothing.
+    }
+    // Strategy 2: react-native-view-shot fallback
+    const captureScreen = resolveViewShot();
+    if (!captureScreen)
+        return null;
+    try {
+        const { width: screenWidth, height: screenHeight } = react_native_1.Dimensions.get('window');
+        const aspectRatio = screenHeight / screenWidth;
+        const outputWidth = Math.min(TARGET_WIDTH, screenWidth);
+        const outputHeight = Math.round(outputWidth * aspectRatio);
+        const base64 = await captureScreen({
+            format: 'jpg',
+            quality: JPEG_QUALITY,
+            width: outputWidth,
+            height: outputHeight,
+            result: 'base64',
+        });
+        if (typeof base64 !== 'string' || base64.length === 0) {
+            return null;
+        }
+        return {
+            image: base64,
+            width: outputWidth,
+            height: outputHeight,
+            format: 'jpeg',
+            source: 'viewshot',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Test-only: reset cached view-shot resolution.
+ */
+function __resetCaptureRefForTests() {
+    viewShotCaptureScreen = null;
+    viewShotResolved = false;
+}

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

@@ -0,0 +1,22 @@
+import { CrashReport } from '../types/crash';
+type CrashCallback = (crash: CrashReport) => void;
+export declare class ErrorTracker {
+    private onCrash;
+    private sessionId;
+    private currentScreen;
+    private originalHandler;
+    private isActive;
+    constructor(onCrash: CrashCallback);
+    setSessionId(id: string | null): void;
+    setCurrentScreen(screen: string | null): void;
+    start(): void;
+    stop(): void;
+    /**
+     * Manual error reporting - allows consumers to report caught errors.
+     */
+    reportError(error: Error, metadata?: Record<string, any>): void;
+    private setupGlobalErrorHandler;
+    private setupUnhandledRejectionHandler;
+    private restoreGlobalErrorHandler;
+}
+export {};

package/dist/trackers/error.tracker.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorTracker = void 0;
+class ErrorTracker {
+    constructor(onCrash) {
+        this.sessionId = null;
+        this.currentScreen = null;
+        this.originalHandler = null;
+        this.isActive = false;
+        this.onCrash = onCrash;
+    }
+    setSessionId(id) {
+        this.sessionId = id;
+    }
+    setCurrentScreen(screen) {
+        this.currentScreen = screen;
+    }
+    start() {
+        if (this.isActive)
+            return;
+        this.isActive = true;
+        this.setupGlobalErrorHandler();
+        this.setupUnhandledRejectionHandler();
+    }
+    stop() {
+        if (!this.isActive)
+            return;
+        this.isActive = false;
+        this.restoreGlobalErrorHandler();
+    }
+    /**
+     * Manual error reporting - allows consumers to report caught errors.
+     */
+    reportError(error, metadata) {
+        try {
+            const crash = {
+                sessionId: this.sessionId || undefined,
+                type: 'js_error',
+                message: error.message,
+                stackTrace: error.stack || undefined,
+                screenName: this.currentScreen || undefined,
+                metadata,
+                timestamp: new Date().toISOString(),
+            };
+            this.onCrash(crash);
+        }
+        catch (_e) {
+            // Never crash the app due to error reporting
+        }
+    }
+    setupGlobalErrorHandler() {
+        try {
+            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
+                    }
+                    // Always call original handler so RN can handle the error
+                    if (this.originalHandler) {
+                        this.originalHandler(error, isFatal);
+                    }
+                });
+            }
+        }
+        catch (_e) {
+            // Never crash the app due to error handler setup
+        }
+    }
+    setupUnhandledRejectionHandler() {
+        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
+                    }
+                };
+            }
+        }
+        catch (_e) {
+            // Never crash the app due to rejection handler setup
+        }
+    }
+    restoreGlobalErrorHandler() {
+        try {
+            const ErrorUtils = global.ErrorUtils;
+            if (ErrorUtils && this.originalHandler) {
+                ErrorUtils.setGlobalHandler(this.originalHandler);
+                this.originalHandler = null;
+            }
+        }
+        catch (_e) {
+            // Never crash the app due to handler restoration
+        }
+    }
+}
+exports.ErrorTracker = ErrorTracker;

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

@@ -0,0 +1,6 @@
+export declare function useNavigationTracker(): {
+    navigationRef: import("react").MutableRefObject<any>;
+    onStateChange: () => void;
+    onReady: () => void;
+};
+export declare function trackScreenChange(fromScreen: string, toScreen: string): void;

package/dist/trackers/navigation.tracker.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useNavigationTracker = useNavigationTracker;
+exports.trackScreenChange = trackScreenChange;
+const react_1 = require("react");
+const client_1 = require("../core/client");
+function getActiveRouteName(state) {
+    if (!state) {
+        return null;
+    }
+    const route = state.routes[state.index];
+    if (!route) {
+        return null;
+    }
+    // Dive into nested navigators
+    if (route.state) {
+        return getActiveRouteName(route.state);
+    }
+    return route.name;
+}
+function useNavigationTracker() {
+    const routeNameRef = (0, react_1.useRef)(null);
+    const navigationRef = (0, react_1.useRef)(null);
+    const onReady = (0, react_1.useCallback)(() => {
+        if (navigationRef.current) {
+            const state = navigationRef.current.getRootState();
+            const currentRouteName = getActiveRouteName(state);
+            routeNameRef.current = currentRouteName;
+            if (currentRouteName) {
+                try {
+                    const analytics = client_1.AppAnalytics.getInstance();
+                    analytics.onScreenEnter(currentRouteName);
+                }
+                catch {
+                    // AppAnalytics not initialized, silently ignore
+                }
+            }
+        }
+    }, []);
+    const onStateChange = (0, react_1.useCallback)(() => {
+        if (!navigationRef.current) {
+            return;
+        }
+        const state = navigationRef.current.getRootState();
+        const currentRouteName = getActiveRouteName(state);
+        const previousRouteName = routeNameRef.current;
+        if (currentRouteName &&
+            previousRouteName &&
+            currentRouteName !== previousRouteName) {
+            try {
+                const analytics = client_1.AppAnalytics.getInstance();
+                analytics.trackNavigation(previousRouteName, currentRouteName);
+                analytics.onScreenExit(previousRouteName);
+                analytics.onScreenEnter(currentRouteName);
+            }
+            catch {
+                // AppAnalytics not initialized, silently ignore
+            }
+        }
+        routeNameRef.current = currentRouteName;
+    }, []);
+    return {
+        navigationRef,
+        onStateChange,
+        onReady,
+    };
+}
+function trackScreenChange(fromScreen, toScreen) {
+    try {
+        const analytics = client_1.AppAnalytics.getInstance();
+        analytics.trackNavigation(fromScreen, toScreen);
+        analytics.onScreenExit(fromScreen);
+        analytics.onScreenEnter(toScreen);
+    }
+    catch {
+        // AppAnalytics not initialized, silently ignore
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare function trackScreenEnter(screenName: string): void;
+export declare function trackScreenExit(screenName: string): void;

package/dist/trackers/screen.tracker.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackScreenEnter = trackScreenEnter;
+exports.trackScreenExit = trackScreenExit;
+const client_1 = require("../core/client");
+function trackScreenEnter(screenName) {
+    try {
+        const analytics = client_1.AppAnalytics.getInstance();
+        analytics.onScreenEnter(screenName);
+    }
+    catch {
+        // AppAnalytics not initialized, silently ignore
+    }
+}
+function trackScreenExit(screenName) {
+    try {
+        const analytics = client_1.AppAnalytics.getInstance();
+        analytics.onScreenExit(screenName);
+    }
+    catch {
+        // AppAnalytics not initialized, silently ignore
+    }
+}

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

@@ -0,0 +1,8 @@
+import React from 'react';
+interface TouchTrackerProps {
+    children: React.ReactNode;
+    screenName?: string;
+    enabled?: boolean;
+}
+export declare const TouchTracker: React.FC<TouchTrackerProps>;
+export {};

package/dist/trackers/touch.tracker.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TouchTracker = void 0;
+const react_1 = __importDefault(require("react"));
+const react_native_1 = require("react-native");
+const client_1 = require("../core/client");
+const TouchTracker = ({ children, screenName, enabled = true, }) => {
+    const handleTouchCapture = react_1.default.useCallback((event) => {
+        if (!enabled) {
+            return false;
+        }
+        try {
+            const analytics = client_1.AppAnalytics.getInstance();
+            const { pageX, pageY } = event.nativeEvent;
+            analytics.trackTouch(pageX, pageY, screenName);
+        }
+        catch {
+            // AppAnalytics not initialized, silently ignore
+        }
+        // Return false so touches pass through to children
+        return false;
+    }, [enabled, screenName]);
+    return (<react_native_1.View style={{ flex: 1 }} onStartShouldSetResponderCapture={handleTouchCapture}>
+      {children}
+    </react_native_1.View>);
+};
+exports.TouchTracker = TouchTracker;

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

@@ -0,0 +1,29 @@
+import { AnalyticsEvent, DeviceInfo, ScreenVisit } from '../types/events';
+import { SnapshotPayload } from '../types/snapshot';
+import { CrashReport } from '../types/crash';
+import { Logger } from '../core/logger';
+export interface SessionResponse {
+    sessionId: string;
+}
+export declare class ApiClient {
+    private baseUrl;
+    private apiKey;
+    private logger;
+    constructor(baseUrl: string, apiKey: string, logger: Logger);
+    private getHeaders;
+    startSession(deviceId: string, deviceInfo?: DeviceInfo): Promise<{
+        id: string;
+    }>;
+    endSession(sessionId: string): Promise<void>;
+    sendEventsBatch(sessionId: string, events: AnalyticsEvent[]): Promise<{
+        count: number;
+    }>;
+    sendScreenVisitsBatch(visits: ScreenVisit[]): Promise<void>;
+    sendSnapshotsBatch(snapshots: SnapshotPayload[]): Promise<{
+        count: number;
+    }>;
+    sendCrashReport(crash: CrashReport): Promise<void>;
+    sendCrashesBatch(crashes: CrashReport[]): Promise<{
+        count: number;
+    }>;
+}

package/dist/transport/api.client.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+class ApiClient {
+    constructor(baseUrl, apiKey, logger) {
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+        this.apiKey = apiKey;
+        this.logger = logger;
+    }
+    getHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            'x-api-key': this.apiKey,
+        };
+    }
+    async startSession(deviceId, deviceInfo) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/sessions/start`, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify({ deviceId, deviceInfo }),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                this.logger.error('Failed to start session:', response.status, text);
+                throw new Error(`Failed to start session: ${response.status}`);
+            }
+            const data = await response.json();
+            this.logger.log('Session started:', data.sessionId);
+            return { id: data.sessionId };
+        }
+        catch (error) {
+            this.logger.error('Error starting session:', error);
+            throw error;
+        }
+    }
+    async endSession(sessionId) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/sessions/${sessionId}/end`, {
+                method: 'PATCH',
+                headers: this.getHeaders(),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                this.logger.error('Failed to end session:', response.status, text);
+                return;
+            }
+            this.logger.log('Session ended:', sessionId);
+        }
+        catch (error) {
+            this.logger.error('Error ending session:', error);
+        }
+    }
+    async sendEventsBatch(sessionId, events) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/events/batch`, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify({ sessionId, events }),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                this.logger.error('Failed to send events batch:', response.status, text);
+                throw new Error(`Failed to send events batch: ${response.status}`);
+            }
+            const data = await response.json();
+            this.logger.log('Events batch sent, count:', data.count);
+            return { count: data.count };
+        }
+        catch (error) {
+            this.logger.error('Error sending events batch:', error);
+            throw error;
+        }
+    }
+    async sendScreenVisitsBatch(visits) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/screens/visit/batch`, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify({ visits }),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                this.logger.error('Failed to send screen visits batch:', response.status, text);
+                throw new Error(`Failed to send screen visits batch: ${response.status}`);
+            }
+            this.logger.log('Screen visits batch sent, count:', visits.length);
+        }
+        catch (error) {
+            this.logger.error('Error sending screen visits batch:', error);
+            throw error;
+        }
+    }
+    async sendSnapshotsBatch(snapshots) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/snapshots/batch`, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify({ snapshots }),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                this.logger.error('Failed to send snapshots batch:', response.status, text);
+                throw new Error(`Failed to send snapshots batch: ${response.status}`);
+            }
+            const data = await response.json();
+            this.logger.log('Snapshots batch sent, count:', data.count);
+            return { count: data.count };
+        }
+        catch (error) {
+            this.logger.error('Error sending snapshots batch:', error);
+            throw error;
+        }
+    }
+    async sendCrashReport(crash) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/crashes`, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify(crash),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                this.logger.error('Failed to send crash report:', response.status, text);
+                return;
+            }
+            this.logger.log('Crash report sent:', crash.type, crash.message);
+        }
+        catch (error) {
+            // Fire-and-forget: catch errors silently, never throw
+            this.logger.error('Error sending crash report:', error);
+        }
+    }
+    async sendCrashesBatch(crashes) {
+        try {
+            const response = await fetch(`${this.baseUrl}/api/crashes/batch`, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify({ crashes }),
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                this.logger.error('Failed to send crashes batch:', response.status, text);
+                throw new Error(`Failed to send crashes batch: ${response.status}`);
+            }
+            const data = await response.json();
+            this.logger.log('Crashes batch sent, count:', data.count);
+            return { count: data.count };
+        }
+        catch (error) {
+            this.logger.error('Error sending crashes batch:', error);
+            throw error;
+        }
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/transport/batch-queue.d.ts

@@ -0,0 +1,18 @@
+export declare class BatchQueue<T> {
+    private buffer;
+    private maxSize;
+    private maxBufferSize;
+    private flushIntervalMs;
+    private onFlush;
+    private intervalId;
+    private flushing;
+    private consecutiveFailures;
+    private ticksToSkip;
+    private static readonly MAX_BACKOFF_TICKS;
+    constructor(maxSize: number | undefined, flushIntervalMs: number | undefined, onFlush: (items: T[]) => Promise<void>, maxBufferSize?: number);
+    add(item: T): void;
+    flush(): Promise<void>;
+    startAutoFlush(): void;
+    stopAutoFlush(): void;
+    get pending(): number;
+}

package/dist/transport/batch-queue.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchQueue = void 0;
+class BatchQueue {
+    constructor(maxSize = 20, flushIntervalMs = 30000, onFlush, maxBufferSize = 1000) {
+        this.buffer = [];
+        this.intervalId = null;
+        this.flushing = false;
+        // Exponential backoff state: on each failure we double the skip count,
+        // capped at 8 ticks. A successful flush resets it to 0.
+        this.consecutiveFailures = 0;
+        this.ticksToSkip = 0;
+        this.maxSize = maxSize;
+        this.flushIntervalMs = flushIntervalMs;
+        this.onFlush = onFlush;
+        this.maxBufferSize = maxBufferSize;
+    }
+    add(item) {
+        // Evict oldest items if buffer is at max capacity
+        if (this.buffer.length >= this.maxBufferSize) {
+            this.buffer.splice(0, this.buffer.length - this.maxBufferSize + 1);
+        }
+        this.buffer.push(item);
+        if (this.buffer.length >= this.maxSize) {
+            this.flush();
+        }
+    }
+    async flush() {
+        if (this.buffer.length === 0 || this.flushing) {
+            return;
+        }
+        this.flushing = true;
+        const items = [...this.buffer];
+        try {
+            await this.onFlush(items);
+            // Only clear the items that were successfully flushed.
+            // New items might have been added during the async flush,
+            // so we splice out only the count we sent.
+            this.buffer.splice(0, items.length);
+            // Successful flush resets the backoff state.
+            this.consecutiveFailures = 0;
+            this.ticksToSkip = 0;
+        }
+        catch {
+            // On failure, keep events in buffer so they can be retried.
+            // Apply exponential backoff: 1, 2, 4, 8 ticks skipped before
+            // the next auto-flush attempt.
+            this.consecutiveFailures++;
+            this.ticksToSkip = Math.min(Math.pow(2, this.consecutiveFailures - 1), BatchQueue.MAX_BACKOFF_TICKS);
+        }
+        finally {
+            this.flushing = false;
+        }
+    }
+    startAutoFlush() {
+        if (this.intervalId !== null) {
+            return;
+        }
+        this.intervalId = setInterval(() => {
+            // Honor backoff: skip this tick if we're still in a cooldown from
+            // a previous failure.
+            if (this.ticksToSkip > 0) {
+                this.ticksToSkip--;
+                return;
+            }
+            this.flush();
+        }, this.flushIntervalMs);
+    }
+    stopAutoFlush() {
+        if (this.intervalId !== null) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    get pending() {
+        return this.buffer.length;
+    }
+}
+exports.BatchQueue = BatchQueue;
+BatchQueue.MAX_BACKOFF_TICKS = 8;

package/dist/types/crash.d.ts

@@ -0,0 +1,10 @@
+export interface CrashReport {
+    sessionId?: string;
+    type: 'js_error' | 'native_crash' | 'unhandled_rejection';
+    message: string;
+    stackTrace?: string;
+    screenName?: string;
+    deviceInfo?: Record<string, any>;
+    metadata?: Record<string, any>;
+    timestamp: string;
+}