@datalyr/react-native 1.1.1 → 1.2.0

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 } 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,25 @@ 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);
+            }
+            debugLog('Platform integrations initialized', {
+                meta: metaIntegration.isAvailable(),
+                tiktok: tiktokIntegration.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 +227,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 +360,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 +480,255 @@ 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(),
+        };
+    }
+    /**
+     * 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)
@@ -683,6 +970,38 @@ 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 async updateTrackingAuthorization(enabled) {
+        await datalyr.updateTrackingAuthorization(enabled);
+    }
 }
 // Export default instance for backward compatibility
 export default datalyr;

package/lib/index.d.ts

@@ -10,4 +10,5 @@ export * from './event-queue';
 export { DatalyrSDK };
 export { ConversionValueEncoder, ConversionTemplates } from './ConversionValueEncoder';
 export { SKAdNetworkBridge } from './native/SKAdNetworkBridge';
+export { metaIntegration, tiktokIntegration } from './integrations';
 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 } from './integrations';
+// Default export for compatibility
 export default DatalyrSDK;

package/lib/integrations/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Platform SDK Integrations
+ * Meta (Facebook) and TikTok SDK wrappers for deferred deep linking and event forwarding
+ */
+export { MetaIntegration, metaIntegration } from './meta-integration';
+export { TikTokIntegration, tiktokIntegration } from './tiktok-integration';

package/lib/integrations/index.js

@@ -0,0 +1,6 @@
+/**
+ * Platform SDK Integrations
+ * Meta (Facebook) and TikTok SDK wrappers for deferred deep linking and event forwarding
+ */
+export { MetaIntegration, metaIntegration } from './meta-integration';
+export { TikTokIntegration, tiktokIntegration } from './tiktok-integration';

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

@@ -0,0 +1,76 @@
+/**
+ * Meta (Facebook) SDK Integration
+ * Uses bundled native iOS SDK for deferred deep linking, event forwarding, and Advanced Matching
+ */
+import { MetaConfig, DeferredDeepLinkResult } from '../types';
+/**
+ * Meta Integration class for handling Facebook SDK operations
+ * Uses native iOS SDK bundled via CocoaPods (no additional npm packages required)
+ */
+export declare class MetaIntegration {
+    private config;
+    private initialized;
+    private available;
+    private debug;
+    private deferredDeepLinkData;
+    /**
+     * Initialize Meta SDK with configuration
+     */
+    initialize(config: MetaConfig, debug?: boolean): Promise<void>;
+    /**
+     * Update tracking authorization status (call after ATT prompt)
+     */
+    updateTrackingAuthorization(enabled: boolean): Promise<void>;
+    /**
+     * Fetch deferred deep link from Meta SDK
+     * This captures fbclid for installs that went through App Store
+     */
+    fetchDeferredDeepLink(): Promise<DeferredDeepLinkResult | null>;
+    /**
+     * Parse deep link URL to extract attribution parameters
+     */
+    private parseDeepLinkUrl;
+    /**
+     * Log purchase event to Meta
+     */
+    logPurchase(value: number, currency: string, parameters?: Record<string, any>): Promise<void>;
+    /**
+     * Log custom event to Meta
+     */
+    logEvent(eventName: string, valueToSum?: number, parameters?: Record<string, any>): Promise<void>;
+    /**
+     * Set user data for Advanced Matching (improves conversion attribution)
+     * Note: Meta's Advanced Matching uses these specific fields - externalId is not supported
+     */
+    setUserData(userData: {
+        email?: string;
+        firstName?: string;
+        lastName?: string;
+        phone?: string;
+        dateOfBirth?: string;
+        gender?: string;
+        city?: string;
+        state?: string;
+        zip?: string;
+        country?: string;
+    }): Promise<void>;
+    /**
+     * Clear user data (call on logout)
+     */
+    clearUserData(): Promise<void>;
+    /**
+     * Get cached deferred deep link data
+     */
+    getDeferredDeepLinkData(): DeferredDeepLinkResult | null;
+    /**
+     * Check if Meta SDK is available and initialized
+     */
+    isAvailable(): boolean;
+    /**
+     * Check if Meta SDK native module is installed
+     */
+    isInstalled(): boolean;
+    private log;
+    private logError;
+}
+export declare const metaIntegration: MetaIntegration;