@datalyr/react-native 1.1.1 → 1.2.1

package/lib/datalyr-sdk.js

@@ -6,6 +6,7 @@ import { attributionManager } from './attribution';
 import { AutoEventsManager } from './auto-events';
 import { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 import { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
+import { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
 export class DatalyrSDK {
     constructor() {
         this.autoEventsManager = null;
@@ -41,7 +42,7 @@ export class DatalyrSDK {
      * Initialize the SDK with configuration
      */
     async initialize(config) {
-        var _a;
+        var _a, _b, _c, _d;
         try {
             debugLog('Initializing Datalyr SDK...', { workspaceId: config.workspaceId });
             // Validate configuration
@@ -116,6 +117,28 @@ export class DatalyrSDK {
                     }
                 }
             }
+            // Initialize Meta SDK 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);
+                    }
+                }
+            }
+            // Initialize TikTok SDK 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);
+            }
+            // Initialize Apple Search Ads attribution (iOS only, auto-fetches on init)
+            await appleSearchAdsIntegration.initialize(config.debug);
+            debugLog('Platform integrations initialized', {
+                meta: metaIntegration.isAvailable(),
+                tiktok: tiktokIntegration.isAvailable(),
+                appleSearchAds: appleSearchAdsIntegration.isAvailable(),
+            });
             // SDK initialized successfully - set state before tracking install event
             this.state.initialized = true;
             // Check for app install (after SDK is marked as initialized)
@@ -207,6 +230,36 @@ export class DatalyrSDK {
                     await this.fetchAndMergeWebAttribution(email);
                 }
             }
+            // Forward user data to platform SDKs for Advanced Matching
+            const email = properties === null || properties === void 0 ? void 0 : properties.email;
+            const phone = properties === null || properties === void 0 ? void 0 : properties.phone;
+            const firstName = ((properties === null || properties === void 0 ? void 0 : properties.first_name) || (properties === null || properties === void 0 ? void 0 : properties.firstName));
+            const lastName = ((properties === null || properties === void 0 ? void 0 : properties.last_name) || (properties === null || properties === void 0 ? void 0 : properties.lastName));
+            const dateOfBirth = ((properties === null || properties === void 0 ? void 0 : properties.date_of_birth) || (properties === null || properties === void 0 ? void 0 : properties.dob) || (properties === null || properties === void 0 ? void 0 : properties.birthday));
+            const gender = properties === null || properties === void 0 ? void 0 : properties.gender;
+            const city = properties === null || properties === void 0 ? void 0 : properties.city;
+            const state = properties === null || properties === void 0 ? void 0 : properties.state;
+            const zip = ((properties === null || properties === void 0 ? void 0 : properties.zip) || (properties === null || properties === void 0 ? void 0 : properties.postal_code) || (properties === null || properties === void 0 ? void 0 : properties.zipcode));
+            const country = properties === null || properties === void 0 ? void 0 : properties.country;
+            // Meta Advanced Matching
+            if (metaIntegration.isAvailable()) {
+                metaIntegration.setUserData({
+                    email,
+                    firstName,
+                    lastName,
+                    phone,
+                    dateOfBirth,
+                    gender,
+                    city,
+                    state,
+                    zip,
+                    country,
+                });
+            }
+            // TikTok identification
+            if (tiktokIntegration.isAvailable()) {
+                tiktokIntegration.identify(email, phone, userId);
+            }
         }
         catch (error) {
             errorLog('Error identifying user:', error);
@@ -310,6 +363,10 @@ export class DatalyrSDK {
             await Storage.removeItem(STORAGE_KEYS.USER_PROPERTIES);
             // Generate new session
             this.state.sessionId = await getOrCreateSessionId();
+            // Clear user data from platform SDKs
+            if (metaIntegration.isAvailable()) {
+                metaIntegration.clearUserData();
+            }
             debugLog('User data reset completed');
         }
         catch (error) {
@@ -426,22 +483,263 @@ export class DatalyrSDK {
         }
     }
     /**
-     * Track purchase with automatic revenue encoding
+     * Track purchase with automatic revenue encoding and platform forwarding
      */
     async trackPurchase(value, currency = 'USD', productId) {
         const properties = { revenue: value, currency };
         if (productId)
             properties.product_id = productId;
         await this.trackWithSKAdNetwork('purchase', properties);
+        // Forward to Meta if available
+        if (metaIntegration.isAvailable()) {
+            metaIntegration.logPurchase(value, currency, { fb_content_id: productId });
+        }
+        // Forward to TikTok if available
+        if (tiktokIntegration.isAvailable()) {
+            tiktokIntegration.logPurchase(value, currency, productId, 'product');
+        }
     }
     /**
-     * Track subscription with automatic revenue encoding
+     * Track subscription with automatic revenue encoding and platform forwarding
      */
     async trackSubscription(value, currency = 'USD', plan) {
         const properties = { revenue: value, currency };
         if (plan)
             properties.plan = plan;
         await this.trackWithSKAdNetwork('subscribe', properties);
+        // Forward to Meta if available
+        if (metaIntegration.isAvailable()) {
+            metaIntegration.logEvent('Subscribe', value, { subscription_plan: plan });
+        }
+        // Forward to TikTok if available
+        if (tiktokIntegration.isAvailable()) {
+            tiktokIntegration.logSubscription(value, currency, plan);
+        }
+    }
+    // MARK: - Standard E-commerce Events
+    /**
+     * Track add to cart event
+     */
+    async trackAddToCart(value, currency = 'USD', productId, productName) {
+        const properties = { value, currency };
+        if (productId)
+            properties.product_id = productId;
+        if (productName)
+            properties.product_name = productName;
+        await this.trackWithSKAdNetwork('add_to_cart', properties);
+        // Forward to Meta
+        if (metaIntegration.isAvailable()) {
+            metaIntegration.logEvent('AddToCart', value, {
+                currency,
+                content_ids: productId ? [productId] : undefined,
+                content_name: productName,
+            });
+        }
+        // Forward to TikTok
+        if (tiktokIntegration.isAvailable()) {
+            tiktokIntegration.logAddToCart(value, currency, productId, 'product');
+        }
+    }
+    /**
+     * Track view content/product event
+     */
+    async trackViewContent(contentId, contentName, contentType = 'product', value, currency) {
+        const properties = { content_type: contentType };
+        if (contentId)
+            properties.content_id = contentId;
+        if (contentName)
+            properties.content_name = contentName;
+        if (value !== undefined)
+            properties.value = value;
+        if (currency)
+            properties.currency = currency;
+        await this.track('view_content', properties);
+        // Forward to Meta
+        if (metaIntegration.isAvailable()) {
+            metaIntegration.logEvent('ViewContent', value, {
+                content_ids: contentId ? [contentId] : undefined,
+                content_name: contentName,
+                content_type: contentType,
+                currency,
+            });
+        }
+        // Forward to TikTok
+        if (tiktokIntegration.isAvailable()) {
+            tiktokIntegration.logViewContent(contentId, contentName, contentType);
+        }
+    }
+    /**
+     * Track initiate checkout event
+     */
+    async trackInitiateCheckout(value, currency = 'USD', numItems, productIds) {
+        const properties = { value, currency };
+        if (numItems !== undefined)
+            properties.num_items = numItems;
+        if (productIds)
+            properties.product_ids = productIds;
+        await this.trackWithSKAdNetwork('initiate_checkout', properties);
+        // Forward to Meta
+        if (metaIntegration.isAvailable()) {
+            metaIntegration.logEvent('InitiateCheckout', value, {
+                currency,
+                num_items: numItems,
+                content_ids: productIds,
+            });
+        }
+        // Forward to TikTok
+        if (tiktokIntegration.isAvailable()) {
+            tiktokIntegration.logInitiateCheckout(value, currency, numItems);
+        }
+    }
+    /**
+     * Track complete registration event
+     */
+    async trackCompleteRegistration(method) {
+        const properties = {};
+        if (method)
+            properties.method = method;
+        await this.trackWithSKAdNetwork('complete_registration', properties);
+        // Forward to Meta
+        if (metaIntegration.isAvailable()) {
+            metaIntegration.logEvent('CompleteRegistration', undefined, { registration_method: method });
+        }
+        // Forward to TikTok
+        if (tiktokIntegration.isAvailable()) {
+            tiktokIntegration.logCompleteRegistration(method);
+        }
+    }
+    /**
+     * Track search event
+     */
+    async trackSearch(query, resultIds) {
+        const properties = { query };
+        if (resultIds)
+            properties.result_ids = resultIds;
+        await this.track('search', properties);
+        // Forward to Meta
+        if (metaIntegration.isAvailable()) {
+            metaIntegration.logEvent('Search', undefined, {
+                search_string: query,
+                content_ids: resultIds,
+            });
+        }
+        // Forward to TikTok
+        if (tiktokIntegration.isAvailable()) {
+            tiktokIntegration.logSearch(query);
+        }
+    }
+    /**
+     * Track lead/contact form submission
+     */
+    async trackLead(value, currency) {
+        const properties = {};
+        if (value !== undefined)
+            properties.value = value;
+        if (currency)
+            properties.currency = currency;
+        await this.trackWithSKAdNetwork('lead', properties);
+        // Forward to Meta
+        if (metaIntegration.isAvailable()) {
+            metaIntegration.logEvent('Lead', value, { currency });
+        }
+        // Forward to TikTok
+        if (tiktokIntegration.isAvailable()) {
+            tiktokIntegration.logLead(value, currency);
+        }
+    }
+    /**
+     * Track add payment info event
+     */
+    async trackAddPaymentInfo(success = true) {
+        await this.track('add_payment_info', { success });
+        // Forward to Meta
+        if (metaIntegration.isAvailable()) {
+            metaIntegration.logEvent('AddPaymentInfo', undefined, { success: success ? 1 : 0 });
+        }
+        // Forward to TikTok
+        if (tiktokIntegration.isAvailable()) {
+            tiktokIntegration.logAddPaymentInfo(success);
+        }
+    }
+    // MARK: - Platform Integration Methods
+    /**
+     * Get deferred attribution data from platform SDKs
+     */
+    getDeferredAttributionData() {
+        return metaIntegration.getDeferredDeepLinkData();
+    }
+    /**
+     * Get platform integration status
+     */
+    getPlatformIntegrationStatus() {
+        return {
+            meta: metaIntegration.isAvailable(),
+            tiktok: tiktokIntegration.isAvailable(),
+            appleSearchAds: appleSearchAdsIntegration.isAvailable(),
+        };
+    }
+    /**
+     * Get Apple Search Ads attribution data
+     * Returns attribution if user installed via Apple Search Ads, null otherwise
+     */
+    getAppleSearchAdsAttribution() {
+        return appleSearchAdsIntegration.getAttributionData();
+    }
+    /**
+     * Update tracking authorization status on all platform SDKs
+     * Call this AFTER the user responds to the ATT permission dialog
+     */
+    async updateTrackingAuthorization(enabled) {
+        if (!this.state.initialized) {
+            errorLog('SDK not initialized. Call initialize() first.');
+            return;
+        }
+        metaIntegration.updateTrackingAuthorization(enabled);
+        tiktokIntegration.updateTrackingAuthorization(enabled);
+        // Track ATT status event
+        await this.track('$att_status', {
+            authorized: enabled,
+            status: enabled ? 3 : 2,
+            status_name: enabled ? 'authorized' : 'denied',
+        });
+        debugLog(`ATT status updated: ${enabled ? 'authorized' : 'denied'}`);
+    }
+    /**
+     * Handle deferred deep link data from platform SDKs
+     */
+    async handleDeferredDeepLink(data) {
+        try {
+            debugLog('Processing deferred deep link:', data);
+            // Track deferred attribution event
+            await this.track('$deferred_deep_link', {
+                url: data.url,
+                source: data.source,
+                fbclid: data.fbclid,
+                ttclid: data.ttclid,
+                utm_source: data.utmSource,
+                utm_medium: data.utmMedium,
+                utm_campaign: data.utmCampaign,
+                utm_content: data.utmContent,
+                utm_term: data.utmTerm,
+                campaign_id: data.campaignId,
+                adset_id: data.adsetId,
+                ad_id: data.adId,
+            });
+            // Merge into attribution manager
+            attributionManager.mergeWebAttribution({
+                fbclid: data.fbclid,
+                ttclid: data.ttclid,
+                utm_source: data.utmSource,
+                utm_medium: data.utmMedium,
+                utm_campaign: data.utmCampaign,
+                utm_content: data.utmContent,
+                utm_term: data.utmTerm,
+            });
+            debugLog('Deferred deep link processed successfully');
+        }
+        catch (error) {
+            errorLog('Error processing deferred deep link:', error);
+        }
     }
     /**
      * Get conversion value for testing (doesn't send to Apple)
@@ -458,6 +756,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,
@@ -479,6 +792,8 @@ export class DatalyrSDK {
                 timestamp: Date.now(),
                 // Attribution data
                 ...attributionData,
+                // Apple Search Ads attribution
+                ...asaData,
             },
             fingerprintData,
             source: 'mobile_app',
@@ -683,6 +998,41 @@ export class Datalyr {
     static updateAutoEventsConfig(config) {
         datalyr.updateAutoEventsConfig(config);
     }
+    // Standard e-commerce events (all forward to Meta and TikTok)
+    static async trackAddToCart(value, currency = 'USD', productId, productName) {
+        await datalyr.trackAddToCart(value, currency, productId, productName);
+    }
+    static async trackViewContent(contentId, contentName, contentType = 'product', value, currency) {
+        await datalyr.trackViewContent(contentId, contentName, contentType, value, currency);
+    }
+    static async trackInitiateCheckout(value, currency = 'USD', numItems, productIds) {
+        await datalyr.trackInitiateCheckout(value, currency, numItems, productIds);
+    }
+    static async trackCompleteRegistration(method) {
+        await datalyr.trackCompleteRegistration(method);
+    }
+    static async trackSearch(query, resultIds) {
+        await datalyr.trackSearch(query, resultIds);
+    }
+    static async trackLead(value, currency) {
+        await datalyr.trackLead(value, currency);
+    }
+    static async trackAddPaymentInfo(success = true) {
+        await datalyr.trackAddPaymentInfo(success);
+    }
+    // Platform integration methods
+    static getDeferredAttributionData() {
+        return datalyr.getDeferredAttributionData();
+    }
+    static getPlatformIntegrationStatus() {
+        return datalyr.getPlatformIntegrationStatus();
+    }
+    static getAppleSearchAdsAttribution() {
+        return datalyr.getAppleSearchAdsAttribution();
+    }
+    static async updateTrackingAuthorization(enabled) {
+        await datalyr.updateTrackingAuthorization(enabled);
+    }
 }
 // Export default instance for backward compatibility
 export default datalyr;

package/lib/index.d.ts

@@ -10,4 +10,6 @@ export * from './event-queue';
 export { DatalyrSDK };
 export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 export { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
+export { metaIntegration, tiktokIntegration, appleSearchAdsIntegration } from './integrations';
+export type { AppleSearchAdsAttribution } from './native/DatalyrNativeBridge';
 export default DatalyrSDK;

package/lib/index.js

@@ -1,5 +1,5 @@
 // Main entry point for React Native CLI
-// Import this with: import { datalyr } from '@datalyr/react-native-sdk';
+// Import with: import { Datalyr } from '@datalyr/react-native';
 import { DatalyrSDK, Datalyr } from './datalyr-sdk';
 // Create singleton instance for easy usage
 export const datalyr = new DatalyrSDK();
@@ -18,5 +18,7 @@ export { DatalyrSDK };
 // Export SKAdNetwork components
 export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 export { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
-// Default export for compatibility  
+// Export platform 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

@@ -0,0 +1,7 @@
+/**
+ * Platform SDK Integrations
+ * Meta (Facebook), TikTok, and Apple Search Ads SDK wrappers
+ */
+export { MetaIntegration, metaIntegration } from './meta-integration';
+export { TikTokIntegration, tiktokIntegration } from './tiktok-integration';
+export { AppleSearchAdsIntegration, appleSearchAdsIntegration } from './apple-search-ads-integration';

package/lib/integrations/index.js

@@ -0,0 +1,7 @@
+/**
+ * Platform SDK Integrations
+ * Meta (Facebook), TikTok, and Apple Search Ads SDK wrappers
+ */
+export { MetaIntegration, metaIntegration } from './meta-integration';
+export { TikTokIntegration, tiktokIntegration } from './tiktok-integration';
+export { AppleSearchAdsIntegration, appleSearchAdsIntegration } from './apple-search-ads-integration';