@probie-dev/react-native 0.1.0

package/dist/config.js

@@ -0,0 +1,64 @@
+function memoryStorage() {
+    const map = new Map();
+    return {
+        getItem: async (k) => (map.has(k) ? map.get(k) : null),
+        setItem: async (k, v) => {
+            map.set(k, v);
+        },
+        removeItem: async (k) => {
+            map.delete(k);
+        },
+    };
+}
+function resolveStorage(injected) {
+    if (injected)
+        return injected;
+    try {
+        const mod = require('@react-native-async-storage/async-storage');
+        const store = mod.default ?? mod;
+        if (store && typeof store.getItem === 'function')
+            return store;
+    }
+    catch {
+    }
+    return memoryStorage();
+}
+function resolveFetch(injected) {
+    if (injected)
+        return injected;
+    const g = globalThis;
+    if (typeof g.fetch === 'function')
+        return (url, init) => g.fetch(url, init);
+    return async () => undefined;
+}
+function clampRate(raw) {
+    const n = raw == null ? 1 : raw;
+    if (typeof n !== 'number' || Number.isNaN(n))
+        return 1;
+    return Math.min(1, Math.max(0, n));
+}
+export function normalizeConfig(config) {
+    if (!config || typeof config.token !== 'string' || config.token.length === 0) {
+        throw new Error('probie: config.token is required');
+    }
+    if (typeof config.apiBase !== 'string' || config.apiBase.length === 0) {
+        throw new Error('probie: config.apiBase is required');
+    }
+    const apiBase = config.apiBase.replace(/\/+$/, '');
+    return {
+        token: config.token,
+        apiBase,
+        endpoint: apiBase + '/api/widget/events',
+        ownPrefix: apiBase + '/api/widget',
+        sampleRate: clampRate(config.sampleRate),
+        captureQuery: config.captureQuery === true,
+        captureErrors: config.captureErrors !== false,
+        captureNetwork: config.captureNetwork !== false,
+        captureUnhandledRejections: config.captureUnhandledRejections !== false,
+        idleTimeoutMs: config.idleTimeoutMs ?? null,
+        flushIntervalMs: config.flushIntervalMs && config.flushIntervalMs > 0 ? config.flushIntervalMs : 12000,
+        appVersion: config.appVersion,
+        storage: resolveStorage(config.storage),
+        fetchImpl: resolveFetch(config.fetchImpl),
+    };
+}

package/dist/deviceContext.d.ts

@@ -0,0 +1,2 @@
+import type { DeviceContext } from './types.js';
+export declare function buildDeviceContext(appVersionOverride?: string): DeviceContext;

package/dist/deviceContext.js

@@ -0,0 +1,43 @@
+import { SDK_NAME, SDK_VERSION } from './version.js';
+export function buildDeviceContext(appVersionOverride) {
+    const ctx = {
+        platform: null,
+        os_version: null,
+        app_version: appVersionOverride ?? null,
+        build: null,
+        device_model: null,
+        sdk_name: SDK_NAME,
+        sdk_version: SDK_VERSION,
+        anon_id: null,
+    };
+    try {
+        const { Platform } = require('react-native');
+        ctx.platform = Platform?.OS ?? null;
+        ctx.os_version = Platform?.Version != null ? String(Platform.Version) : null;
+    }
+    catch {
+    }
+    try {
+        const App = require('expo-application');
+        if (ctx.app_version == null)
+            ctx.app_version = App.nativeApplicationVersion ?? null;
+        ctx.build = App.nativeBuildVersion ?? null;
+    }
+    catch {
+    }
+    try {
+        const Device = require('expo-device');
+        ctx.device_model = Device.modelName ?? null;
+    }
+    catch {
+    }
+    if (ctx.app_version == null) {
+        try {
+            const Constants = require('expo-constants').default ?? require('expo-constants');
+            ctx.app_version = Constants?.expoConfig?.version ?? null;
+        }
+        catch {
+        }
+    }
+    return ctx;
+}

package/dist/element.d.ts

@@ -0,0 +1,3 @@
+import type { ElementInfo, ElementSource } from './types.js';
+export declare function elementInfoFrom(source: ElementSource | ElementInfo | null | undefined): ElementInfo | null;
+export declare function elementKey(source: ElementSource | ElementInfo | null | undefined): string;

package/dist/element.js

