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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@magicpixel/rn-mp-client-sdk",
-  "version": "1.13.0",
-  "description": "test",
+  "version": "1.13.21",
+  "description": "React Native SDK for MagicPixel analytics and tag management",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
   "types": "lib/typescript/index.d.ts",
@@ -10,40 +10,36 @@
   "files": [
     "src",
     "lib",
-    "android",
-    "ios",
-    "cpp",
-    "rn-mp-client-sdk.podspec",
     "!lib/typescript/example",
-    "!android/build",
-    "!ios/build",
     "!**/__tests__",
     "!**/__fixtures__",
     "!**/__mocks__"
   ],
   "scripts": {
-    "test": "jest",
+    "test": "echo 'No tests configured'",
     "typescript": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
     "prepare": "bob build",
     "release": "release-it",
     "example": "yarn --cwd example",
     "bootstrap": "yarn example && yarn && yarn example pods",
-    "postpublish": "node quick-version-increment.js",
-    "localpublish": "npm publish --@magicpixel:registry=http://localhost:4873 && npm run postpublish"
+    "localpublish": "npm publish --@magicpixel:registry=http://localhost:4873"
   },
   "keywords": [
     "react-native",
     "ios",
     "android"
   ],
-  "repository": "https://github.com/mp",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:digital-madtech/mp-rn-client-sdk.git"
+  },
   "author": "MP Engineering <engineering@magicpixel.io> (https://magicpixel.io)",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/mp/issues"
+    "url": "https://github.com/digital-madtech/mp-rn-client-sdk/issues"
   },
-  "homepage": "https://github.com/mp#readme",
+  "homepage": "https://github.com/digital-madtech/mp-rn-client-sdk#readme",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
@@ -53,38 +49,34 @@
     "@babel/eslint-parser": "7.19.1",
     "@babel/runtime": "7.26.10",
     "@commitlint/config-conventional": "17.1.0",
+    "@octokit/plugin-paginate-rest": "9.2.2",
+    "@octokit/request": "8.4.1",
+    "@octokit/request-error": "5.1.1",
     "@react-native-community/eslint-config": "3.1.0",
     "@release-it/conventional-changelog": "8.0.1",
     "@types/flat": "5.0.2",
-    "@types/jest": "29.0.3",
-    "@types/react": "~17.0.21",
+    "@types/react": "17.0.50",
     "@types/react-native": "0.72.8",
     "@types/uuid": "9.0.0",
+    "braces": "3.0.3",
     "commitlint": "17.1.2",
+    "cross-spawn": "7.0.5",
     "eslint": "8.23.1",
     "eslint-config-prettier": "8.5.0",
     "eslint-plugin-prettier": "4.2.1",
-    "jest": "29.1.1",
+    "micromatch": "4.0.8",
     "pod-install": "0.1.38",
     "prettier": "2.7.1",
     "react": "18.2.0",
     "react-native": "0.72.17",
     "react-native-builder-bob": "0.18.3",
     "release-it": "17.1.1",
-    "ts-jest": "29.0.2",
     "tsconfig-paths": "4.1.0",
     "typescript": "4.8.3",
-    "ts-node": "10.9.1",
-    "@octokit/plugin-paginate-rest": "9.2.2",
-    "@octokit/request": "8.4.1",
-    "@octokit/request-error": "5.1.1",
-    "braces": "3.0.3",
-    "cross-spawn": "7.0.5",
-    "micromatch": "4.0.8",
     "ws": "7.5.10"
   },
   "resolutions": {
-    "@types/react": "17.0.21",
+    "@types/react": "17.0.50",
     "ip": "2.0.2",
     "pac-resolver": "7.0.1",
     "socks": "2.7.3",
@@ -93,20 +85,14 @@
     "socks-proxy-agent": "8.0.2",
     "agent-base": "7.1.0"
   },
+  "overrides": {
+    "diff": "8.0.3",
+    "tmp": "0.2.4"
+  },
   "peerDependencies": {
     "react": "*",
     "react-native": "*"
   },
