@octovise/react-native-sdk 1.0.0

package/dist/latency.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildLatencyBreakdown = buildLatencyBreakdown;
+function buildLatencyBreakdown(t, m) {
+    return {
+        total_ms: m.impression - t.t0,
+        network_ms: t.tCheck - t.t0,
+        image_ms: m.hasImage ? Math.max(0, m.shown - m.showStart) : 0,
+        render_ms: Math.max(0, m.impression - m.shown),
+    };
+}

package/dist/native.d.ts

@@ -0,0 +1 @@
+export declare function configureNative(apiKey: string, userId: string, baseUrl: string): void;

package/dist/native.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureNative = configureNative;
+const react_native_1 = require("react-native");
+function configureNative(apiKey, userId, baseUrl) {
+    const mod = react_native_1.NativeModules['OctoPushModule'];
+    if (!mod || typeof mod.configure !== 'function')
+        return;
+    try {
+        mod.configure(apiKey, userId, baseUrl);
+    }
+    catch {
+    }
+}

package/dist/navigation/reactNavigation.d.ts

@@ -0,0 +1,12 @@
+import type { NavAdapter } from '../types';
+interface NavigationRefLike {
+    isReady?: () => boolean;
+    navigate: (name: string, params?: object) => void;
+    getCurrentRoute?: () => {
+        name?: string;
+        params?: Record<string, unknown>;
+    } | undefined;
+    addListener?: (type: string, callback: () => void) => () => void;
+}
+export declare function makeReactNavigationAdapter(navigationRef: NavigationRefLike): NavAdapter;
+export {};

package/dist/navigation/reactNavigation.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeReactNavigationAdapter = makeReactNavigationAdapter;
+function makeReactNavigationAdapter(navigationRef) {
+    return {
+        navigate(routeName, params) {
+            if (typeof navigationRef.isReady === 'function' && !navigationRef.isReady())
+                return;
+            navigationRef.navigate(routeName, params);
+        },
+        getCurrentScreen() {
+            return navigationRef.getCurrentRoute?.()?.name ?? null;
+        },
+        subscribeScreenChange(cb) {
+            if (typeof navigationRef.addListener !== 'function')
+                return () => { };
+            return navigationRef.addListener('state', () => {
+                const route = navigationRef.getCurrentRoute?.();
+                if (route?.name)
+                    cb(route.name, route.params);
+            });
+        },
+    };
+}

package/dist/navigation/resolveCTA.d.ts

@@ -0,0 +1,12 @@
+import type { NavAdapter } from '../types';
+export interface ParsedOctoviseUrl {
+    routeName: string;
+    params: Record<string, string>;
+}
+export declare function parseOctoviseUrl(url: string): ParsedOctoviseUrl | null;
+export interface CTAConfig {
+    nav?: NavAdapter;
+    onCTA?: (url: string) => void;
+    resolveRoute?: (routeToken: string) => string | null;
+}
+export declare function handleCTA(rawUrl: string | undefined | null, cfg: CTAConfig): void;

