mobiqo-react-native 0.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mobiqo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,196 @@
+# Mobiqo React Native SDK
+
+**⚠️ THIS PLUGIN HAS TO BE USED ALONG WITH THE ANALYTICS SERVICE MOBIQO ⚠️**
+
+**👉 CREATE AN ACCOUNT HERE: https://getmobiqo.com?utm_source=npm**
+
+---
+
+A React Native library for integrating Mobiqo analytics into your mobile applications.
+
+## Installation
+
+```bash
+npm install mobiqo-react-native
+```
+
+### Peer Dependencies
+
+This library requires `@react-native-async-storage/async-storage` as a peer dependency. Install it separately:
+
+```bash
+npm install @react-native-async-storage/async-storage
+```
+
+For iOS, you'll also need to run:
+
+```bash
+cd ios && pod install
+```
+
+## Usage
+
+### Import the SDK
+
+```typescript
+import Mobiqo from 'mobiqo-react-native';
+import { EventType } from 'mobiqo-react-native';
+```
+
+### Initialize the service
+
+```typescript
+const mobiqo = new Mobiqo();
+
+// Initialize with your Mobiqo API key
+await mobiqo.init({ mobiqoKey: 'your-mobiqo-api-key' });
+```
+
+### Sync user data
+
+```typescript
+// With additional data (optional)
+await mobiqo.syncUser({
+  revenue_cat_user_id: 'user-123',
+  additional_data: {
+    email: 'user@example.com',
+    plan: 'premium'
+  }
+});
+
+// Without additional data
+await mobiqo.syncUser({
+  revenue_cat_user_id: 'user-123'
+});
+```
+
+### Track events
+
+```typescript
+// Track an event with additional data (optional)
+await mobiqo.trackEvent(
+  'button_clicked',
+  EventType.CLICK,
+  {
+    button_name: 'subscribe',
+    screen: 'home'
+  }
+);
+
+// Track an event without additional data
+await mobiqo.trackEvent('screen_opened', EventType.SCREEN_VIEW);
+```
+
+### Get user information
+
+```typescript
+const userInfo = await mobiqo.getUserInfo({
+  revenue_cat_user_id: 'user-123'
+});
+```
+
+### Automatic Session Tracking
+
+The SDK automatically sends heartbeats every 30 seconds after user sync to maintain session tracking. No manual intervention is required.
+
+## API Reference
+
+### Methods
+
+#### `init(options)`
+Initialize the Mobiqo service with your API key.
+- `options.mobiqoKey` (string): Your Mobiqo API key
+
+#### `syncUser(options)`
+Sync user data with Mobiqo and start a session.
+- `options.revenue_cat_user_id` (string): RevenueCat user ID
+- `options.additional_data` (Record<string, any>, optional): Additional user data
+
+#### `getUserInfo(options)`
+Retrieve user information from Mobiqo.
+- `options.revenue_cat_user_id` (string): RevenueCat user ID
+
+#### `trackEvent(event, eventType, additionalData?)`
+Track custom events.
+- `event` (string): Event name
+- `eventType` (EventType): Event type from the EventType enum
+- `additionalData` (Record<string, any>, optional): Additional event data
+
+### Event Types
+
+```typescript
+enum EventType {
+  CLICK = 'click',
+  ACTION = 'action',
+  SCREEN_VIEW = 'screen_view',
+  PAYWALL_VIEW = 'paywall_view',
+  PAYWALL_DISMISS = 'paywall_dismiss',
+  PURCHASE_ATTEMPT = 'purchase_attempt',
+  PURCHASE_SUCCESS = 'purchase_success',
+  FORM_SUBMIT = 'form_submit',
+  NAVIGATION = 'navigation',
+  ERROR = 'error',
+  CUSTOM = 'custom'
+}
+```
+
+### Response Interfaces
+
+#### `SyncUserResponse`
+```typescript
+interface SyncUserResponse {
+  isNewUser: boolean;
+  appUser: AppUser;
+  statistics: Statistics;
+}
+```
+
+#### `GetUserInfoResponse`
+```typescript
+interface GetUserInfoResponse {
+  appUser: AppUser;
+  statistics: Statistics;
+}
+```
+
+#### `AppUser`
+```typescript
+interface AppUser {
+  id: string;
+  project_id: string;
+  revenue_cat_user_id?: string;
+  mobiqo_username: string;
+  os: 'ios' | 'android';
+  os_version: string;
+  app_version: string;
+  country?: string;
+  language?: string;
+  first_seen_at: string;
+  last_seen_at: string;
+  active_entitlements: string[];
+}
+```
+
+#### `Statistics`
+```typescript
+interface Statistics {
+  purchasing_power_parity: number;
+  purchase_probability: number;
+  avg_arpu: number;
+  avg_arppu: number;
+  avg_ltv: number;
+}
+```
+
+## Requirements
+
+- React Native
+- TypeScript 4.0+
+
+## License
+
+MIT
+
+## Support
+
+For support and questions, please contact the Mobiqo team.

