@datalyr/react-native 1.3.0 → 1.3.1

package/lib/datalyr-sdk.js

@@ -8,10 +8,12 @@ import { AutoEventsManager } from './auto-events';
 import { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 import { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
 import { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
+import { networkStatusManager } from './network-status';
 export class DatalyrSDK {
     constructor() {
         this.autoEventsManager = null;
         this.appStateSubscription = null;
+        this.networkStatusUnsubscribe = null;
         // Initialize state with defaults
         this.state = {
             initialized: false,
@@ -73,18 +75,20 @@ export class DatalyrSDK {
                 flushInterval: this.state.config.flushInterval || 30000,
                 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();
-            }
-            // Initialize journey tracking (for first-touch, last-touch, touchpoints)
-            await journeyManager.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(),
+            ]);
+            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();
             if (initialAttribution.utm_source || initialAttribution.fbclid || initialAttribution.gclid || initialAttribution.lyr) {
@@ -122,7 +126,7 @@ export class DatalyrSDK {
                     errorLog('Error setting up app state monitoring (non-blocking):', error);
                 }
             }, 50);
-            // Initialize SKAdNetwork conversion encoder
+            // Initialize SKAdNetwork conversion encoder (synchronous, no await needed)
             if (config.skadTemplate) {
                 const template = ConversionTemplates[config.skadTemplate];
                 if (template) {
@@ -134,25 +138,34 @@ 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 = [
+                // 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 ((_b = config.meta) === null || _b === void 0 ? void 0 : _b.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 (((_c = config.tiktok) === null || _c === void 0 ? void 0 : _c.appId) && ((_d = config.tiktok) === null || _d === void 0 ? void 0 : _d.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(),
                 tiktok: tiktokIntegration.isAvailable(),
@@ -900,6 +913,41 @@ export class DatalyrSDK {
             errorLog('Error persisting user data:', error);
         }
     }
+    /**
+     * Initialize network status monitoring
+     * Automatically updates event queue when network status changes
+     */
+    async initializeNetworkMonitoring() {
+        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);
+            // Default to online if monitoring fails
+            this.state.isOnline = true;
+            this.eventQueue.setOnlineStatus(true);
+        }
+    }
     /**
      * Set up app state monitoring for lifecycle events (optimized)
      */
@@ -920,6 +968,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();
@@ -957,6 +1007,13 @@ export class DatalyrSDK {
                 this.appStateSubscription.remove();
                 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();
             // Reset state

package/lib/index.d.ts

@@ -12,6 +12,8 @@ export * from './event-queue';
 export { DatalyrSDK };
 export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 export { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
-export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
+export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
+export { networkStatusManager } from './network-status';
+export type { NetworkState, NetworkStateListener } from './network-status';
 export type { AppleSearchAdsAttribution } from './native/DatalyrNativeBridge';
 export default DatalyrSDK;

package/lib/index.js

@@ -20,6 +20,8 @@ export { DatalyrSDK };
 export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 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';
 // Default export for compatibility
 export default DatalyrSDK;

package/lib/integrations/play-install-referrer.d.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.
  */
 export interface PlayInstallReferrer {
@@ -28,6 +30,8 @@ export interface PlayInstallReferrer {
     installBeginTimestamp: number;
     installCompleteTimestamp?: number;
     gclid?: string;
+    gbraid?: string;
+    wbraid?: string;
     utmSource?: string;
     utmMedium?: string;
     utmCampaign?: string;

package/lib/integrations/play-install-referrer.js

@@ -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.
  */
 import { Platform, NativeModules } from 'react-native';
@@ -61,6 +63,8 @@ class PlayInstallReferrerIntegration {
                     utmSource: this.referrerData.utmSource,
                     utmMedium: this.referrerData.utmMedium,
                     hasGclid: !!this.referrerData.gclid,
+                    hasGbraid: !!this.referrerData.gbraid,
+                    hasWbraid: !!this.referrerData.wbraid,
                 });
             }
         }
@@ -109,11 +113,14 @@ class PlayInstallReferrerIntegration {
             params.utmCampaign = searchParams.get('utm_campaign') || undefined;
             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;
                 }
             });
@@ -141,8 +148,11 @@ class PlayInstallReferrerIntegration {
             install_referrer_url: this.referrerData.referrerUrl,
             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,

package/lib/native/SKAdNetworkBridge.d.ts

@@ -5,6 +5,46 @@ export interface SKANConversionResult {
     lockWindow: boolean;
     priority: number;
 }
+export interface PostbackUpdateResponse {
+    success: boolean;
+    framework: 'AdAttributionKit' | 'SKAdNetwork';
+    fineValue: number;
+    coarseValue: string;
+    lockWindow: boolean;
+    type?: 'reengagement';
+}
+export interface AttributionFrameworkInfo {
+    framework: 'AdAttributionKit' | 'SKAdNetwork' | 'none';
+    version: string;
+    reengagement_available: boolean;
+    overlapping_windows: boolean;
+    fine_value_range: {
+        min: number;
+        max: number;
+    };
+    coarse_values: string[];
+}
+export interface EnhancedAttributionInfo extends AttributionFrameworkInfo {
+    geo_postback_available: boolean;
+    development_postbacks: boolean;
+    features: string[];
+}
+export interface PostbackEnvironmentResponse {
+    environment: 'production' | 'sandbox';
+    isSandbox: boolean;
+    note: string;
+}
+export interface OverlappingWindowPostbackResponse {
+    success: boolean;
+    framework: string;
+    version: string;
+    fineValue: number;
+    coarseValue: string;
+    lockWindow: boolean;
+    windowIndex: number;
+    overlappingWindows: boolean;
+    note?: string;
+}
 export declare class SKAdNetworkBridge {
     private static _isSKAN4Available;
     /**
@@ -22,4 +62,85 @@ export declare class SKAdNetworkBridge {
      */
     static isSKAN4Available(): Promise<boolean>;
     static isAvailable(): boolean;
+    /**
+     * Check if AdAttributionKit is available (iOS 17.4+)
+     * AdAttributionKit is Apple's replacement for SKAdNetwork with enhanced features
+     */
+    private static _isAdAttributionKitAvailable;
+    static isAdAttributionKitAvailable(): Promise<boolean>;
+    /**
+     * Register for ad network attribution
+     * Uses AdAttributionKit on iOS 17.4+, SKAdNetwork on earlier versions
+     */
+    static registerForAttribution(): Promise<{
+        framework: string;
+        registered: boolean;
+    } | null>;
+    /**
+     * Get attribution framework info
+     * Returns details about which framework is being used and its capabilities
+     */
+    static getAttributionInfo(): Promise<AttributionFrameworkInfo | null>;
+    /**
+     * Check if overlapping conversion windows are available (iOS 18.4+)
+     * Overlapping windows allow multiple conversion windows to be active simultaneously
+     */
+    private static _isOverlappingWindowsAvailable;
+    static isOverlappingWindowsAvailable(): Promise<boolean>;
+    /**
+     * Update conversion value for re-engagement attribution (AdAttributionKit iOS 17.4+ only)
+     * Re-engagement tracks users who return to the app via an ad after initial install.
+     *
+     * @param result - Conversion result with fine value (0-63), coarse value, and lock window
+     * @returns Response with framework info, or null if not supported
+     */
+    static updateReengagementConversionValue(result: SKANConversionResult): Promise<PostbackUpdateResponse | null>;
+    /**
+     * Get a summary of attribution capabilities for the current device
+     */
+    static getCapabilitiesSummary(): Promise<{
+        skadnetwork3: boolean;
+        skadnetwork4: boolean;
+        adAttributionKit: boolean;
+        reengagement: boolean;
+        overlappingWindows: boolean;
+        geoPostback: boolean;
+        developmentPostbacks: boolean;
+        framework: string;
+    }>;
+    /**
+     * Check if geo-level postback data is available (iOS 18.4+)
+     * Geo postbacks include country code information for regional analytics
+     */
+    private static _isGeoPostbackAvailable;
+    static isGeoPostbackAvailable(): Promise<boolean>;
+    /**
+     * Set postback environment for testing (iOS 18.4+)
+     * Note: Actual sandbox mode requires Developer Mode enabled in iOS Settings
+     *
+     * @param environment - 'production' or 'sandbox'
+     */
+    static setPostbackEnvironment(environment: 'production' | 'sandbox'): Promise<PostbackEnvironmentResponse | null>;
+    /**
+     * Get enhanced attribution info including iOS 18.4+ features
+     * Returns details about geo postbacks, development mode, and all available features
+     */
+    static getEnhancedAttributionInfo(): Promise<EnhancedAttributionInfo | null>;
+    /**
+     * Update postback with overlapping window support (iOS 18.4+)
+     * Allows tracking conversions across multiple time windows simultaneously
+     *
+     * @param result - Conversion result with fine value, coarse value, and lock window
+     * @param windowIndex - Window index: 0 (0-2 days), 1 (3-7 days), 2 (8-35 days)
+     */
+    static updatePostbackWithWindow(result: SKANConversionResult, windowIndex: 0 | 1 | 2): Promise<OverlappingWindowPostbackResponse | null>;
+    /**
+     * Enable development/sandbox mode for testing attribution
+     * Convenience method that sets sandbox environment
+     */
+    static enableDevelopmentMode(): Promise<boolean>;
+    /**
+     * Disable development mode (switch to production)
+     */
+    static disableDevelopmentMode(): Promise<boolean>;
 }