@datalyr/react-native 1.3.0 → 1.4.0

package/lib/native/DatalyrNativeBridge.js

@@ -6,12 +6,28 @@
  * - iOS: Meta SDK, TikTok SDK, Apple Search Ads (AdServices)
  * - Android: Meta SDK, TikTok SDK, Play Install Referrer
  */
-var _a;
+var _a, _b;
 import { NativeModules, Platform } from 'react-native';
+import { requireNativeModule } from 'expo-modules-core';
 // Native modules - available on both iOS and Android
-const DatalyrNative = (_a = NativeModules.DatalyrNative) !== null && _a !== void 0 ? _a : null;
-// Play Install Referrer - Android only
-const DatalyrPlayInstallReferrer = Platform.OS === 'android' ? NativeModules.DatalyrPlayInstallReferrer : null;
+// iOS uses Expo Modules (new arch compatible), Android uses NativeModules (interop layer)
+let DatalyrNative = null;
+if (Platform.OS === 'ios') {
+    try {
+        DatalyrNative = requireNativeModule('DatalyrNative');
+    }
+    catch (_c) {
+        // Native module not available
+    }
+}
+else if (Platform.OS === 'android') {
+    DatalyrNative = (_a = NativeModules.DatalyrNative) !== null && _a !== void 0 ? _a : null;
+}
+// Play Install Referrer - Android only (stays on NativeModules)
+let DatalyrPlayInstallReferrer = null;
+if (Platform.OS === 'android') {
+    DatalyrPlayInstallReferrer = (_b = NativeModules.DatalyrPlayInstallReferrer) !== null && _b !== void 0 ? _b : null;
+}
 /**
  * Check if native module is available
  */

package/lib/native/SKAdNetworkBridge.d.ts

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

package/lib/native/SKAdNetworkBridge.js

