@datalyr/react-native 1.3.0 → 1.3.1

package/lib/native/SKAdNetworkBridge.js

@@ -36,7 +36,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 +44,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 +75,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;

package/lib/network-status.js

@@ -0,0 +1,281 @@
+import { debugLog, errorLog } from './utils';
+/**
+ * Network status manager that detects online/offline status
+ * Uses @react-native-community/netinfo for React Native or expo-network for Expo
+ */
+class NetworkStatusManager {
+    constructor() {
+        this.state = {
+            isConnected: true, // Default to true until we know otherwise
+            isInternetReachable: null,
+            type: 'unknown',
+        };
+        this.listeners = new Set();
+        this.unsubscribe = null;
+        this.initialized = false;
+        this.netInfoModule = null;
+        this.expoNetworkModule = null;
+        /**
+         * Poll expo-network for changes (since it doesn't have a listener API)
+         */
+        this.pollingInterval = null;
+    }
+    /**
+     * Initialize network status monitoring
+     * Call this during SDK initialization
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        // Try @react-native-community/netinfo first (most common in RN apps)
+        try {
+            this.netInfoModule = require('@react-native-community/netinfo').default;
+            await this.initializeWithNetInfo();
+            this.initialized = true;
+            debugLog('Network status initialized with @react-native-community/netinfo');
+            return;
+        }
+        catch (_a) {
+            // Module not available, try expo-network
+        }
+        // Try expo-network (for Expo apps)
+        try {
+            this.expoNetworkModule = require('expo-network');
+            await this.initializeWithExpoNetwork();
+            this.initialized = true;
+            debugLog('Network status initialized with expo-network');
+            return;
+        }
+        catch (_b) {
+            // Module not available
+        }
+        // Fallback: assume online (no network monitoring available)
+        debugLog('No network status module available, defaulting to online');
+        this.state = {
+            isConnected: true,
+            isInternetReachable: true,
+            type: 'unknown',
+        };
+        this.initialized = true;
+    }
+    /**
+     * Initialize with @react-native-community/netinfo
+     */
+    async initializeWithNetInfo() {
+        const NetInfo = this.netInfoModule;
+        // Get initial state
+        try {
+            const netState = await NetInfo.fetch();
+            this.updateStateFromNetInfo(netState);
+        }
+        catch (error) {
+            errorLog('Failed to fetch initial network state:', error);
+        }
+        // Subscribe to changes
+        this.unsubscribe = NetInfo.addEventListener((netState) => {
+            this.updateStateFromNetInfo(netState);
+        });
+    }
+    /**
+     * Update state from NetInfo response
+     */
+    updateStateFromNetInfo(netState) {
+        var _a;
+        const previouslyConnected = this.state.isConnected;
+        this.state = {
+            isConnected: (_a = netState.isConnected) !== null && _a !== void 0 ? _a : true,
+            isInternetReachable: netState.isInternetReachable,
+            type: this.mapNetInfoType(netState.type),
+        };
+        // Notify listeners if connection status changed
+        if (previouslyConnected !== this.state.isConnected) {
+            debugLog(`Network status changed: ${this.state.isConnected ? 'online' : 'offline'} (${this.state.type})`);
+            this.notifyListeners();
+        }
+    }
+    /**
+     * Map NetInfo type to our simplified type
+     */
+    mapNetInfoType(type) {
+        switch (type) {
+            case 'wifi':
+                return 'wifi';
+            case 'cellular':
+                return 'cellular';
+            case 'ethernet':
+                return 'ethernet';
+            case 'bluetooth':
+                return 'bluetooth';
+            case 'vpn':
+                return 'vpn';
+            case 'none':
+                return 'none';
+            default:
+                return 'unknown';
+        }
+    }
+    /**
+     * Initialize with expo-network
+     */
+    async initializeWithExpoNetwork() {
+        const Network = this.expoNetworkModule;
+        // Get initial state
+        try {
+            const networkState = await Network.getNetworkStateAsync();
+            this.updateStateFromExpoNetwork(networkState);
+        }
+        catch (error) {
+            errorLog('Failed to fetch initial network state from expo-network:', error);
+        }
+        // Note: expo-network doesn't have a listener API like netinfo
+        // We'll poll periodically or rely on app state changes
+        this.startExpoNetworkPolling();
+    }
+    /**
+     * Update state from expo-network response
+     */
+    updateStateFromExpoNetwork(networkState) {
+        var _a, _b;
+        const previouslyConnected = this.state.isConnected;
+        this.state = {
+            isConnected: (_a = networkState.isConnected) !== null && _a !== void 0 ? _a : true,
+            isInternetReachable: (_b = networkState.isInternetReachable) !== null && _b !== void 0 ? _b : null,
+            type: this.mapExpoNetworkType(networkState.type),
+        };
+        if (previouslyConnected !== this.state.isConnected) {
+            debugLog(`Network status changed: ${this.state.isConnected ? 'online' : 'offline'} (${this.state.type})`);
+            this.notifyListeners();
+        }
+    }
+    /**
+     * Map expo-network type to our simplified type
+     */
+    mapExpoNetworkType(type) {
+        switch (type) {
+            case 'WIFI':
+                return 'wifi';
+            case 'CELLULAR':
+                return 'cellular';
+            case 'ETHERNET':
+                return 'ethernet';
+            case 'BLUETOOTH':
+                return 'bluetooth';
+            case 'VPN':
+                return 'vpn';
+            case 'NONE':
+                return 'none';
+            default:
+                return 'unknown';
+        }
+    }
+    startExpoNetworkPolling() {
+        // Poll every 5 seconds for network changes
+        this.pollingInterval = setInterval(async () => {
+            try {
+                if (this.expoNetworkModule) {
+                    const networkState = await this.expoNetworkModule.getNetworkStateAsync();
+                    this.updateStateFromExpoNetwork(networkState);
+                }
+            }
+            catch (error) {
+                // Ignore polling errors
+            }
+        }, 5000);
+    }
+    /**
+     * Notify all listeners of state change
+     */
+    notifyListeners() {
+        this.listeners.forEach((listener) => {
+            try {
+                listener(this.state);
+            }
+            catch (error) {
+                errorLog('Error in network state listener:', error);
+            }
+        });
+    }
+    /**
+     * Get current network state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Check if device is currently online
+     */
+    isOnline() {
+        // Consider online if connected OR if we're not sure about internet reachability
+        return this.state.isConnected && (this.state.isInternetReachable !== false);
+    }
+    /**
+     * Get current network type
+     */
+    getNetworkType() {
+        return this.state.type;
+    }
+    /**
+     * Subscribe to network state changes
+     * Returns an unsubscribe function
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        // Immediately call with current state
+        try {
+            listener(this.state);
+        }
+        catch (error) {
+            errorLog('Error calling network state listener:', error);
+        }
+        // Return unsubscribe function
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /**
+     * Refresh network state manually
+     * Useful when returning from background
+     */
+    async refresh() {
+        if (this.netInfoModule) {
+            try {
+                const netState = await this.netInfoModule.fetch();
+                this.updateStateFromNetInfo(netState);
+            }
+            catch (error) {
+                errorLog('Failed to refresh network state:', error);
+            }
+        }
+        else if (this.expoNetworkModule) {
+            try {
+                const networkState = await this.expoNetworkModule.getNetworkStateAsync();
+                this.updateStateFromExpoNetwork(networkState);
+            }
+            catch (error) {
+                errorLog('Failed to refresh network state from expo-network:', error);
+            }
+        }
+        return this.state;
+    }
+    /**
+     * Cleanup and stop monitoring
+     */
+    destroy() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+        if (this.pollingInterval) {
+            clearInterval(this.pollingInterval);
+            this.pollingInterval = null;
+        }
+        this.listeners.clear();
+        this.initialized = false;
+        debugLog('Network status manager destroyed');
+    }
+}
+// Export singleton instance
+export const networkStatusManager = new NetworkStatusManager();
+// Export for direct access
+export default networkStatusManager;