rampkit-expo-dev 0.0.19 → 0.0.22

package/build/EventManager.js

@@ -0,0 +1,419 @@
+"use strict";
+/**
+ * RampKit Event Manager
+ * Handles event tracking for the /app-user-events endpoint
+ */
+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.EventManager = exports.eventManager = void 0;
+const Crypto = __importStar(require("expo-crypto"));
+const constants_1 = require("./constants");
+/**
+ * Generate a UUID v4 using expo-crypto
+ */
+async function generateEventId() {
+    try {
+        const bytes = (await Crypto.getRandomBytesAsync(16));
+        bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0"));
+        return (hex[0] +
+            hex[1] +
+            hex[2] +
+            hex[3] +
+            "-" +
+            hex[4] +
+            hex[5] +
+            "-" +
+            hex[6] +
+            hex[7] +
+            "-" +
+            hex[8] +
+            hex[9] +
+            "-" +
+            hex[10] +
+            hex[11] +
+            hex[12] +
+            hex[13] +
+            hex[14] +
+            hex[15]);
+    }
+    catch (_a) {
+        // Fallback using Math.random
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+}
+/**
+ * Synchronous UUID generator for when async is not practical
+ */
+function generateEventIdSync() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+class EventManager {
+    constructor() {
+        this.appId = null;
+        this.appUserId = null;
+        this.sessionId = null;
+        this.device = null;
+        this.baseContext = {};
+        // Current context tracking
+        this.currentScreenName = null;
+        this.currentFlowId = null;
+        this.currentVariantId = null;
+        this.currentPaywallId = null;
+        this.currentPlacement = null;
+        // Onboarding tracking
+        this.onboardingStartTime = null;
+        this.currentOnboardingId = null;
+        // Initialization state
+        this.initialized = false;
+    }
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new EventManager();
+        }
+        return this._instance;
+    }
+    /**
+     * Initialize the event manager with device info
+     */
+    initialize(appId, deviceInfo) {
+        this.appId = appId;
+        this.appUserId = deviceInfo.appUserId;
+        this.sessionId = deviceInfo.appSessionId;
+        this.device = {
+            platform: deviceInfo.platform,
+            platformVersion: deviceInfo.platformVersion,
+            deviceModel: deviceInfo.deviceModel,
+            sdkVersion: deviceInfo.sdkVersion,
+            appVersion: deviceInfo.appVersion,
+            buildNumber: deviceInfo.buildNumber,
+        };
+        this.baseContext = {
+            locale: deviceInfo.deviceLocale,
+            regionCode: deviceInfo.regionCode,
+        };
+        this.initialized = true;
+        console.log("[RampKit] EventManager: Initialized");
+    }
+    /**
+     * Check if the event manager is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Set current screen context
+     */
+    setCurrentScreen(screenName) {
+        this.currentScreenName = screenName;
+    }
+    /**
+     * Set current flow context (e.g., onboarding flow ID)
+     */
+    setCurrentFlow(flowId, variantId) {
+        this.currentFlowId = flowId;
+        if (variantId !== undefined) {
+            this.currentVariantId = variantId;
+        }
+    }
+    /**
+     * Set current paywall context
+     */
+    setCurrentPaywall(paywallId, placement) {
+        this.currentPaywallId = paywallId;
+        if (placement !== undefined) {
+            this.currentPlacement = placement;
+        }
+    }
+    /**
+     * Start onboarding tracking
+     */
+    startOnboardingTracking(onboardingId) {
+        this.currentOnboardingId = onboardingId;
+        this.onboardingStartTime = new Date();
+        this.currentFlowId = onboardingId;
+    }
+    /**
+     * Get onboarding duration in seconds
+     */
+    getOnboardingDurationSeconds() {
+        if (!this.onboardingStartTime)
+            return 0;
+        return Math.floor((Date.now() - this.onboardingStartTime.getTime()) / 1000);
+    }
+    /**
+     * End onboarding tracking
+     */
+    endOnboardingTracking() {
+        this.currentOnboardingId = null;
+        this.onboardingStartTime = null;
+        this.currentFlowId = null;
+    }
+    /**
+     * Get current onboarding ID
+     */
+    getCurrentOnboardingId() {
+        return this.currentOnboardingId;
+    }
+    /**
+     * Track an event
+     */
+    async track(eventName, properties = {}, contextOverrides) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        if (!this.initialized || !this.appId || !this.appUserId || !this.sessionId || !this.device) {
+            console.warn("[RampKit] EventManager: Not initialized, skipping event:", eventName);
+            return;
+        }
+        const eventId = generateEventIdSync();
+        const occurredAt = new Date().toISOString();
+        const context = {
+            screenName: (_a = contextOverrides === null || contextOverrides === void 0 ? void 0 : contextOverrides.screenName) !== null && _a !== void 0 ? _a : this.currentScreenName,
+            flowId: (_b = contextOverrides === null || contextOverrides === void 0 ? void 0 : contextOverrides.flowId) !== null && _b !== void 0 ? _b : this.currentFlowId,
+            variantId: (_c = contextOverrides === null || contextOverrides === void 0 ? void 0 : contextOverrides.variantId) !== null && _c !== void 0 ? _c : this.currentVariantId,
+            paywallId: (_d = contextOverrides === null || contextOverrides === void 0 ? void 0 : contextOverrides.paywallId) !== null && _d !== void 0 ? _d : this.currentPaywallId,
+            locale: (_f = (_e = contextOverrides === null || contextOverrides === void 0 ? void 0 : contextOverrides.locale) !== null && _e !== void 0 ? _e : this.baseContext.locale) !== null && _f !== void 0 ? _f : null,
+            regionCode: (_h = (_g = contextOverrides === null || contextOverrides === void 0 ? void 0 : contextOverrides.regionCode) !== null && _g !== void 0 ? _g : this.baseContext.regionCode) !== null && _h !== void 0 ? _h : null,
+            placement: (_j = contextOverrides === null || contextOverrides === void 0 ? void 0 : contextOverrides.placement) !== null && _j !== void 0 ? _j : this.currentPlacement,
+        };
+        const event = {
+            appId: this.appId,
+            appUserId: this.appUserId,
+            eventId,
+            eventName,
+            sessionId: this.sessionId,
+            occurredAt,
+            device: this.device,
+            context,
+            properties,
+        };
+        // Fire and forget - don't await
+        this.sendEvent(event);
+    }
+    /**
+     * Send event to backend (fire and forget)
+     */
+    async sendEvent(event) {
+        try {
+            const url = `${constants_1.ENDPOINTS.BASE_URL}${constants_1.ENDPOINTS.APP_USER_EVENTS}`;
+            const response = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    apikey: constants_1.SUPABASE_ANON_KEY,
+                    Authorization: `Bearer ${constants_1.SUPABASE_ANON_KEY}`,
+                },
+                body: JSON.stringify(event),
+            });
+            if (!response.ok) {
+                console.warn("[RampKit] EventManager: Failed to send event:", event.eventName, response.status);
+            }
+            else {
+                console.log("[RampKit] EventManager: Event sent:", event.eventName);
+            }
+        }
+        catch (error) {
+            console.warn("[RampKit] EventManager: Error sending event:", event.eventName, error);
+        }
+    }
+    // ============================================================================
+    // Convenience methods for specific event types
+    // ============================================================================
+    /**
+     * Track app session started
+     */
+    trackAppSessionStarted(isFirstLaunch, launchCount) {
+        this.track("app_session_started", { isFirstLaunch, launchCount });
+    }
+    /**
+     * Track app backgrounded
+     */
+    trackAppBackgrounded(sessionDurationSeconds) {
+        this.track("app_backgrounded", { sessionDurationSeconds });
+    }
+    /**
+     * Track app foregrounded
+     */
+    trackAppForegrounded() {
+        this.track("app_foregrounded", {});
+    }
+    /**
+     * Track screen view
+     */
+    trackScreenView(screenName, referrer) {
+        this.setCurrentScreen(screenName);
+        this.track("screen_view", { screenName, referrer });
+    }
+    /**
+     * Track CTA tap
+     */
+    trackCtaTap(buttonId, buttonText) {
+        this.track("cta_tap", { buttonId, buttonText });
+    }
+    /**
+     * Track onboarding started
+     */
+    trackOnboardingStarted(onboardingId, totalSteps) {
+        this.startOnboardingTracking(onboardingId);
+        this.track("onboarding_started", { onboardingId, totalSteps });
+    }
+    /**
+     * Track onboarding screen viewed
+     */
+    trackOnboardingScreenViewed(screenName, screenIndex, totalScreens, onboardingId) {
+        this.setCurrentScreen(screenName);
+        this.track("onboarding_screen_viewed", {
+            onboardingId: onboardingId || this.currentOnboardingId,
+            screenName,
+            screenIndex,
+            totalScreens,
+        });
+    }
+    /**
+     * Track onboarding question answered
+     */
+    trackOnboardingQuestionAnswered(questionId, answer, questionText, onboardingId) {
+        this.track("onboarding_question_answered", {
+            onboardingId: onboardingId || this.currentOnboardingId,
+            questionId,
+            answer,
+            questionText,
+        });
+    }
+    /**
+     * Track onboarding completed
+     */
+    trackOnboardingCompleted(completedSteps, totalSteps, onboardingId) {
+        const timeToCompleteSeconds = this.getOnboardingDurationSeconds();
+        this.track("onboarding_completed", {
+            onboardingId: onboardingId || this.currentOnboardingId,
+            timeToCompleteSeconds,
+            completedSteps,
+            totalSteps,
+        });
+        this.endOnboardingTracking();
+    }
+    /**
+     * Track onboarding abandoned
+     */
+    trackOnboardingAbandoned(reason, lastScreenName, onboardingId) {
+        const timeSpentSeconds = this.getOnboardingDurationSeconds();
+        this.track("onboarding_abandoned", {
+            onboardingId: onboardingId || this.currentOnboardingId,
+            reason,
+            lastScreenName,
+            timeSpentSeconds,
+        });
+        this.endOnboardingTracking();
+    }
+    /**
+     * Track notification prompt shown
+     */
+    trackNotificationsPromptShown() {
+        this.track("notifications_prompt_shown", {});
+    }
+    /**
+     * Track notification response
+     */
+    trackNotificationsResponse(status) {
+        this.track("notifications_response", { status });
+    }
+    /**
+     * Track paywall shown
+     */
+    trackPaywallShown(paywallId, placement, products) {
+        this.setCurrentPaywall(paywallId, placement);
+        this.track("paywall_shown", { paywallId, placement, products }, { paywallId, placement });
+    }
+    /**
+     * Track paywall primary action tap
+     */
+    trackPaywallPrimaryActionTap(paywallId, productId) {
+        this.track("paywall_primary_action_tap", { paywallId, productId }, { paywallId });
+    }
+    /**
+     * Track paywall closed
+     */
+    trackPaywallClosed(paywallId, reason) {
+        this.track("paywall_closed", { paywallId, reason }, { paywallId });
+        this.setCurrentPaywall(null);
+    }
+    /**
+     * Track purchase started
+     */
+    trackPurchaseStarted(productId, amount, currency) {
+        this.track("purchase_started", { productId, amount, currency });
+    }
+    /**
+     * Track purchase completed
+     */
+    trackPurchaseCompleted(properties) {
+        this.track("purchase_completed", properties);
+    }
+    /**
+     * Track purchase failed
+     */
+    trackPurchaseFailed(productId, errorCode, errorMessage) {
+        this.track("purchase_failed", { productId, errorCode, errorMessage });
+    }
+    /**
+     * Reset the event manager (e.g., on logout)
+     */
+    reset() {
+        this.appId = null;
+        this.appUserId = null;
+        this.sessionId = null;
+        this.device = null;
+        this.baseContext = {};
+        this.currentScreenName = null;
+        this.currentFlowId = null;
+        this.currentVariantId = null;
+        this.currentPaywallId = null;
+        this.currentPlacement = null;
+        this.onboardingStartTime = null;
+        this.currentOnboardingId = null;
+        this.initialized = false;
+    }
+}
+exports.EventManager = EventManager;
+exports.eventManager = EventManager.instance;