package/dist/EventType.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Event types for Mobiqo analytics tracking
+ *
+ * Use these predefined event types to categorize user interactions and behaviors.
+ * This helps with analytics reporting and filtering in the Mobiqo dashboard.
+ *
+ * @example
+ * ```typescript
+ * import { EventType } from 'mobiqo-capacitor';
+ *
+ * // Track different types of events
+ * await mobiqo.trackEvent('subscribe_button', EventType.CLICK, { location: 'home' });
+ * await mobiqo.trackEvent('paywall_shown', EventType.PAYWALL_VIEW);
+ * ```
+ */
+export declare enum EventType {
+    /** Button or UI element tapped/clicked */
+    CLICK = "click",
+    /** User performs an action */
+    ACTION = "action",
+    /** A screen/page is displayed to the user */
+    SCREEN_VIEW = "screen_view",
+    /** Paywall or subscription screen is shown */
+    PAYWALL_VIEW = "paywall_view",
+    /** User closes or dismisses paywall */
+    PAYWALL_DISMISS = "paywall_dismiss",
+    /** User initiates a purchase flow */
+    PURCHASE_ATTEMPT = "purchase_attempt",
+    /** In-app purchase completed successfully (if not using RevenueCat webhook) */
+    PURCHASE_SUCCESS = "purchase_success",
+    /** Form or input field submitted */
+    FORM_SUBMIT = "form_submit",
+    /** User navigates to another screen/section */
+    NAVIGATION = "navigation",
+    /** A handled error or issue occurred */
+    ERROR = "error",
+    /** Custom event type for user-defined cases */
+    CUSTOM = "custom"
+}

package/dist/EventType.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventType = void 0;
+/**
+ * Event types for Mobiqo analytics tracking
+ *
+ * Use these predefined event types to categorize user interactions and behaviors.
+ * This helps with analytics reporting and filtering in the Mobiqo dashboard.
+ *
+ * @example
+ * ```typescript
+ * import { EventType } from 'mobiqo-capacitor';
+ *
+ * // Track different types of events
+ * await mobiqo.trackEvent('subscribe_button', EventType.CLICK, { location: 'home' });
+ * await mobiqo.trackEvent('paywall_shown', EventType.PAYWALL_VIEW);
+ * ```
+ */
+var EventType;
+(function (EventType) {
+    /** Button or UI element tapped/clicked */
+    EventType["CLICK"] = "click";
+    /** User performs an action */
+    EventType["ACTION"] = "action";
+    /** A screen/page is displayed to the user */
+    EventType["SCREEN_VIEW"] = "screen_view";
+    /** Paywall or subscription screen is shown */
+    EventType["PAYWALL_VIEW"] = "paywall_view";
+    /** User closes or dismisses paywall */
+    EventType["PAYWALL_DISMISS"] = "paywall_dismiss";
+    /** User initiates a purchase flow */
+    EventType["PURCHASE_ATTEMPT"] = "purchase_attempt";
+    /** In-app purchase completed successfully (if not using RevenueCat webhook) */
+    EventType["PURCHASE_SUCCESS"] = "purchase_success";
+    /** Form or input field submitted */
+    EventType["FORM_SUBMIT"] = "form_submit";
+    /** User navigates to another screen/section */
+    EventType["NAVIGATION"] = "navigation";
+    /** A handled error or issue occurred */
+    EventType["ERROR"] = "error";
+    /** Custom event type for user-defined cases */
+    EventType["CUSTOM"] = "custom";
+})(EventType || (exports.EventType = EventType = {}));

package/dist/index.d.ts

