@axyle/expo-sdk 1.0.0

package/dist/integrations/reactNavigation.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * React Navigation integration for automatic screen tracking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNavigationTracker = createNavigationTracker;
+exports.trackNavigationReady = trackNavigationReady;
+exports.trackNavigationStateChange = trackNavigationStateChange;
+const core_1 = require("../core");
+/**
+ * Get the current route name from navigation state
+ */
+function getActiveRouteName(state) {
+    if (!state || typeof state.index !== 'number') {
+        return undefined;
+    }
+    const route = state.routes[state.index];
+    if (route.state) {
+        return getActiveRouteName(route.state);
+    }
+    return route.name;
+}
+/**
+ * Create a navigation state change handler for React Navigation
+ *
+ * @example
+ * ```tsx
+ * import { NavigationContainer } from '@react-navigation/native';
+ * import { createNavigationTracker } from '@axyle/expo-sdk';
+ *
+ * const navigationTracker = createNavigationTracker();
+ *
+ * function App() {
+ *   return (
+ *     <NavigationContainer
+ *       onStateChange={navigationTracker}
+ *     >
+ *       {/* Your navigators *\/}
+ *     </NavigationContainer>
+ *   );
+ * }
+ * ```
+ */
+function createNavigationTracker() {
+    let previousRouteName;
+    return (state) => {
+        const currentRouteName = getActiveRouteName(state);
+        if (currentRouteName && currentRouteName !== previousRouteName) {
+            // Track screen view
+            (0, core_1.track)('Screen Viewed', {
+                screen: currentRouteName,
+                previousScreen: previousRouteName || null,
+            });
+            previousRouteName = currentRouteName;
+        }
+    };
+}
+/**
+ * Alternative: Get navigation ref and track manually
+ *
+ * @example
+ * ```tsx
+ * import { NavigationContainer } from '@react-navigation/native';
+ * import { trackNavigationReady, trackNavigationStateChange } from '@axyle/expo-sdk';
+ *
+ * const navigationRef = createNavigationContainerRef();
+ *
+ * function App() {
+ *   return (
+ *     <NavigationContainer
+ *       ref={navigationRef}
+ *       onReady={() => trackNavigationReady(navigationRef)}
+ *       onStateChange={() => trackNavigationStateChange(navigationRef)}
+ *     >
+ *       {/* Your navigators *\/}
+ *     </NavigationContainer>
+ *   );
+ * }
+ * ```
+ */
+let currentRouteName;
+function trackNavigationReady(navigationRef) {
+    currentRouteName = navigationRef.current?.getCurrentRoute()?.name;
+    if (currentRouteName) {
+        (0, core_1.track)('Screen Viewed', {
+            screen: currentRouteName,
+        });
+    }
+}
+function trackNavigationStateChange(navigationRef) {
+    const previousRouteName = currentRouteName;
+    const route = navigationRef.current?.getCurrentRoute();
+    currentRouteName = route?.name;
+    if (currentRouteName && currentRouteName !== previousRouteName) {
+        (0, core_1.track)('Screen Viewed', {
+            screen: currentRouteName,
+            previousScreen: previousRouteName || null,
+            params: route?.params || {},
+        });
+    }
+}

package/dist/queue.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Event queue manager
+ * Handles queuing, batching, and flushing events
+ */
+import { AnalyticsEvent } from './types';
+import { Transport } from './transport';
+export interface QueueConfig {
+    maxQueueSize: number;
+    flushInterval: number;
+}
+export declare class EventQueue {
+    private config;
+    private transport;
+    private logger;
+    private flushTimer;
+    private isFlushing;
+    constructor(config: QueueConfig, transport: Transport, logger: any);
+    /**
+     * Initialize the queue
+     * Starts the flush timer and attempts to flush any persisted events
+     */
+    initialize(): Promise<void>;
+    /**
+     * Add event to queue
+     */
+    enqueue(event: AnalyticsEvent): Promise<void>;
+    /**
+     * Flush all queued events
+     */
+    flush(): Promise<void>;
+    /**
+     * Start periodic flush timer
+     */
+    private startFlushTimer;
+    /**
+     * Stop periodic flush timer
+     */
+    private stopFlushTimer;
+    /**
+     * Get queue size
+     */
+    getQueueSize(): Promise<number>;
+    /**
+     * Clear all queued events
+     */
+    clear(): Promise<void>;
+    /**
+     * Shutdown the queue
+     * Flushes remaining events and stops timer
+     */
+    shutdown(): Promise<void>;
+}

