riuve-rn 1.0.0

package/dist/Rive.js

@@ -0,0 +1,402 @@
+"use strict";
+/**
+ * Rive SDK - Main SDK Class (Singleton)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const uuid_1 = require("./utils/uuid");
+const react_native_1 = require("react-native");
+const EventQueue_1 = require("./core/EventQueue");
+const ApiClient_1 = require("./core/ApiClient");
+const DeviceInfo_1 = require("./core/DeviceInfo");
+const Storage_1 = require("./core/Storage");
+const IdentityManager_1 = require("./managers/IdentityManager");
+const NetworkManager_1 = require("./managers/NetworkManager");
+const BatchManager_1 = require("./managers/BatchManager");
+const constants_1 = require("./constants");
+const logger_1 = require("./utils/logger");
+const validators_1 = require("./utils/validators");
+class RiveSDK {
+    /**
+     * Private constructor for singleton pattern
+     */
+    constructor() {
+        this.config = null;
+        this.isInitialized = false;
+        this.eventQueue = null;
+        this.apiClient = null;
+        this.identityManager = null;
+        this.networkManager = null;
+        this.batchManager = null;
+        this.appStateSubscription = null;
+        this.pendingEvents = [];
+    }
+    /**
+     * Gets the singleton instance
+     */
+    static getInstance() {
+        if (!RiveSDK.instance) {
+            RiveSDK.instance = new RiveSDK();
+        }
+        return RiveSDK.instance;
+    }
+    /**
+     * Initializes the SDK
+     */
+    async initialize(apiKey, config) {
+        // Validate API key
+        (0, validators_1.validateApiKey)(apiKey);
+        // Build full config
+        this.config = {
+            ...constants_1.DEFAULT_CONFIG,
+            ...config,
+            apiKey,
+        };
+        // Enable debug mode if configured
+        logger_1.logger.setDebugMode(this.config.debugMode);
+        logger_1.logger.info('Initializing Rive SDK...');
+        logger_1.logger.debug('Config:', this.config);
+        try {
+            // Initialize managers
+            this.identityManager = new IdentityManager_1.IdentityManager();
+            const anonymousId = await this.identityManager.initialize();
+            this.networkManager = new NetworkManager_1.NetworkManager();
+            await this.networkManager.initialize();
+            // Initialize API client with hardcoded base URL
+            this.apiClient = new ApiClient_1.ApiClient(constants_1.API_BASE_URL, this.config.apiKey, this.config.maxRetries, this.config.retryDelay, this.config.requestTimeout);
+            // Initialize event queue
+            this.eventQueue = new EventQueue_1.EventQueue(this.config.batchSize, this.config.batchTimeout, this.config.maxQueueSize);
+            // Load persisted events from storage
+            await this.eventQueue.loadFromStorage();
+            // Initialize batch manager
+            this.batchManager = new BatchManager_1.BatchManager(this.eventQueue, this.apiClient, this.networkManager, this.identityManager, this.config.eventRetentionDays);
+            // Collect device info
+            const deviceInfo = await DeviceInfo_1.deviceInfoCollector.collect();
+            // Call initialize endpoint
+            if (this.networkManager.isConnected()) {
+                try {
+                    await this.apiClient.initialize({
+                        anonymous_id: anonymousId,
+                        device_info: deviceInfo,
+                    });
+                    logger_1.logger.info('SDK initialized successfully on backend');
+                }
+                catch (error) {
+                    logger_1.logger.warn('Failed to initialize on backend (will retry):', error);
+                }
+            }
+            else {
+                logger_1.logger.warn('Offline - backend initialization will occur when online');
+            }
+            // Setup app state listener for background flush
+            if (this.config.autoFlushOnBackground) {
+                this.setupAppStateListener();
+            }
+            // Process pending events (events that were tracked before initialization)
+            if (this.pendingEvents.length > 0) {
+                logger_1.logger.info(`Processing ${this.pendingEvents.length} pending events...`);
+                const anonymousId = this.identityManager.getAnonymousId();
+                const externalUserId = this.identityManager.getExternalUserId();
+                let processedCount = 0;
+                for (const pendingEvent of this.pendingEvents) {
+                    try {
+                        const event = {
+                            id: (0, uuid_1.generateUUID)(),
+                            name: pendingEvent.eventName,
+                            properties: pendingEvent.eventProperties,
+                            timestamp: pendingEvent.timestamp, // Use original timestamp
+                            anonymousId,
+                            externalUserId: externalUserId || undefined,
+                        };
+                        await this.eventQueue.enqueue(event);
+                        processedCount++;
+                        logger_1.logger.info(`  Processed pending event: ${pendingEvent.eventName} (id: ${event.id})`);
+                    }
+                    catch (error) {
+                        logger_1.logger.error(`Failed to process pending event '${pendingEvent.eventName}':`, error);
+                    }
+                }
+                logger_1.logger.info(`Successfully processed ${processedCount}/${this.pendingEvents.length} pending events`);
+                this.pendingEvents = []; // Clear pending events
+            }
+            this.isInitialized = true;
+            logger_1.logger.info('Rive SDK initialized successfully');
+            // Flush any offline queue
+            await this.batchManager.flushOfflineQueue();
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to initialize SDK:', error);
+            throw error;
+        }
+    }
+    /**
+     * Identifies a user
+     */
+    async identify(externalUserId, userProperties) {
+        this.ensureInitialized();
+        // Validate inputs
+        (0, validators_1.validateUserId)(externalUserId);
+        if (userProperties) {
+            (0, validators_1.validateUserProperties)(userProperties);
+        }
+        logger_1.logger.info(`Identifying user: ${externalUserId}`);
+        try {
+            // Update identity manager
+            await this.identityManager.identify(externalUserId, userProperties);
+            // Call identify endpoint if online
+            if (this.networkManager.isConnected()) {
+                try {
+                    const anonymousId = this.identityManager.getAnonymousId();
+                    await this.apiClient.identify({
+                        anonymous_id: anonymousId,
+                        external_user_id: externalUserId,
+                        user_properties: userProperties,
+                    });
+                    logger_1.logger.info('User identified on backend successfully');
+                }
+                catch (error) {
+                    logger_1.logger.warn('Failed to identify user on backend:', error);
+                }
+            }
+            else {
+                logger_1.logger.warn('Offline - user will be identified when online');
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to identify user:', error);
+            throw error;
+        }
+    }
+    /**
+     * Tracks an event
+     */
+    async track(eventName, eventProperties) {
+        // Validate inputs
+        (0, validators_1.validateEventName)(eventName);
+        if (eventProperties) {
+            (0, validators_1.validateEventProperties)(eventProperties);
+        }
+        // If SDK is not initialized yet, add to pending events queue
+        if (!this.isInitialized) {
+            const timestamp = Date.now();
+            this.pendingEvents.push({
+                eventName,
+                eventProperties,
+                timestamp,
+            });
+            const propsStr = eventProperties ? this.truncateJson(JSON.stringify(eventProperties), 150) : 'none';
+            logger_1.logger.info(`Event tracked: ${eventName}`);
+            logger_1.logger.info(`  Properties: ${propsStr}`);
+            logger_1.logger.info(`  Timestamp: ${new Date(timestamp).toISOString()}`);
+            logger_1.logger.info(`  Status: Added to pending queue (SDK not initialized yet)`);
+            logger_1.logger.info(`  Pending queue size: ${this.pendingEvents.length}`);
+            return;
+        }
+        // SDK is initialized, proceed with normal flow
+        try {
+            const event = {
+                id: (0, uuid_1.generateUUID)(),
+                name: eventName,
+                properties: eventProperties,
+                timestamp: Date.now(),
+                anonymousId: this.identityManager.getAnonymousId(),
+                externalUserId: this.identityManager.getExternalUserId() || undefined,
+            };
+            const queueSizeBefore = this.eventQueue.size();
+            // Add to queue
+            await this.eventQueue.enqueue(event);
+            const queueSizeAfter = this.eventQueue.size();
+            const propsStr = eventProperties ? this.truncateJson(JSON.stringify(eventProperties), 150) : 'none';
+            logger_1.logger.info(`Event tracked: ${eventName}`);
+            logger_1.logger.info(`  Properties: ${propsStr}`);
+            logger_1.logger.info(`  Event ID: ${event.id.substring(0, 8)}...`);
+            logger_1.logger.info(`  Timestamp: ${new Date(event.timestamp).toISOString()}`);
+            logger_1.logger.info(`  Queue size: ${queueSizeBefore} -> ${queueSizeAfter}/${this.config.maxQueueSize}`);
+            logger_1.logger.info(`  Status: Added to queue`);
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to track event '${eventName}':`, error);
+            throw error;
+        }
+    }
+    /**
+     * Sets the FCM token for push notifications
+     */
+    async setFcmToken(token) {
+        this.ensureInitialized();
+        if (typeof token !== 'string' || token.trim().length === 0) {
+            throw new Error('FCM token must be a non-empty string');
+        }
+        logger_1.logger.info('Setting FCM token...');
+        try {
+            // Store token
+            await Storage_1.storage.set('FCM_TOKEN', token);
+            // Send to backend if online
+            if (this.networkManager.isConnected()) {
+                try {
+                    const anonymousId = this.identityManager.getAnonymousId();
+                    const externalUserId = this.identityManager.getExternalUserId();
+                    await this.apiClient.setFcmToken({
+                        anonymous_id: anonymousId,
+                        external_user_id: externalUserId || undefined,
+                        fcm_token: token,
+                    });
+                    logger_1.logger.info('FCM token set successfully');
+                }
+                catch (error) {
+                    logger_1.logger.warn('Failed to set FCM token on backend:', error);
+                }
+            }
+            else {
+                logger_1.logger.warn('Offline - FCM token will be sent when online');
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to set FCM token:', error);
+            throw error;
+        }
+    }
+    /**
+     * Manually flushes all pending events
+     */
+    async flush() {
+        this.ensureInitialized();
+        logger_1.logger.info('Manually flushing events...');
+        try {
+            await this.eventQueue.flush();
+            logger_1.logger.info('Flush completed');
+        }
+        catch (error) {
+            logger_1.logger.error('Flush failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Resets the SDK (new anonymous user)
+     */
+    async reset() {
+        this.ensureInitialized();
+        logger_1.logger.info('Resetting SDK...');
+        try {
+            // Flush pending events
+            await this.flush();
+            // Reset identity
+            await this.identityManager.reset();
+            // Clear FCM token
+            await Storage_1.storage.remove('FCM_TOKEN');
+            logger_1.logger.info('SDK reset successfully');
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to reset SDK:', error);
+            throw error;
+        }
+    }
+    /**
+     * Gets the anonymous ID
+     */
+    getAnonymousId() {
+        if (!this.isInitialized || !this.identityManager) {
+            return null;
+        }
+        return this.identityManager.getAnonymousId();
+    }
+    /**
+     * Gets the external user ID
+     */
+    getExternalUserId() {
+        if (!this.isInitialized || !this.identityManager) {
+            return null;
+        }
+        return this.identityManager.getExternalUserId();
+    }
+    /**
+     * Gets the current configuration
+     */
+    getConfig() {
+        return this.config ? { ...this.config } : null;
+    }
+    /**
+     * Gets the event queue size
+     */
+    getQueueSize() {
+        if (!this.isInitialized || !this.eventQueue) {
+            return 0;
+        }
+        return this.eventQueue.size();
+    }
+    /**
+     * Gets the failed batch count
+     */
+    async getFailedBatchCount() {
+        if (!this.isInitialized || !this.batchManager) {
+            return 0;
+        }
+        return this.batchManager.getFailedBatchCount();
+    }
+    /**
+     * Checks if the SDK is initialized
+     */
+    isReady() {
+        return this.isInitialized;
+    }
+    /**
+     * Sets up app state listener for background flush
+     */
+    setupAppStateListener() {
+        this.appStateSubscription = react_native_1.AppState.addEventListener('change', (nextAppState) => {
+            if (nextAppState === 'background' || nextAppState === 'inactive') {
+                logger_1.logger.info('App going to background, flushing events...');
+                this.flush().catch((error) => {
+                    logger_1.logger.error('Background flush failed:', error);
+                });
+            }
+        });
+    }
+    /**
+     * Ensures the SDK is initialized before operations
+     */
+    ensureInitialized() {
+        if (!this.isInitialized) {
+            throw new Error(constants_1.ERROR_MESSAGES.NOT_INITIALIZED);
+        }
+    }
+    /**
+     * Truncates JSON string if too long
+     */
+    truncateJson(json, maxLength) {
+        if (json.length <= maxLength) {
+            return json;
+        }
+        return json.substring(0, maxLength) + '...';
+    }
+    /**
+     * Cleanup method (for testing or app shutdown)
+     */
+    async cleanup() {
+        logger_1.logger.info('Cleaning up SDK...');
+        // Flush pending events
+        if (this.eventQueue) {
+            try {
+                await this.eventQueue.flush();
+            }
+            catch (error) {
+                logger_1.logger.warn('Failed to flush during cleanup:', error);
+            }
+            this.eventQueue.destroy();
+        }
+        // Cleanup network manager
+        if (this.networkManager) {
+            this.networkManager.cleanup();
+        }
+        // Remove app state listener
+        if (this.appStateSubscription) {
+            this.appStateSubscription.remove();
+            this.appStateSubscription = null;
+        }
+        this.isInitialized = false;
+        logger_1.logger.info('SDK cleanup completed');
+    }
+}
+RiveSDK.instance = null;
+// Export singleton instance methods
+const Rive = RiveSDK.getInstance();
+exports.default = Rive;

package/dist/adapters/deviceInfo/ExpoDeviceInfo.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Expo DeviceInfo Adapter
+ *
+ * Uses Expo SDK modules for device information.
+ * This adapter works in Expo Go without requiring a development build.
+ */
+import type { DeviceInfoAdapter, DeviceInfoType } from './types';
+export declare class ExpoDeviceInfo implements DeviceInfoAdapter {
+    private cachedInfo;
+    collect(): Promise<DeviceInfoType>;
+    getCached(): DeviceInfoType | null;
+}
+//# sourceMappingURL=ExpoDeviceInfo.d.ts.map

package/dist/adapters/deviceInfo/ExpoDeviceInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoDeviceInfo.d.ts","sourceRoot":"","sources":["../../../src/adapters/deviceInfo/ExpoDeviceInfo.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEjE,qBAAa,cAAe,YAAW,iBAAiB;IACtD,OAAO,CAAC,UAAU,CAA+B;IAE3C,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;IA4CxC,SAAS,IAAI,cAAc,GAAG,IAAI;CAGnC"}

package/dist/adapters/deviceInfo/ExpoDeviceInfo.js

@@ -0,0 +1,91 @@
+"use strict";
+/**
+ * Expo DeviceInfo Adapter
+ *
+ * Uses Expo SDK modules for device information.
+ * This adapter works in Expo Go without requiring a development build.
+ */
+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.ExpoDeviceInfo = void 0;
+const react_native_1 = require("react-native");
+class ExpoDeviceInfo {
+    constructor() {
+        this.cachedInfo = null;
+    }
+    async collect() {
+        if (this.cachedInfo) {
+            return this.cachedInfo;
+        }
+        try {
+            // Lazy import - only import when this adapter is actually used
+            // @ts-ignore - expo modules are optional peer dependencies
+            const Device = await Promise.resolve().then(() => __importStar(require('expo-device')));
+            // @ts-ignore - expo modules are optional peer dependencies
+            const Application = await Promise.resolve().then(() => __importStar(require('expo-application')));
+            // @ts-ignore - expo modules are optional peer dependencies
+            const Localization = await Promise.resolve().then(() => __importStar(require('expo-localization')));
+            const platform = react_native_1.Platform.OS;
+            const systemVersion = Device.osVersion || react_native_1.Platform.Version.toString();
+            const osVersion = `${react_native_1.Platform.OS === 'ios' ? 'iOS' : 'Android'} ${systemVersion}`;
+            const deviceInfo = {
+                os_version: osVersion,
+                device_model: Device.modelName || 'Unknown',
+                app_version: Application.nativeApplicationVersion || '1.0.0',
+                locale: Localization.locale || 'en-US',
+                platform,
+                manufacturer: Device.manufacturer || undefined,
+                brand: Device.brand || undefined,
+            };
+            this.cachedInfo = deviceInfo;
+            return deviceInfo;
+        }
+        catch (error) {
+            // Fallback if expo modules fail
+            const fallbackInfo = {
+                os_version: react_native_1.Platform.Version.toString(),
+                device_model: 'Unknown',
+                app_version: '1.0.0',
+                locale: 'en-US',
+                platform: react_native_1.Platform.OS,
+            };
+            return fallbackInfo;
+        }
+    }
+    getCached() {
+        return this.cachedInfo;
+    }
+}
+exports.ExpoDeviceInfo = ExpoDeviceInfo;

package/dist/adapters/deviceInfo/FallbackDeviceInfo.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Fallback DeviceInfo Adapter
+ *
+ * Uses only React Native's Platform API for minimal device information.
+ * This adapter works in any React Native environment without any dependencies.
+ */
+import type { DeviceInfoAdapter, DeviceInfoType } from './types';
+export declare class FallbackDeviceInfo implements DeviceInfoAdapter {
+    private cachedInfo;
+    collect(): Promise<DeviceInfoType>;
+    getCached(): DeviceInfoType | null;
+}
+//# sourceMappingURL=FallbackDeviceInfo.d.ts.map

package/dist/adapters/deviceInfo/FallbackDeviceInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FallbackDeviceInfo.d.ts","sourceRoot":"","sources":["../../../src/adapters/deviceInfo/FallbackDeviceInfo.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEjE,qBAAa,kBAAmB,YAAW,iBAAiB;IAC1D,OAAO,CAAC,UAAU,CAA+B;IAE3C,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;IAqBxC,SAAS,IAAI,cAAc,GAAG,IAAI;CAGnC"}

package/dist/adapters/deviceInfo/FallbackDeviceInfo.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * Fallback DeviceInfo Adapter
+ *
+ * Uses only React Native's Platform API for minimal device information.
+ * This adapter works in any React Native environment without any dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackDeviceInfo = void 0;
+const react_native_1 = require("react-native");
+class FallbackDeviceInfo {
+    constructor() {
+        this.cachedInfo = null;
+    }
+    async collect() {
+        if (this.cachedInfo) {
+            return this.cachedInfo;
+        }
+        const platform = react_native_1.Platform.OS;
+        const version = react_native_1.Platform.Version.toString();
+        const osVersion = `${react_native_1.Platform.OS === 'ios' ? 'iOS' : 'Android'} ${version}`;
+        const deviceInfo = {
+            os_version: osVersion,
+            device_model: 'Unknown',
+            app_version: '1.0.0',
+            locale: 'en-US',
+            platform,
+        };
+        this.cachedInfo = deviceInfo;
+        return deviceInfo;
+    }
+    getCached() {
+        return this.cachedInfo;
+    }
+}
+exports.FallbackDeviceInfo = FallbackDeviceInfo;

package/dist/adapters/deviceInfo/NativeDeviceInfo.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Native DeviceInfo Adapter
+ *
+ * Uses react-native-device-info for maximum device information.
+ * This adapter provides the most comprehensive data but requires native modules.
+ */
+import type { DeviceInfoAdapter, DeviceInfoType } from './types';
+export declare class NativeDeviceInfo implements DeviceInfoAdapter {
+    private cachedInfo;
+    collect(): Promise<DeviceInfoType>;
+    getCached(): DeviceInfoType | null;
+    /**
+     * Gets the device locale using NativeModules
+     */
+    private getLocale;
+}
+//# sourceMappingURL=NativeDeviceInfo.d.ts.map

package/dist/adapters/deviceInfo/NativeDeviceInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeDeviceInfo.d.ts","sourceRoot":"","sources":["../../../src/adapters/deviceInfo/NativeDeviceInfo.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEjE,qBAAa,gBAAiB,YAAW,iBAAiB;IACxD,OAAO,CAAC,UAAU,CAA+B;IAE3C,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;IAoDxC,SAAS,IAAI,cAAc,GAAG,IAAI;IAIlC;;OAEG;IACH,OAAO,CAAC,SAAS;CAiBlB"}

package/dist/adapters/deviceInfo/NativeDeviceInfo.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Native DeviceInfo Adapter
+ *
+ * Uses react-native-device-info for maximum device information.
+ * This adapter provides the most comprehensive data but requires native modules.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeDeviceInfo = void 0;
+const react_native_device_info_1 = __importDefault(require("react-native-device-info"));
+const react_native_1 = require("react-native");
+class NativeDeviceInfo {
+    constructor() {
+        this.cachedInfo = null;
+    }
+    async collect() {
+        if (this.cachedInfo) {
+            return this.cachedInfo;
+        }
+        try {
+            const [systemVersion, model, version, manufacturer, brand,] = await Promise.all([
+                react_native_device_info_1.default.getSystemVersion(),
+                react_native_device_info_1.default.getModel(),
+                react_native_device_info_1.default.getVersion(),
+                react_native_device_info_1.default.getManufacturer(),
+                react_native_device_info_1.default.getBrand(),
+            ]);
+            // Get locale
+            const locale = this.getLocale();
+            const platform = react_native_1.Platform.OS === 'ios' ? 'ios' : 'android';
+            const osVersion = `${react_native_1.Platform.OS === 'ios' ? 'iOS' : 'Android'} ${systemVersion}`;
+            const deviceInfo = {
+                os_version: osVersion,
+                device_model: model,
+                app_version: version,
+                locale,
+                platform,
+                manufacturer,
+                brand,
+            };
+            this.cachedInfo = deviceInfo;
+            return deviceInfo;
+        }
+        catch (error) {
+            // Fallback if native module fails
+            const fallbackInfo = {
+                os_version: `${react_native_1.Platform.OS} unknown`,
+                device_model: 'unknown',
+                app_version: '1.0.0',
+                locale: this.getLocale(),
+                platform: react_native_1.Platform.OS === 'ios' ? 'ios' : 'android',
+            };
+            return fallbackInfo;
+        }
+    }
+    getCached() {
+        return this.cachedInfo;
+    }
+    /**
+     * Gets the device locale using NativeModules
+     */
+    getLocale() {
+        try {
+            if (react_native_1.Platform.OS === 'ios') {
+                const locale = react_native_1.NativeModules.SettingsManager?.settings?.AppleLocale ||
+                    react_native_1.NativeModules.SettingsManager?.settings?.AppleLanguages?.[0] ||
+                    'en-US';
+                return locale;
+            }
+            else {
+                const locale = react_native_1.NativeModules.I18nManager?.localeIdentifier || 'en-US';
+                return locale;
+            }
+        }
+        catch (error) {
+            return 'en-US';
+        }
+    }
+}
+exports.NativeDeviceInfo = NativeDeviceInfo;

package/dist/adapters/deviceInfo/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * DeviceInfo Adapter Selector
+ *
+ * Automatically detects available modules and selects the best adapter:
+ * 1. NativeDeviceInfo (react-native-device-info) - Best performance & data
+ * 2. ExpoDeviceInfo (expo-device, expo-application) - Expo Go compatible
+ * 3. FallbackDeviceInfo (Platform API only) - Always works
+ */
+import type { DeviceInfoAdapter } from './types';
+/**
+ * Gets the appropriate DeviceInfo adapter for the current environment
+ */
+export declare function getDeviceInfoAdapter(): DeviceInfoAdapter;
+//# sourceMappingURL=index.d.ts.map