package/build/RampKit.d.ts

@@ -1,27 +1,109 @@
+/**
+ * RampKit Core SDK
+ * Main SDK class for RampKit Expo integration
+ */
+import { DeviceInfo, RampKitConfig, EventContext } from "./types";
 export declare class RampKitCore {
     private static _instance;
     private config;
     private onboardingData;
     private userId;
     private appId;
+    private deviceInfo;
     private onOnboardingFinished?;
     private onShowPaywall?;
-    private static readonly MANIFEST_BASE_URL;
+    private appStateSubscription;
+    private lastAppState;
+    private initialized;
     static get instance(): RampKitCore;
-    init(config: {
-        appId: string;
-        apiKey?: string;
-        environment?: string;
-        autoShowOnboarding?: boolean;
-        onOnboardingFinished?: (payload?: any) => void;
-        onShowPaywall?: (payload?: any) => void;
-        showPaywall?: (payload?: any) => void;
-    }): Promise<void>;
+    /**
+     * Initialize the RampKit SDK
+     */
+    init(config: RampKitConfig): Promise<void>;
+    /**
+     * Send user/device data to the /app-users endpoint
+     */
+    private sendUserDataToBackend;
+    /**
+     * Setup app state listener for background/foreground tracking
+     */
+    private setupAppStateListener;
+    /**
+     * Get the onboarding data
+     */
     getOnboardingData(): any;
+    /**
+     * Get the user ID
+     */
     getUserId(): string | null;
+    /**
+     * Get the device info
+     */
+    getDeviceInfo(): DeviceInfo | null;
+    /**
+     * Check if SDK is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Show the onboarding overlay
+     */
     showOnboarding(opts?: {
         onShowPaywall?: (payload?: any) => void;
         showPaywall?: (payload?: any) => void;
     }): void;
+    /**
+     * Close the onboarding overlay
+     */
     closeOnboarding(): void;
+    /**
+     * Track a custom event
+     */
+    trackEvent(eventName: string, properties?: Record<string, any>, context?: Partial<EventContext>): void;
+    /**
+     * Track a screen view
+     */
+    trackScreenView(screenName: string, referrer?: string): void;
+    /**
+     * Track a CTA tap
+     */
+    trackCtaTap(buttonId: string, buttonText?: string): void;
+    /**
+     * Track paywall shown
+     */
+    trackPaywallShown(paywallId: string, placement?: string, products?: Array<{
+        productId: string;
+        price?: number;
+        currency?: string;
+    }>): void;
+    /**
+     * Track paywall primary action tap
+     */
+    trackPaywallPrimaryActionTap(paywallId: string, productId?: string): void;
+    /**
+     * Track paywall closed
+     */
+    trackPaywallClosed(paywallId: string, reason: "dismissed" | "purchased" | "backgrounded"): void;
+    /**
+     * Track purchase started
+     */
+    trackPurchaseStarted(productId: string, amount?: number, currency?: string): void;
+    /**
+     * Track purchase completed
+     */
+    trackPurchaseCompleted(properties: {
+        productId: string;
+        amount: number;
+        currency: string;
+        transactionId: string;
+        originalTransactionId?: string;
+        purchaseDate?: string;
+    }): void;
+    /**
+     * Track purchase failed
+     */
+    trackPurchaseFailed(productId: string, errorCode: string, errorMessage: string): void;
+    /**
+     * Cleanup SDK resources
+     */
+    cleanup(): void;
 }