package/dist/queue.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Event queue manager
+ * Handles queuing, batching, and flushing events
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventQueue = void 0;
+const storage_1 = require("./storage");
+class EventQueue {
+    constructor(config, transport, logger) {
+        this.flushTimer = null;
+        this.isFlushing = false;
+        this.config = config;
+        this.transport = transport;
+        this.logger = logger;
+    }
+    /**
+     * Initialize the queue
+     * Starts the flush timer and attempts to flush any persisted events
+     */
+    async initialize() {
+        // Start periodic flush
+        this.startFlushTimer();
+        // Try to flush any events that were persisted from previous session
+        await this.flush();
+    }
+    /**
+     * Add event to queue
+     */
+    async enqueue(event) {
+        try {
+            // Add to persistent storage
+            await storage_1.Storage.addEventToQueue(event);
+            this.logger.log(`Event queued: ${event.name}`);
+            // Check if we should flush
+            const queuedEvents = await storage_1.Storage.getQueuedEvents();
+            this.logger.log(`Current queue size: ${queuedEvents.length}/${this.config.maxQueueSize}`);
+            if (queuedEvents.length >= this.config.maxQueueSize) {
+                this.logger.log('Queue size limit reached, flushing...');
+                await this.flush();
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to enqueue event:', error);
+        }
+    }
+    /**
+     * Flush all queued events
+     */
+    async flush() {
+        // Prevent concurrent flushes
+        if (this.isFlushing) {
+            this.logger.log('Flush already in progress, skipping');
+            return;
+        }
+        this.isFlushing = true;
+        try {
+            const events = await storage_1.Storage.getQueuedEvents();
+            if (events.length === 0) {
+                this.logger.log('No events to flush');
+                return;
+            }
+            this.logger.log(`Flushing ${events.length} events...`);
+            // Send events via transport
+            const sentEventIds = await this.transport.sendBatch(events);
+            // Remove successfully sent events from queue
+            if (sentEventIds.length > 0) {
+                await storage_1.Storage.removeEventsFromQueue(sentEventIds);
+                this.logger.log(`Successfully flushed ${sentEventIds.length} events`);
+            }
+            // Check if there are failed events remaining
+            const remainingEvents = await storage_1.Storage.getQueuedEvents();
+            if (remainingEvents.length > 0) {
+                this.logger.warn(`${remainingEvents.length} events failed to send, will retry later`);
+            }
+        }
+        catch (error) {
+            this.logger.error('Error during flush:', error);
+        }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+    /**
+     * Start periodic flush timer
+     */
+    startFlushTimer() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        this.flushTimer = setInterval(() => {
+            this.flush().catch((error) => {
+                this.logger.error('Error in periodic flush:', error);
+            });
+        }, this.config.flushInterval);
+        this.logger.log(`Started flush timer with interval: ${this.config.flushInterval}ms`);
+    }
+    /**
+     * Stop periodic flush timer
+     */
+    stopFlushTimer() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+            this.logger.log('Stopped flush timer');
+        }
+    }
+    /**
+     * Get queue size
+     */
+    async getQueueSize() {
+        try {
+            const events = await storage_1.Storage.getQueuedEvents();
+            return events.length;
+        }
+        catch (error) {
+            this.logger.error('Failed to get queue size:', error);
+            return 0;
+        }
+    }
+    /**
+     * Clear all queued events
+     */
+    async clear() {
+        try {
+            await storage_1.Storage.clearQueue();
+            this.logger.log('Queue cleared');
+        }
+        catch (error) {
+            this.logger.error('Failed to clear queue:', error);
+        }
+    }
+    /**
+     * Shutdown the queue
+     * Flushes remaining events and stops timer
+     */
+    async shutdown() {
+        this.logger.log('Shutting down event queue...');
+        this.stopFlushTimer();
+        await this.flush();
+    }
+}
+exports.EventQueue = EventQueue;

package/dist/session.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Session management with 30-minute timeout
+ */
+export declare class SessionManager {
+    private sessionTimeout;
+    private currentSession;
+    private logger;
+    private onSessionStart?;
+    private onSessionEnd?;
+    constructor(sessionTimeout: number, logger: any, callbacks?: {
+        onSessionStart?: (sessionId: string) => void;
+        onSessionEnd?: (sessionId: string, duration: number) => void;
+    });
+    /**
+     * Initialize session manager
+     * Loads existing session or creates new one
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get current session ID
+     */
+    getSessionId(): string | null;
+    /**
+     * Update last activity time
+     * Checks if session should be renewed
+     */
+    updateActivity(): Promise<void>;
+    /**
+     * Start a new session
+     */
+    private startNewSession;
+    /**
+     * End a session
+     */
+    private endSession;
+    /**
+     * Force end current session
+     */
+    forceEndSession(): Promise<void>;
+    /**
+     * Reset session (start fresh)
+     */
+    reset(): Promise<void>;
+}

