@datalyr/react-native 1.3.0 → 1.3.1

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,6 +1,6 @@
 {
   "name": "@datalyr/react-native",
-  "version": "1.3.0",
+  "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",
@@ -59,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",
@@ -106,6 +107,9 @@
     },
     "react-native-device-info": {
       "optional": true
+    },
+    "@react-native-community/netinfo": {
+      "optional": true
     }
   }
 }

package/src/datalyr-sdk.ts

@@ -33,6 +33,7 @@ import { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEn
 import { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
 import { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
 import { AppleSearchAdsAttribution } from './native/DatalyrNativeBridge';
+import { networkStatusManager } from './network-status';
 
 export class DatalyrSDK {
   private state: SDKState;
@@ -40,6 +41,7 @@ export class DatalyrSDK {
   private eventQueue: EventQueue;
   private autoEventsManager: AutoEventsManager | null = null;
   private appStateSubscription: any = null;
+  private networkStatusUnsubscribe: (() => void) | null = null;
   private static conversionEncoder?: ConversionValueEncoder;
   private static debugEnabled = false;
 
@@ -112,21 +114,21 @@ export class DatalyrSDK {
         maxRetryCount: this.state.config.maxRetries || 3,
       });
 
-      // Initialize visitor ID, anonymous ID and session
-      this.state.visitorId = await getOrCreateVisitorId();
-      this.state.anonymousId = await getOrCreateAnonymousId();
-      this.state.sessionId = await getOrCreateSessionId();
-
-      // Load persisted user data
-      await this.loadPersistedUserData();
-
-      // Initialize attribution manager
-      if (this.state.config.enableAttribution) {
-        await attributionManager.initialize();
-      }
+      // PARALLEL INITIALIZATION: IDs and core managers
+      // Run ID creation and core manager initialization in parallel for faster startup
+      const [visitorId, anonymousId, sessionId] = await Promise.all([
+        getOrCreateVisitorId(),
+        getOrCreateAnonymousId(),
+        getOrCreateSessionId(),
+        // These run concurrently but don't return values we need to capture
+        this.loadPersistedUserData(),
+        this.state.config.enableAttribution ? attributionManager.initialize() : Promise.resolve(),
+        journeyManager.initialize(),
+      ]);
 
-      // Initialize journey tracking (for first-touch, last-touch, touchpoints)
-      await journeyManager.initialize();
+      this.state.visitorId = visitorId;
+      this.state.anonymousId = anonymousId;
+      this.state.sessionId = sessionId;
 
       // Record initial attribution to journey if this is a new session with attribution
       const initialAttribution = attributionManager.getAttributionData();
@@ -169,7 +171,7 @@ export class DatalyrSDK {
         }
       }, 50);
 
-      // Initialize SKAdNetwork conversion encoder
+      // Initialize SKAdNetwork conversion encoder (synchronous, no await needed)
       if (config.skadTemplate) {
         const template = ConversionTemplates[config.skadTemplate];
         if (template) {
@@ -183,29 +185,41 @@ export class DatalyrSDK {
         }
       }
 
-      // Initialize Meta SDK if configured
+      // PARALLEL INITIALIZATION: Network monitoring and platform integrations
+      // These are independent and can run concurrently for faster startup
+      const platformInitPromises: Promise<void>[] = [
+        // Network monitoring
+        this.initializeNetworkMonitoring(),
+        // Apple Search Ads (iOS only)
+        appleSearchAdsIntegration.initialize(config.debug),
+        // Google Play Install Referrer (Android only)
+        playInstallReferrerIntegration.initialize(),
+      ];
+
+      // Add Meta initialization if configured
       if (config.meta?.appId) {
-        await metaIntegration.initialize(config.meta, config.debug);
-
-        // Fetch deferred deep link and merge with attribution
-        if (config.enableAttribution !== false) {
-          const deferredLink = await metaIntegration.fetchDeferredDeepLink();
-          if (deferredLink) {
-            await this.handleDeferredDeepLink(deferredLink);
-          }
-        }
+        platformInitPromises.push(
+          metaIntegration.initialize(config.meta, config.debug).then(async () => {
+            // After Meta initializes, fetch deferred deep link
+            if (config.enableAttribution !== false) {
+              const deferredLink = await metaIntegration.fetchDeferredDeepLink();
+              if (deferredLink) {
+                await this.handleDeferredDeepLink(deferredLink);
+              }
+            }
+          })
+        );
       }
 
-      // Initialize TikTok SDK if configured
+      // Add TikTok initialization if configured
       if (config.tiktok?.appId && config.tiktok?.tiktokAppId) {
-        await tiktokIntegration.initialize(config.tiktok, config.debug);
+        platformInitPromises.push(
+          tiktokIntegration.initialize(config.tiktok, config.debug)
+        );
       }
 
-      // Initialize Apple Search Ads attribution (iOS only, auto-fetches on init)
-      await appleSearchAdsIntegration.initialize(config.debug);
-
-      // Initialize Google Play Install Referrer (Android only)
-      await playInstallReferrerIntegration.initialize();
+      // Wait for all platform integrations to complete
+      await Promise.all(platformInitPromises);
 
       debugLog('Platform integrations initialized', {
         meta: metaIntegration.isAvailable(),
@@ -1094,6 +1108,45 @@ export class DatalyrSDK {
     }
   }
 
+  /**
+   * Initialize network status monitoring
+   * Automatically updates event queue when network status changes
+   */
+  private async initializeNetworkMonitoring(): Promise<void> {
+    try {
+      await networkStatusManager.initialize();
+
+      // Update event queue with current network status
+      this.state.isOnline = networkStatusManager.isOnline();
+      this.eventQueue.setOnlineStatus(this.state.isOnline);
+
+      // Subscribe to network changes
+      this.networkStatusUnsubscribe = networkStatusManager.subscribe((state) => {
+        const isOnline = state.isConnected && (state.isInternetReachable !== false);
+        this.state.isOnline = isOnline;
+        this.eventQueue.setOnlineStatus(isOnline);
+
+        // Track network status change event (only if SDK is fully initialized)
+        if (this.state.initialized) {
+          this.track('$network_status_change', {
+            is_online: isOnline,
+            network_type: state.type,
+            is_internet_reachable: state.isInternetReachable,
+          }).catch(() => {
+            // Ignore errors for network status events
+          });
+        }
+      });
+
+      debugLog(`Network monitoring initialized, online: ${this.state.isOnline}`);
+    } catch (error) {
+      errorLog('Error initializing network monitoring (non-blocking):', error as Error);
+      // Default to online if monitoring fails
+      this.state.isOnline = true;
+      this.eventQueue.setOnlineStatus(true);
+    }
+  }
+
   /**
    * Set up app state monitoring for lifecycle events (optimized)
    */
@@ -1114,6 +1167,8 @@ export class DatalyrSDK {
         } else if (nextAppState === 'active') {
           // App became active, ensure we have fresh session if needed
           this.refreshSession();
+          // Refresh network status when coming back from background
+          networkStatusManager.refresh();
           // Notify auto-events manager for session handling
           if (this.autoEventsManager) {
             this.autoEventsManager.handleAppForeground();
@@ -1154,6 +1209,15 @@ export class DatalyrSDK {
         this.appStateSubscription = null;
       }
 
+      // Remove network status listener
+      if (this.networkStatusUnsubscribe) {
+        this.networkStatusUnsubscribe();
+        this.networkStatusUnsubscribe = null;
+      }
+
+      // Destroy network status manager
+      networkStatusManager.destroy();
+
       // Destroy event queue
       this.eventQueue.destroy();
 

package/src/index.ts

@@ -29,7 +29,11 @@ export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEn
 export { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
 
 // Export platform integrations
-export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
+export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
+
+// Export network status manager
+export { networkStatusManager } from './network-status';
+export type { NetworkState, NetworkStateListener } from './network-status';
 
 // Export native bridge types
 export type { AppleSearchAdsAttribution } from './native/DatalyrNativeBridge';

package/src/integrations/play-install-referrer.ts

@@ -19,7 +19,9 @@
  * - referrer_url: Full referrer URL from Play Store
  * - referrer_click_timestamp: When the referrer link was clicked
  * - install_begin_timestamp: When the install began
- * - gclid: Google Ads click ID (if present)
+ * - gclid: Google Ads click ID (standard)
+ * - gbraid: Google Ads privacy-safe click ID (iOS App campaigns)
+ * - wbraid: Google Ads privacy-safe click ID (Web-to-App campaigns)
  * - utm_source, utm_medium, utm_campaign, etc.
  */
 
@@ -37,6 +39,10 @@ export interface PlayInstallReferrer {
   installCompleteTimestamp?: number;
   // Google Ads click ID
   gclid?: string;
+  // Google Ads privacy-safe click IDs (iOS App campaigns)
+  gbraid?: string;
+  // Google Ads privacy-safe click IDs (Web-to-App campaigns)
+  wbraid?: string;
   // UTM Parameters
   utmSource?: string;
   utmMedium?: string;
@@ -94,6 +100,8 @@ class PlayInstallReferrerIntegration {
           utmSource: this.referrerData.utmSource,
           utmMedium: this.referrerData.utmMedium,
           hasGclid: !!this.referrerData.gclid,
+          hasGbraid: !!this.referrerData.gbraid,
+          hasWbraid: !!this.referrerData.wbraid,
         });
       }
     } catch (error) {
@@ -149,12 +157,15 @@ class PlayInstallReferrerIntegration {
       params.utmTerm = searchParams.get('utm_term') || undefined;
       params.utmContent = searchParams.get('utm_content') || undefined;
 
-      // Extract click IDs
+      // Extract click IDs (gclid, gbraid, wbraid)
       params.gclid = searchParams.get('gclid') || undefined;
+      params.gbraid = searchParams.get('gbraid') || undefined;
+      params.wbraid = searchParams.get('wbraid') || undefined;
 
       // Store any additional parameters
+      const knownParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content', 'gclid', 'gbraid', 'wbraid'];
       searchParams.forEach((value, key) => {
-        if (!key.startsWith('utm_') && key !== 'gclid') {
+        if (!knownParams.includes(key) && !key.startsWith('utm_')) {
           params[key] = value;
         }
       });
@@ -186,8 +197,12 @@ class PlayInstallReferrerIntegration {
       referrer_click_timestamp: this.referrerData.referrerClickTimestamp,
       install_begin_timestamp: this.referrerData.installBeginTimestamp,
 
-      // Standard attribution fields
+      // Google Ads click IDs (gclid is standard, gbraid/wbraid are privacy-safe alternatives)
       gclid: this.referrerData.gclid,
+      gbraid: this.referrerData.gbraid,
+      wbraid: this.referrerData.wbraid,
+
+      // UTM parameters
       utm_source: this.referrerData.utmSource,
       utm_medium: this.referrerData.utmMedium,
       utm_campaign: this.referrerData.utmCampaign,