@magicpixel/rn-mp-client-sdk 1.13.0 → 1.13.20

package/src/common/data-store.ts

@@ -4,7 +4,6 @@ import type {
   MapLike,
   MpDeviceInfo,
   QcInfoItem,
-  RunQueueModel,
   SdkInitOptions,
   UrlInfo,
   VisitInfo,
@@ -21,8 +20,7 @@ import type {
 } from '../models/mp-client-sdk';
 import { Platform } from 'react-native';
 import { Utils } from './utils';
-
-const CORE_VERSION = '0.8.6';
+import { version as SDK_VERSION } from '../../package.json';
 
 export class DataStore {
   private static isDataStoreInitialized = false;
@@ -34,14 +32,12 @@ export class DataStore {
   private static clientSdk: MpClientSdk;
   private static urls: UrlInfo;
   private static debugId: string;
-  private static visitorInfo: VisitorInfo;
+  private static visitorInfo: VisitorInfo | null;
   private static visitInfo: VisitInfo;
   private static pageLang = 'en';
   private static mpEnvShort: 'stg' | 'prd';
   private static devicePlatform = 'unknown';
   private static deviceType = 'mobile';
-  private static runQueue: RunQueueModel[] = [];
-  private static isProcessing = false;
   private static sdkInitOptions: SdkInitOptions;
   private static deviceInfo: MpDeviceInfo;
   private static geoInfo: GeoResponse;
@@ -117,16 +113,6 @@ export class DataStore {
     return true;
   }
 
-  static enQueueTMFire(
-    sseOnly: boolean,
-    name: string,
-    dcrName: string,
-    eventId: string,
-    dcrPayload?: Record<string, any>
-  ): void {
-    this.runQueue.push({ sseOnly, name, dcrName, eventId, dcrPayload });
-  }
-
   static isDataStoreReady(): boolean {
     return this.isDataStoreInitialized;
   }
@@ -163,18 +149,6 @@ export class DataStore {
     this.sdkInitOptions = options;
   }
 
-  static deQueueTMFire(): RunQueueModel {
-    return this.runQueue.length > 0 ? this.runQueue.pop() : null;
-  }
-
-  static isTagManagerProcessing(): boolean {
-    return this.isProcessing;
-  }
-
-  static setTagManagerProcessing(status: boolean): void {
-    this.isProcessing = status;
-  }
-
   static getSdkDataElements(): MapLike<ClientSdkDeItem> {
     return this.clientSdk?.d || {};
   }
@@ -217,10 +191,14 @@ export class DataStore {
       : undefined;
   }
 
-  static setVisitorInfo(visitorInfo: VisitorInfo): void {
+  static setVisitorInfo(visitorInfo: VisitorInfo | null): void {
     this.visitorInfo = visitorInfo;
   }
 
+  static getVisitorInfo(): VisitorInfo | null {
+    return this.visitorInfo;
+  }
+
   static getDebugId(): string {
     return this.debugId;
   }
@@ -380,7 +358,7 @@ export class DataStore {
   }
 
   static getCoreVersion(): string {
-    return CORE_VERSION;
+    return SDK_VERSION;
   }
 
   static getMpEnv(): 'stg' | 'prd' {

package/src/common/deeplink-helper.ts

@@ -0,0 +1,181 @@
+import { Linking } from 'react-native';
+import { Logger } from './logger';
+
+export enum DeepLinkType {
+  CUSTOM_SCHEME = 'custom_scheme', // myapp://
+  UNIVERSAL_LINK = 'universal_link', // https:// (iOS Universal Links)
+  APP_LINK = 'app_link', // https:// (Android App Links)
+  HTTP_LINK = 'http_link', // http://
+}
+
+/**
+ * Helper class to automatically detect and handle deeplinks
+ *
+ * Supports multiple link types:
+ * 1. Custom URL Schemes: myapp://product/123
+ * 2. Universal Links (iOS): https://my-site.com/product/123
+ * 3. App Links (Android): https://my-site.com/product/123
+ * 4. HTTP Links: http://my-site.com/product/123
+ *
+ * Common use cases:
+ * - Ad clicks (Facebook, Google, TikTok ads with http/https URLs)
+ * - Push notification deep links
+ * - Email marketing links
+ * - SMS campaign links
+ * - QR codes
+ */
+export class DeepLinkHelper {
+  private static listener: any = null;
+  private static onDeepLinkCallback:
+    | ((url: string, linkType: DeepLinkType) => void)
+    | null = null;
+
+  /**
+   * Determine the type of deeplink
+   * @param url The URL to analyze
+   * @returns The type of deeplink
+   */
+  static getLinkType(url: string): DeepLinkType {
+    try {
+      if (url.startsWith('https://')) {
+        // Universal Links (iOS) and App Links (Android) both use HTTPS
+        return DeepLinkType.UNIVERSAL_LINK;
+      } else if (url.startsWith('http://')) {
+        return DeepLinkType.HTTP_LINK;
+      } else {
+        // Custom URL scheme (e.g., myapp://)
+        return DeepLinkType.CUSTOM_SCHEME;
+      }
+    } catch (error) {
+      Logger.logError('Error determining link type:', error);
+      return DeepLinkType.CUSTOM_SCHEME;
+    }
+  }
+
+  /**
+   * Initialize deeplink detection
+   * - Checks if app was opened with initial URL (custom scheme, universal link, or HTTP link)
+   * - Sets up listener for deeplinks while app is running
+   * @param callback Optional callback to be notified when deeplink is detected
+   * @returns The initial URL if app was opened with deeplink, null otherwise
+   */
+  static async initialize(
+    callback?: (url: string, linkType: DeepLinkType) => void
+  ): Promise<string | null> {
+    try {
+      // Store callback if provided
+      if (callback) {
+        this.onDeepLinkCallback = callback;
+      }
+
+      // Check if app was opened with a deeplink
+      // This works for:
+      // - Custom schemes: myapp://product/123
+      // - Universal Links (iOS): https://my-site.com/product/123
+      // - App Links (Android): https://my-site.com/product/123
+      // - HTTP links: http://my-site.com/product/123
+      const initialUrl = await Linking.getInitialURL();
+
+      if (initialUrl) {
+        const linkType = this.getLinkType(initialUrl);
+        Logger.logDbg(`App opened with initial ${linkType}:`, initialUrl);
+        this.handleDeepLink(initialUrl);
+      }
+
+      // ALWAYS set up listener for deeplinks while app is running
+      // This ensures we can detect deeplinks even if app was opened with initial deeplink
+      this.setupListener();
+
+      return initialUrl;
+    } catch (error) {
+      Logger.logError('Error initializing deeplink detection:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Set up listener for deeplinks received while app is running
+   * Works for all link types: custom schemes, universal links, app links, HTTP links
+   */
+  private static setupListener(): void {
+    // Remove existing listener if any
+    if (this.listener) {
+      this.listener.remove();
+    }
+
+    // Listen for deeplinks while app is running (e.g., user clicks link while app is open)
+    this.listener = Linking.addEventListener('url', (event) => {
+      const linkType = this.getLinkType(event.url);
+      Logger.logDbg(`Deeplink received (${linkType}):`, event.url);
+      this.handleDeepLink(event.url);
+    });
+
+    Logger.logDbg(
+      'Deeplink listener set up (supports custom schemes, universal/app links, HTTP links)'
+    );
+  }
+
+  /**
+   * Handle deeplink URL - notify callback if registered
+   * @param url The deeplink URL
+   */
+  private static handleDeepLink(url: string): void {
+    if (this.onDeepLinkCallback) {
+      const linkType = this.getLinkType(url);
+      this.onDeepLinkCallback(url, linkType);
+    }
+  }
+
+  /**
+   * Remove deeplink listener and clear callback
+   */
+  static cleanup(): void {
+    if (this.listener) {
+      this.listener.remove();
+      this.listener = null;
+    }
+    this.onDeepLinkCallback = null;
+    Logger.logDbg('Deeplink listener and callback cleared');
+  }
+
+  /**
+   * Parse UTM parameters and other campaign data from URL
+   * @param url The deeplink URL
+   * @returns Object containing campaign parameters
+   */
+  static parseCampaignParams(url: string): Record<string, string> {
+    try {
+      const urlObj = new URL(url);
+      const params: Record<string, string> = {};
+
+      // Common campaign parameters
+      const campaignParams = [
+        'utm_source',
+        'utm_medium',
+        'utm_campaign',
+        'utm_term',
+        'utm_content',
+        'utm_id',
+        'gclid', // Google Click ID
+        'fbclid', // Facebook Click ID
+        'ttclid', // TikTok Click ID
+        'campaign_id',
+        'ad_id',
+        'adset_id',
+        'creative_id',
+      ];
+
+      campaignParams.forEach((param) => {
+        const value = urlObj.searchParams.get(param);
+        if (value) {
+          params[param] = value;
+        }
+      });
+
+      return params;
+    } catch (error) {
+      Logger.logError('Error parsing campaign params from URL:', error);
+      return {};
+    }
+  }
+}

package/src/common/device-info-helper.ts

@@ -0,0 +1,190 @@
+import { Platform } from 'react-native';
+import { Logger } from './logger';
+
+interface DeviceAppInfo {
+  app_version: string;
+  build_number: string;
+  package_name: string;
+  device_model_name: string;
+  device_manufacturer: string;
+  device_id: string;
+  os_name: string;
+  os_version: string;
+  is_tablet: boolean;
+  is_emulator: boolean;
+}
+
+/**
+ * Helper class to automatically detect device and app information
+ * Supports both Expo and bare React Native:
+ * 1. Tries Expo modules first (works in Expo Go)
+ * 2. Falls back to react-native-device-info (for bare RN)
+ * 3. Returns safe defaults if neither is available
+ */
+export class DeviceInfoHelper {
+  private static expoApplication: any = null;
+  private static expoDevice: any = null;
+  private static expoConstants: any = null;
+  private static deviceInfo: any = null;
+  private static initialized = false;
+
+  /**
+   * Try to load Expo modules and react-native-device-info
+   * This uses dynamic imports to avoid errors when modules aren't available
+   */
+  private static async initialize(): Promise<void> {
+    if (this.initialized) return;
+
+    // Try to load Expo modules first (works in Expo Go)
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      this.expoApplication = require('expo-application');
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      this.expoDevice = require('expo-device');
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      this.expoConstants = require('expo-constants').default;
+      Logger.logDbg('Using Expo modules for device info');
+    } catch (error) {
+      Logger.logDbg(
+        'Expo modules not available, will try react-native-device-info'
+      );
+    }
+
+    // Fall back to react-native-device-info (for bare RN)
+    if (!this.expoApplication) {
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        this.deviceInfo = require('react-native-device-info').default;
+        Logger.logDbg('Using react-native-device-info for device info');
+      } catch (error) {
+        Logger.logError(
+          'Neither Expo modules nor react-native-device-info available:',
+          error
+        );
+      }
+    }
+
+    this.initialized = true;
+  }
+
+  /**
+   * Get comprehensive app and device information
+   * All methods are async-safe and handle errors gracefully
+   */
+  static async getAppInfo(): Promise<DeviceAppInfo> {
+    await this.initialize();
+
+    try {
+      // Try Expo modules first
+      if (this.expoApplication && this.expoDevice) {
+        return await this.getAppInfoFromExpo();
+      }
+
+      // Fall back to react-native-device-info
+      if (this.deviceInfo) {
+        return await this.getAppInfoFromDeviceInfo();
+      }
+
+      // Return safe fallback values
+      return this.getSafeDefaults();
+    } catch (error) {
+      Logger.logError('Error getting device info:', error);
+      return this.getSafeDefaults();
+    }
+  }
+
+  /**
+   * Get device info using Expo modules (works in Expo Go)
+   */
+  private static async getAppInfoFromExpo(): Promise<DeviceAppInfo> {
+    const version = this.expoApplication.nativeApplicationVersion || 'unknown';
+    const buildNumber = this.expoApplication.nativeBuildVersion || 'unknown';
+    const packageName = this.expoApplication.applicationId || 'unknown';
+
+    return {
+      // App information
+      app_version: version,
+      build_number: buildNumber,
+      package_name: packageName,
+
+      // Device information
+      device_model_name: this.expoDevice.modelName || 'unknown',
+      device_manufacturer: this.expoDevice.manufacturer || 'unknown',
+      device_id: this.expoConstants.sessionId || 'unknown',
+
+      // OS information
+      os_name: Platform.OS,
+      os_version:
+        this.expoDevice.osVersion || Platform.Version?.toString() || 'unknown',
+
+      // Additional useful info
+      // DeviceType enum: UNKNOWN=0, PHONE=1, TABLET=2, DESKTOP=3, TV=4
+      is_tablet: this.expoDevice.deviceType === 2, // DeviceType.TABLET = 2
+      is_emulator: !this.expoDevice.isDevice,
+    };
+  }
+
+  /**
+   * Get device info using react-native-device-info (for bare RN)
+   */
+  private static async getAppInfoFromDeviceInfo(): Promise<DeviceAppInfo> {
+    const [version, buildNumber, uniqueId, bundleId] = await Promise.all([
+      this.deviceInfo.getVersion(),
+      this.deviceInfo.getBuildNumber(),
+      this.deviceInfo.getUniqueId(),
+      this.deviceInfo.getBundleId(),
+    ]);
+
+    return {
+      // App information
+      app_version: version,
+      build_number: buildNumber,
+      package_name: bundleId,
+
+      // Device information
+      device_model_name: this.deviceInfo.getModel(),
+      device_manufacturer: this.deviceInfo.getManufacturerSync(),
+      device_id: uniqueId,
+
+      // OS information
+      os_name: Platform.OS,
+      os_version: this.deviceInfo.getSystemVersion(),
+
+      // Additional useful info
+      is_tablet: this.deviceInfo.isTablet(),
+      is_emulator: await this.deviceInfo.isEmulator(),
+    };
+  }
+
+  /**
+   * Safe default values when no device info library is available
+   */
+  private static getSafeDefaults(): DeviceAppInfo {
+    return {
+      app_version: 'unknown',
+      build_number: 'unknown',
+      package_name: 'unknown',
+      device_model_name: 'unknown',
+      device_manufacturer: 'unknown',
+      device_id: 'unknown',
+      os_name: Platform.OS,
+      os_version: Platform.Version?.toString() || 'unknown',
+      is_tablet: false,
+      is_emulator: false,
+    };
+  }
+
+  /**
+   * Get app version in format: "1.0.0 (123)"
+   * Combines version and build number for better tracking
+   */
+  static async getFormattedAppVersion(): Promise<string> {
+    try {
+      const info = await this.getAppInfo();
+      return `${info.app_version} (${info.build_number})`;
+    } catch (error) {
+      Logger.logError('Error getting formatted app version:', error);
+      return 'unknown';
+    }
+  }
+}

package/src/common/event-bus.ts

@@ -16,6 +16,45 @@ export class EventBus {
     }
   }
 
+  /**
+   * Remove a specific callback for an event
+   * @param eventName Event name to remove callback from
+   * @param callback The callback function to remove
+   */
+  static off(eventName: string, callback: EventBusCallback): void {
+    if (this.eventRegister.has(eventName)) {
+      const callbacks = this.eventRegister.get(eventName);
+      const index = callbacks.indexOf(callback);
+      if (index > -1) {
+        callbacks.splice(index, 1);
+        Logger.logDbg(`Removed listener for event: ${eventName}`);
+      }
+      // Clean up empty arrays
+      if (callbacks.length === 0) {
+        this.eventRegister.delete(eventName);
+      }
+    }
+  }
+
+  /**
+   * Remove all callbacks for a specific event
+   * @param eventName Event name to clear all listeners for
+   */
+  static clearEvent(eventName: string): void {
+    if (this.eventRegister.has(eventName)) {
+      this.eventRegister.delete(eventName);
+      Logger.logDbg(`Cleared all listeners for event: ${eventName}`);
+    }
+  }
+
+  /**
+   * Remove all event listeners (used during SDK shutdown)
+   */
+  static clearAll(): void {
+    this.eventRegister.clear();
+    Logger.logDbg('Cleared all event listeners');
+  }
+
   static triggerEvent(eventName: string, payload: any): void {
     if (this.eventRegister.has(eventName)) {
       for (const cb of this.eventRegister.get(eventName)) {

package/src/common/network-service.ts

@@ -1,40 +1,173 @@
 import { Logger } from './logger';
 import type { MapLike, SdkInitOptions, VisitorInfo } from './app-types';
 import { DataStore } from './data-store';
-import { Reporter } from './reporter';
 import type { MpClientSdk } from '../models/mp-client-sdk';
 
+const DEFAULT_RETRY_COUNT = 3;
+const DEFAULT_RETRY_DELAY_MS = 1000;
+const DEFAULT_TIMEOUT_MS = 10000;
+
 export class NetworkService {
-  public static async fetchIdlInfo(url: string): Promise<VisitorInfo> {
-    const response = await NetworkService.sendNetworkRequest('get', url);
-    if (response) {
-      return response.json();
-    } else {
+  /**
+   * Sleep for a specified duration
+   */
+  private static sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Fetch with timeout wrapper
+   */
+  private static async fetchWithTimeout(
+    url: string,
+    options: RequestInit,
+    timeoutMs: number = DEFAULT_TIMEOUT_MS
+  ): Promise<Response> {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal,
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Fetch visitor/identity info from server
+   * Returns null if fetch fails (caller should handle retry logic)
+   */
+  public static async fetchIdlInfo(url: string): Promise<VisitorInfo | null> {
+    try {
+      const response = await this.fetchWithTimeout(
+        url,
+        {
+          method: 'GET',
+          headers: {
+            'Content-Type': 'text/plain',
+            'cache-control': 'no-store',
+            ...DataStore.getCommonCookies(),
+          },
+        },
+        DEFAULT_TIMEOUT_MS
+      );
+
+      if (response && response.ok) {
+        return response.json();
+      } else {
+        Logger.logError(
+          `Failed to fetch IDL info: ${response?.status} ${response?.statusText}`
+        );
+        return null;
+      }
+    } catch (err) {
+      Logger.logError('Error fetching IDL info:', err);
       return null;
     }
   }
 
+  /**
+   * Fetch visitor/identity info with retry logic
+   * @param url The IDL URL
+   * @param retries Number of retries (default: 3)
+   * @returns VisitorInfo or null if all retries fail
+   */
+  public static async fetchIdlInfoWithRetry(
+    url: string,
+    retries: number = DEFAULT_RETRY_COUNT
+  ): Promise<VisitorInfo | null> {
+    let lastError: Error | null = null;
+
+    for (let attempt = 1; attempt <= retries; attempt++) {
+      try {
+        Logger.logDbg(`Fetching IDL info (attempt ${attempt}/${retries})`);
+        const result = await this.fetchIdlInfo(url);
+
+        if (result) {
+          Logger.logDbg('IDL info fetched successfully');
+          return result;
+        }
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        Logger.logError(`IDL fetch attempt ${attempt} failed:`, err);
+      }
+
+      // Wait before retry (exponential backoff)
+      if (attempt < retries) {
+        const delay = DEFAULT_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+        Logger.logDbg(`Retrying IDL fetch in ${delay}ms...`);
+        await this.sleep(delay);
+      }
+    }
+
+    Logger.logError(`All ${retries} IDL fetch attempts failed`, lastError);
+    return null;
+  }
+
+  /**
+   * Refresh client SDK JSON configuration with retry logic
+   * @param sdkInitOptions SDK initialization options
+   * @returns true if successful, throws Error if all retries fail
+   */
   public static async refreshClientSdkJson(
     sdkInitOptions: SdkInitOptions
   ): Promise<void> {
-    try {
-      const response = await this.sendNetworkRequest(
-        'get',
-        `${sdkInitOptions.baseUrl}/${sdkInitOptions.projectId}${
-          sdkInitOptions.env === 'staging' ? '-staging' : ''
-        }.json`
-      );
+    const url = `${sdkInitOptions.baseUrl}/${sdkInitOptions.projectId}${
+      sdkInitOptions.env === 'staging' ? '-staging' : ''
+    }.json`;
+
+    let lastError: Error | null = null;
 
-      if (response) {
-        const sdkJson: MpClientSdk = await response.json();
-        Logger.logDbg('Client Sdk:: ', sdkJson);
-        // sdkJson.s.c_url = 'http://localhost:3003';
-        await DataStore.init(sdkJson);
+    for (let attempt = 1; attempt <= DEFAULT_RETRY_COUNT; attempt++) {
+      try {
+        Logger.logDbg(
+          `Fetching SDK config (attempt ${attempt}/${DEFAULT_RETRY_COUNT}): ${url}`
+        );
+
+        const response = await this.fetchWithTimeout(
+          url,
+          {
+            method: 'GET',
+            headers: {
+              'Content-Type': 'text/plain',
+              'cache-control': 'no-store',
+            },
+          },
+          DEFAULT_TIMEOUT_MS
+        );
+
+        if (response && response.ok) {
+          const sdkJson: MpClientSdk = await response.json();
+          Logger.logDbg('Client SDK config fetched successfully');
+          await DataStore.init(sdkJson);
+          return; // Success - exit the retry loop
+        } else {
+          throw new Error(
+            `HTTP ${response?.status}: ${
+              response?.statusText || 'Unknown error'
+            }`
+          );
+        }
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+        Logger.logError(`SDK config fetch attempt ${attempt} failed:`, err);
+
+        // Wait before retry (exponential backoff)
+        if (attempt < DEFAULT_RETRY_COUNT) {
+          const delay = DEFAULT_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+          Logger.logDbg(`Retrying SDK config fetch in ${delay}ms...`);
+          await this.sleep(delay);
+        }
       }
-    } catch (err) {
-      Reporter.reportError('refreshClientSdk', err);
-      // throw new Error('Unable to fetch MagicPixel SDK at this time.');
     }
+
+    // All retries failed - throw error so caller can handle it
+    throw new Error(
+      `Failed to fetch SDK configuration after ${DEFAULT_RETRY_COUNT} attempts: ${lastError?.message}`
+    );
   }
 
   public static sendPostRequest(url: string, body: MapLike): void {