@@ -0,0 +1,209 @@
+import { EventType } from "./EventType";
+export { EventType } from "./EventType";
+/**
+ * Mobiqo app user data structure
+ */
+export interface AppUser {
+    /** Internal Mobiqo user ID */
+    id: string;
+    /** Project ID this user belongs to */
+    project_id: string;
+    /** RevenueCat user identifier */
+    revenue_cat_user_id?: string;
+    /** Mobiqo-generated username */
+    mobiqo_username: string;
+    /** User's operating system */
+    os: 'ios' | 'android';
+    /** Operating system version */
+    os_version: string;
+    /** Application version */
+    app_version: string;
+    /** User's country code */
+    country?: string;
+    /** User's language preference */
+    language?: string;
+    /** Timestamp when user was first seen */
+    first_seen_at: string;
+    /** Timestamp when user was last seen */
+    last_seen_at: string;
+    /** Currently active entitlements/subscriptions */
+    active_entitlements: string[];
+}
+/**
+ * User analytics and prediction statistics
+ */
+export interface Statistics {
+    /** Purchasing power parity score */
+    purchasing_power_parity: number;
+    /** Predicted probability of making a purchase */
+    purchase_probability: number;
+    /** Average revenue per user */
+    avg_arpu: number;
+    /** Average revenue per paying user */
+    avg_arppu: number;
+    /** Average lifetime value */
+    avg_ltv: number;
+}
+/**
+ * Response from syncUser method
+ */
+export interface SyncUserResponse {
+    /** Whether this is a new user (first time syncing) */
+    isNewUser: boolean;
+    /** Complete user data */
+    appUser: AppUser;
+    /** User analytics and predictions */
+    statistics: Statistics;
+}
+/**
+ * Response from getUserInfo method
+ */
+export interface GetUserInfoResponse {
+    /** Complete user data */
+    appUser: AppUser;
+    /** User analytics and predictions */
+    statistics: Statistics;
+}
+/**
+ * Mobiqo Analytics Service for Capacitor apps
+ *
+ * This service provides analytics tracking, user management, and session handling
+ * for mobile applications using the Mobiqo platform.
+ *
+ * @example
+ * ```typescript
+ * import Mobiqo, { EventType, SyncUserResponse, AppUser } from 'mobiqo-capacitor';
+ *
+ * const mobiqo = new Mobiqo();
+ * await mobiqo.init({ mobiqoKey: 'your-api-key' });
+ *
+ * // Sync user with optional additional data
+ * const result: SyncUserResponse = await mobiqo.syncUser({
+ *   revenue_cat_user_id: 'user-123',
+ *   additional_data: { plan: 'premium' }
+ * });
+ * console.log('User OS:', result.appUser.os);
+ * console.log('Purchase probability:', result.statistics.purchase_probability);
+ *
+ * // Track events with optional additional data
+ * await mobiqo.trackEvent('button_clicked', EventType.CLICK, { screen: 'home' });
+ * await mobiqo.trackEvent('screen_viewed', EventType.SCREEN_VIEW);
+ * ```
+ */
+export default class Mobiqo {
+    private API_URL;
+    private heartbeatInterval;
+    /**
+     * Initialize the Mobiqo service with your API key
+     *
+     * This method must be called before using any other Mobiqo features.
+     * It validates your API key and stores the project ID for subsequent requests.
+     *
+     * @param options - Configuration options
+     * @param options.mobiqoKey - Your Mobiqo API key from the dashboard
+     * @returns Promise that resolves when initialization is complete
+     *
+     * @example
+     * ```typescript
+     * const mobiqo = new Mobiqo();
+     * await mobiqo.init({ mobiqoKey: 'your-mobiqo-api-key' });
+     * ```
+     */
+    init({ mobiqoKey }: {
+        mobiqoKey: string;
+    }): Promise<void>;
+    /**
+     * Sync user data with Mobiqo and start a tracking session
+     *
+     * This method links a RevenueCat user ID with Mobiqo analytics and starts
+     * automatic heartbeat tracking (every 30 seconds). Call this after user login
+     * or when you want to start tracking a user's session.
+     *
+     * @param options - User sync options
+     * @param options.revenue_cat_user_id - The RevenueCat user identifier
+     * @param options.additional_data - Optional extra user data to store (email, plan, etc.)
+     * @returns Promise that resolves with user sync response including user data and statistics
+     *
+     * @example
+     * ```typescript
+     * // With additional data
+     * await mobiqo.syncUser({
+     *   revenue_cat_user_id: 'user-123',
+     *   additional_data: {
+     *     email: 'user@example.com',
+     *     plan: 'premium',
+     *     signupDate: '2024-01-01'
+     *   }
+     * });
+     *
+     * // Without additional data
+     * await mobiqo.syncUser({
+     *   revenue_cat_user_id: 'user-123'
+     * });
+     * ```
+     */
+    syncUser({ revenue_cat_user_id, additional_data }: {
+        revenue_cat_user_id: string;
+        additional_data?: Record<string, any>;
+    }): Promise<SyncUserResponse | undefined>;
+    /**
+     * Retrieve user information from Mobiqo
+     *
+     * Fetches stored user data and analytics information for a specific user.
+     * Useful for displaying user stats or personalizing the app experience.
+     *
+     * @param options - User lookup options
+     * @param options.revenue_cat_user_id - The RevenueCat user identifier to look up
+     * @returns Promise that resolves with user information including user data and statistics
+     *
+     * @example
+     * ```typescript
+     * const userInfo = await mobiqo.getUserInfo({
+     *   revenue_cat_user_id: 'user-123'
+     * });
+     * console.log('User OS:', userInfo.appUser.os);
+     * console.log('Purchase probability:', userInfo.statistics.purchase_probability);
+     * ```
+     */
+    getUserInfo({ revenue_cat_user_id }: {
+        revenue_cat_user_id: string;
+    }): Promise<GetUserInfoResponse | undefined>;
+    /**
+     * Track a custom event with Mobiqo analytics
+     *
+     * Records user interactions, behaviors, and custom events for analytics.
+     * Events are automatically timestamped and associated with the current user session.
+     *
+     * @param event - Name/identifier for the event (e.g., 'button_clicked', 'screen_viewed')
+     * @param eventType - Type of event from EventType enum (CLICK, SCREEN_VIEW, etc.)
+     * @param additionalData - Optional custom data to attach to the event
+     * @returns Promise that resolves with tracking confirmation
+     *
+     * @example
+     * ```typescript
+     * // Track a button click with additional data
+     * await mobiqo.trackEvent(
+     *   'subscribe_button_clicked',
+     *   EventType.CLICK,
+     *   {
+     *     button_location: 'home_screen',
+     *     user_plan: 'free'
+     *   }
+     * );
+     *
+     * // Track a screen view without additional data
+     * await mobiqo.trackEvent('settings_screen', EventType.SCREEN_VIEW);
+     * ```
+     */
+    trackEvent(event: string, eventType: EventType, additionalData?: Record<string, any>): Promise<any>;
+    /**
+     * Send a heartbeat to maintain the user session
+     *
+     * Heartbeats are automatically sent every 30 seconds after syncUser() is called.
+     * This helps track active session duration and is handled internally by the SDK.
+     *
+     * @returns Promise that resolves with heartbeat confirmation
+     * @private
+     */
+    private sendHeartbeat;
+}