-  "jest": {
-    "preset": "react-native",
-    "transform": {
-      ".+\\.(t|j)s$": "ts-jest"
-    },
-    "modulePathIgnorePatterns": [
-      "<rootDir>/example/node_modules",
-      "<rootDir>/lib/"
-    ]
-  },
   "commitlint": {
     "extends": [
       "@commitlint/config-conventional"
@@ -174,7 +160,10 @@
     "flat": "5.0.2",
     "nanoid": "5.1.5",
     "performant-array-to-tree": "1.11.0",
+    "react-native-device-info": "15.0.1",
+    "react-native-get-random-values": "1.11.0",
     "react-native-url-polyfill": "1.3.0",
+    "ulid": "3.0.1",
     "uuid": "9.0.0"
   }
 }

package/src/common/app-types.ts

@@ -4,14 +4,6 @@ export interface MapLike<T = any> {
   [key: string]: T;
 }
 
-export interface RunQueueModel {
-  sseOnly: boolean;
-  name: string;
-  dcrName: string;
-  eventId: string;
-  dcrPayload?: Record<string, any>;
-}
-
 export type TypedAny = Record<
   string,
   | string
@@ -38,6 +30,7 @@ export interface AppCustomerInfo {
 
 export interface AppPageLoad {
   page_name: string;
+  page_url?: string;
   is_entry?: number;
   deep_link_url?: string;
   app_version?: string;
@@ -94,6 +87,7 @@ export interface Report {
   tagCt: number; // expected tag count on this page
   dws: 'j' | 'n'; // down stream configuration. java or node
   v: string; // client sdk version for this call
+  devPayload?: string; // base64 encoded developer payload
 }
 
 export interface UrlInfo {
@@ -130,18 +124,47 @@ export interface SdkInitOptions {
   baseUrl: string;
   logLevel: string;
 
+  /**
+   * @deprecated device_type is now auto-detected and cannot be overridden
+   * This field is ignored. The SDK uses Expo/react-native-device-info for reliable detection.
+   */
   device_type?: string;
 
+  /**
+   * @deprecated app_version is now auto-detected and cannot be overridden
+   * This field is ignored. The SDK will always use the actual app version from the device.
+   */
   app_version?: string;
+
+  /**
+   * @deprecated os_version is now auto-detected and cannot be overridden
+   * This field is ignored. The SDK will always use the actual OS version from the device.
+   */
   os_version?: string;
+
+  /**
+   * Event deduplication window in milliseconds
+   * If the same event (name + payload) fires within this window, it will be skipped
+   * Purchase events are deduplicated by transaction_id regardless of other fields
+   * Default: 5000ms (5 seconds)
+   * Set to 0 to disable deduplication
+   */
+  eventDeduplicationWindowMs?: number;
+
+  /**
+   * Callback invoked when SDK initialization fails after all retries
+   * Use this to handle initialization failures gracefully in your app
+   * @param error The error that caused the failure
+   */
+  onInitFailure?: (error: Error) => void;
 }
 
 export interface MpDeviceInfo {
   package_name?: string; // app package name like com.company.starter
   short_version?: string;
   long_version?: string;
-  os_version: string;
-  device_model_name: string;
+  os_version?: string; // Will be auto-detected if not provided
+  device_model_name?: string; // Will be auto-detected if not provided
   locale?: string;
   timezone_abbreviation?: string;
   carrier?: string;

package/src/common/constants.ts

@@ -1,14 +1,8 @@
-import { customAlphabet } from 'nanoid/non-secure';
 import type { BaseResourceParamType } from '../models/mp-client-sdk';
 
 export class Constants {
   static PLACEHOLDER_REGEX = new RegExp(/({{)([A-Z_0-9 -]+)(}})/gi);
 
-  static LARGE_RANDOM_POOL = customAlphabet(
-    '1234567090abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
-    21
-  );
-
   static MP_DL_EVT = 'mp_dl_event';
   static CUST_EVT = 'custom_event';
 

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';
+    }
+  }
+}