@@ -0,0 +1,26 @@
+import { hashString } from './hash.js';
+function isElementInfo(x) {
+    return typeof x.path === 'string' && 'text_hash' in x;
+}
+export function elementInfoFrom(source) {
+    if (!source)
+        return null;
+    if (isElementInfo(source))
+        return source;
+    const role = source.accessibilityRole ?? null;
+    const testid = source.testID ?? null;
+    const label = String(source.accessibilityLabel ?? source.text ?? '').trim().slice(0, 80);
+    const describe = `${role ?? 'view'}${testid ? '#' + testid : ''}`;
+    return {
+        path: source.path ?? describe,
+        role,
+        name: source.name ?? null,
+        type: source.type ?? null,
+        testid,
+        text_hash: label ? hashString(label) : null,
+    };
+}
+export function elementKey(source) {
+    const info = elementInfoFrom(source);
+    return info ? info.path : 'view';
+}

package/dist/hash.d.ts

@@ -0,0 +1 @@
+export declare function hashString(s: string): string;

package/dist/hash.js

@@ -0,0 +1,6 @@
+export function hashString(s) {
+    let h = 5381;
+    for (let i = 0; i < s.length; i++)
+        h = ((h << 5) + h + s.charCodeAt(i)) | 0;
+    return (h >>> 0).toString(36);
+}

package/dist/identity.d.ts

@@ -0,0 +1,6 @@
+import type { AsyncStorageLike } from './types.js';
+export interface Identity {
+    getAnonId(): string | null;
+    readonly ready: Promise<void>;
+}
+export declare function createIdentity(storage: AsyncStorageLike): Identity;

package/dist/identity.js

@@ -0,0 +1,18 @@
+import { genId } from './ids.js';
+const DID_KEY = 'probie_did';
+export function createIdentity(storage) {
+    let anonId = null;
+    const ready = (async () => {
+        try {
+            let did = await storage.getItem(DID_KEY);
+            if (!did) {
+                did = genId();
+                await storage.setItem(DID_KEY, did);
+            }
+            anonId = did;
+        }
+        catch {
+        }
+    })();
+    return { getAnonId: () => anonId, ready };
+}

package/dist/ids.d.ts

@@ -0,0 +1 @@
+export declare function genId(): string;

package/dist/ids.js