package/dist/navigation/resolveCTA.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOctoviseUrl = parseOctoviseUrl;
+exports.handleCTA = handleCTA;
+const safeNavUrl_1 = require("../safeNavUrl");
+const SCHEME = 'octovise://';
+function safeDecode(s) {
+    try {
+        return decodeURIComponent(s);
+    }
+    catch {
+        return s;
+    }
+}
+function parseOctoviseUrl(url) {
+    if (!url || !url.toLowerCase().startsWith(SCHEME))
+        return null;
+    let rest = url.slice(SCHEME.length);
+    let query = '';
+    const q = rest.indexOf('?');
+    if (q >= 0) {
+        query = rest.slice(q + 1);
+        rest = rest.slice(0, q);
+    }
+    let path = rest;
+    if (path.toLowerCase().startsWith('route/'))
+        path = path.slice('route/'.length);
+    const seg = path.split('/')[0];
+    if (!seg)
+        return null;
+    const params = {};
+    if (query) {
+        for (const pair of query.split('&')) {
+            if (!pair)
+                continue;
+            const eq = pair.indexOf('=');
+            const k = safeDecode(eq >= 0 ? pair.slice(0, eq) : pair);
+            const v = eq >= 0 ? safeDecode(pair.slice(eq + 1)) : '';
+            if (k)
+                params[k] = v;
+        }
+    }
+    return { routeName: safeDecode(seg), params };
+}
+function handleCTA(rawUrl, cfg) {
+    const safe = (0, safeNavUrl_1.safeNavUrl)(rawUrl);
+    if (!safe)
+        return;
+    const parsed = parseOctoviseUrl(safe);
+    if (parsed && cfg.nav) {
+        const screen = cfg.resolveRoute ? cfg.resolveRoute(parsed.routeName) : null;
+        if (screen) {
+            cfg.nav.navigate(screen, parsed.params);
+            return;
+        }
+        if (!/^\d+$/.test(parsed.routeName)) {
+            cfg.nav.navigate(parsed.routeName, parsed.params);
+            return;
+        }
+    }
+    if (cfg.onCTA) {
+        cfg.onCTA(safe);
+        return;
+    }
+    openExternal(safe);
+}
+function openExternal(url) {
+    try {
+        const { Linking } = require('react-native');
+        Linking.openURL(url).catch(() => { });
+    }
+    catch {
+    }
+}

package/dist/push.d.ts

@@ -0,0 +1,3 @@
+export declare function setupPush(): Promise<void>;
+export declare function startPushListeners(onCTA?: (url: string) => void): void;
+export declare function stopPushListeners(): void;

package/dist/push.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupPush = setupPush;
+exports.startPushListeners = startPushListeners;
+exports.stopPushListeners = stopPushListeners;
+const react_native_1 = require("react-native");
+const api = __importStar(require("./api"));
+const types_1 = require("./types");
+let messaging = null;
+let unsubscribeOnMessage = null;
+let unsubscribeOnOpen = null;
+function getMessaging() {
+    if (!messaging) {
+        try {
+            messaging = require('@react-native-firebase/messaging').default;
+        }
+        catch {
+            console.warn('[OctoSDK] @react-native-firebase/messaging not installed. ' +
+                'Push features require: npm install @react-native-firebase/messaging');
+            return null;
+        }
+    }
+    return messaging;
+}
+function isOctovise(data) {
+    return data?.source === 'octovise';
+}
+async function setupPush() {
+    const msg = getMessaging();
+    if (!msg)
+        return;
+    try {
+        const authStatus = await msg().requestPermission();
+        if (authStatus !== msg.AuthorizationStatus.AUTHORIZED &&
+            authStatus !== msg.AuthorizationStatus.PROVISIONAL) {
+            return;
+        }
+        const token = await msg().getToken();
+        if (token) {
+            await api.registerDevice(token);
+        }
+        msg().onTokenRefresh(async (newToken) => {
+            await api.registerDevice(newToken);
+        });
+    }
+    catch (err) {
+        console.warn('[OctoSDK] Push setup failed:', err);
+    }
+}
+function startPushListeners(onCTA) {
+    const msg = getMessaging();
+    if (!msg)
+        return;
+    unsubscribeOnMessage = msg().onMessage(async (remoteMessage) => {
+        if (!isOctovise(remoteMessage.data))
+            return;
+        const sendId = (0, types_1.parsePushSendId)(remoteMessage.data.send_id);
+        api.trackEvent(sendId, 'received', {
+            device: 'mobile',
+            platform: react_native_1.Platform.OS,
+        });
+    });
+    unsubscribeOnOpen = msg().onNotificationOpenedApp((remoteMessage) => {
+        if (!isOctovise(remoteMessage.data))
+            return;
+        const sendId = (0, types_1.parsePushSendId)(remoteMessage.data.send_id);
+        api.trackEvent(sendId, 'click', {
+            device: 'mobile',
+            platform: react_native_1.Platform.OS,
+        });
+        if (remoteMessage.data.deep_link && onCTA) {
+            onCTA(remoteMessage.data.deep_link);
+        }
+    });
+    msg()
+        .getInitialNotification()
+        .then((remoteMessage) => {
+        if (!remoteMessage || !isOctovise(remoteMessage.data))
+            return;
+        const sendId = (0, types_1.parsePushSendId)(remoteMessage.data.send_id);
+        api.trackEvent(sendId, 'click', {
+            device: 'mobile',
+            platform: react_native_1.Platform.OS,
+        });
+        if (remoteMessage.data.deep_link && onCTA) {
+            onCTA(remoteMessage.data.deep_link);
+        }
+    })
+        .catch(() => { });
+}
+function stopPushListeners() {
+    unsubscribeOnMessage?.();
+    unsubscribeOnOpen?.();
+    unsubscribeOnMessage = null;
+    unsubscribeOnOpen = null;
+}

