@datalyr/react-native 1.1.1 → 1.2.1

package/lib/integrations/tiktok-integration.js

@@ -0,0 +1,356 @@
+/**
+ * TikTok Business SDK Integration
+ * Uses bundled native iOS SDK for event forwarding and user identification
+ */
+import { Platform } from 'react-native';
+import { TikTokNativeBridge, isNativeModuleAvailable } from '../native/DatalyrNativeBridge';
+/**
+ * TikTok standard event names (current as of 2025)
+ * Note: CompletePayment and SubmitForm are legacy, use Purchase and Lead instead
+ */
+const TikTokEvents = {
+    // Commerce events
+    PURCHASE: 'Purchase',
+    ADD_TO_CART: 'AddToCart',
+    ADD_TO_WISHLIST: 'AddToWishlist',
+    INITIATE_CHECKOUT: 'InitiateCheckout',
+    ADD_PAYMENT_INFO: 'AddPaymentInfo',
+    VIEW_CONTENT: 'ViewContent',
+    SEARCH: 'Search',
+    // User events
+    COMPLETE_REGISTRATION: 'CompleteRegistration',
+    SUBSCRIBE: 'Subscribe',
+    START_TRIAL: 'StartTrial',
+    LEAD: 'Lead',
+    CONTACT: 'Contact',
+    // App events
+    DOWNLOAD: 'Download',
+    SCHEDULE: 'Schedule',
+    SUBMIT_APPLICATION: 'SubmitApplication',
+};
+/**
+ * TikTok Integration class for handling TikTok Business SDK operations
+ * Uses native iOS SDK bundled via CocoaPods (no additional npm packages required)
+ */
+export class TikTokIntegration {
+    constructor() {
+        this.config = null;
+        this.initialized = false;
+        this.available = false;
+        this.debug = false;
+    }
+    /**
+     * Initialize TikTok SDK with configuration
+     */
+    async initialize(config, debug = false) {
+        this.debug = debug;
+        this.config = config;
+        // Only available on iOS via native module
+        if (Platform.OS !== 'ios') {
+            this.log('TikTok SDK only available on iOS');
+            return;
+        }
+        this.available = isNativeModuleAvailable();
+        if (!this.available) {
+            this.log('TikTok native module not available');
+            return;
+        }
+        try {
+            const success = await TikTokNativeBridge.initialize(config.appId, config.tiktokAppId, config.accessToken, debug);
+            if (success) {
+                this.initialized = true;
+                this.log(`TikTok SDK initialized with App ID: ${config.tiktokAppId}`);
+            }
+        }
+        catch (error) {
+            this.logError('Failed to initialize TikTok SDK:', error);
+        }
+    }
+    /**
+     * Update tracking authorization status (call after ATT prompt)
+     */
+    async updateTrackingAuthorization(enabled) {
+        if (!this.available || !this.initialized)
+            return;
+        try {
+            // TikTok SDK auto-handles ATT, but we track the event
+            if (enabled) {
+                await this.trackEvent('ATTAuthorized');
+            }
+            await TikTokNativeBridge.updateTrackingAuthorization(enabled);
+            this.log(`TikTok ATT status: ${enabled ? 'authorized' : 'not authorized'}`);
+        }
+        catch (error) {
+            this.logError('Failed to update TikTok tracking authorization:', error);
+        }
+    }
+    /**
+     * Log purchase event to TikTok (uses Purchase - TikTok's current standard event)
+     */
+    async logPurchase(value, currency, contentId, contentType, parameters) {
+        var _a;
+        if (!this.available || !this.initialized)
+            return;
+        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableAppEvents) === false)
+            return;
+        try {
+            const properties = {
+                value,
+                currency,
+                ...parameters,
+            };
+            if (contentId)
+                properties.content_id = contentId;
+            if (contentType)
+                properties.content_type = contentType;
+            await TikTokNativeBridge.trackEvent(TikTokEvents.PURCHASE, undefined, properties);
+            this.log(`TikTok Purchase event logged: ${value} ${currency}`);
+        }
+        catch (error) {
+            this.logError('Failed to log TikTok purchase:', error);
+        }
+    }
+    /**
+     * Log subscription event to TikTok
+     */
+    async logSubscription(value, currency, plan) {
+        var _a;
+        if (!this.available || !this.initialized)
+            return;
+        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableAppEvents) === false)
+            return;
+        try {
+            const properties = {
+                value,
+                currency,
+            };
+            if (plan) {
+                properties.content_id = plan;
+                properties.content_type = 'subscription';
+            }
+            await TikTokNativeBridge.trackEvent(TikTokEvents.SUBSCRIBE, undefined, properties);
+            this.log(`TikTok subscription event logged: ${value} ${currency}`);
+        }
+        catch (error) {
+            this.logError('Failed to log TikTok subscription:', error);
+        }
+    }
+    /**
+     * Log add to cart event
+     */
+    async logAddToCart(value, currency, contentId, contentType) {
+        var _a;
+        if (!this.available || !this.initialized)
+            return;
+        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableAppEvents) === false)
+            return;
+        try {
+            const properties = {
+                value,
+                currency,
+            };
+            if (contentId)
+                properties.content_id = contentId;
+            if (contentType)
+                properties.content_type = contentType;
+            await TikTokNativeBridge.trackEvent(TikTokEvents.ADD_TO_CART, undefined, properties);
+            this.log('TikTok add to cart event logged');
+        }
+        catch (error) {
+            this.logError('Failed to log TikTok add to cart:', error);
+        }
+    }
+    /**
+     * Log view content event
+     */
+    async logViewContent(contentId, contentName, contentType) {
+        var _a;
+        if (!this.available || !this.initialized)
+            return;
+        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableAppEvents) === false)
+            return;
+        try {
+            const properties = {};
+            if (contentId)
+                properties.content_id = contentId;
+            if (contentName)
+                properties.content_name = contentName;
+            if (contentType)
+                properties.content_type = contentType;
+            await TikTokNativeBridge.trackEvent(TikTokEvents.VIEW_CONTENT, undefined, properties);
+            this.log('TikTok view content event logged');
+        }
+        catch (error) {
+            this.logError('Failed to log TikTok view content:', error);
+        }
+    }
+    /**
+     * Log initiate checkout event
+     */
+    async logInitiateCheckout(value, currency, numItems) {
+        var _a;
+        if (!this.available || !this.initialized)
+            return;
+        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableAppEvents) === false)
+            return;
+        try {
+            const properties = {
+                value,
+                currency,
+            };
+            if (numItems)
+                properties.quantity = numItems;
+            await TikTokNativeBridge.trackEvent(TikTokEvents.INITIATE_CHECKOUT, undefined, properties);
+            this.log('TikTok initiate checkout event logged');
+        }
+        catch (error) {
+            this.logError('Failed to log TikTok initiate checkout:', error);
+        }
+    }
+    /**
+     * Log complete registration event
+     */
+    async logCompleteRegistration(method) {
+        var _a;
+        if (!this.available || !this.initialized)
+            return;
+        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableAppEvents) === false)
+            return;
+        try {
+            const properties = {};
+            if (method)
+                properties.registration_method = method;
+            await TikTokNativeBridge.trackEvent(TikTokEvents.COMPLETE_REGISTRATION, undefined, properties);
+            this.log('TikTok complete registration event logged');
+        }
+        catch (error) {
+            this.logError('Failed to log TikTok complete registration:', error);
+        }
+    }
+    /**
+     * Log search event
+     */
+    async logSearch(query) {
+        var _a;
+        if (!this.available || !this.initialized)
+            return;
+        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableAppEvents) === false)
+            return;
+        try {
+            await TikTokNativeBridge.trackEvent(TikTokEvents.SEARCH, undefined, { query });
+            this.log('TikTok search event logged');
+        }
+        catch (error) {
+            this.logError('Failed to log TikTok search:', error);
+        }
+    }
+    /**
+     * Log lead event (uses Lead - current standard, SubmitForm is legacy)
+     */
+    async logLead(value, currency) {
+        var _a;
+        if (!this.available || !this.initialized)
+            return;
+        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableAppEvents) === false)
+            return;
+        try {
+            const properties = {};
+            if (value !== undefined)
+                properties.value = value;
+            if (currency)
+                properties.currency = currency;
+            await TikTokNativeBridge.trackEvent(TikTokEvents.LEAD, undefined, properties);
+            this.log('TikTok lead event logged');
+        }
+        catch (error) {
+            this.logError('Failed to log TikTok lead:', error);
+        }
+    }
+    /**
+     * Log add payment info event
+     */
+    async logAddPaymentInfo(success) {
+        var _a;
+        if (!this.available || !this.initialized)
+            return;
+        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableAppEvents) === false)
+            return;
+        try {
+            await TikTokNativeBridge.trackEvent(TikTokEvents.ADD_PAYMENT_INFO, undefined, { success });
+            this.log('TikTok add payment info event logged');
+        }
+        catch (error) {
+            this.logError('Failed to log TikTok add payment info:', error);
+        }
+    }
+    /**
+     * Log custom event to TikTok
+     */
+    async trackEvent(eventName, properties) {
+        var _a;
+        if (!this.available || !this.initialized)
+            return;
+        if (((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableAppEvents) === false)
+            return;
+        try {
+            await TikTokNativeBridge.trackEvent(eventName, undefined, properties || {});
+            this.log(`TikTok event logged: ${eventName}`);
+        }
+        catch (error) {
+            this.logError('Failed to log TikTok event:', error);
+        }
+    }
+    /**
+     * Identify user for improved attribution matching
+     */
+    async identify(email, phone, externalId) {
+        if (!this.available || !this.initialized)
+            return;
+        // Only call identify if we have at least one value
+        if (!email && !phone && !externalId)
+            return;
+        try {
+            await TikTokNativeBridge.identify(externalId, email, phone);
+            this.log('TikTok user identification set');
+        }
+        catch (error) {
+            this.logError('Failed to identify TikTok user:', error);
+        }
+    }
+    /**
+     * Clear user session (call on logout)
+     */
+    async logout() {
+        if (!this.available || !this.initialized)
+            return;
+        try {
+            await TikTokNativeBridge.logout();
+            this.log('TikTok user logged out');
+        }
+        catch (error) {
+            this.logError('Failed to logout TikTok user:', error);
+        }
+    }
+    /**
+     * Check if TikTok SDK is available and initialized
+     */
+    isAvailable() {
+        return this.available && this.initialized;
+    }
+    /**
+     * Check if TikTok SDK native module is installed
+     */
+    isInstalled() {
+        return this.available;
+    }
+    log(message, data) {
+        if (this.debug) {
+            console.log(`[Datalyr/TikTok] ${message}`, data || '');
+        }
+    }
+    logError(message, error) {
+        console.error(`[Datalyr/TikTok] ${message}`, error);
+    }
+}
+// Export singleton instance
+export const tiktokIntegration = new TikTokIntegration();

