@datalyr/react-native 1.2.1 → 1.3.1

package/lib/network-status.d.ts

@@ -0,0 +1,84 @@
+export type NetworkState = {
+    isConnected: boolean;
+    isInternetReachable: boolean | null;
+    type: 'wifi' | 'cellular' | 'ethernet' | 'bluetooth' | 'vpn' | 'none' | 'unknown';
+};
+export type NetworkStateListener = (state: NetworkState) => void;
+/**
+ * Network status manager that detects online/offline status
+ * Uses @react-native-community/netinfo for React Native or expo-network for Expo
+ */
+declare class NetworkStatusManager {
+    private state;
+    private listeners;
+    private unsubscribe;
+    private initialized;
+    private netInfoModule;
+    private expoNetworkModule;
+    /**
+     * Initialize network status monitoring
+     * Call this during SDK initialization
+     */
+    initialize(): Promise<void>;
+    /**
+     * Initialize with @react-native-community/netinfo
+     */
+    private initializeWithNetInfo;
+    /**
+     * Update state from NetInfo response
+     */
+    private updateStateFromNetInfo;
+    /**
+     * Map NetInfo type to our simplified type
+     */
+    private mapNetInfoType;
+    /**
+     * Initialize with expo-network
+     */
+    private initializeWithExpoNetwork;
+    /**
+     * Update state from expo-network response
+     */
+    private updateStateFromExpoNetwork;
+    /**
+     * Map expo-network type to our simplified type
+     */
+    private mapExpoNetworkType;
+    /**
+     * Poll expo-network for changes (since it doesn't have a listener API)
+     */
+    private pollingInterval;
+    private startExpoNetworkPolling;
+    /**
+     * Notify all listeners of state change
+     */
+    private notifyListeners;
+    /**
+     * Get current network state
+     */
+    getState(): NetworkState;
+    /**
+     * Check if device is currently online
+     */
+    isOnline(): boolean;
+    /**
+     * Get current network type
+     */
+    getNetworkType(): NetworkState['type'];
+    /**
+     * Subscribe to network state changes
+     * Returns an unsubscribe function
+     */
+    subscribe(listener: NetworkStateListener): () => void;
+    /**
+     * Refresh network state manually
+     * Useful when returning from background
+     */
+    refresh(): Promise<NetworkState>;
+    /**
+     * Cleanup and stop monitoring
+     */
+    destroy(): void;
+}
+export declare const networkStatusManager: NetworkStatusManager;
+export default networkStatusManager;

package/lib/network-status.js