package/dist/safeNavUrl.d.ts

@@ -0,0 +1,2 @@
+export declare function isUrlSafe(value: unknown): boolean;
+export declare function safeNavUrl(value: unknown): string;

package/dist/safeNavUrl.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUrlSafe = isUrlSafe;
+exports.safeNavUrl = safeNavUrl;
+const DANGEROUS_SCHEMES = /^\s*(javascript|vbscript|data):/i;
+function isUrlSafe(value) {
+    if (value === null || value === undefined)
+        return false;
+    const s = String(value).trim();
+    if (s === '')
+        return false;
+    return !DANGEROUS_SCHEMES.test(s);
+}
+function safeNavUrl(value) {
+    if (!isUrlSafe(value))
+        return '';
+    return String(value).trim();
+}

package/dist/screenStream.d.ts

@@ -0,0 +1,17 @@
+import type { ScreenViewWire } from './api';
+export declare function record(screenName: string): void;
+export declare function setEntity(entity: {
+    type?: string;
+    id?: number | string | null;
+    ref?: string | null;
+} | null): void;
+export declare function flush(): Promise<void>;
+export declare function start(): void;
+export declare function stop(): void;
+export declare function __resetForTests(): void;
+export declare function __getBuffer(): ScreenViewWire[];
+export declare const __TEST_CONSTANTS: {
+    readonly FLUSH_INTERVAL_MS: 15000;
+    readonly FLUSH_SIZE: 20;
+    readonly MAX_BUFFER: 500;
+};

package/dist/screenStream.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__TEST_CONSTANTS = void 0;
+exports.record = record;
+exports.setEntity = setEntity;
+exports.flush = flush;
+exports.start = start;
+exports.stop = stop;
+exports.__resetForTests = __resetForTests;
+exports.__getBuffer = __getBuffer;
+const react_native_1 = require("react-native");
+const api = __importStar(require("./api"));
+const session = __importStar(require("./session"));
+const screenTargeting = __importStar(require("./screenTargeting"));
+const FLUSH_INTERVAL_MS = 15000;
+const FLUSH_SIZE = 20;
+const MAX_BUFFER = 500;
+let buffer = [];
+let timer = null;
+let appStateSub = null;
+let currentView = null;
+function record(screenName) {
+    const payload = screenTargeting.buildScreenViewForName(screenName);
+    if (!payload) {
+        currentView = null;
+        return;
+    }
+    if (buffer.length >= MAX_BUFFER)
+        buffer.shift();
+    const view = {
+        ...payload,
+        session_id: session.currentSessionId(),
+        ts: new Date().toISOString(),
+    };
+    buffer.push(view);
+    currentView = view;
+    if (buffer.length >= FLUSH_SIZE)
+        void flush();
+}
+function setEntity(entity) {
+    if (!currentView)
+        return;
+    const norm = screenTargeting.normalizeEntity(entity);
+    currentView.entity_type = norm ? norm.entity_type : null;
+    currentView.entity_id = norm ? norm.entity_id : null;
+    currentView.reference = norm ? norm.reference : null;
+}
+async function flush() {
+    if (buffer.length === 0)
+        return;
+    const batch = buffer.splice(0, buffer.length);
+    currentView = null;
+    const ok = await api.trackScreenViews(batch);
+    if (!ok) {
+        buffer.unshift(...batch.slice(-MAX_BUFFER));
+    }
+}
+function start() {
+    if (timer)
+        return;
+    timer = setInterval(() => void flush(), FLUSH_INTERVAL_MS);
+    if (typeof timer.unref === 'function') {
+        timer.unref();
+    }
+    appStateSub = react_native_1.AppState.addEventListener('change', (next) => {
+        if (next !== 'active')
+            void flush();
+    });
+}
+function stop() {
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+    appStateSub?.remove();
+    appStateSub = null;
+    currentView = null;
+    void flush();
+}
+function __resetForTests() {
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+    appStateSub?.remove();
+    appStateSub = null;
+    buffer = [];
+    currentView = null;
+}
+function __getBuffer() {
+    return buffer;
+}
+exports.__TEST_CONSTANTS = { FLUSH_INTERVAL_MS, FLUSH_SIZE, MAX_BUFFER };