package/lib/native/DatalyrNativeBridge.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Native Bridge for Meta, TikTok, and Apple Search Ads
+ * Uses bundled native modules instead of separate npm packages
+ */
+/**
+ * Apple Search Ads attribution data returned from AdServices API
+ */
+export interface AppleSearchAdsAttribution {
+    attribution: boolean;
+    orgId?: number;
+    orgName?: string;
+    campaignId?: number;
+    campaignName?: string;
+    adGroupId?: number;
+    adGroupName?: string;
+    keywordId?: number;
+    keyword?: string;
+    clickDate?: string;
+    conversionType?: string;
+    countryOrRegion?: string;
+}
+/**
+ * Check if native module is available
+ */
+export declare const isNativeModuleAvailable: () => boolean;
+/**
+ * Get SDK availability status
+ */
+export declare const getSDKAvailability: () => Promise<{
+    meta: boolean;
+    tiktok: boolean;
+    appleSearchAds: boolean;
+}>;
+export declare const MetaNativeBridge: {
+    initialize(appId: string, clientToken?: string, advertiserTrackingEnabled?: boolean): Promise<boolean>;
+    fetchDeferredAppLink(): Promise<string | null>;
+    logEvent(eventName: string, valueToSum?: number, parameters?: Record<string, any>): Promise<boolean>;
+    logPurchase(amount: number, currency: string, parameters?: Record<string, any>): Promise<boolean>;
+    setUserData(userData: Record<string, string | undefined>): Promise<boolean>;
+    clearUserData(): Promise<boolean>;
+    updateTrackingAuthorization(enabled: boolean): Promise<boolean>;
+};
+export declare const TikTokNativeBridge: {
+    initialize(appId: string, tiktokAppId: string, accessToken?: string, debug?: boolean): Promise<boolean>;
+    trackEvent(eventName: string, eventId?: string, properties?: Record<string, any>): Promise<boolean>;
+    identify(externalId?: string, email?: string, phone?: string): Promise<boolean>;
+    logout(): Promise<boolean>;
+    updateTrackingAuthorization(enabled: boolean): Promise<boolean>;
+};
+export declare const AppleSearchAdsNativeBridge: {
+    /**
+     * Get Apple Search Ads attribution data
+     * Uses AdServices framework (iOS 14.3+)
+     * Returns null if user didn't come from Apple Search Ads or on older iOS
+     */
+    getAttribution(): Promise<AppleSearchAdsAttribution | null>;
+};

