@datalyr/react-native 1.2.0 → 1.3.0

package/lib/datalyr-sdk.js

@@ -3,10 +3,11 @@ import { getOrCreateVisitorId, getOrCreateAnonymousId, getOrCreateSessionId, cre
 import { createHttpClient, HttpClient } from './http-client';
 import { createEventQueue, EventQueue } from './event-queue';
 import { attributionManager } from './attribution';
+import { journeyManager } from './journey';
 import { AutoEventsManager } from './auto-events';
 import { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 import { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
-import { metaIntegration, tiktokIntegration } from './integrations';
+import { metaIntegration, tiktokIntegration, appleSearchAdsIntegration, playInstallReferrerIntegration } from './integrations';
 export class DatalyrSDK {
     constructor() {
         this.autoEventsManager = null;
@@ -82,6 +83,22 @@ export class DatalyrSDK {
             if (this.state.config.enableAttribution) {
                 await attributionManager.initialize();
             }
+            // Initialize journey tracking (for first-touch, last-touch, touchpoints)
+            await journeyManager.initialize();
+            // 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) {
+                await journeyManager.recordAttribution(this.state.sessionId, {
+                    source: initialAttribution.utm_source || initialAttribution.campaign_source,
+                    medium: initialAttribution.utm_medium || initialAttribution.campaign_medium,
+                    campaign: initialAttribution.utm_campaign || initialAttribution.campaign_name,
+                    fbclid: initialAttribution.fbclid,
+                    gclid: initialAttribution.gclid,
+                    ttclid: initialAttribution.ttclid,
+                    clickIdType: initialAttribution.fbclid ? 'fbclid' : initialAttribution.gclid ? 'gclid' : initialAttribution.ttclid ? 'ttclid' : undefined,
+                    lyr: initialAttribution.lyr,
+                });
+            }
             // Initialize auto-events manager (asynchronously to avoid blocking)
             if (this.state.config.enableAutoEvents) {
                 this.autoEventsManager = new AutoEventsManager(this.track.bind(this), this.state.config.autoEventConfig);
@@ -132,9 +149,15 @@ export class DatalyrSDK {
             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);
             }
+            // 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();
             debugLog('Platform integrations initialized', {
                 meta: metaIntegration.isAvailable(),
                 tiktok: tiktokIntegration.isAvailable(),
+                appleSearchAds: appleSearchAdsIntegration.isAvailable(),
+                playInstallReferrer: playInstallReferrerIntegration.isAvailable(),
             });
             // SDK initialized successfully - set state before tracking install event
             this.state.initialized = true;
@@ -395,6 +418,7 @@ export class DatalyrSDK {
             currentUserId: this.state.currentUserId,
             queueStats: this.eventQueue.getStats(),
             attribution: attributionManager.getAttributionSummary(),
+            journey: journeyManager.getJourneySummary(),
         };
     }
     /**
@@ -404,10 +428,28 @@ export class DatalyrSDK {
         return this.state.anonymousId;
     }
     /**
-     * Get detailed attribution data
+     * Get detailed attribution data (includes journey tracking data)
      */
     getAttributionData() {
-        return attributionManager.getAttributionData();
+        const attribution = attributionManager.getAttributionData();
+        const journeyData = journeyManager.getAttributionData();
+        // Merge attribution with journey data
+        return {
+            ...attribution,
+            ...journeyData,
+        };
+    }
+    /**
+     * Get journey tracking summary
+     */
+    getJourneySummary() {
+        return journeyManager.getJourneySummary();
+    }
+    /**
+     * Get full customer journey (all touchpoints)
+     */
+    getJourney() {
+        return journeyManager.getJourney();
     }
     /**
      * Set custom attribution data (for testing or manual attribution)
@@ -457,22 +499,25 @@ export class DatalyrSDK {
     // MARK: - SKAdNetwork Enhanced Methods
     /**
      * Track event with automatic SKAdNetwork conversion value encoding
+     * Uses SKAN 4.0 on iOS 16.1+ with coarse values and lock window support
      */
     async trackWithSKAdNetwork(event, properties) {
         // Existing tracking (keep exactly as-is)
         await this.track(event, properties);
-        // NEW: Automatic SKAdNetwork encoding
+        // Automatic SKAdNetwork encoding with SKAN 4.0 support
         if (!DatalyrSDK.conversionEncoder) {
             if (DatalyrSDK.debugEnabled) {
                 errorLog('SKAdNetwork encoder not initialized. Pass skadTemplate in initialize()');
             }
             return;
         }
-        const conversionValue = DatalyrSDK.conversionEncoder.encode(event, properties);
-        if (conversionValue > 0) {
-            const success = await SKAdNetworkBridge.updateConversionValue(conversionValue);
+        // Use SKAN 4.0 encoding (includes coarse value and lock window)
+        const result = DatalyrSDK.conversionEncoder.encodeWithSKAN4(event, properties);
+        if (result.fineValue > 0 || result.priority > 0) {
+            // Use SKAN 4.0 method (automatically falls back to SKAN 3.0 on older iOS)
+            const success = await SKAdNetworkBridge.updatePostbackConversionValue(result);
             if (DatalyrSDK.debugEnabled) {
-                debugLog(`Event: ${event}, Conversion Value: ${conversionValue}, Success: ${success}`, properties);
+                debugLog(`SKAN: event=${event}, fine=${result.fineValue}, coarse=${result.coarseValue}, lock=${result.lockWindow}, success=${success}`, properties);
             }
         }
         else if (DatalyrSDK.debugEnabled) {
@@ -672,8 +717,25 @@ export class DatalyrSDK {
         return {
             meta: metaIntegration.isAvailable(),
             tiktok: tiktokIntegration.isAvailable(),
+            appleSearchAds: appleSearchAdsIntegration.isAvailable(),
+            playInstallReferrer: playInstallReferrerIntegration.isAvailable(),
         };
     }
+    /**
+     * Get Apple Search Ads attribution data
+     * Returns attribution if user installed via Apple Search Ads, null otherwise
+     */
+    getAppleSearchAdsAttribution() {
+        return appleSearchAdsIntegration.getAttributionData();
+    }
+    /**
+     * Get Google Play Install Referrer attribution data (Android only)
+     * Returns referrer data if available, null otherwise
+     */
+    getPlayInstallReferrer() {
+        const data = playInstallReferrerIntegration.getReferrerData();
+        return data ? playInstallReferrerIntegration.getAttributionData() : null;
+    }
     /**
      * Update tracking authorization status on all platform SDKs
      * Call this AFTER the user responds to the ATT permission dialog
@@ -745,6 +807,21 @@ export class DatalyrSDK {
         const deviceInfo = await getDeviceInfo();
         const fingerprintData = await createFingerprintData();
         const attributionData = attributionManager.getAttributionData();
+        // Get Apple Search Ads attribution if available
+        const asaAttribution = appleSearchAdsIntegration.getAttributionData();
+        const asaData = (asaAttribution === null || asaAttribution === void 0 ? void 0 : asaAttribution.attribution) ? {
+            asa_campaign_id: asaAttribution.campaignId,
+            asa_campaign_name: asaAttribution.campaignName,
+            asa_ad_group_id: asaAttribution.adGroupId,
+            asa_ad_group_name: asaAttribution.adGroupName,
+            asa_keyword_id: asaAttribution.keywordId,
+            asa_keyword: asaAttribution.keyword,
+            asa_org_id: asaAttribution.orgId,
+            asa_org_name: asaAttribution.orgName,
+            asa_click_date: asaAttribution.clickDate,
+            asa_conversion_type: asaAttribution.conversionType,
+            asa_country_or_region: asaAttribution.countryOrRegion,
+        } : {};
         const payload = {
             workspaceId: this.state.config.workspaceId || 'mobile_sdk',
             visitorId: this.state.visitorId,
@@ -766,6 +843,8 @@ export class DatalyrSDK {
                 timestamp: Date.now(),
                 // Attribution data
                 ...attributionData,
+                // Apple Search Ads attribution
+                ...asaData,
             },
             fingerprintData,
             source: 'mobile_app',
@@ -999,6 +1078,9 @@ export class Datalyr {
     static getPlatformIntegrationStatus() {
         return datalyr.getPlatformIntegrationStatus();
     }
+    static getAppleSearchAdsAttribution() {
+        return datalyr.getAppleSearchAdsAttribution();
+    }
     static async updateTrackingAuthorization(enabled) {
         await datalyr.updateTrackingAuthorization(enabled);
     }

package/lib/index.d.ts

@@ -3,6 +3,8 @@ export declare const datalyr: DatalyrSDK;
 export { Datalyr };
 export * from './types';
 export { attributionManager } from './attribution';
+export { journeyManager } from './journey';
+export type { TouchAttribution, TouchPoint } from './journey';
 export { createAutoEventsManager, AutoEventsManager } from './auto-events';
 export * from './utils';
 export * from './http-client';
@@ -10,5 +12,6 @@ export * from './event-queue';
 export { DatalyrSDK };
 export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 export { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
-export { metaIntegration, tiktokIntegration } from './integrations';
+export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
+export type { AppleSearchAdsAttribution } from './native/DatalyrNativeBridge';
 export default DatalyrSDK;

package/lib/index.js

@@ -8,6 +8,7 @@ export { Datalyr };
 // Export types and utilities
 export * from './types';
 export { attributionManager } from './attribution';
+export { journeyManager } from './journey';
 export { createAutoEventsManager, AutoEventsManager } from './auto-events';
 // Re-export utilities for advanced usage
 export * from './utils';
@@ -19,6 +20,6 @@ export { DatalyrSDK };
 export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 export { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
 // Export platform integrations
-export { metaIntegration, tiktokIntegration } from './integrations';
+export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
 // Default export for compatibility
 export default DatalyrSDK;

package/lib/integrations/apple-search-ads-integration.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Apple Search Ads Attribution Integration
+ * Uses AdServices framework (iOS 14.3+) to capture attribution from App Store search ads
+ */
+import { AppleSearchAdsAttribution } from '../native/DatalyrNativeBridge';
+/**
+ * Apple Search Ads Integration class
+ * Fetches attribution data for users who installed via Apple Search Ads
+ */
+export declare class AppleSearchAdsIntegration {
+    private attributionData;
+    private fetched;
+    private available;
+    private debug;
+    /**
+     * Initialize and fetch Apple Search Ads attribution
+     */
+    initialize(debug?: boolean): Promise<void>;
+    /**
+     * Fetch attribution data from Apple's AdServices API
+     * Call this during app initialization
+     */
+    fetchAttribution(): Promise<AppleSearchAdsAttribution | null>;
+    /**
+     * Get cached attribution data
+     */
+    getAttributionData(): AppleSearchAdsAttribution | null;
+    /**
+     * Check if user came from Apple Search Ads
+     */
+    hasAttribution(): boolean;
+    /**
+     * Check if Apple Search Ads is available (iOS 14.3+)
+     */
+    isAvailable(): boolean;
+    /**
+     * Check if attribution has been fetched
+     */
+    hasFetched(): boolean;
+    private log;
+    private logError;
+}
+export declare const appleSearchAdsIntegration: AppleSearchAdsIntegration;

package/lib/integrations/apple-search-ads-integration.js

@@ -0,0 +1,106 @@
+/**
+ * Apple Search Ads Attribution Integration
+ * Uses AdServices framework (iOS 14.3+) to capture attribution from App Store search ads
+ */
+import { Platform } from 'react-native';
+import { AppleSearchAdsNativeBridge, isNativeModuleAvailable } from '../native/DatalyrNativeBridge';
+/**
+ * Apple Search Ads Integration class
+ * Fetches attribution data for users who installed via Apple Search Ads
+ */
+export class AppleSearchAdsIntegration {
+    constructor() {
+        this.attributionData = null;
+        this.fetched = false;
+        this.available = false;
+        this.debug = false;
+    }
+    /**
+     * Initialize and fetch Apple Search Ads attribution
+     */
+    async initialize(debug = false) {
+        this.debug = debug;
+        // Only available on iOS via native module
+        if (Platform.OS !== 'ios') {
+            this.log('Apple Search Ads only available on iOS');
+            return;
+        }
+        this.available = isNativeModuleAvailable();
+        if (!this.available) {
+            this.log('Apple Search Ads native module not available');
+            return;
+        }
+        // Automatically fetch attribution on init
+        await this.fetchAttribution();
+    }
+    /**
+     * Fetch attribution data from Apple's AdServices API
+     * Call this during app initialization
+     */
+    async fetchAttribution() {
+        var _a;
+        if (!this.available) {
+            return null;
+        }
+        // Only fetch once
+        if (this.fetched) {
+            return this.attributionData;
+        }
+        try {
+            this.attributionData = await AppleSearchAdsNativeBridge.getAttribution();
+            this.fetched = true;
+            if ((_a = this.attributionData) === null || _a === void 0 ? void 0 : _a.attribution) {
+                this.log('Apple Search Ads attribution found:', {
+                    campaignId: this.attributionData.campaignId,
+                    campaignName: this.attributionData.campaignName,
+                    adGroupId: this.attributionData.adGroupId,
+                    keyword: this.attributionData.keyword,
+                });
+            }
+            else {
+                this.log('No Apple Search Ads attribution (user did not come from search ad)');
+            }
+            return this.attributionData;
+        }
+        catch (error) {
+            this.logError('Failed to fetch Apple Search Ads attribution:', error);
+            this.fetched = true;
+            return null;
+        }
+    }
+    /**
+     * Get cached attribution data
+     */
+    getAttributionData() {
+        return this.attributionData;
+    }
+    /**
+     * Check if user came from Apple Search Ads
+     */
+    hasAttribution() {
+        var _a;
+        return ((_a = this.attributionData) === null || _a === void 0 ? void 0 : _a.attribution) === true;
+    }
+    /**
+     * Check if Apple Search Ads is available (iOS 14.3+)
+     */
+    isAvailable() {
+        return this.available;
+    }
+    /**
+     * Check if attribution has been fetched
+     */
+    hasFetched() {
+        return this.fetched;
+    }
+    log(message, data) {
+        if (this.debug) {
+            console.log(`[Datalyr/AppleSearchAds] ${message}`, data || '');
+        }
+    }
+    logError(message, error) {
+        console.error(`[Datalyr/AppleSearchAds] ${message}`, error);
+    }
+}
+// Export singleton instance
+export const appleSearchAdsIntegration = new AppleSearchAdsIntegration();

package/lib/integrations/index.d.ts

@@ -1,6 +1,9 @@
 /**
  * Platform SDK Integrations
- * Meta (Facebook) and TikTok SDK wrappers for deferred deep linking and event forwarding
+ * Meta (Facebook), TikTok, Apple Search Ads, and Google Play Install Referrer SDK wrappers
  */
 export { MetaIntegration, metaIntegration } from './meta-integration';
 export { TikTokIntegration, tiktokIntegration } from './tiktok-integration';
+export { AppleSearchAdsIntegration, appleSearchAdsIntegration } from './apple-search-ads-integration';
+export { playInstallReferrerIntegration } from './play-install-referrer';
+export type { PlayInstallReferrer } from './play-install-referrer';

package/lib/integrations/index.js

@@ -1,6 +1,8 @@
 /**
  * Platform SDK Integrations
- * Meta (Facebook) and TikTok SDK wrappers for deferred deep linking and event forwarding
+ * Meta (Facebook), TikTok, Apple Search Ads, and Google Play Install Referrer SDK wrappers
  */
 export { MetaIntegration, metaIntegration } from './meta-integration';
 export { TikTokIntegration, tiktokIntegration } from './tiktok-integration';
+export { AppleSearchAdsIntegration, appleSearchAdsIntegration } from './apple-search-ads-integration';
+export { playInstallReferrerIntegration } from './play-install-referrer';

package/lib/integrations/meta-integration.d.ts

@@ -15,6 +15,7 @@ export declare class MetaIntegration {
     private deferredDeepLinkData;
     /**
      * Initialize Meta SDK with configuration
+     * Supported on both iOS and Android via native modules
      */
     initialize(config: MetaConfig, debug?: boolean): Promise<void>;
     /**

package/lib/integrations/meta-integration.js

@@ -18,14 +18,15 @@ export class MetaIntegration {
     }
     /**
      * Initialize Meta SDK with configuration
+     * Supported on both iOS and Android via native modules
      */
     async initialize(config, debug = false) {
         var _a;
         this.debug = debug;
         this.config = config;
-        // Only available on iOS via native module
-        if (Platform.OS !== 'ios') {
-            this.log('Meta SDK only available on iOS');
+        // Only available on iOS and Android via native modules
+        if (Platform.OS !== 'ios' && Platform.OS !== 'android') {
+            this.log('Meta SDK only available on iOS and Android');
             return;
         }
         this.available = isNativeModuleAvailable();

package/lib/integrations/play-install-referrer.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Google Play Install Referrer Integration
+ *
+ * Provides Android install attribution via the Google Play Install Referrer API.
+ * This captures UTM parameters and click IDs passed through Google Play Store.
+ *
+ * How it works:
+ * 1. User clicks ad/link with UTM parameters
+ * 2. Google Play Store stores the referrer URL
+ * 3. On first app launch, SDK retrieves the referrer
+ * 4. Attribution data (utm_source, utm_medium, gclid, etc.) is extracted
+ *
+ * Requirements:
+ * - Android only (returns null on iOS)
+ * - Requires Google Play Install Referrer Library in build.gradle:
+ *   implementation 'com.android.installreferrer:installreferrer:2.2'
+ *
+ * Attribution data captured:
+ * - 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)
+ * - utm_source, utm_medium, utm_campaign, etc.
+ */
+export interface PlayInstallReferrer {
+    referrerUrl: string;
+    referrerClickTimestamp: number;
+    installBeginTimestamp: number;
+    installCompleteTimestamp?: number;
+    gclid?: string;
+    utmSource?: string;
+    utmMedium?: string;
+    utmCampaign?: string;
+    utmTerm?: string;
+    utmContent?: string;
+    [key: string]: any;
+}
+/**
+ * Google Play Install Referrer Integration
+ *
+ * Retrieves install attribution data from Google Play Store.
+ * Only available on Android.
+ */
+declare class PlayInstallReferrerIntegration {
+    private referrerData;
+    private initialized;
+    /**
+     * Check if Play Install Referrer is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Initialize and fetch install referrer data
+     * Should be called once on first app launch
+     */
+    initialize(): Promise<void>;
+    /**
+     * Fetch install referrer from Play Store
+     */
+    fetchInstallReferrer(): Promise<PlayInstallReferrer | null>;
+    /**
+     * Parse referrer URL to extract UTM parameters and click IDs
+     */
+    private parseReferrerUrl;
+    /**
+     * Get cached install referrer data
+     */
+    getReferrerData(): PlayInstallReferrer | null;
+    /**
+     * Get attribution data in standard format
+     */
+    getAttributionData(): Record<string, any>;
+}
+export declare const playInstallReferrerIntegration: PlayInstallReferrerIntegration;
+export {};

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

@@ -0,0 +1,156 @@
+/**
+ * Google Play Install Referrer Integration
+ *
+ * Provides Android install attribution via the Google Play Install Referrer API.
+ * This captures UTM parameters and click IDs passed through Google Play Store.
+ *
+ * How it works:
+ * 1. User clicks ad/link with UTM parameters
+ * 2. Google Play Store stores the referrer URL
+ * 3. On first app launch, SDK retrieves the referrer
+ * 4. Attribution data (utm_source, utm_medium, gclid, etc.) is extracted
+ *
+ * Requirements:
+ * - Android only (returns null on iOS)
+ * - Requires Google Play Install Referrer Library in build.gradle:
+ *   implementation 'com.android.installreferrer:installreferrer:2.2'
+ *
+ * Attribution data captured:
+ * - 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)
+ * - utm_source, utm_medium, utm_campaign, etc.
+ */
+import { Platform, NativeModules } from 'react-native';
+import { debugLog, errorLog } from '../utils';
+const { DatalyrPlayInstallReferrer } = NativeModules;
+/**
+ * Google Play Install Referrer Integration
+ *
+ * Retrieves install attribution data from Google Play Store.
+ * Only available on Android.
+ */
+class PlayInstallReferrerIntegration {
+    constructor() {
+        this.referrerData = null;
+        this.initialized = false;
+    }
+    /**
+     * Check if Play Install Referrer is available
+     */
+    isAvailable() {
+        return Platform.OS === 'android' && !!DatalyrPlayInstallReferrer;
+    }
+    /**
+     * Initialize and fetch install referrer data
+     * Should be called once on first app launch
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        if (!this.isAvailable()) {
+            debugLog('[PlayInstallReferrer] Not available (iOS or native module missing)');
+            return;
+        }
+        try {
+            this.referrerData = await this.fetchInstallReferrer();
+            this.initialized = true;
+            if (this.referrerData) {
+                debugLog('[PlayInstallReferrer] Install referrer fetched:', {
+                    utmSource: this.referrerData.utmSource,
+                    utmMedium: this.referrerData.utmMedium,
+                    hasGclid: !!this.referrerData.gclid,
+                });
+            }
+        }
+        catch (error) {
+            errorLog('[PlayInstallReferrer] Failed to initialize:', error);
+        }
+    }
+    /**
+     * Fetch install referrer from Play Store
+     */
+    async fetchInstallReferrer() {
+        if (!this.isAvailable()) {
+            return null;
+        }
+        try {
+            const referrer = await DatalyrPlayInstallReferrer.getInstallReferrer();
+            if (!referrer) {
+                return null;
+            }
+            // Parse UTM parameters from referrer URL
+            const parsed = this.parseReferrerUrl(referrer.referrerUrl);
+            return {
+                ...referrer,
+                ...parsed,
+            };
+        }
+        catch (error) {
+            errorLog('[PlayInstallReferrer] Error fetching referrer:', error);
+            return null;
+        }
+    }
+    /**
+     * Parse referrer URL to extract UTM parameters and click IDs
+     */
+    parseReferrerUrl(referrerUrl) {
+        const params = {};
+        if (!referrerUrl)
+            return params;
+        try {
+            // Referrer URL is URL-encoded, decode it first
+            const decoded = decodeURIComponent(referrerUrl);
+            const searchParams = new URLSearchParams(decoded);
+            // Extract UTM parameters
+            params.utmSource = searchParams.get('utm_source') || undefined;
+            params.utmMedium = searchParams.get('utm_medium') || undefined;
+            params.utmCampaign = searchParams.get('utm_campaign') || undefined;
+            params.utmTerm = searchParams.get('utm_term') || undefined;
+            params.utmContent = searchParams.get('utm_content') || undefined;
+            // Extract click IDs
+            params.gclid = searchParams.get('gclid') || undefined;
+            // Store any additional parameters
+            searchParams.forEach((value, key) => {
+                if (!key.startsWith('utm_') && key !== 'gclid') {
+                    params[key] = value;
+                }
+            });
+            debugLog('[PlayInstallReferrer] Parsed referrer URL:', params);
+        }
+        catch (error) {
+            errorLog('[PlayInstallReferrer] Error parsing referrer URL:', error);
+        }
+        return params;
+    }
+    /**
+     * Get cached install referrer data
+     */
+    getReferrerData() {
+        return this.referrerData;
+    }
+    /**
+     * Get attribution data in standard format
+     */
+    getAttributionData() {
+        if (!this.referrerData)
+            return {};
+        return {
+            // Install referrer specific
+            install_referrer_url: this.referrerData.referrerUrl,
+            referrer_click_timestamp: this.referrerData.referrerClickTimestamp,
+            install_begin_timestamp: this.referrerData.installBeginTimestamp,
+            // Standard attribution fields
+            gclid: this.referrerData.gclid,
+            utm_source: this.referrerData.utmSource,
+            utm_medium: this.referrerData.utmMedium,
+            utm_campaign: this.referrerData.utmCampaign,
+            utm_term: this.referrerData.utmTerm,
+            utm_content: this.referrerData.utmContent,
+            // Source indicators
+            attribution_source: 'play_install_referrer',
+        };
+    }
+}
+export const playInstallReferrerIntegration = new PlayInstallReferrerIntegration();

package/lib/integrations/tiktok-integration.d.ts

@@ -14,6 +14,7 @@ export declare class TikTokIntegration {
     private debug;
     /**
      * Initialize TikTok SDK with configuration
+     * Supported on both iOS and Android via native modules
      */
     initialize(config: TikTokConfig, debug?: boolean): Promise<void>;
     /**