package/dist/screenTargeting.d.ts

@@ -0,0 +1,37 @@
+import type { RuleEntry } from './api';
+export interface RouteEntry {
+    id: number;
+    name?: string;
+    device?: 'web' | 'mobile' | 'both';
+    mobile_screen?: string;
+    web_path?: string;
+}
+export declare function sync(): Promise<boolean>;
+export declare function isSynced(): boolean;
+export declare function getRoutes(): RouteEntry[];
+export declare function getRules(): RuleEntry[];
+export declare function resolveScreen(routeList: RouteEntry[], routeToken: string): string | null;
+export declare function routeHasMobileDestination(routeList: RouteEntry[], url: string | undefined | null): boolean;
+export declare function ctaHasMobileDestination(url: string | undefined | null): boolean;
+export declare function matchRule(routeList: RouteEntry[], ruleList: RuleEntry[], screenName: string): RuleEntry | null;
+export declare function routeForScreen(routeList: RouteEntry[], screenName: string): RouteEntry | null;
+export interface ScreenViewPayload {
+    screen_id: number;
+    entity_type: string | null;
+    entity_id: number | null;
+    reference: string | null;
+}
+export declare function normalizeEntity(e: {
+    type?: string;
+    id?: number | string | null;
+    ref?: string | null;
+} | null | undefined): {
+    entity_type: string;
+    entity_id: number | null;
+    reference: string | null;
+} | null;
+export declare function buildScreenView(routeList: RouteEntry[], screenName: string): ScreenViewPayload | null;
+export declare function resolveScreenForRoute(routeToken: string): string | null;
+export declare function matchRuleForScreen(screenName: string): RuleEntry | null;
+export declare function buildScreenViewForName(screenName: string): ScreenViewPayload | null;
+export declare function reset(): void;