@@ -0,0 +1,281 @@
+import { debugLog, errorLog } from './utils';
+/**
+ * Network status manager that detects online/offline status
+ * Uses @react-native-community/netinfo for React Native or expo-network for Expo
+ */
+class NetworkStatusManager {
+    constructor() {
+        this.state = {
+            isConnected: true, // Default to true until we know otherwise
+            isInternetReachable: null,
+            type: 'unknown',
+        };
+        this.listeners = new Set();
+        this.unsubscribe = null;
+        this.initialized = false;
+        this.netInfoModule = null;
+        this.expoNetworkModule = null;
+        /**
+         * Poll expo-network for changes (since it doesn't have a listener API)
+         */
+        this.pollingInterval = null;
+    }
+    /**
+     * Initialize network status monitoring
+     * Call this during SDK initialization
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        // Try @react-native-community/netinfo first (most common in RN apps)
+        try {
+            this.netInfoModule = require('@react-native-community/netinfo').default;
+            await this.initializeWithNetInfo();
+            this.initialized = true;
+            debugLog('Network status initialized with @react-native-community/netinfo');
+            return;
+        }
+        catch (_a) {
+            // Module not available, try expo-network
+        }
+        // Try expo-network (for Expo apps)
+        try {
+            this.expoNetworkModule = require('expo-network');
+            await this.initializeWithExpoNetwork();
+            this.initialized = true;
+            debugLog('Network status initialized with expo-network');
+            return;
+        }
+        catch (_b) {
+            // Module not available
+        }
+        // Fallback: assume online (no network monitoring available)
+        debugLog('No network status module available, defaulting to online');
+        this.state = {
+            isConnected: true,
+            isInternetReachable: true,
+            type: 'unknown',
+        };
+        this.initialized = true;
+    }
+    /**
+     * Initialize with @react-native-community/netinfo
+     */
+    async initializeWithNetInfo() {
+        const NetInfo = this.netInfoModule;
+        // Get initial state
+        try {
+            const netState = await NetInfo.fetch();
+            this.updateStateFromNetInfo(netState);
+        }
+        catch (error) {
+            errorLog('Failed to fetch initial network state:', error);
+        }
+        // Subscribe to changes
+        this.unsubscribe = NetInfo.addEventListener((netState) => {
+            this.updateStateFromNetInfo(netState);
+        });
+    }
+    /**
+     * Update state from NetInfo response
+     */
+    updateStateFromNetInfo(netState) {
+        var _a;
+        const previouslyConnected = this.state.isConnected;
+        this.state = {
+            isConnected: (_a = netState.isConnected) !== null && _a !== void 0 ? _a : true,
+            isInternetReachable: netState.isInternetReachable,
+            type: this.mapNetInfoType(netState.type),
+        };
+        // Notify listeners if connection status changed
+        if (previouslyConnected !== this.state.isConnected) {
+            debugLog(`Network status changed: ${this.state.isConnected ? 'online' : 'offline'} (${this.state.type})`);
+            this.notifyListeners();
+        }
+    }
+    /**
+     * Map NetInfo type to our simplified type
+     */
+    mapNetInfoType(type) {
+        switch (type) {
+            case 'wifi':
+                return 'wifi';
+            case 'cellular':
+                return 'cellular';
+            case 'ethernet':
+                return 'ethernet';
+            case 'bluetooth':
+                return 'bluetooth';
+            case 'vpn':
+                return 'vpn';
+            case 'none':
+                return 'none';
+            default:
+                return 'unknown';
+        }
+    }
+    /**
+     * Initialize with expo-network
+     */
+    async initializeWithExpoNetwork() {
+        const Network = this.expoNetworkModule;
+        // Get initial state
+        try {
+            const networkState = await Network.getNetworkStateAsync();
+            this.updateStateFromExpoNetwork(networkState);
+        }
+        catch (error) {
+            errorLog('Failed to fetch initial network state from expo-network:', error);
+        }
+        // Note: expo-network doesn't have a listener API like netinfo
+        // We'll poll periodically or rely on app state changes
+        this.startExpoNetworkPolling();
+    }
+    /**
+     * Update state from expo-network response
+     */
+    updateStateFromExpoNetwork(networkState) {
+        var _a, _b;
+        const previouslyConnected = this.state.isConnected;
+        this.state = {
+            isConnected: (_a = networkState.isConnected) !== null && _a !== void 0 ? _a : true,
+            isInternetReachable: (_b = networkState.isInternetReachable) !== null && _b !== void 0 ? _b : null,
+            type: this.mapExpoNetworkType(networkState.type),
+        };
+        if (previouslyConnected !== this.state.isConnected) {
+            debugLog(`Network status changed: ${this.state.isConnected ? 'online' : 'offline'} (${this.state.type})`);
+            this.notifyListeners();
+        }
+    }
+    /**
+     * Map expo-network type to our simplified type
+     */
+    mapExpoNetworkType(type) {
+        switch (type) {
+            case 'WIFI':
+                return 'wifi';
+            case 'CELLULAR':
+                return 'cellular';
+            case 'ETHERNET':
+                return 'ethernet';
+            case 'BLUETOOTH':
+                return 'bluetooth';
+            case 'VPN':
+                return 'vpn';
+            case 'NONE':
+                return 'none';
+            default:
+                return 'unknown';
+        }
+    }
+    startExpoNetworkPolling() {
+        // Poll every 5 seconds for network changes
+        this.pollingInterval = setInterval(async () => {
+            try {
+                if (this.expoNetworkModule) {
+                    const networkState = await this.expoNetworkModule.getNetworkStateAsync();
+                    this.updateStateFromExpoNetwork(networkState);
+                }
+            }
+            catch (error) {
+                // Ignore polling errors
+            }
+        }, 5000);
+    }
+    /**
+     * Notify all listeners of state change
+     */
+    notifyListeners() {
+        this.listeners.forEach((listener) => {
+            try {
+                listener(this.state);
+            }
+            catch (error) {
+                errorLog('Error in network state listener:', error);
+            }
+        });
+    }
+    /**
+     * Get current network state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Check if device is currently online
+     */
+    isOnline() {
+        // Consider online if connected OR if we're not sure about internet reachability
+        return this.state.isConnected && (this.state.isInternetReachable !== false);
+    }
+    /**
+     * Get current network type
+     */
+    getNetworkType() {
+        return this.state.type;
+    }
+    /**
+     * Subscribe to network state changes
+     * Returns an unsubscribe function
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        // Immediately call with current state
+        try {
+            listener(this.state);
+        }
+        catch (error) {
+            errorLog('Error calling network state listener:', error);
+        }
+        // Return unsubscribe function
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * Refresh network state manually
+     * Useful when returning from background
+     */
+    async refresh() {
+        if (this.netInfoModule) {
+            try {
+                const netState = await this.netInfoModule.fetch();
+                this.updateStateFromNetInfo(netState);
+            }
+            catch (error) {
+                errorLog('Failed to refresh network state:', error);
+            }
+        }
+        else if (this.expoNetworkModule) {
+            try {
+                const networkState = await this.expoNetworkModule.getNetworkStateAsync();
+                this.updateStateFromExpoNetwork(networkState);
+            }
+            catch (error) {
+                errorLog('Failed to refresh network state from expo-network:', error);
+            }
+        }
+        return this.state;
+    }
+    /**
+     * Cleanup and stop monitoring
+     */
+    destroy() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = null;
+        }
+        this.listeners.clear();
+        this.initialized = false;
+        debugLog('Network status manager destroyed');
+    }
+}
+// Export singleton instance
+export const networkStatusManager = new NetworkStatusManager();
+// Export for direct access
+export default networkStatusManager;