package/dist/index.js

@@ -0,0 +1,288 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventType = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+var EventType_1 = require("./EventType");
+Object.defineProperty(exports, "EventType", { enumerable: true, get: function () { return EventType_1.EventType; } });
+/**
+ * Mobiqo Analytics Service for Capacitor apps
+ *
+ * This service provides analytics tracking, user management, and session handling
+ * for mobile applications using the Mobiqo platform.
+ *
+ * @example
+ * ```typescript
+ * import Mobiqo, { EventType, SyncUserResponse, AppUser } from 'mobiqo-capacitor';
+ *
+ * const mobiqo = new Mobiqo();
+ * await mobiqo.init({ mobiqoKey: 'your-api-key' });
+ *
+ * // Sync user with optional additional data
+ * const result: SyncUserResponse = await mobiqo.syncUser({
+ *   revenue_cat_user_id: 'user-123',
+ *   additional_data: { plan: 'premium' }
+ * });
+ * console.log('User OS:', result.appUser.os);
+ * console.log('Purchase probability:', result.statistics.purchase_probability);
+ *
+ * // Track events with optional additional data
+ * await mobiqo.trackEvent('button_clicked', EventType.CLICK, { screen: 'home' });
+ * await mobiqo.trackEvent('screen_viewed', EventType.SCREEN_VIEW);
+ * ```
+ */
+class Mobiqo {
+    constructor() {
+        this.API_URL = "https://us-central1-mobiqo-582b4.cloudfunctions.net";
+        this.heartbeatInterval = null;
+    }
+    /**
+     * Initialize the Mobiqo service with your API key
+     *
+     * This method must be called before using any other Mobiqo features.
+     * It validates your API key and stores the project ID for subsequent requests.
+     *
+     * @param options - Configuration options
+     * @param options.mobiqoKey - Your Mobiqo API key from the dashboard
+     * @returns Promise that resolves when initialization is complete
+     *
+     * @example
+     * ```typescript
+     * const mobiqo = new Mobiqo();
+     * await mobiqo.init({ mobiqoKey: 'your-mobiqo-api-key' });
+     * ```
+     */
+    init(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ mobiqoKey }) {
+            try {
+                const response = yield fetch(this.API_URL + "/init", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify({ mobiqoKey })
+                });
+                const responseData = yield response.json();
+                if (!responseData.authorized) {
+                    yield async_storage_1.default.removeItem('mobiqo_project_id');
+                    console.error('Project not found or not authorized');
+                    return;
+                }
+                yield async_storage_1.default.setItem('mobiqo_project_id', responseData.project.id);
+            }
+            catch (error) {
+                console.error('Error initializing Mobiqo', error);
+                return;
+            }
+        });
+    }
+    /**
+     * Sync user data with Mobiqo and start a tracking session
+     *
+     * This method links a RevenueCat user ID with Mobiqo analytics and starts
+     * automatic heartbeat tracking (every 30 seconds). Call this after user login
+     * or when you want to start tracking a user's session.
+     *
+     * @param options - User sync options
+     * @param options.revenue_cat_user_id - The RevenueCat user identifier
+     * @param options.additional_data - Optional extra user data to store (email, plan, etc.)
+     * @returns Promise that resolves with user sync response including user data and statistics
+     *
+     * @example
+     * ```typescript
+     * // With additional data
+     * await mobiqo.syncUser({
+     *   revenue_cat_user_id: 'user-123',
+     *   additional_data: {
+     *     email: 'user@example.com',
+     *     plan: 'premium',
+     *     signupDate: '2024-01-01'
+     *   }
+     * });
+     *
+     * // Without additional data
+     * await mobiqo.syncUser({
+     *   revenue_cat_user_id: 'user-123'
+     * });
+     * ```
+     */
+    syncUser(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ revenue_cat_user_id, additional_data }) {
+            try {
+                const project_id = yield async_storage_1.default.getItem('mobiqo_project_id');
+                if (!project_id) {
+                    console.error('Project ID not found');
+                    return;
+                }
+                const response = yield fetch(this.API_URL + "/linkUser", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify({ revenue_cat_user_id, project_id, additional_data, local_timestamp: new Date().getTime() })
+                });
+                const responseData = yield response.json();
+                yield async_storage_1.default.setItem('mobiqo_session_id', responseData.sessionId);
+                // Initialize heartbeat interval if not already running
+                if (!this.heartbeatInterval) {
+                    this.heartbeatInterval = setInterval(() => {
+                        this.sendHeartbeat();
+                    }, 30000); // 30 seconds
+                }
+                return responseData;
+            }
+            catch (error) {
+                console.error('Error linking user to Mobiqo', error);
+                return;
+            }
+        });
+    }
+    /**
+     * Retrieve user information from Mobiqo
+     *
+     * Fetches stored user data and analytics information for a specific user.
+     * Useful for displaying user stats or personalizing the app experience.
+     *
+     * @param options - User lookup options
+     * @param options.revenue_cat_user_id - The RevenueCat user identifier to look up
+     * @returns Promise that resolves with user information including user data and statistics
+     *
+     * @example
+     * ```typescript
+     * const userInfo = await mobiqo.getUserInfo({
+     *   revenue_cat_user_id: 'user-123'
+     * });
+     * console.log('User OS:', userInfo.appUser.os);
+     * console.log('Purchase probability:', userInfo.statistics.purchase_probability);
+     * ```
+     */
+    getUserInfo(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ revenue_cat_user_id }) {
+            try {
+                const project_id = yield async_storage_1.default.getItem('mobiqo_project_id');
+                if (!project_id) {
+                    console.error('Project ID not found');
+                    return;
+                }
+                const response = yield fetch(this.API_URL + "/getAppUser", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify({ revenue_cat_user_id })
+                });
+                const responseData = yield response.json();
+                return responseData;
+            }
+            catch (error) {
+                console.error('Error getting user info', error);
+                return;
+            }
+        });
+    }
+    /**
+     * Track a custom event with Mobiqo analytics
+     *
+     * Records user interactions, behaviors, and custom events for analytics.
+     * Events are automatically timestamped and associated with the current user session.
+     *
+     * @param event - Name/identifier for the event (e.g., 'button_clicked', 'screen_viewed')
+     * @param eventType - Type of event from EventType enum (CLICK, SCREEN_VIEW, etc.)
+     * @param additionalData - Optional custom data to attach to the event
+     * @returns Promise that resolves with tracking confirmation
+     *
+     * @example
+     * ```typescript
+     * // Track a button click with additional data
+     * await mobiqo.trackEvent(
+     *   'subscribe_button_clicked',
+     *   EventType.CLICK,
+     *   {
+     *     button_location: 'home_screen',
+     *     user_plan: 'free'
+     *   }
+     * );
+     *
+     * // Track a screen view without additional data
+     * await mobiqo.trackEvent('settings_screen', EventType.SCREEN_VIEW);
+     * ```
+     */
+    trackEvent(event, eventType, additionalData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                additionalData = additionalData || {};
+                const session_id = yield async_storage_1.default.getItem('mobiqo_session_id');
+                if (!session_id) {
+                    console.error('Session ID not found');
+                    return;
+                }
+                additionalData.local_timestamp = new Date().getTime();
+                const response = yield fetch(this.API_URL + "/trackEvent", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify({ event_name: event, event_type: eventType, session_id, additional_data: additionalData })
+                });
+                const responseData = yield response.json();
+                return responseData;
+                // send event
+                // additionalData is a dictionary of key-value pairs that will be sent to the Mobiqo API
+                // additionalData will be sent to the Mobiqo API as a JSON object
+                // additionalData will be sent to the Mobiqo API as a JSON object
+            }
+            catch (error) {
+                console.error('Error tracking event', error);
+                return;
+            }
+        });
+    }
+    /**
+     * Send a heartbeat to maintain the user session
+     *
+     * Heartbeats are automatically sent every 30 seconds after syncUser() is called.
+     * This helps track active session duration and is handled internally by the SDK.
+     *
+     * @returns Promise that resolves with heartbeat confirmation
+     * @private
+     */
+    sendHeartbeat() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const session_id = yield async_storage_1.default.getItem('mobiqo_session_id');
+                if (!session_id) {
+                    console.error('Session ID not found');
+                    return;
+                }
+                const response = yield fetch(this.API_URL + "/heartbeat", {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify({ session_id })
+                });
+                const responseData = yield response.json();
+                // Update session ID if a new one is provided
+                if (responseData.sessionId) {
+                    yield async_storage_1.default.setItem('mobiqo_session_id', responseData.sessionId);
+                }
+                return responseData;
+            }
+            catch (error) {
+                console.error('Error sending heartbeat:', error);
+            }
+        });
+    }
+}
+exports.default = Mobiqo;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "mobiqo-react-native",
+  "version": "0.0.5",
+  "description": "Mobiqo SDK for Capacitor apps - Mobile analytics and user tracking",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "echo \"No tests specified\" && exit 0",
+    "publish": "npm run prepublishOnly && npm publish"
+  },
+  "keywords": [
+    "typescript",
+    "capacitor",
+    "mobiqo",
+    "analytics",
+    "mobile",
+    "tracking",
+    "sdk",
+    "revenueCat",
+    "user-analytics"
+  ],
+  "author": "Mobiqo",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mobiqo/mobiqo-capacitor.git"
+  },
+  "homepage": "https://github.com/mobiqo/mobiqo-capacitor#readme",
+  "bugs": {
+    "url": "https://github.com/mobiqo/mobiqo-capacitor/issues"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3",
+    "@react-native-async-storage/async-storage": "^1.19.0"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": ">=1.19.0"
+  },
+  "dependencies": {}
+}