package/dist/screenTargeting.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sync = sync;
+exports.isSynced = isSynced;
+exports.getRoutes = getRoutes;
+exports.getRules = getRules;
+exports.resolveScreen = resolveScreen;
+exports.routeHasMobileDestination = routeHasMobileDestination;
+exports.ctaHasMobileDestination = ctaHasMobileDestination;
+exports.matchRule = matchRule;
+exports.routeForScreen = routeForScreen;
+exports.normalizeEntity = normalizeEntity;
+exports.buildScreenView = buildScreenView;
+exports.resolveScreenForRoute = resolveScreenForRoute;
+exports.matchRuleForScreen = matchRuleForScreen;
+exports.buildScreenViewForName = buildScreenViewForName;
+exports.reset = reset;
+const api = __importStar(require("./api"));
+const resolveCTA_1 = require("./navigation/resolveCTA");
+const telemetry_1 = require("./telemetry");
+let routes = [];
+let rules = [];
+let synced = false;
+async function sync() {
+    const data = await api.fetchRules();
+    if (!data)
+        return false;
+    routes = Array.isArray(data.routes) ? data.routes : [];
+    rules = Array.isArray(data.rules) ? data.rules : [];
+    (0, telemetry_1.setMetricSampleDigits)(data.telemetry?.metric_sample_digits);
+    synced = true;
+    return true;
+}
+function isSynced() {
+    return synced;
+}
+function getRoutes() {
+    return routes;
+}
+function getRules() {
+    return rules;
+}
+function resolveScreen(routeList, routeToken) {
+    if (!routeToken)
+        return null;
+    const byId = routeList.find((r) => String(r.id) === String(routeToken));
+    if (byId?.mobile_screen)
+        return byId.mobile_screen;
+    const byName = routeList.find((r) => r.name != null && r.name === routeToken);
+    return byName?.mobile_screen ?? null;
+}
+function routeHasMobileDestination(routeList, url) {
+    if (!url)
+        return false;
+    const parsed = (0, resolveCTA_1.parseOctoviseUrl)(url);
+    if (!parsed)
+        return true;
+    if (resolveScreen(routeList, parsed.routeName))
+        return true;
+    if (!/^\d+$/.test(parsed.routeName))
+        return true;
+    return false;
+}
+function ctaHasMobileDestination(url) {
+    return routeHasMobileDestination(routes, url);
+}
+function matchRule(routeList, ruleList, screenName) {
+    if (!screenName)
+        return null;
+    const idsForScreen = new Set(routeList.filter((r) => r.mobile_screen === screenName).map((r) => Number(r.id)));
+    if (idsForScreen.size === 0)
+        return null;
+    for (const rule of ruleList) {
+        const ts = rule.target_screens;
+        if (!ts || ts.length === 0)
+            continue;
+        if (ts.some((id) => idsForScreen.has(Number(id))))
+            return rule;
+    }
+    return null;
+}
+function routeForScreen(routeList, screenName) {
+    if (!screenName)
+        return null;
+    return routeList.find((r) => r.mobile_screen === screenName) ?? null;
+}
+function normalizeEntity(e) {
+    if (!e || typeof e.type !== 'string' || e.type.trim() === '')
+        return null;
+    const n = e.id == null ? Number.NaN : Number(e.id);
+    const entity_id = Number.isInteger(n) && n > 0 ? n : null;
+    const reference = typeof e.ref === 'string' && e.ref.trim() !== '' ? e.ref.slice(0, 128) : null;
+    if (entity_id === null && reference === null)
+        return null;
+    return { entity_type: e.type, entity_id, reference };
+}
+function buildScreenView(routeList, screenName) {
+    const route = routeForScreen(routeList, screenName);
+    if (!route)
+        return null;
+    return {
+        screen_id: route.id,
+        entity_type: null,
+        entity_id: null,
+        reference: null,
+    };
+}
+function resolveScreenForRoute(routeToken) {
+    return resolveScreen(routes, routeToken);
+}
+function matchRuleForScreen(screenName) {
+    return matchRule(routes, rules, screenName);
+}
+function buildScreenViewForName(screenName) {
+    return buildScreenView(routes, screenName);
+}
+function reset() {
+    routes = [];
+    rules = [];
+    synced = false;
+}

package/dist/session.d.ts

@@ -0,0 +1,2 @@
+export declare function currentSessionId(): string;
+export declare function reset(): void;

package/dist/session.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentSessionId = currentSessionId;
+exports.reset = reset;
+const SESSION_GAP_MS = 30 * 60 * 1000;
+let sessionId = null;
+let lastActivityAt = 0;
+function generateId() {
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function currentSessionId() {
+    const now = Date.now();
+    if (!sessionId || now - lastActivityAt > SESSION_GAP_MS) {
+        sessionId = generateId();
+    }
+    lastActivityAt = now;
+    return sessionId;
+}
+function reset() {
+    sessionId = null;
+    lastActivityAt = 0;
+}

package/dist/state.d.ts

@@ -0,0 +1,8 @@
+export declare function canInit(): boolean;
+export declare function markInit(): void;
+export declare function isDuplicate(messageId: string | undefined): boolean;
+export declare function setCurrentMessage(messageId: string | undefined): void;
+export declare function clearCurrentMessage(): void;
+export declare function startForegroundListener(onForeground: () => void): void;
+export declare function stopForegroundListener(): void;
+export declare function reset(): void;