package/lib/types.d.ts

@@ -32,32 +32,83 @@ export interface DeferredDeepLinkResult {
     adsetId?: string;
     adId?: string;
 }
+/**
+ * Core SDK Configuration
+ *
+ * @example
+ * ```typescript
+ * await Datalyr.initialize({
+ *   apiKey: 'dk_your_api_key',
+ *   debug: true,
+ *   enableAutoEvents: true,
+ *   enableAttribution: true,
+ *   skadTemplate: 'ecommerce',
+ *   meta: { appId: 'FB_APP_ID' },
+ *   tiktok: { appId: 'APP_ID', tiktokAppId: 'TIKTOK_APP_ID' },
+ * });
+ * ```
+ */
 export interface DatalyrConfig {
+    /** Required: API key from Datalyr dashboard (starts with 'dk_') */
     apiKey: string;
+    /** Optional: Workspace ID for multi-workspace setups */
     workspaceId?: string;
+    /** Enable console logging for debugging. Default: false */
     debug?: boolean;
+    /**
+     * API endpoint URL. Default: 'https://api.datalyr.com'
+     * @deprecated Use `endpoint` instead
+     */
     apiUrl?: string;
+    /** API endpoint URL. Default: 'https://api.datalyr.com' */
     endpoint?: string;
+    /** Use server-side tracking. Default: true */
     useServerTracking?: boolean;
+    /** Maximum retry attempts for failed requests. Default: 3 */
     maxRetries?: number;
+    /** Delay between retries in milliseconds. Default: 1000 */
     retryDelay?: number;
+    /** Request timeout in milliseconds. Default: 15000 */
     timeout?: number;
+    /** Number of events per batch. Default: 10 */
     batchSize?: number;
+    /** Interval between automatic flushes in milliseconds. Default: 30000 */
     flushInterval?: number;
+    /** Maximum events to store in queue. Default: 100 */
     maxQueueSize?: number;
+    /**
+     * Maximum events to store in queue. Default: 100
+     * @deprecated Use `maxQueueSize` instead
+     */
     maxEventQueueSize?: number;
+    /** Respect browser Do Not Track setting. Default: true */
     respectDoNotTrack?: boolean;
+    /** Enable automatic event tracking (sessions, app lifecycle). Default: false */
     enableAutoEvents?: boolean;
+    /** Enable attribution tracking (deep links, install referrer). Default: false */
     enableAttribution?: boolean;
+    /** Enable web-to-app attribution matching via email. Default: true */
     enableWebToAppAttribution?: boolean;
+    /**
+     * Auto-events configuration
+     * @deprecated Use `autoEventConfig` instead
+     */
     autoEvents?: AutoEventConfig;
+    /** Auto-events configuration */
     autoEventConfig?: AutoEventConfig;
+    /**
+     * Retry configuration
+     * @deprecated Use `maxRetries` and `retryDelay` instead
+     */
     retryConfig?: {
         maxRetries: number;
         retryDelay: number;
     };
+    /** SKAdNetwork template for automatic conversion value encoding (iOS only) */
     skadTemplate?: 'ecommerce' | 'gaming' | 'subscription';
+    /** Meta (Facebook) SDK Configuration */
     meta?: MetaConfig;
+    /** TikTok SDK Configuration */
     tiktok?: TikTokConfig;
 }
 export interface EventData {

package/lib/utils.d.ts

@@ -36,9 +36,14 @@ export declare const getOrCreateAnonymousId: () => Promise<string>;
  */
 export declare const getOrCreateSessionId: () => Promise<string>;
 /**
- * Collect comprehensive device information
+ * Collect comprehensive device information (cached after first call)
+ * Device info is cached because it rarely changes during app session
  */
 export declare const getDeviceInfo: () => Promise<DeviceInfoType>;
+/**
+ * Clear the cached device info (useful for testing or after app update)
+ */
+export declare const clearDeviceInfoCache: () => void;
 /**
  * Create fingerprint data for attribution
  */

package/lib/utils.js

@@ -114,10 +114,43 @@ export const getOrCreateSessionId = async () => {
         return generateSessionId(); // Fallback to memory-only ID
     }
 };