@@ -1,5 +1,15 @@
-import { NativeModules, Platform } from 'react-native';
-const { DatalyrSKAdNetwork } = NativeModules;
+import { Platform } from 'react-native';
+import { requireNativeModule } from 'expo-modules-core';
+// SKAdNetwork is iOS-only, use Expo Modules for new arch compatibility
+let DatalyrSKAdNetwork;
+if (Platform.OS === 'ios') {
+    try {
+        DatalyrSKAdNetwork = requireNativeModule('DatalyrSKAdNetwork');
+    }
+    catch (_a) {
+        // Module not available
+    }
+}
 export class SKAdNetworkBridge {
     /**
      * SKAN 3.0 - Update conversion value (0-63)
@@ -36,7 +46,7 @@ export class SKAdNetworkBridge {
             return false;
         }
         try {
-            const success = await DatalyrSKAdNetwork.updatePostbackConversionValue(result.fineValue, result.coarseValue, result.lockWindow);
+            const response = await DatalyrSKAdNetwork.updatePostbackConversionValue(result.fineValue, result.coarseValue, result.lockWindow);
             const isSKAN4 = await this.isSKAN4Available();
             if (isSKAN4) {
                 console.log(`[Datalyr] SKAN 4.0 postback updated: fineValue=${result.fineValue}, coarseValue=${result.coarseValue}, lockWindow=${result.lockWindow}`);
@@ -44,7 +54,7 @@ export class SKAdNetworkBridge {
             else {
                 console.log(`[Datalyr] SKAN 3.0 fallback: conversionValue=${result.fineValue}`);
             }
-            return success;
+            return response.success;
         }
         catch (error) {
             console.warn('[Datalyr] Failed to update SKAdNetwork postback conversion value:', error);
@@ -75,5 +85,279 @@ export class SKAdNetworkBridge {
     static isAvailable() {
         return Platform.OS === 'ios' && !!DatalyrSKAdNetwork;
     }
+    static async isAdAttributionKitAvailable() {
+        if (Platform.OS !== 'ios') {
+            return false;
+        }
+        if (this._isAdAttributionKitAvailable !== null) {
+            return this._isAdAttributionKitAvailable;
+        }
+        if (!(DatalyrSKAdNetwork === null || DatalyrSKAdNetwork === void 0 ? void 0 : DatalyrSKAdNetwork.isAdAttributionKitAvailable)) {
+            return false;
+        }
+        try {
+            this._isAdAttributionKitAvailable = await DatalyrSKAdNetwork.isAdAttributionKitAvailable();
+            return this._isAdAttributionKitAvailable;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Register for ad network attribution
+     * Uses AdAttributionKit on iOS 17.4+, SKAdNetwork on earlier versions
+     */
+    static async registerForAttribution() {
+        if (Platform.OS !== 'ios') {
+            return null;
+        }
+        if (!(DatalyrSKAdNetwork === null || DatalyrSKAdNetwork === void 0 ? void 0 : DatalyrSKAdNetwork.registerForAttribution)) {
+            console.warn('[Datalyr] Attribution registration not available');
+            return null;
+        }
+        try {
+            const result = await DatalyrSKAdNetwork.registerForAttribution();
+            console.log(`[Datalyr] Registered for attribution: ${result.framework}`);
+            return result;
+        }
+        catch (error) {
+            console.warn('[Datalyr] Failed to register for attribution:', error);
+            return null;
+        }
+    }
+    /**
+     * Get attribution framework info
+     * Returns details about which framework is being used and its capabilities
+     */
+    static async getAttributionInfo() {
+        if (Platform.OS !== 'ios') {
+            return {
+                framework: 'none',
+                version: '0',
+                reengagement_available: false,
+                overlapping_windows: false,
+                fine_value_range: { min: 0, max: 0 },
+                coarse_values: [],
+            };
+        }
+        if (!(DatalyrSKAdNetwork === null || DatalyrSKAdNetwork === void 0 ? void 0 : DatalyrSKAdNetwork.getAttributionInfo)) {
+            return null;
+        }
+        try {
+            return await DatalyrSKAdNetwork.getAttributionInfo();
+        }
+        catch (error) {
+            console.warn('[Datalyr] Failed to get attribution info:', error);
+            return null;
+        }
+    }
+    static async isOverlappingWindowsAvailable() {
+        if (Platform.OS !== 'ios') {
+            return false;
+        }
+        if (this._isOverlappingWindowsAvailable !== null) {
+            return this._isOverlappingWindowsAvailable;
+        }
+        if (!(DatalyrSKAdNetwork === null || DatalyrSKAdNetwork === void 0 ? void 0 : DatalyrSKAdNetwork.isOverlappingWindowsAvailable)) {
+            return false;
+        }
+        try {
+            this._isOverlappingWindowsAvailable = await DatalyrSKAdNetwork.isOverlappingWindowsAvailable();
+            return this._isOverlappingWindowsAvailable;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Update conversion value for re-engagement attribution (AdAttributionKit iOS 17.4+ only)
+     * Re-engagement tracks users who return to the app via an ad after initial install.
+     *
+     * @param result - Conversion result with fine value (0-63), coarse value, and lock window
+     * @returns Response with framework info, or null if not supported
+     */
+    static async updateReengagementConversionValue(result) {
+        if (Platform.OS !== 'ios') {
+            return null; // Android doesn't support AdAttributionKit
+        }
+        // Check if AdAttributionKit is available (required for re-engagement)
+        const isAAKAvailable = await this.isAdAttributionKitAvailable();
+        if (!isAAKAvailable) {
+            console.warn('[Datalyr] Re-engagement attribution requires iOS 17.4+ (AdAttributionKit)');
+            return null;
+        }
+        if (!(DatalyrSKAdNetwork === null || DatalyrSKAdNetwork === void 0 ? void 0 : DatalyrSKAdNetwork.updateReengagementConversionValue)) {
+            console.warn('[Datalyr] Re-engagement native module not available');
+            return null;
+        }
+        try {
+            const response = await DatalyrSKAdNetwork.updateReengagementConversionValue(result.fineValue, result.coarseValue, result.lockWindow);
+            console.log(`[Datalyr] AdAttributionKit re-engagement updated: fineValue=${result.fineValue}, coarseValue=${result.coarseValue}, lockWindow=${result.lockWindow}`);
+            return response;
+        }
+        catch (error) {
+            console.warn('[Datalyr] Failed to update re-engagement conversion value:', error);
+            return null;
+        }
+    }
+    /**
+     * Get a summary of attribution capabilities for the current device
+     */
+    static async getCapabilitiesSummary() {
+        var _a, _b;
+        const info = await this.getAttributionInfo();
+        const isSKAN4 = await this.isSKAN4Available();
+        const isAAK = await this.isAdAttributionKitAvailable();
+        const isOverlapping = await this.isOverlappingWindowsAvailable();
+        const isGeo = await this.isGeoPostbackAvailable();
+        return {
+            skadnetwork3: Platform.OS === 'ios',
+            skadnetwork4: isSKAN4,
+            adAttributionKit: isAAK,
+            reengagement: (_a = info === null || info === void 0 ? void 0 : info.reengagement_available) !== null && _a !== void 0 ? _a : false,
+            overlappingWindows: isOverlapping,
+            geoPostback: isGeo,
+            developmentPostbacks: isGeo, // Same iOS version requirement
+            framework: (_b = info === null || info === void 0 ? void 0 : info.framework) !== null && _b !== void 0 ? _b : 'none',
+        };
+    }
+    static async isGeoPostbackAvailable() {
+        if (Platform.OS !== 'ios') {
+            return false;
+        }
+        if (this._isGeoPostbackAvailable !== null) {
+            return this._isGeoPostbackAvailable;
+        }
+        if (!(DatalyrSKAdNetwork === null || DatalyrSKAdNetwork === void 0 ? void 0 : DatalyrSKAdNetwork.isGeoPostbackAvailable)) {
+            return false;
+        }
+        try {
+            this._isGeoPostbackAvailable = await DatalyrSKAdNetwork.isGeoPostbackAvailable();
+            return this._isGeoPostbackAvailable;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Set postback environment for testing (iOS 18.4+)
+     * Note: Actual sandbox mode requires Developer Mode enabled in iOS Settings
+     *
+     * @param environment - 'production' or 'sandbox'
+     */
+    static async setPostbackEnvironment(environment) {
+        if (Platform.OS !== 'ios') {
+            return null;
+        }
+        if (!(DatalyrSKAdNetwork === null || DatalyrSKAdNetwork === void 0 ? void 0 : DatalyrSKAdNetwork.setPostbackEnvironment)) {
+            console.warn('[Datalyr] Development postbacks require iOS 18.4+');
+            return null;
+        }
+        try {
+            const result = await DatalyrSKAdNetwork.setPostbackEnvironment(environment);
+            console.log(`[Datalyr] Postback environment: ${result.environment}`);
+            return result;
+        }
+        catch (error) {
+            console.warn('[Datalyr] Failed to set postback environment:', error);
+            return null;
+        }
+    }
+    /**
+     * Get enhanced attribution info including iOS 18.4+ features
+     * Returns details about geo postbacks, development mode, and all available features
+     */
+    static async getEnhancedAttributionInfo() {
+        if (Platform.OS !== 'ios') {
+            return {
+                framework: 'none',
+                version: '0',
+                reengagement_available: false,
+                overlapping_windows: false,
+                geo_postback_available: false,
+                development_postbacks: false,
+                fine_value_range: { min: 0, max: 0 },
+                coarse_values: [],
+                features: [],
+            };
+        }
+        if (!(DatalyrSKAdNetwork === null || DatalyrSKAdNetwork === void 0 ? void 0 : DatalyrSKAdNetwork.getEnhancedAttributionInfo)) {
+            // Fallback to basic info if enhanced not available
+            const basicInfo = await this.getAttributionInfo();
+            if (basicInfo) {
+                return {
+                    ...basicInfo,
+                    geo_postback_available: false,
+                    development_postbacks: false,
+                    features: [],
+                };
+            }
+            return null;
+        }
+        try {
+            return await DatalyrSKAdNetwork.getEnhancedAttributionInfo();
+        }
+        catch (error) {
+            console.warn('[Datalyr] Failed to get enhanced attribution info:', error);
+            return null;
+        }
+    }
+    /**
+     * Update postback with overlapping window support (iOS 18.4+)
+     * Allows tracking conversions across multiple time windows simultaneously
+     *
+     * @param result - Conversion result with fine value, coarse value, and lock window
+     * @param windowIndex - Window index: 0 (0-2 days), 1 (3-7 days), 2 (8-35 days)
+     */
+    static async updatePostbackWithWindow(result, windowIndex) {
+        if (Platform.OS !== 'ios') {
+            return null;
+        }
+        if (!(DatalyrSKAdNetwork === null || DatalyrSKAdNetwork === void 0 ? void 0 : DatalyrSKAdNetwork.updatePostbackWithWindow)) {
+            console.warn('[Datalyr] Overlapping windows require iOS 16.1+ (full support on iOS 18.4+)');
+            return null;
+        }
+        try {
+            const response = await DatalyrSKAdNetwork.updatePostbackWithWindow(result.fineValue, result.coarseValue, result.lockWindow, windowIndex);
+            console.log(`[Datalyr] Postback updated for window ${windowIndex}: fineValue=${result.fineValue}, overlapping=${response.overlappingWindows}`);
+            return response;
+        }
+        catch (error) {
+            console.warn('[Datalyr] Failed to update postback with window:', error);
+            return null;
+        }
+    }
+    /**
+     * Enable development/sandbox mode for testing attribution
+     * Convenience method that sets sandbox environment
+     */
+    static async enableDevelopmentMode() {
+        var _a;
+        const result = await this.setPostbackEnvironment('sandbox');
+        return (_a = result === null || result === void 0 ? void 0 : result.isSandbox) !== null && _a !== void 0 ? _a : false;
+    }
+    /**
+     * Disable development mode (switch to production)
+     */
+    static async disableDevelopmentMode() {
+        const result = await this.setPostbackEnvironment('production');
+        return result !== null && !result.isSandbox;
+    }
 }
 SKAdNetworkBridge._isSKAN4Available = null;
+/**
+ * Check if AdAttributionKit is available (iOS 17.4+)
+ * AdAttributionKit is Apple's replacement for SKAdNetwork with enhanced features
+ */
+SKAdNetworkBridge._isAdAttributionKitAvailable = null;
+/**
+ * Check if overlapping conversion windows are available (iOS 18.4+)
+ * Overlapping windows allow multiple conversion windows to be active simultaneously
+ */
+SKAdNetworkBridge._isOverlappingWindowsAvailable = null;
+// ===== iOS 18.4+ Features =====
+/**
+ * Check if geo-level postback data is available (iOS 18.4+)
+ * Geo postbacks include country code information for regional analytics
+ */
+SKAdNetworkBridge._isGeoPostbackAvailable = null;

package/lib/network-status.d.ts

@@ -0,0 +1,84 @@
+export type NetworkState = {
+    isConnected: boolean;
+    isInternetReachable: boolean | null;
+    type: 'wifi' | 'cellular' | 'ethernet' | 'bluetooth' | 'vpn' | 'none' | 'unknown';
+};
+export type NetworkStateListener = (state: NetworkState) => void;
+/**
+ * Network status manager that detects online/offline status
+ * Uses @react-native-community/netinfo for React Native or expo-network for Expo
+ */
+declare class NetworkStatusManager {
+    private state;
+    private listeners;
+    private unsubscribe;
+    private initialized;
+    private netInfoModule;
+    private expoNetworkModule;
+    /**
+     * Initialize network status monitoring
+     * Call this during SDK initialization
+     */
+    initialize(): Promise<void>;
+    /**
+     * Initialize with @react-native-community/netinfo
+     */
+    private initializeWithNetInfo;
+    /**
+     * Update state from NetInfo response
+     */
+    private updateStateFromNetInfo;
+    /**
+     * Map NetInfo type to our simplified type
+     */
+    private mapNetInfoType;
+    /**
+     * Initialize with expo-network
+     */
+    private initializeWithExpoNetwork;
+    /**
+     * Update state from expo-network response
+     */
+    private updateStateFromExpoNetwork;
+    /**
+     * Map expo-network type to our simplified type
+     */
+    private mapExpoNetworkType;
+    /**
+     * Poll expo-network for changes (since it doesn't have a listener API)
+     */
+    private pollingInterval;
+    private startExpoNetworkPolling;
+    /**
+     * Notify all listeners of state change
+     */
+    private notifyListeners;
+    /**
+     * Get current network state
+     */
+    getState(): NetworkState;
+    /**
+     * Check if device is currently online
+     */
+    isOnline(): boolean;
+    /**
+     * Get current network type
+     */
+    getNetworkType(): NetworkState['type'];
+    /**
+     * Subscribe to network state changes
+     * Returns an unsubscribe function
+     */
+    subscribe(listener: NetworkStateListener): () => void;
+    /**
+     * Refresh network state manually
+     * Useful when returning from background
+     */
+    refresh(): Promise<NetworkState>;
+    /**
+     * Cleanup and stop monitoring
+     */
+    destroy(): void;
+}
+export declare const networkStatusManager: NetworkStatusManager;
+export default networkStatusManager;