package/lib/native/DatalyrNativeBridge.js

@@ -0,0 +1,187 @@
+/**
+ * Native Bridge for Meta, TikTok, and Apple Search Ads
+ * Uses bundled native modules instead of separate npm packages
+ */
+import { NativeModules, Platform } from 'react-native';
+// Native module is only available on iOS
+const DatalyrNative = Platform.OS === 'ios' ? NativeModules.DatalyrNative : null;
+/**
+ * Check if native module is available
+ */
+export const isNativeModuleAvailable = () => {
+    return DatalyrNative !== null;
+};
+/**
+ * Get SDK availability status
+ */
+export const getSDKAvailability = async () => {
+    if (!DatalyrNative) {
+        return { meta: false, tiktok: false, appleSearchAds: false };
+    }
+    try {
+        return await DatalyrNative.getSDKAvailability();
+    }
+    catch (_a) {
+        return { meta: false, tiktok: false, appleSearchAds: false };
+    }
+};
+// MARK: - Meta SDK Bridge
+export const MetaNativeBridge = {
+    async initialize(appId, clientToken, advertiserTrackingEnabled = false) {
+        if (!DatalyrNative)
+            return false;
+        try {
+            return await DatalyrNative.initializeMetaSDK(appId, clientToken || null, advertiserTrackingEnabled);
+        }
+        catch (error) {
+            console.error('[Datalyr/MetaNative] Initialize failed:', error);
+            return false;
+        }
+    },
+    async fetchDeferredAppLink() {
+        if (!DatalyrNative)
+            return null;
+        try {
+            return await DatalyrNative.fetchDeferredAppLink();
+        }
+        catch (_a) {
+            return null;
+        }
+    },
+    async logEvent(eventName, valueToSum, parameters) {
+        if (!DatalyrNative)
+            return false;
+        try {
+            return await DatalyrNative.logMetaEvent(eventName, valueToSum !== null && valueToSum !== void 0 ? valueToSum : null, parameters || null);
+        }
+        catch (error) {
+            console.error('[Datalyr/MetaNative] Log event failed:', error);
+            return false;
+        }
+    },
+    async logPurchase(amount, currency, parameters) {
+        if (!DatalyrNative)
+            return false;
+        try {
+            return await DatalyrNative.logMetaPurchase(amount, currency, parameters || null);
+        }
+        catch (error) {
+            console.error('[Datalyr/MetaNative] Log purchase failed:', error);
+            return false;
+        }
+    },
+    async setUserData(userData) {
+        if (!DatalyrNative)
+            return false;
+        try {
+            return await DatalyrNative.setMetaUserData(userData);
+        }
+        catch (error) {
+            console.error('[Datalyr/MetaNative] Set user data failed:', error);
+            return false;
+        }
+    },
+    async clearUserData() {
+        if (!DatalyrNative)
+            return false;
+        try {
+            return await DatalyrNative.clearMetaUserData();
+        }
+        catch (error) {
+            console.error('[Datalyr/MetaNative] Clear user data failed:', error);
+            return false;
+        }
+    },
+    async updateTrackingAuthorization(enabled) {
+        if (!DatalyrNative)
+            return false;
+        try {
+            return await DatalyrNative.updateMetaTrackingAuthorization(enabled);
+        }
+        catch (error) {
+            console.error('[Datalyr/MetaNative] Update tracking failed:', error);
+            return false;
+        }
+    },
+};
+// MARK: - TikTok SDK Bridge
+export const TikTokNativeBridge = {
+    async initialize(appId, tiktokAppId, accessToken, debug = false) {
+        if (!DatalyrNative)
+            return false;
+        try {
+            return await DatalyrNative.initializeTikTokSDK(appId, tiktokAppId, accessToken || null, debug);
+        }
+        catch (error) {
+            console.error('[Datalyr/TikTokNative] Initialize failed:', error);
+            return false;
+        }
+    },
+    async trackEvent(eventName, eventId, properties) {
+        if (!DatalyrNative)
+            return false;
+        try {
+            return await DatalyrNative.trackTikTokEvent(eventName, eventId || null, properties || null);
+        }
+        catch (error) {
+            console.error('[Datalyr/TikTokNative] Track event failed:', error);
+            return false;
+        }
+    },
+    async identify(externalId, email, phone) {
+        if (!DatalyrNative)
+            return false;
+        // Only call if we have at least one value
+        if (!externalId && !email && !phone)
+            return false;
+        try {
+            return await DatalyrNative.identifyTikTokUser(externalId || '', '', // externalUserName - not typically available
+            phone || '', email || '');
+        }
+        catch (error) {
+            console.error('[Datalyr/TikTokNative] Identify failed:', error);
+            return false;
+        }
+    },
+    async logout() {
+        if (!DatalyrNative)
+            return false;
+        try {
+            return await DatalyrNative.logoutTikTok();
+        }
+        catch (error) {
+            console.error('[Datalyr/TikTokNative] Logout failed:', error);
+            return false;
+        }
+    },
+    async updateTrackingAuthorization(enabled) {
+        if (!DatalyrNative)
+            return false;
+        try {
+            return await DatalyrNative.updateTikTokTrackingAuthorization(enabled);
+        }
+        catch (error) {
+            console.error('[Datalyr/TikTokNative] Update tracking failed:', error);
+            return false;
+        }
+    },
+};
+// MARK: - Apple Search Ads Bridge
+export const AppleSearchAdsNativeBridge = {
+    /**
+     * Get Apple Search Ads attribution data
+     * Uses AdServices framework (iOS 14.3+)
+     * Returns null if user didn't come from Apple Search Ads or on older iOS
+     */
+    async getAttribution() {
+        if (!DatalyrNative)
+            return null;
+        try {
+            return await DatalyrNative.getAppleSearchAdsAttribution();
+        }
+        catch (error) {
+            console.error('[Datalyr/AppleSearchAds] Get attribution failed:', error);
+            return null;
+        }
+    },
+};