+// Cached device info to avoid repeated async calls
+let cachedDeviceInfo = null;
+let deviceInfoPromise = null;
 /**
- * Collect comprehensive device information
+ * Collect comprehensive device information (cached after first call)
+ * Device info is cached because it rarely changes during app session
  */
 export const getDeviceInfo = async () => {
+    // Return cached info if available
+    if (cachedDeviceInfo) {
+        return cachedDeviceInfo;
+    }
+    // If a fetch is already in progress, wait for it (prevents concurrent fetches)
+    if (deviceInfoPromise) {
+        return deviceInfoPromise;
+    }
+    // Start fetching and cache the promise
+    deviceInfoPromise = fetchDeviceInfoInternal();
+    try {
+        cachedDeviceInfo = await deviceInfoPromise;
+        return cachedDeviceInfo;
+    }
+    finally {
+        deviceInfoPromise = null;
+    }
+};
+/**
+ * Clear the cached device info (useful for testing or after app update)
+ */
+export const clearDeviceInfoCache = () => {
+    cachedDeviceInfo = null;
+    deviceInfoPromise = null;
+};
+/**
+ * Internal function to fetch device info
+ */
+const fetchDeviceInfoInternal = async () => {
     const { width, height } = Dimensions.get('window');
     // If DeviceInfo is not available (like in Expo Go), use fallback
     if (!DeviceInfo) {
@@ -204,11 +237,28 @@ export const createFingerprintData = async () => {
         },
     };
 };
+// Import network status manager for network type detection
+let networkStatusManagerRef = null;
+// Lazy load to avoid circular dependencies
+const getNetworkStatusManager = () => {
+    if (!networkStatusManagerRef) {
+        try {
+            networkStatusManagerRef = require('./network-status').networkStatusManager;
+        }
+        catch (_a) {
+            // Module not loaded yet
+        }
+    }
+    return networkStatusManagerRef;
+};
 /**
  * Get network connection type
  */
 export const getNetworkType = () => {
-    // This will be enhanced with react-native-netinfo if needed
+    const manager = getNetworkStatusManager();
+    if (manager) {
+        return manager.getNetworkType();
+    }
     return 'unknown';
 };
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datalyr/react-native",
-  "version": "1.2.1",
-  "description": "Datalyr SDK for React Native & Expo - Server-side attribution tracking with bundled Meta and TikTok SDKs",
+  "version": "1.3.1",
+  "description": "Datalyr SDK for React Native & Expo - Server-side attribution tracking with bundled Meta and TikTok SDKs for iOS and Android",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
@@ -15,6 +15,7 @@
     "lib/",
     "src/",
     "ios/",
+    "android/",
     "README.md",
     "CHANGELOG.md",
     "LICENSE",
@@ -38,11 +39,15 @@
     "tiktok-attribution",
     "google-attribution",
     "ios-attribution",
+    "android-attribution",
     "apple-search-ads",
+    "play-install-referrer",
+    "gclid",
     "conversion-tracking",
     "revenue-optimization",
     "deferred-deep-linking",
-    "fbclid"
+    "fbclid",
+    "ttclid"
   ],
   "author": "Datalyr",
   "license": "MIT",
@@ -54,7 +59,8 @@
   "peerDependencies": {
     "react": ">=18.0.0",
     "react-native": ">=0.72.0",
-    "react-native-device-info": ">=12.0.0"
+    "react-native-device-info": ">=12.0.0",
+    "@react-native-community/netinfo": ">=11.0.0"
   },
   "dependencies": {
     "@react-native-async-storage/async-storage": "^2.2.0",
@@ -101,6 +107,9 @@
     },
     "react-native-device-info": {
       "optional": true
+    },
+    "@react-native-community/netinfo": {
+      "optional": true
     }
   }
 }