@axyle/expo-sdk 1.0.0

package/dist/context.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Device and app context collection using Expo APIs
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextCollector = void 0;
+const Application = __importStar(require("expo-application"));
+const expo_constants_1 = __importDefault(require("expo-constants"));
+const Device = __importStar(require("expo-device"));
+const react_native_1 = require("react-native");
+class ContextCollector {
+    /**
+     * Get device and app context
+     * Caches result for performance
+     */
+    static async getContext(environment) {
+        // Return cached context if available
+        if (this.cachedContext) {
+            return this.cachedContext;
+        }
+        try {
+            const { width, height } = react_native_1.Dimensions.get("window");
+            const scale = react_native_1.Dimensions.get("window").scale;
+            const context = {
+                app: {
+                    name: Application.applicationName || "Unknown",
+                    version: Application.nativeApplicationVersion || "0.0.0",
+                    build: Application.nativeBuildVersion || "0",
+                    namespace: Application.applicationId || "unknown",
+                },
+                device: {
+                    id: await this.getDeviceId(),
+                    manufacturer: Device.manufacturer || null,
+                    model: Device.modelName || null,
+                    name: Device.deviceName || null,
+                    type: this.getDeviceType(),
+                    brand: Device.brand || null,
+                },
+                os: {
+                    name: react_native_1.Platform.OS,
+                    version: react_native_1.Platform.Version.toString(),
+                },
+                screen: {
+                    width,
+                    height,
+                    density: scale,
+                },
+                locale: this.getLocale(),
+                timezone: this.getTimezone(),
+                environment,
+            };
+            // Cache the context
+            this.cachedContext = context;
+            return context;
+        }
+        catch (error) {
+            console.error("[Axyle] Failed to collect context:", error);
+            // Return minimal context on error
+            return this.getMinimalContext(environment);
+        }
+    }
+    /**
+     * Get device ID (may be null on some platforms)
+     */
+    static async getDeviceId() {
+        try {
+            // Use Android ID on Android, IDFV on iOS
+            if (react_native_1.Platform.OS === "android") {
+                return expo_constants_1.default.sessionId || null;
+            }
+            else if (react_native_1.Platform.OS === "ios") {
+                return expo_constants_1.default.sessionId || null;
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Determine device type
+     */
+    static getDeviceType() {
+        try {
+            if (Device.deviceType === Device.DeviceType.PHONE) {
+                return "PHONE";
+            }
+            else if (Device.deviceType === Device.DeviceType.TABLET) {
+                return "TABLET";
+            }
+            else if (Device.deviceType === Device.DeviceType.DESKTOP) {
+                return "DESKTOP";
+            }
+            else if (Device.deviceType === Device.DeviceType.TV) {
+                return "TV";
+            }
+            return "UNKNOWN";
+        }
+        catch (error) {
+            return "UNKNOWN";
+        }
+    }
+    /**
+     * Get device locale
+     */
+    static getLocale() {
+        try {
+            // Try to get locale from Intl API (works on most platforms)
+            if (typeof Intl !== "undefined" && Intl.DateTimeFormat) {
+                const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+                if (locale)
+                    return locale;
+            }
+            return "en-US";
+        }
+        catch (error) {
+            return "en-US";
+        }
+    }
+    /**
+     * Get device timezone
+     */
+    static getTimezone() {
+        try {
+            // Get timezone offset in minutes
+            const offset = new Date().getTimezoneOffset();
+            const hours = Math.abs(Math.floor(offset / 60));
+            const minutes = Math.abs(offset % 60);
+            const sign = offset <= 0 ? "+" : "-";
+            return `UTC${sign}${hours.toString().padStart(2, "0")}:${minutes
+                .toString()
+                .padStart(2, "0")}`;
+        }
+        catch (error) {
+            return "UTC";
+        }
+    }
+    /**
+     * Get minimal context as fallback
+     */
+    static getMinimalContext(environment) {
+        const { width, height } = react_native_1.Dimensions.get("window");
+        return {
+            app: {
+                name: "Unknown",
+                version: "0.0.0",
+                build: "0",
+                namespace: "unknown",
+            },
+            device: {
+                id: null,
+                manufacturer: null,
+                model: null,
+                name: null,
+                type: "UNKNOWN",
+                brand: null,
+            },
+            os: {
+                name: react_native_1.Platform.OS,
+                version: react_native_1.Platform.Version.toString(),
+            },
+            screen: {
+                width,
+                height,
+                density: 1,
+            },
+            locale: "en-US",
+            timezone: "UTC",
+            environment,
+        };
+    }
+    /**
+     * Clear cached context (useful for testing or when app info changes)
+     */
+    static clearCache() {
+        this.cachedContext = null;
+    }
+}
+exports.ContextCollector = ContextCollector;
+ContextCollector.cachedContext = null;

package/dist/core.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Core SDK module - exports the singleton client instance
+ * This module is used to avoid circular dependencies between index.ts and integrations
+ */
+import { AxyleClient } from "./client";
+import type { EventProperties } from "./types";
+export declare const client: AxyleClient;
+export declare function track(eventName: string, properties?: EventProperties): void;
+export declare function isInitialized(): boolean;

package/dist/core.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Core SDK module - exports the singleton client instance
+ * This module is used to avoid circular dependencies between index.ts and integrations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.client = void 0;
+exports.track = track;
+exports.isInitialized = isInitialized;
+const client_1 = require("./client");
+// Create and export singleton instance
+exports.client = new client_1.AxyleClient();
+// Maximum retries when SDK is not initialized
+const MAX_INIT_RETRIES = 50; // 5 seconds max (50 * 100ms)
+// Export a track function that can be used by integrations
+// Note: client.track is async, but we call it without awaiting to avoid blocking
+function track(eventName, properties) {
+    // Check if initialized before tracking
+    if (!exports.client.isInitialized) {
+        // Queue the event to be tracked once initialized
+        let retryCount = 0;
+        const checkAndTrack = () => {
+            if (exports.client.isInitialized) {
+                exports.client.track(eventName, properties).catch(() => {
+                    // Silently handle errors - track already handles errors internally
+                });
+            }
+            else if (retryCount < MAX_INIT_RETRIES) {
+                retryCount++;
+                setTimeout(checkAndTrack, 100);
+            }
+            // After max retries, silently drop the event
+        };
+        checkAndTrack();
+        return;
+    }
+    // Fire and forget - track is async but we don't need to wait for it
+    exports.client.track(eventName, properties).catch(() => {
+        // Silently handle errors - track already handles errors internally
+    });
+}
+// Export isInitialized getter for integrations to check
+function isInitialized() {
+    return exports.client.isInitialized;
+}

package/dist/hooks/useFeatureTracking.d.ts

@@ -0,0 +1,34 @@
+/**
+ * React hook and utilities for feature usage tracking
+ */
+/**
+ * Track when a feature is used
+ *
+ * @example
+ * ```tsx
+ * function ProfileScreen() {
+ *   const handleEditProfile = () => {
+ *     trackFeatureUsage('edit_profile', { screen: 'Profile' });
+ *     // ... edit profile logic
+ *   };
+ *
+ *   return <Button onPress={handleEditProfile}>Edit Profile</Button>;
+ * }
+ * ```
+ */
+export declare function trackFeatureUsage(featureName: string, properties?: Record<string, any>): void;
+/**
+ * Track feature usage with additional context
+ */
+export declare function trackFeatureUsageWithContext(featureName: string, context: {
+    screen?: string;
+    category?: string;
+    action?: string;
+    value?: number | string;
+    [key: string]: any;
+}): void;
+/**
+ * Hook to automatically track feature usage on component mount
+ * Useful for tracking feature discovery/views
+ */
+export declare function useFeatureViewTracking(featureName: string, properties?: Record<string, any>): void;

package/dist/hooks/useFeatureTracking.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * React hook and utilities for feature usage tracking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackFeatureUsage = trackFeatureUsage;
+exports.trackFeatureUsageWithContext = trackFeatureUsageWithContext;
+exports.useFeatureViewTracking = useFeatureViewTracking;
+const react_1 = require("react");
+const core_1 = require("../core");
+/**
+ * Track when a feature is used
+ *
+ * @example
+ * ```tsx
+ * function ProfileScreen() {
+ *   const handleEditProfile = () => {
+ *     trackFeatureUsage('edit_profile', { screen: 'Profile' });
+ *     // ... edit profile logic
+ *   };
+ *
+ *   return <Button onPress={handleEditProfile}>Edit Profile</Button>;
+ * }
+ * ```
+ */
+function trackFeatureUsage(featureName, properties) {
+    (0, core_1.track)("Feature Used", {
+        feature: featureName,
+        ...properties,
+    });
+}
+/**
+ * Track feature usage with additional context
+ */
+function trackFeatureUsageWithContext(featureName, context) {
+    (0, core_1.track)("Feature Used", {
+        feature: featureName,
+        feature_category: context.category,
+        feature_action: context.action,
+        feature_value: context.value,
+        screen: context.screen,
+        ...context,
+    });
+}
+/**
+ * Hook to automatically track feature usage on component mount
+ * Useful for tracking feature discovery/views
+ */
+function useFeatureViewTracking(featureName, properties) {
+    const hasTracked = (0, react_1.useRef)(false);
+    (0, react_1.useEffect)(() => {
+        if (!hasTracked.current) {
+            (0, core_1.track)("Feature Viewed", {
+                feature: featureName,
+                ...properties,
+            });
+            hasTracked.current = true;
+        }
+    }, [featureName, properties]);
+}

package/dist/hooks/useOnboardingTracking.d.ts

@@ -0,0 +1,85 @@
+/**
+ * React hook for user flow tracking
+ * Generic flow tracking that can be used for onboarding, checkout, tutorials, etc.
+ */
+export interface FlowTrackingOptions {
+    /** Flow identifier (e.g., 'onboarding', 'checkout', 'tutorial') */
+    flowId: string;
+    /** Flow type/category (e.g., 'onboarding', 'checkout', 'tutorial', 'feature-discovery') */
+    flowType?: string;
+    /** Current step/screen in the flow */
+    step: number;
+    /** Total number of steps in the flow */
+    totalSteps: number;
+    /** Step/screen name */
+    stepName: string;
+    /** Additional properties to track */
+    properties?: Record<string, any>;
+}
+/**
+ * Hook to track user flow progress and drop-offs
+ * Works for any multi-step flow: onboarding, checkout, tutorials, etc.
+ *
+ * @example
+ * ```tsx
+ * // Onboarding example
+ * function OnboardingStep1() {
+ *   useFlowTracking({
+ *     flowId: 'welcome-onboarding',
+ *     flowType: 'onboarding',
+ *     step: 1,
+ *     totalSteps: 5,
+ *     stepName: 'Welcome'
+ *   });
+ *   return <View>...</View>;
+ * }
+ *
+ * // Checkout example
+ * function CheckoutStep2() {
+ *   useFlowTracking({
+ *     flowId: 'checkout-process',
+ *     flowType: 'checkout',
+ *     step: 2,
+ *     totalSteps: 4,
+ *     stepName: 'Shipping Info'
+ *   });
+ *   return <View>...</View>;
+ * }
+ * ```
+ */
+export declare function useFlowTracking(options: FlowTrackingOptions): void;
+/**
+ * Helper function to track flow completion
+ * Call this when user completes the entire flow
+ *
+ * @example
+ * ```tsx
+ * trackFlowCompleted('welcome-onboarding', 5, { flowType: 'onboarding' });
+ * ```
+ */
+export declare function trackFlowCompleted(flowId: string, totalSteps: number, properties?: Record<string, any>): void;
+/**
+ * Helper function to track flow abandonment
+ * Call this when user explicitly exits a flow
+ *
+ * @example
+ * ```tsx
+ * trackFlowAbandoned('checkout-process', 2, 4, {
+ *   flowType: 'checkout',
+ *   stepName: 'Shipping Info'
+ * });
+ * ```
+ */
+export declare function trackFlowAbandoned(flowId: string, currentStep: number, totalSteps: number, properties?: Record<string, any>): void;
+/**
+ * @deprecated Use useFlowTracking instead
+ */
+export declare const useOnboardingTracking: typeof useFlowTracking;
+/**
+ * @deprecated Use trackFlowCompleted instead
+ */
+export declare const trackOnboardingCompleted: (flowId: string, totalSteps: number, properties?: Record<string, any>) => void;
+/**
+ * @deprecated Use trackFlowAbandoned instead
+ */
+export declare const trackOnboardingAbandoned: (flowId: string, currentStep: number, totalSteps: number, properties?: Record<string, any>) => void;

package/dist/hooks/useOnboardingTracking.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * React hook for user flow tracking
+ * Generic flow tracking that can be used for onboarding, checkout, tutorials, etc.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackOnboardingAbandoned = exports.trackOnboardingCompleted = exports.useOnboardingTracking = void 0;
+exports.useFlowTracking = useFlowTracking;
+exports.trackFlowCompleted = trackFlowCompleted;
+exports.trackFlowAbandoned = trackFlowAbandoned;
+const react_1 = require("react");
+const core_1 = require("../core");
+/**
+ * Hook to track user flow progress and drop-offs
+ * Works for any multi-step flow: onboarding, checkout, tutorials, etc.
+ *
+ * @example
+ * ```tsx
+ * // Onboarding example
+ * function OnboardingStep1() {
+ *   useFlowTracking({
+ *     flowId: 'welcome-onboarding',
+ *     flowType: 'onboarding',
+ *     step: 1,
+ *     totalSteps: 5,
+ *     stepName: 'Welcome'
+ *   });
+ *   return <View>...</View>;
+ * }
+ *
+ * // Checkout example
+ * function CheckoutStep2() {
+ *   useFlowTracking({
+ *     flowId: 'checkout-process',
+ *     flowType: 'checkout',
+ *     step: 2,
+ *     totalSteps: 4,
+ *     stepName: 'Shipping Info'
+ *   });
+ *   return <View>...</View>;
+ * }
+ * ```
+ */
+function useFlowTracking(options) {
+    const { flowId, flowType, step, totalSteps, stepName, properties = {}, } = options;
+    const hasTracked = (0, react_1.useRef)(false);
+    const stepStartTime = (0, react_1.useRef)(null);
+    const flowStartTime = (0, react_1.useRef)(null);
+    (0, react_1.useEffect)(() => {
+        const startTime = Date.now();
+        stepStartTime.current = startTime;
+        // Track flow start on first step
+        if (step === 1 && !hasTracked.current) {
+            flowStartTime.current = startTime;
+            (0, core_1.track)("Flow Started", {
+                flow_id: flowId,
+                flow_type: flowType || "custom",
+                flow_start_time: startTime,
+                total_steps: totalSteps,
+                ...properties,
+            });
+        }
+        // Track step view
+        if (!hasTracked.current) {
+            (0, core_1.track)("Flow Step Viewed", {
+                flow_id: flowId,
+                flow_type: flowType || "custom",
+                step: step,
+                step_name: stepName,
+                total_steps: totalSteps,
+                step_start_time: startTime,
+                progress_percentage: Math.round((step / totalSteps) * 100),
+                ...properties,
+            });
+            hasTracked.current = true;
+        }
+        // Track step completion and potential drop-off when component unmounts
+        return () => {
+            if (stepStartTime.current !== null) {
+                const endTime = Date.now();
+                const stepDuration = endTime - stepStartTime.current;
+                // Track step completion
+                (0, core_1.track)("Flow Step Completed", {
+                    flow_id: flowId,
+                    flow_type: flowType || "custom",
+                    step: step,
+                    step_name: stepName,
+                    step_duration_ms: stepDuration,
+                    step_duration_seconds: Math.round(stepDuration / 1000),
+                    progress_percentage: Math.round((step / totalSteps) * 100),
+                    ...properties,
+                });
+                // If not the last step, this could be a drop-off
+                if (step < totalSteps) {
+                    (0, core_1.track)("Flow Step Exited", {
+                        flow_id: flowId,
+                        flow_type: flowType || "custom",
+                        step: step,
+                        step_name: stepName,
+                        next_step: step + 1,
+                        is_drop_off: true,
+                        step_duration_ms: stepDuration,
+                        ...properties,
+                    });
+                }
+            }
+        };
+    }, [flowId, flowType, step, totalSteps, stepName, properties]);
+}
+/**
+ * Helper function to track flow completion
+ * Call this when user completes the entire flow
+ *
+ * @example
+ * ```tsx
+ * trackFlowCompleted('welcome-onboarding', 5, { flowType: 'onboarding' });
+ * ```
+ */
+function trackFlowCompleted(flowId, totalSteps, properties) {
+    (0, core_1.track)("Flow Completed", {
+        flow_id: flowId,
+        flow_type: properties?.flowType || "custom",
+        total_steps: totalSteps,
+        completed_at: Date.now(),
+        ...properties,
+    });
+}
+/**
+ * Helper function to track flow abandonment
+ * Call this when user explicitly exits a flow
+ *
+ * @example
+ * ```tsx
+ * trackFlowAbandoned('checkout-process', 2, 4, {
+ *   flowType: 'checkout',
+ *   stepName: 'Shipping Info'
+ * });
+ * ```
+ */
+function trackFlowAbandoned(flowId, currentStep, totalSteps, properties) {
+    (0, core_1.track)("Flow Abandoned", {
+        flow_id: flowId,
+        flow_type: properties?.flowType || "custom",
+        abandoned_at_step: currentStep,
+        abandoned_step_name: properties?.stepName || `Step ${currentStep}`,
+        total_steps: totalSteps,
+        progress_percentage: Math.round((currentStep / totalSteps) * 100),
+        abandoned_at: Date.now(),
+        ...properties,
+    });
+}
+// Legacy exports for backward compatibility (deprecated)
+/**
+ * @deprecated Use useFlowTracking instead
+ */
+exports.useOnboardingTracking = useFlowTracking;
+/**
+ * @deprecated Use trackFlowCompleted instead
+ */
+const trackOnboardingCompleted = (flowId, totalSteps, properties) => trackFlowCompleted(flowId, totalSteps, {
+    ...properties,
+    flowType: "onboarding",
+});
+exports.trackOnboardingCompleted = trackOnboardingCompleted;
+/**
+ * @deprecated Use trackFlowAbandoned instead
+ */
+const trackOnboardingAbandoned = (flowId, currentStep, totalSteps, properties) => trackFlowAbandoned(flowId, currentStep, totalSteps, {
+    ...properties,
+    flowType: "onboarding",
+});
+exports.trackOnboardingAbandoned = trackOnboardingAbandoned;

package/dist/hooks/useScreenTracking.d.ts

@@ -0,0 +1,23 @@
+/**
+ * React hook for automatic screen tracking with time tracking
+ */
+export interface ScreenTrackingOptions {
+    /** Screen name to track */
+    screenName: string;
+    /** Additional properties to track with screen view */
+    properties?: Record<string, any>;
+    /** Whether to track time spent on screen (default: true) */
+    trackTime?: boolean;
+}
+/**
+ * Hook to automatically track screen views with time tracking
+ *
+ * @example
+ * ```tsx
+ * function HomeScreen() {
+ *   useScreenTracking({ screenName: 'Home' });
+ *   return <View>...</View>;
+ * }
+ * ```
+ */
+export declare function useScreenTracking(options: ScreenTrackingOptions): void;