package/lib/native/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Native Module Exports
+ */
+export { SKAdNetworkBridge } from './SKAdNetworkBridge';
+export { isNativeModuleAvailable, getSDKAvailability, MetaNativeBridge, TikTokNativeBridge, } from './DatalyrNativeBridge';

package/lib/native/index.js

@@ -0,0 +1,5 @@
+/**
+ * Native Module Exports
+ */
+export { SKAdNetworkBridge } from './SKAdNetworkBridge';
+export { isNativeModuleAvailable, getSDKAvailability, MetaNativeBridge, TikTokNativeBridge, } from './DatalyrNativeBridge';

package/lib/types.d.ts

@@ -5,6 +5,33 @@ export interface AutoEventConfig {
     trackPerformance?: boolean;
     sessionTimeoutMs?: number;
 }
+export interface MetaConfig {
+    appId: string;
+    clientToken?: string;
+    enableDeferredDeepLink?: boolean;
+    enableAppEvents?: boolean;
+    advertiserTrackingEnabled?: boolean;
+}
+export interface TikTokConfig {
+    appId: string;
+    tiktokAppId: string;
+    accessToken?: string;
+    enableAppEvents?: boolean;
+}
+export interface DeferredDeepLinkResult {
+    url?: string;
+    source?: string;
+    fbclid?: string;
+    ttclid?: string;
+    utmSource?: string;
+    utmMedium?: string;
+    utmCampaign?: string;
+    utmContent?: string;
+    utmTerm?: string;
+    campaignId?: string;
+    adsetId?: string;
+    adId?: string;
+}
 export interface DatalyrConfig {
     apiKey: string;
     workspaceId?: string;
@@ -30,6 +57,8 @@ export interface DatalyrConfig {
         retryDelay: number;
     };
     skadTemplate?: 'ecommerce' | 'gaming' | 'subscription';
+    meta?: MetaConfig;
+    tiktok?: TikTokConfig;
 }
 export interface EventData {
     [key: string]: any;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datalyr/react-native",
-  "version": "1.1.1",
-  "description": "Datalyr SDK for React Native & Expo - Server-side attribution tracking",
+  "version": "1.2.1",
+  "description": "Datalyr SDK for React Native & Expo - Server-side attribution tracking with bundled Meta and TikTok SDKs",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
@@ -14,8 +14,11 @@
   "files": [
     "lib/",
     "src/",
-    "*.md",
-    "examples/"
+    "ios/",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "*.podspec"
   ],
   "keywords": [
     "react-native",
@@ -35,8 +38,11 @@
     "tiktok-attribution",
     "google-attribution",
     "ios-attribution",
+    "apple-search-ads",
     "conversion-tracking",
-    "revenue-optimization"
+    "revenue-optimization",
+    "deferred-deep-linking",
+    "fbclid"
   ],
   "author": "Datalyr",
   "license": "MIT",