riuve-rn 1.0.0

package/dist/core/Storage.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Storage Layer - AsyncStorage Wrapper
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storage = void 0;
+const async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+const constants_1 = require("../constants");
+const logger_1 = require("../utils/logger");
+class Storage {
+    /**
+     * Sets a value in storage
+     */
+    async set(key, value) {
+        try {
+            const storageKey = constants_1.STORAGE_KEYS[key];
+            const serialized = JSON.stringify(value);
+            await async_storage_1.default.setItem(storageKey, serialized);
+            // Removed verbose debug logging for production
+        }
+        catch (error) {
+            logger_1.logger.error(`Storage set failed for ${key}:`, error);
+            throw new Error(`${constants_1.ERROR_MESSAGES.STORAGE_ERROR}: ${error.message}`);
+        }
+    }
+    /**
+     * Gets a value from storage
+     */
+    async get(key) {
+        try {
+            const storageKey = constants_1.STORAGE_KEYS[key];
+            const serialized = await async_storage_1.default.getItem(storageKey);
+            if (serialized === null) {
+                return null;
+            }
+            const value = JSON.parse(serialized);
+            return value;
+        }
+        catch (error) {
+            logger_1.logger.error(`Storage get failed for ${key}:`, error);
+            throw new Error(`${constants_1.ERROR_MESSAGES.STORAGE_ERROR}: ${error.message}`);
+        }
+    }
+    /**
+     * Removes a value from storage
+     */
+    async remove(key) {
+        try {
+            const storageKey = constants_1.STORAGE_KEYS[key];
+            await async_storage_1.default.removeItem(storageKey);
+            // Removed verbose debug logging for production
+        }
+        catch (error) {
+            logger_1.logger.error(`Storage remove failed for ${key}:`, error);
+            throw new Error(`${constants_1.ERROR_MESSAGES.STORAGE_ERROR}: ${error.message}`);
+        }
+    }
+    /**
+     * Clears all SDK-related storage
+     */
+    async clear() {
+        try {
+            const keys = Object.values(constants_1.STORAGE_KEYS);
+            await async_storage_1.default.multiRemove(keys);
+            // Removed verbose info logging for production
+        }
+        catch (error) {
+            logger_1.logger.error('Storage clear failed:', error);
+            throw new Error(`${constants_1.ERROR_MESSAGES.STORAGE_ERROR}: ${error.message}`);
+        }
+    }
+    /**
+     * Checks if a key exists in storage
+     */
+    async has(key) {
+        try {
+            const value = await this.get(key);
+            return value !== null;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+exports.storage = new Storage();

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Riuve React Native SDK
+ * Main export file
+ */
+import Riuve from './Riuve';
+export default Riuve;
+export type { RiuveConfig, RiuveConfigInput, Event, DeviceInfo, EventBatch, FailedBatch, InitializeRequest, InitializeResponse, IdentifyRequest, IdentifyResponse, TrackRequest, TrackResponse, SetFcmTokenRequest, SetFcmTokenResponse, ApiError, ErrorType, } from './types';
+export { DEFAULT_CONFIG, ERROR_MESSAGES } from './constants';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,MAAM,SAAS,CAAC;AAG5B,eAAe,KAAK,CAAC;AAGrB,YAAY,EACV,WAAW,EACX,gBAAgB,EAChB,KAAK,EACL,UAAU,EACV,UAAU,EACV,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,QAAQ,EACR,SAAS,GACV,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Riuve React Native SDK
+ * Main export file
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_MESSAGES = exports.DEFAULT_CONFIG = void 0;
+const Riuve_1 = __importDefault(require("./Riuve"));
+// Export the SDK instance as default
+exports.default = Riuve_1.default;
+// Export constants for advanced users
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "DEFAULT_CONFIG", { enumerable: true, get: function () { return constants_1.DEFAULT_CONFIG; } });
+Object.defineProperty(exports, "ERROR_MESSAGES", { enumerable: true, get: function () { return constants_1.ERROR_MESSAGES; } });

package/dist/managers/BatchManager.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Batch Manager - Orchestrates batch sending and offline queue
+ */
+import { EventQueue } from '../core/EventQueue';
+import { ApiClient } from '../core/ApiClient';
+import { NetworkManager } from './NetworkManager';
+import { IdentityManager } from './IdentityManager';
+import type { Event } from '../types';
+export declare class BatchManager {
+    private eventQueue;
+    private apiClient;
+    private networkManager;
+    private identityManager;
+    private isFlushing;
+    private eventRetentionDays;
+    constructor(eventQueue: EventQueue, apiClient: ApiClient, networkManager: NetworkManager, identityManager: IdentityManager, eventRetentionDays: number);
+    /**
+     * Sends a batch of events to the API
+     */
+    sendBatch(events: Event[]): Promise<void>;
+    /**
+     * Saves a failed batch for later retry
+     */
+    private saveFailedBatch;
+    /**
+     * Flushes the offline queue (retries failed batches)
+     */
+    flushOfflineQueue(): Promise<void>;
+    /**
+     * Validates UUID format (8-4-4-4-12 hex characters)
+     */
+    private isValidUUID;
+    /**
+     * Fixes invalid event IDs in a batch
+     */
+    private fixEventIds;
+    /**
+     * Processes and retries failed batches
+     */
+    private processFailedBatches;
+    /**
+     * Gets the count of failed batches
+     */
+    getFailedBatchCount(): Promise<number>;
+    /**
+     * Clears all failed batches
+     */
+    clearFailedBatches(): Promise<void>;
+}
+//# sourceMappingURL=BatchManager.d.ts.map

package/dist/managers/BatchManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BatchManager.d.ts","sourceRoot":"","sources":["../../src/managers/BatchManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,UAAU,CAAC;AAGnD,qBAAa,YAAY;IACvB,OAAO,CAAC,UAAU,CAAa;IAC/B,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,kBAAkB,CAAS;gBAGjC,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,SAAS,EACpB,cAAc,EAAE,cAAc,EAC9B,eAAe,EAAE,eAAe,EAChC,kBAAkB,EAAE,MAAM;IAsB5B;;OAEG;IACG,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAsF/C;;OAEG;YACW,eAAe;IAoC7B;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAYxC;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB;;OAEG;IACH,OAAO,CAAC,WAAW;IAqBnB;;OAEG;YACW,oBAAoB;IAuElC;;OAEG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC;IAU5C;;OAEG;IACG,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ1C"}

package/dist/managers/BatchManager.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * Batch Manager - Orchestrates batch sending and offline queue
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchManager = void 0;
+const uuid_1 = require("../utils/uuid");
+const Storage_1 = require("../core/Storage");
+const logger_1 = require("../utils/logger");
+class BatchManager {
+    constructor(eventQueue, apiClient, networkManager, identityManager, eventRetentionDays) {
+        this.isFlushing = false;
+        this.eventQueue = eventQueue;
+        this.apiClient = apiClient;
+        this.networkManager = networkManager;
+        this.identityManager = identityManager;
+        this.eventRetentionDays = eventRetentionDays;
+        // Set flush callback on event queue
+        this.eventQueue.setFlushCallback((events) => this.sendBatch(events));
+        // Listen for network status changes
+        this.networkManager.onStatusChange((isOnline) => {
+            if (isOnline) {
+                logger_1.logger.info('Network came online, processing offline queue...');
+                this.flushOfflineQueue().catch((error) => {
+                    logger_1.logger.error('Failed to flush offline queue:', error);
+                });
+            }
+        });
+    }
+    /**
+     * Sends a batch of events to the API
+     */
+    async sendBatch(events) {
+        if (events.length === 0) {
+            return;
+        }
+        // Check if online
+        if (!this.networkManager.isConnected()) {
+            logger_1.logger.warn('Offline, events will be stored for later');
+            logger_1.logger.warn(`  Events not sent: ${events.length} events`);
+            events.forEach((event, index) => {
+                logger_1.logger.warn(`    ${index + 1}. ${event.name} (id: ${event.id}, timestamp: ${new Date(event.timestamp).toISOString()})`);
+            });
+            await this.saveFailedBatch(events, 'Network offline');
+            return;
+        }
+        // Prevent concurrent flushes
+        if (this.isFlushing) {
+            logger_1.logger.debug('Already flushing, skipping...');
+            return;
+        }
+        this.isFlushing = true;
+        const startTime = Date.now();
+        try {
+            logger_1.logger.info(`Sending batch: ${events.length} events`);
+            if (events.length <= 5) {
+                logger_1.logger.info(`  Events:`);
+                events.forEach((event, index) => {
+                    logger_1.logger.info(`    ${index + 1}. ${event.name} (id: ${event.id.substring(0, 8)}...)`);
+                });
+            }
+            else {
+                logger_1.logger.info(`  Events: ${events.map(e => e.name).join(', ')}`);
+            }
+            const anonymousId = this.identityManager.getAnonymousId();
+            const externalUserId = this.identityManager.getExternalUserId();
+            if (!anonymousId) {
+                throw new Error('Anonymous ID not set');
+            }
+            logger_1.logger.info(`  Anonymous ID: ${anonymousId}`);
+            if (externalUserId) {
+                logger_1.logger.info(`  External User ID: ${externalUserId}`);
+            }
+            // Send to API
+            const response = await this.apiClient.track({
+                anonymous_id: anonymousId,
+                external_user_id: externalUserId || undefined,
+                events,
+            });
+            const responseTime = Date.now() - startTime;
+            logger_1.logger.info(`Batch sent successfully`);
+            logger_1.logger.info(`  Processed: ${response.processed}/${events.length} events`);
+            logger_1.logger.info(`  Response time: ${responseTime}ms`);
+            if (response.processed < events.length) {
+                logger_1.logger.warn(`  Warning: Only ${response.processed} out of ${events.length} events were processed`);
+            }
+        }
+        catch (error) {
+            const responseTime = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            logger_1.logger.error(`Failed to send batch (${responseTime}ms): ${errorMessage}`);
+            if (events.length <= 5) {
+                logger_1.logger.error(`  Events not sent:`);
+                events.forEach((event, index) => {
+                    logger_1.logger.error(`    ${index + 1}. ${event.name} (id: ${event.id.substring(0, 8)}...)`);
+                });
+            }
+            else {
+                logger_1.logger.error(`  Events not sent: ${events.length} events (${events.map(e => e.name).join(', ')})`);
+            }
+            // Save as failed batch for retry
+            await this.saveFailedBatch(events, errorMessage);
+            throw error;
+        }
+        finally {
+            this.isFlushing = false;
+        }
+    }
+    /**
+     * Saves a failed batch for later retry
+     */
+    async saveFailedBatch(events, errorMessage) {
+        try {
+            const failedBatch = {
+                id: (0, uuid_1.generateUUID)(),
+                events,
+                failedAt: Date.now(),
+                retryCount: 0,
+                lastError: errorMessage,
+            };
+            // Get existing failed batches
+            const existingBatches = (await Storage_1.storage.get('FAILED_BATCHES')) || [];
+            // Add new failed batch
+            existingBatches.push(failedBatch);
+            // Save back to storage
+            await Storage_1.storage.set('FAILED_BATCHES', existingBatches);
+            logger_1.logger.warn(`Saved failed batch: ${failedBatch.id.substring(0, 8)}...`);
+            logger_1.logger.warn(`  Events: ${events.length} events`);
+            logger_1.logger.warn(`  Error: ${errorMessage}`);
+            if (events.length <= 5) {
+                logger_1.logger.warn(`  Events in failed batch:`);
+                events.forEach((event, index) => {
+                    logger_1.logger.warn(`    ${index + 1}. ${event.name} (id: ${event.id.substring(0, 8)}...)`);
+                });
+            }
+            else {
+                logger_1.logger.warn(`  Events: ${events.map(e => e.name).join(', ')}`);
+            }
+            logger_1.logger.warn(`  Total failed batches: ${existingBatches.length}`);
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to save failed batch:', error);
+        }
+    }
+    /**
+     * Flushes the offline queue (retries failed batches)
+     */
+    async flushOfflineQueue() {
+        // First, process any failed batches
+        await this.processFailedBatches();
+        // Then, flush any events in the current queue
+        try {
+            await this.eventQueue.flush();
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to flush event queue:', error);
+        }
+    }
+    /**
+     * Validates UUID format (8-4-4-4-12 hex characters)
+     */
+    isValidUUID(uuid) {
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        return uuidRegex.test(uuid);
+    }
+    /**
+     * Fixes invalid event IDs in a batch
+     */
+    fixEventIds(events) {
+        let fixedCount = 0;
+        const fixedEvents = events.map((event) => {
+            if (!this.isValidUUID(event.id)) {
+                logger_1.logger.warn(`Invalid event ID detected: ${event.id}. Generating new ID.`);
+                fixedCount++;
+                return {
+                    ...event,
+                    id: (0, uuid_1.generateUUID)(),
+                };
+            }
+            return event;
+        });
+        if (fixedCount > 0) {
+            logger_1.logger.info(`Fixed ${fixedCount} invalid event IDs in batch`);
+        }
+        return fixedEvents;
+    }
+    /**
+     * Processes and retries failed batches
+     */
+    async processFailedBatches() {
+        try {
+            const failedBatches = (await Storage_1.storage.get('FAILED_BATCHES')) || [];
+            if (failedBatches.length === 0) {
+                logger_1.logger.debug('No failed batches to process');
+                return;
+            }
+            logger_1.logger.info(`Processing ${failedBatches.length} failed batches...`);
+            const successfulBatches = [];
+            const updatedBatches = [];
+            let discardedCount = 0;
+            for (const batch of failedBatches) {
+                // Check if batch is too old (exceeded retention period)
+                const age = Date.now() - batch.failedAt;
+                const maxAge = this.eventRetentionDays * 24 * 60 * 60 * 1000;
+                if (age > maxAge) {
+                    const ageDays = Math.floor(age / (24 * 60 * 60 * 1000));
+                    logger_1.logger.warn(`Batch ${batch.id} is too old (${ageDays} days), discarding`);
+                    logger_1.logger.warn(`  Events discarded: ${batch.events.length} events`);
+                    batch.events.forEach((event, index) => {
+                        logger_1.logger.warn(`    ${index + 1}. ${event.name} (id: ${event.id})`);
+                    });
+                    discardedCount++;
+                    continue;
+                }
+                logger_1.logger.info(`Retrying failed batch: ${batch.id}`);
+                logger_1.logger.info(`  Previous error: ${batch.lastError}`);
+                logger_1.logger.info(`  Retry attempt: ${batch.retryCount + 1}`);
+                logger_1.logger.info(`  Events: ${batch.events.length} events`);
+                // Fix invalid event IDs before retrying
+                const fixedEvents = this.fixEventIds(batch.events);
+                // Try to send the batch
+                try {
+                    await this.sendBatch(fixedEvents);
+                    successfulBatches.push(batch.id);
+                    logger_1.logger.info(`Successfully retried batch ${batch.id}`);
+                    logger_1.logger.info(`  Events sent: ${batch.events.length} events`);
+                }
+                catch (error) {
+                    // Update retry count and error, but use fixed events
+                    batch.retryCount += 1;
+                    batch.lastError = error instanceof Error ? error.message : 'Unknown error';
+                    batch.events = fixedEvents; // Update with fixed events
+                    updatedBatches.push(batch);
+                    logger_1.logger.warn(`Failed to retry batch ${batch.id} (attempt ${batch.retryCount}):`, error);
+                    logger_1.logger.warn(`  Error: ${batch.lastError}`);
+                    logger_1.logger.warn(`  Events still failed: ${batch.events.length} events`);
+                }
+            }
+            // Update storage with remaining failed batches
+            await Storage_1.storage.set('FAILED_BATCHES', updatedBatches);
+            logger_1.logger.info(`Processed failed batches:`);
+            logger_1.logger.info(`  Succeeded: ${successfulBatches.length}`);
+            logger_1.logger.info(`  Still failed: ${updatedBatches.length}`);
+            logger_1.logger.info(`  Discarded (too old): ${discardedCount}`);
+            logger_1.logger.info(`  Total processed: ${failedBatches.length}`);
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to process failed batches:', error);
+        }
+    }
+    /**
+     * Gets the count of failed batches
+     */
+    async getFailedBatchCount() {
+        try {
+            const failedBatches = (await Storage_1.storage.get('FAILED_BATCHES')) || [];
+            return failedBatches.length;
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to get failed batch count:', error);
+            return 0;
+        }
+    }
+    /**
+     * Clears all failed batches
+     */
+    async clearFailedBatches() {
+        try {
+            await Storage_1.storage.set('FAILED_BATCHES', []);
+            logger_1.logger.info('Cleared all failed batches');
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to clear failed batches:', error);
+        }
+    }
+}
+exports.BatchManager = BatchManager;

package/dist/managers/IdentityManager.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Identity Manager - Manages user identity
+ */
+export declare class IdentityManager {
+    private anonymousId;
+    private externalUserId;
+    private userProperties;
+    /**
+     * Validates UUID format (8-4-4-4-12 hex characters)
+     */
+    private isValidUUID;
+    /**
+     * Initializes the identity manager
+     * Generates or loads anonymous ID from storage
+     */
+    initialize(): Promise<string>;
+    /**
+     * Identifies a user with an external user ID and optional properties
+     */
+    identify(externalUserId: string, properties?: Record<string, any>): Promise<void>;
+    /**
+     * Resets the user identity
+     * Generates a new anonymous ID and clears external user ID and properties
+     */
+    reset(): Promise<void>;
+    /**
+     * Updates user properties (merges with existing)
+     */
+    updateUserProperties(properties: Record<string, any>): Promise<void>;
+    /**
+     * Gets the anonymous ID
+     */
+    getAnonymousId(): string | null;
+    /**
+     * Gets the external user ID
+     */
+    getExternalUserId(): string | null;
+    /**
+     * Gets user properties
+     */
+    getUserProperties(): Record<string, any>;
+    /**
+     * Checks if the user is identified
+     */
+    isIdentified(): boolean;
+}
+//# sourceMappingURL=IdentityManager.d.ts.map

package/dist/managers/IdentityManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IdentityManager.d.ts","sourceRoot":"","sources":["../../src/managers/IdentityManager.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,qBAAa,eAAe;IAC1B,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,cAAc,CAA2B;IAEjD;;OAEG;IACH,OAAO,CAAC,WAAW;IAKnB;;;OAGG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAkCnC;;OAEG;IACG,QAAQ,CACZ,cAAc,EAAE,MAAM,EACtB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAC/B,OAAO,CAAC,IAAI,CAAC;IAyBhB;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB5B;;OAEG;IACG,oBAAoB,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAY1E;;OAEG;IACH,cAAc,IAAI,MAAM,GAAG,IAAI;IAI/B;;OAEG;IACH,iBAAiB,IAAI,MAAM,GAAG,IAAI;IAIlC;;OAEG;IACH,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAIxC;;OAEG;IACH,YAAY,IAAI,OAAO;CAGxB"}

package/dist/managers/IdentityManager.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Identity Manager - Manages user identity
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityManager = void 0;
+const uuid_1 = require("../utils/uuid");
+const Storage_1 = require("../core/Storage");
+const logger_1 = require("../utils/logger");
+const validators_1 = require("../utils/validators");
+class IdentityManager {
+    constructor() {
+        this.anonymousId = null;
+        this.externalUserId = null;
+        this.userProperties = {};
+    }
+    /**
+     * Validates UUID format (8-4-4-4-12 hex characters)
+     */
+    isValidUUID(uuid) {
+        const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        return uuidRegex.test(uuid);
+    }
+    /**
+     * Initializes the identity manager
+     * Generates or loads anonymous ID from storage
+     */
+    async initialize() {
+        // Try to load existing anonymous ID from storage
+        const storedAnonymousId = await Storage_1.storage.get('ANONYMOUS_ID');
+        if (storedAnonymousId && this.isValidUUID(storedAnonymousId)) {
+            logger_1.logger.info(`Loaded existing anonymous ID: ${storedAnonymousId}`);
+            this.anonymousId = storedAnonymousId;
+        }
+        else {
+            // Generate new anonymous ID if none exists or if stored one is invalid
+            if (storedAnonymousId && !this.isValidUUID(storedAnonymousId)) {
+                logger_1.logger.warn(`Invalid UUID format detected: ${storedAnonymousId}. Generating new UUID.`);
+            }
+            this.anonymousId = (0, uuid_1.generateUUID)();
+            await Storage_1.storage.set('ANONYMOUS_ID', this.anonymousId);
+            logger_1.logger.info(`Generated new anonymous ID: ${this.anonymousId}`);
+        }
+        // Load external user ID if it exists
+        const storedExternalUserId = await Storage_1.storage.get('EXTERNAL_USER_ID');
+        if (storedExternalUserId) {
+            this.externalUserId = storedExternalUserId;
+            logger_1.logger.info(`Loaded external user ID: ${this.externalUserId}`);
+        }
+        // Load user properties if they exist
+        const storedUserProperties = await Storage_1.storage.get('USER_PROPERTIES');
+        if (storedUserProperties) {
+            this.userProperties = storedUserProperties;
+            logger_1.logger.info('Loaded user properties');
+        }
+        return this.anonymousId;
+    }
+    /**
+     * Identifies a user with an external user ID and optional properties
+     */
+    async identify(externalUserId, properties) {
+        // Validate inputs
+        (0, validators_1.validateUserId)(externalUserId);
+        if (properties) {
+            (0, validators_1.validateUserProperties)(properties);
+        }
+        // Store external user ID
+        this.externalUserId = externalUserId;
+        await Storage_1.storage.set('EXTERNAL_USER_ID', externalUserId);
+        logger_1.logger.info(`User identified: ${externalUserId}`);
+        // Merge user properties
+        if (properties) {
+            this.userProperties = {
+                ...this.userProperties,
+                ...properties,
+            };
+            await Storage_1.storage.set('USER_PROPERTIES', this.userProperties);
+            logger_1.logger.info('User properties updated');
+        }
+    }
+    /**
+     * Resets the user identity
+     * Generates a new anonymous ID and clears external user ID and properties
+     */
+    async reset() {
+        logger_1.logger.info('Resetting user identity...');
+        // Generate new anonymous ID
+        this.anonymousId = (0, uuid_1.generateUUID)();
+        await Storage_1.storage.set('ANONYMOUS_ID', this.anonymousId);
+        // Clear external user ID
+        this.externalUserId = null;
+        await Storage_1.storage.remove('EXTERNAL_USER_ID');
+        // Clear user properties
+        this.userProperties = {};
+        await Storage_1.storage.remove('USER_PROPERTIES');
+        logger_1.logger.info(`Identity reset. New anonymous ID: ${this.anonymousId}`);
+    }
+    /**
+     * Updates user properties (merges with existing)
+     */
+    async updateUserProperties(properties) {
+        (0, validators_1.validateUserProperties)(properties);
+        this.userProperties = {
+            ...this.userProperties,
+            ...properties,
+        };
+        await Storage_1.storage.set('USER_PROPERTIES', this.userProperties);
+        logger_1.logger.info('User properties updated');
+    }
+    /**
+     * Gets the anonymous ID
+     */
+    getAnonymousId() {
+        return this.anonymousId;
+    }
+    /**
+     * Gets the external user ID
+     */
+    getExternalUserId() {
+        return this.externalUserId;
+    }
+    /**
+     * Gets user properties
+     */
+    getUserProperties() {
+        return { ...this.userProperties };
+    }
+    /**
+     * Checks if the user is identified
+     */
+    isIdentified() {
+        return this.externalUserId !== null;
+    }
+}
+exports.IdentityManager = IdentityManager;

package/dist/managers/NetworkManager.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Network Manager - Monitors network connectivity
+ *
+ * Uses the adapter pattern to automatically select the best network implementation
+ * based on available modules (Native > Expo > Fallback)
+ */
+export type NetworkStatusCallback = (isOnline: boolean) => void;
+export declare class NetworkManager {
+    private adapter;
+    constructor();
+    /**
+     * Initializes the network manager and starts monitoring
+     */
+    initialize(): Promise<void>;
+    /**
+     * Adds a listener for network status changes
+     */
+    onStatusChange(callback: NetworkStatusCallback): () => void;
+    /**
+     * Checks if currently online
+     */
+    isConnected(): boolean;
+    /**
+     * Manually refreshes network status
+     */
+    refresh(): Promise<boolean>;
+    /**
+     * Cleans up the network manager
+     */
+    cleanup(): void;
+}
+//# sourceMappingURL=NetworkManager.d.ts.map

package/dist/managers/NetworkManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NetworkManager.d.ts","sourceRoot":"","sources":["../../src/managers/NetworkManager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,MAAM,MAAM,qBAAqB,GAAG,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAC;AAEhE,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAAiB;;IAMhC;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAKjC;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,qBAAqB,GAAG,MAAM,IAAI;IAoB3D;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC;IAOjC;;OAEG;IACH,OAAO,IAAI,IAAI;CAIhB"}