package/dist/session.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Session management with 30-minute timeout
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const storage_1 = require("./storage");
+const utils_1 = require("./utils");
+class SessionManager {
+    constructor(sessionTimeout, logger, callbacks) {
+        this.currentSession = null;
+        this.sessionTimeout = sessionTimeout;
+        this.logger = logger;
+        this.onSessionStart = callbacks?.onSessionStart;
+        this.onSessionEnd = callbacks?.onSessionEnd;
+    }
+    /**
+     * Initialize session manager
+     * Loads existing session or creates new one
+     */
+    async initialize() {
+        try {
+            const savedSession = await storage_1.Storage.getSessionData();
+            const now = Date.now();
+            if (savedSession) {
+                // Check if session is still valid
+                const timeSinceLastActivity = now - savedSession.lastActivityTime;
+                if (timeSinceLastActivity < this.sessionTimeout) {
+                    // Resume existing session
+                    this.currentSession = savedSession;
+                    this.logger.log('Resumed existing session:', savedSession.sessionId);
+                    await this.updateActivity();
+                }
+                else {
+                    // Session expired, end it and start new one
+                    this.logger.log('Session expired, starting new session');
+                    await this.endSession(savedSession);
+                    await this.startNewSession();
+                }
+            }
+            else {
+                // No existing session, start new one
+                await this.startNewSession();
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize session:', error);
+            // Start new session as fallback
+            await this.startNewSession();
+        }
+    }
+    /**
+     * Get current session ID
+     */
+    getSessionId() {
+        if (!this.currentSession) {
+            return null;
+        }
+        return this.currentSession.sessionId;
+    }
+    /**
+     * Update last activity time
+     * Checks if session should be renewed
+     */
+    async updateActivity() {
+        if (!this.currentSession)
+            return;
+        const now = Date.now();
+        const timeSinceLastActivity = now - this.currentSession.lastActivityTime;
+        // If session expired, end it and start new one
+        if (timeSinceLastActivity >= this.sessionTimeout) {
+            this.logger.log('Session timeout detected, starting new session');
+            await this.endSession(this.currentSession);
+            await this.startNewSession();
+        }
+        else {
+            // Update activity time
+            this.currentSession.lastActivityTime = now;
+            await storage_1.Storage.saveSessionData(this.currentSession);
+        }
+    }
+    /**
+     * Start a new session
+     */
+    async startNewSession() {
+        const now = Date.now();
+        const sessionId = `session_${now}_${(0, utils_1.generateUUID)()}`;
+        this.currentSession = {
+            sessionId,
+            startTime: now,
+            lastActivityTime: now,
+        };
+        await storage_1.Storage.saveSessionData(this.currentSession);
+        this.logger.log('Started new session:', sessionId);
+        // Trigger callback
+        if (this.onSessionStart) {
+            try {
+                this.onSessionStart(sessionId);
+            }
+            catch (error) {
+                this.logger.error('Error in onSessionStart callback:', error);
+            }
+        }
+    }
+    /**
+     * End a session
+     */
+    async endSession(session) {
+        const duration = session.lastActivityTime - session.startTime;
+        this.logger.log(`Ended session ${session.sessionId}, duration: ${duration}ms`);
+        // Trigger callback
+        if (this.onSessionEnd) {
+            try {
+                this.onSessionEnd(session.sessionId, duration);
+            }
+            catch (error) {
+                this.logger.error('Error in onSessionEnd callback:', error);
+            }
+        }
+    }
+    /**
+     * Force end current session
+     */
+    async forceEndSession() {
+        if (this.currentSession) {
+            await this.endSession(this.currentSession);
+            await storage_1.Storage.clearSessionData();
+            this.currentSession = null;
+        }
+    }
+    /**
+     * Reset session (start fresh)
+     */
+    async reset() {
+        await this.forceEndSession();
+        await this.startNewSession();
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/sessionAnalytics.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Session Analytics Counter
+ * Tracks and counts analytics events locally for the current session
+ */
+import { AnalyticsEvent } from "./types";
+export interface SessionAnalyticsStats {
+    totalEvents: number;
+    eventsByType: Record<string, number>;
+    eventsByScreen: Record<string, number>;
+    sessionStartTime: number;
+    sessionDuration: number;
+    lastEventTime: number | null;
+}
+export declare class SessionAnalytics {
+    private events;
+    private sessionStartTime;
+    private lastEventTime;
+    constructor(sessionStartTime: number);
+    /**
+     * Add an event to the session analytics
+     */
+    addEvent(event: AnalyticsEvent): void;
+    /**
+     * Get current session statistics
+     */
+    getStats(): SessionAnalyticsStats;
+    /**
+     * Get all events in the session
+     */
+    getEvents(): AnalyticsEvent[];
+    /**
+     * Get events by type
+     */
+    getEventsByType(eventName: string): AnalyticsEvent[];
+    /**
+     * Clear all events (for new session)
+     */
+    clear(): void;
+    /**
+     * Reset session start time
+     */
+    resetSession(sessionStartTime: number): void;
+}

package/dist/sessionAnalytics.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Session Analytics Counter
+ * Tracks and counts analytics events locally for the current session
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionAnalytics = void 0;
+class SessionAnalytics {
+    constructor(sessionStartTime) {
+        this.events = [];
+        this.lastEventTime = null;
+        this.sessionStartTime = sessionStartTime;
+    }
+    /**
+     * Add an event to the session analytics
+     */
+    addEvent(event) {
+        this.events.push(event);
+        this.lastEventTime = Date.now();
+    }
+    /**
+     * Get current session statistics
+     */
+    getStats() {
+        const now = Date.now();
+        const eventsByType = {};
+        const eventsByScreen = {};
+        // Count events by type and screen
+        for (const event of this.events) {
+            // Count by event name
+            eventsByType[event.name] = (eventsByType[event.name] || 0) + 1;
+            // Count by screen if available
+            const screen = event.properties?.screen;
+            if (screen) {
+                eventsByScreen[screen] = (eventsByScreen[screen] || 0) + 1;
+            }
+        }
+        return {
+            totalEvents: this.events.length,
+            eventsByType,
+            eventsByScreen,
+            sessionStartTime: this.sessionStartTime,
+            sessionDuration: now - this.sessionStartTime,
+            lastEventTime: this.lastEventTime,
+        };
+    }
+    /**
+     * Get all events in the session
+     */
+    getEvents() {
+        return [...this.events];
+    }
+    /**
+     * Get events by type
+     */
+    getEventsByType(eventName) {
+        return this.events.filter((event) => event.name === eventName);
+    }
+    /**
+     * Clear all events (for new session)
+     */
+    clear() {
+        this.events = [];
+        this.lastEventTime = null;
+    }
+    /**
+     * Reset session start time
+     */
+    resetSession(sessionStartTime) {
+        this.sessionStartTime = sessionStartTime;
+        this.clear();
+    }
+}
+exports.SessionAnalytics = SessionAnalytics;

package/dist/storage.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Storage layer using AsyncStorage for persistence
+ * Handles event queue, user IDs, session data, and preferences
+ */
+import { AnalyticsEvent, SessionData } from './types';
+export declare class Storage {
+    /**
+     * Get all queued events
+     */
+    static getQueuedEvents(): Promise<AnalyticsEvent[]>;
+    /**
+     * Save events to queue
+     */
+    static saveQueuedEvents(events: AnalyticsEvent[]): Promise<void>;
+    /**
+     * Add event to queue
+     */
+    static addEventToQueue(event: AnalyticsEvent): Promise<void>;
+    /**
+     * Remove events from queue
+     */
+    static removeEventsFromQueue(eventIds: string[]): Promise<void>;
+    /**
+     * Clear all queued events
+     */
+    static clearQueue(): Promise<void>;
+    /**
+     * Get anonymous ID (create if doesn't exist)
+     */
+    static getAnonymousId(): Promise<string>;
+    /**
+     * Get user ID
+     */
+    static getUserId(): Promise<string | null>;
+    /**
+     * Set user ID
+     */
+    static setUserId(userId: string): Promise<void>;
+    /**
+     * Clear user ID (on reset/logout)
+     */
+    static clearUserId(): Promise<void>;
+    /**
+     * Get session data
+     */
+    static getSessionData(): Promise<SessionData | null>;
+    /**
+     * Save session data
+     */
+    static saveSessionData(session: SessionData): Promise<void>;
+    /**
+     * Clear session data
+     */
+    static clearSessionData(): Promise<void>;
+    /**
+     * Check if user has opted out
+     */
+    static isOptedOut(): Promise<boolean>;
+    /**
+     * Set opt-out status
+     */
+    static setOptOut(optOut: boolean): Promise<void>;
+    /**
+     * Clear all analytics data
+     */
+    static clearAll(): Promise<void>;
+}