@@ -0,0 +1,13 @@
+export function genId() {
+    try {
+        const crypto = require('expo-crypto');
+        if (crypto && typeof crypto.randomUUID === 'function') {
+            const id = crypto.randomUUID();
+            if (id)
+                return String(id);
+        }
+    }
+    catch {
+    }
+    return 'pb-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2);
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export type { ProbieClient, ProbieConfig, ProbieEvent, EventType, ElementInfo, ElementSource, DeviceContext } from './types.js';
+export { init, getClient, identify, reset, trackScreen, track, flush, __teardown } from './singleton.js';
+export { ProbieProvider } from './react/ProbieProvider.js';
+export { ProbiePressable } from './react/ProbiePressable.js';
+export { useProbieForm } from './react/useProbieForm.js';
+export { useProbieClient } from './react/hooks.js';
+export { useProbieExpoRouter } from './nav/expoRouter.js';
+export { probieNavigationContainerProps } from './nav/reactNavigation.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { init, getClient, identify, reset, trackScreen, track, flush, __teardown } from './singleton.js';
+export { ProbieProvider } from './react/ProbieProvider.js';
+export { ProbiePressable } from './react/ProbiePressable.js';
+export { useProbieForm } from './react/useProbieForm.js';
+export { useProbieClient } from './react/hooks.js';
+export { useProbieExpoRouter } from './nav/expoRouter.js';
+export { probieNavigationContainerProps } from './nav/reactNavigation.js';

package/dist/interceptors/errors.d.ts

@@ -0,0 +1,3 @@
+type Emit = (type: 'js_error', payload: Record<string, unknown>) => void;
+export declare function installErrors(emit: Emit, captureUnhandledRejections: boolean): () => void;
+export {};

package/dist/interceptors/errors.js

@@ -0,0 +1,59 @@
+function messageOf(err) {
+    if (err && typeof err === 'object' && 'message' in err && err.message) {
+        return String(err.message).slice(0, 500);
+    }
+    return String(err).slice(0, 500);
+}
+function stackOf(err) {
+    if (err && typeof err === 'object' && 'stack' in err && err.stack) {
+        return String(err.stack).slice(0, 2000);
+    }
+    return '';
+}
+export function installErrors(emit, captureUnhandledRejections) {
+    const cleanups = [];
+    const EU = globalThis.ErrorUtils;
+    if (EU && typeof EU.getGlobalHandler === 'function' && typeof EU.setGlobalHandler === 'function') {
+        const prev = EU.getGlobalHandler();
+        EU.setGlobalHandler((error, isFatal) => {
+            try {
+                emit('js_error', { message: messageOf(error), stack: stackOf(error), fatal: !!isFatal });
+            }
+            catch {
+            }
+            if (typeof prev === 'function')
+                prev(error, isFatal);
+        });
+        cleanups.push(() => {
+            try {
+                EU.setGlobalHandler(prev);
+            }
+            catch {
+            }
+        });
+    }
+    if (captureUnhandledRejections) {
+        try {
+            const tracking = require('promise/setimmediate/rejection-tracking');
+            if (tracking && typeof tracking.enable === 'function') {
+                tracking.enable({
+                    allRejections: true,
+                    onUnhandled: (_id, error) => {
+                        try {
+                            emit('js_error', { message: messageOf(error), stack: stackOf(error), unhandled_rejection: true });
+                        }
+                        catch {
+                        }
+                    },
+                    onHandled: () => { },
+                });
+            }
+        }
+        catch {
+        }
+    }
+    return () => {
+        for (const fn of cleanups)
+            fn();
+    };
+}

package/dist/interceptors/network.d.ts

@@ -0,0 +1,3 @@
+type Emit = (type: 'fetch_error', payload: Record<string, unknown>) => void;
+export declare function installNetwork(emit: Emit, isOwnEndpoint: (url: string) => boolean, sanitizeUrl: (url: string) => string): () => void;
+export {};

package/dist/interceptors/network.js

@@ -0,0 +1,47 @@
+export function installNetwork(emit, isOwnEndpoint, sanitizeUrl) {
+    const XHR = globalThis.XMLHttpRequest && globalThis.XMLHttpRequest.prototype;
+    if (!XHR || typeof XHR.open !== 'function' || typeof XHR.send !== 'function') {
+        return () => { };
+    }
+    const origOpen = XHR.open;
+    const origSend = XHR.send;
+    XHR.open = function (method, url) {
+        try {
+            this.__pb = { method, url, start: 0 };
+        }
+        catch {
+        }
+        return origOpen.apply(this, arguments);
+    };
+    XHR.send = function () {
+        try {
+            const meta = this.__pb;
+            if (meta && !isOwnEndpoint(String(meta.url ?? ''))) {
+                meta.start = Date.now();
+                const xhr = this;
+                this.addEventListener('loadend', function () {
+                    try {
+                        const status = xhr.status;
+                        if (status === 0 || status >= 400) {
+                            emit('fetch_error', {
+                                method: String(meta.method ?? 'GET').toUpperCase(),
+                                url: sanitizeUrl(String(meta.url ?? '')),
+                                status,
+                                duration_ms: Date.now() - meta.start,
+                            });
+                        }
+                    }
+                    catch {
+                    }
+                });
+            }
+        }
+        catch {
+        }
+        return origSend.apply(this, arguments);
+    };
+    return () => {
+        XHR.open = origOpen;
+        XHR.send = origSend;
+    };
+}

package/dist/nav/expoRouter.d.ts

@@ -0,0 +1 @@
+export declare function useProbieExpoRouter(): void;

package/dist/nav/expoRouter.js

@@ -0,0 +1,17 @@
+import { useEffect } from 'react';
+import { trackScreen } from '../singleton.js';
+let useSegments = null;
+try {
+    useSegments = require('expo-router').useSegments;
+}
+catch {
+    useSegments = null;
+}
+export function useProbieExpoRouter() {
+    const segments = useSegments ? useSegments() : [];
+    const route = Array.isArray(segments) ? segments.join('/') : '';
+    useEffect(() => {
+        if (useSegments)
+            trackScreen(route);
+    }, [route]);
+}

package/dist/nav/reactNavigation.d.ts

@@ -0,0 +1,6 @@
+export interface NavigationContainerBinding {
+    ref?: unknown;
+    onReady?: () => void;
+    onStateChange?: () => void;
+}
+export declare function probieNavigationContainerProps(): NavigationContainerBinding;

package/dist/nav/reactNavigation.js

@@ -0,0 +1,25 @@
+import { trackScreen } from '../singleton.js';
+let navRef = null;
+try {
+    navRef = require('@react-navigation/native').createNavigationContainerRef();
+}
+catch {
+    navRef = null;
+}
+export function probieNavigationContainerProps() {
+    if (!navRef)
+        return {};
+    let prev;
+    const report = () => {
+        try {
+            const route = navRef.getCurrentRoute?.();
+            if (route && route.name && route.name !== prev) {
+                prev = route.name;
+                trackScreen(route.name, route.params);
+            }
+        }
+        catch {
+        }
+    };
+    return { ref: navRef, onReady: report, onStateChange: report };
+}

package/dist/react/ProbiePressable.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { type PressableProps } from 'react-native';
+export interface ProbiePressableProps extends PressableProps {
+    probiePath?: string;
+}
+export declare function ProbiePressable({ probiePath, onPress, ...rest }: ProbiePressableProps): React.ReactElement;

package/dist/react/ProbiePressable.js

@@ -0,0 +1,21 @@
+import React from 'react';
+import { Pressable } from 'react-native';
+import { getClient } from '../singleton.js';
+export function ProbiePressable({ probiePath, onPress, ...rest }) {
+    const handlePress = (e) => {
+        try {
+            const source = {
+                path: probiePath,
+                testID: typeof rest.testID === 'string' ? rest.testID : null,
+                accessibilityRole: rest.accessibilityRole ?? null,
+                accessibilityLabel: typeof rest.accessibilityLabel === 'string' ? rest.accessibilityLabel : null,
+            };
+            getClient()?.recordTap(source);
+        }
+        catch {
+        }
+        if (typeof onPress === 'function')
+            onPress(e);
+    };
+    return React.createElement(Pressable, { ...rest, onPress: handlePress });
+}

package/dist/react/ProbieProvider.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { ProbieConfig } from '../types.js';
+export interface ProbieProviderProps {
+    config: ProbieConfig;
+    children?: React.ReactNode;
+}
+export declare function ProbieProvider({ config, children }: ProbieProviderProps): React.ReactElement;

package/dist/react/ProbieProvider.js

@@ -0,0 +1,11 @@
+import React, { useEffect } from 'react';
+import { init, __teardown } from '../singleton.js';
+export function ProbieProvider({ config, children }) {
+    useEffect(() => {
+        init(config);
+        return () => {
+            __teardown();
+        };
+    }, [config.token, config.apiBase]);
+    return React.createElement(React.Fragment, null, children);
+}

package/dist/react/hooks.d.ts

@@ -0,0 +1,2 @@
+import type { ProbieClientImpl } from '../client.js';
+export declare function useProbieClient(): ProbieClientImpl | null;

package/dist/react/hooks.js

@@ -0,0 +1,4 @@
+import { getClient } from '../singleton.js';
+export function useProbieClient() {
+    return getClient();
+}

package/dist/react/useProbieForm.d.ts

@@ -0,0 +1,6 @@
+export interface ProbieFormHandlers {
+    onFocus(): void;
+    onSubmit(): void;
+    formKey: string;
+}
+export declare function useProbieForm(key: string): ProbieFormHandlers;

package/dist/react/useProbieForm.js

@@ -0,0 +1,12 @@
+import { useMemo } from 'react';
+import { getClient } from '../singleton.js';
+export function useProbieForm(key) {
+    return useMemo(() => {
+        const source = { path: key };
+        return {
+            formKey: key,
+            onFocus: () => getClient()?.touchForm(key, source),
+            onSubmit: () => getClient()?.submitForm(key, source),
+        };
+    }, [key]);
+}

package/dist/session.d.ts

@@ -0,0 +1,7 @@
+import type { AsyncStorageLike } from './types.js';
+export interface Session {
+    getId(): string;
+    readonly ready: Promise<void>;
+    rotate(): void;
+}
+export declare function createSession(storage: AsyncStorageLike, idleTimeoutMs: number | null): Session;

package/dist/session.js

@@ -0,0 +1,36 @@
+import { genId } from './ids.js';
+const SID_KEY = 'probie_sid';
+const SID_TS_KEY = 'probie_sid_ts';
+export function createSession(storage, idleTimeoutMs) {
+    let id = genId();
+    const ready = (async () => {
+        try {
+            const now = Date.now();
+            if (idleTimeoutMs != null) {
+                const stored = await storage.getItem(SID_KEY);
+                const tsRaw = await storage.getItem(SID_TS_KEY);
+                const last = tsRaw ? Number(tsRaw) : 0;
+                if (stored && Number.isFinite(last) && last > 0 && now - last < idleTimeoutMs) {
+                    id = stored;
+                }
+            }
+            await storage.setItem(SID_KEY, id);
+            await storage.setItem(SID_TS_KEY, String(now));
+        }
+        catch {
+        }
+    })();
+    return {
+        getId: () => id,
+        ready,
+        rotate: () => {
+            id = genId();
+            try {
+                void storage.setItem(SID_KEY, id);
+                void storage.setItem(SID_TS_KEY, String(Date.now()));
+            }
+            catch {
+            }
+        },
+    };
+}

package/dist/singleton.d.ts

@@ -0,0 +1,10 @@
+import { ProbieClientImpl } from './client.js';
+import type { ElementInfo, ElementSource, EventType, ProbieClient, ProbieConfig } from './types.js';
+export declare function init(config: ProbieConfig): ProbieClient;
+export declare function getClient(): ProbieClientImpl | null;
+export declare function identify(userId: string | null): void;
+export declare function reset(): void;
+export declare function trackScreen(name: string, params?: Record<string, unknown>): void;
+export declare function track(type: EventType, payload?: Record<string, unknown>, element?: ElementSource | ElementInfo | null): void;
+export declare function flush(): Promise<void>;
+export declare function __teardown(): void;

package/dist/singleton.js

@@ -0,0 +1,30 @@
+import { ProbieClientImpl } from './client.js';
+let singleton = null;
+export function init(config) {
+    if (singleton)
+        return singleton;
+    singleton = new ProbieClientImpl(config);
+    return singleton;
+}
+export function getClient() {
+    return singleton;
+}
+export function identify(userId) {
+    singleton?.identify(userId);
+}
+export function reset() {
+    singleton?.reset();
+}
+export function trackScreen(name, params) {
+    singleton?.trackScreen(name, params);
+}
+export function track(type, payload, element) {
+    singleton?.track(type, payload, element);
+}
+export function flush() {
+    return singleton ? singleton.flush() : Promise.resolve();
+}
+export function __teardown() {
+    singleton?.dispose();
+    singleton = null;
+}

package/dist/transport.d.ts

@@ -0,0 +1,9 @@
+import type { ProbieEvent } from './types.js';
+export declare const MAX_BATCH = 100;
+export declare const MAX_BODY_BYTES = 262144;
+export declare const MAX_EVENT_BYTES = 8192;
+export declare function utf8Len(s: string): number;
+export declare function buildBatches(events: ProbieEvent[], tokenBytes: number): ProbieEvent[][];
+type FetchImpl = (url: string, init: unknown) => Promise<unknown>;
+export declare function sendEvents(endpoint: string, token: string, events: ProbieEvent[], fetchImpl: FetchImpl): Promise<void>;
+export {};

package/dist/transport.js

@@ -0,0 +1,67 @@
+export const MAX_BATCH = 100;
+export const MAX_BODY_BYTES = 262144;
+export const MAX_EVENT_BYTES = 8192;
+const ENVELOPE_OVERHEAD = 40;
+export function utf8Len(s) {
+    let n = 0;
+    for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c < 0x80)
+            n += 1;
+        else if (c < 0x800)
+            n += 2;
+        else if (c >= 0xd800 && c <= 0xdbff) {
+            n += 4;
+            i++;
+        }
+        else
+            n += 3;
+    }
+    return n;
+}
+export function buildBatches(events, tokenBytes) {
+    const sized = [];
+    for (const event of events) {
+        const bytes = utf8Len(JSON.stringify(event));
+        if (bytes > MAX_EVENT_BYTES)
+            continue;
+        sized.push({ event, bytes });
+    }
+    const batches = [];
+    let cur = [];
+    let curBytes = ENVELOPE_OVERHEAD + tokenBytes;
+    for (const { event, bytes } of sized) {
+        const withComma = bytes + 1;
+        const overflow = curBytes + withComma > MAX_BODY_BYTES;
+        if (cur.length > 0 && (cur.length >= MAX_BATCH || overflow)) {
+            batches.push(cur);
+            cur = [];
+            curBytes = ENVELOPE_OVERHEAD + tokenBytes;
+        }
+        cur.push(event);
+        curBytes += withComma;
+    }
+    if (cur.length > 0)
+        batches.push(cur);
+    return batches;
+}
+async function postBatch(endpoint, token, batch, fetchImpl) {
+    try {
+        const body = JSON.stringify({ token, events: batch });
+        await fetchImpl(endpoint, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'X-Widget-Token': token },
+            body,
+        });
+    }
+    catch {
+    }
+}
+export async function sendEvents(endpoint, token, events, fetchImpl) {
+    if (events.length === 0)
+        return;
+    const batches = buildBatches(events, utf8Len(token));
+    for (const batch of batches) {
+        await postBatch(endpoint, token, batch, fetchImpl);
+    }
+}