@dashx/react-native 1.1.2 → 1.1.3

package/__tests__/index.test.js

@@ -0,0 +1,363 @@
+const mockNativeModule = {
+  configure: jest.fn(),
+  identify: jest.fn(),
+  setIdentity: jest.fn(),
+  reset: jest.fn(),
+  track: jest.fn(),
+  screen: jest.fn(),
+  fetchRecord: jest.fn(),
+  searchRecords: jest.fn(),
+  fetchStoredPreferences: jest.fn(),
+  saveStoredPreferences: jest.fn(),
+  subscribe: jest.fn(),
+  unsubscribe: jest.fn(),
+  setLogLevel: jest.fn(),
+  uploadAsset: jest.fn(),
+  fetchAsset: jest.fn(),
+  enableLifecycleTracking: jest.fn(),
+  enableAdTracking: jest.fn(),
+  requestNotificationPermission: jest.fn(),
+  getNotificationPermissionStatus: jest.fn(),
+  addListener: jest.fn(),
+  removeListeners: jest.fn(),
+};
+
+const mockAddListener = jest.fn(() => ({ remove: jest.fn() }));
+
+jest.mock('react-native', () => ({
+  NativeModules: {
+    DashXReactNative: mockNativeModule,
+  },
+  NativeEventEmitter: jest.fn().mockImplementation(() => ({
+    addListener: mockAddListener,
+  })),
+  Platform: {
+    select: jest.fn((obj) => obj.default || ''),
+  },
+}));
+
+const DashX = require('../index').default;
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+// --- configure ---
+
+describe('configure', () => {
+  it('calls native configure with options', () => {
+    DashX.configure({ publicKey: 'pk_test' });
+    expect(mockNativeModule.configure).toHaveBeenCalledWith({
+      publicKey: 'pk_test',
+    });
+  });
+
+  it('throws if options is not an object', () => {
+    expect(() => DashX.configure(null)).toThrow('options must be an object');
+    expect(() => DashX.configure('string')).toThrow('options must be an object');
+  });
+
+  it('throws if publicKey is missing', () => {
+    expect(() => DashX.configure({})).toThrow('publicKey is required');
+  });
+
+  it('throws if publicKey is not a string', () => {
+    expect(() => DashX.configure({ publicKey: 123 })).toThrow(
+      'publicKey is required and must be a string'
+    );
+  });
+});
+
+// --- identify ---
+
+describe('identify', () => {
+  it('calls native identify with options', () => {
+    DashX.identify({ email: 'test@example.com' });
+    expect(mockNativeModule.identify).toHaveBeenCalledWith({
+      email: 'test@example.com',
+    });
+  });
+
+  it('throws if options is not an object', () => {
+    expect(() => DashX.identify(null)).toThrow('options must be an object');
+  });
+});
+
+// --- setIdentity ---
+
+describe('setIdentity', () => {
+  it('calls native setIdentity with uid and token', () => {
+    DashX.setIdentity('user-1', 'token-abc');
+    expect(mockNativeModule.setIdentity).toHaveBeenCalledWith(
+      'user-1',
+      'token-abc'
+    );
+  });
+
+  it('throws if uid is missing', () => {
+    expect(() => DashX.setIdentity(null, 'token')).toThrow('uid is required');
+  });
+
+  it('throws if token is missing', () => {
+    expect(() => DashX.setIdentity('uid', null)).toThrow(
+      'token is required'
+    );
+  });
+});
+
+// --- reset ---
+
+describe('reset', () => {
+  it('calls native reset', () => {
+    DashX.reset();
+    expect(mockNativeModule.reset).toHaveBeenCalled();
+  });
+});
+
+// --- track ---
+
+describe('track', () => {
+  it('calls native track with event and data', () => {
+    DashX.track('purchase', { amount: 100 });
+    expect(mockNativeModule.track).toHaveBeenCalledWith('purchase', {
+      amount: 100,
+    });
+  });
+
+  it('calls native track with null data when omitted', () => {
+    DashX.track('page_view');
+    expect(mockNativeModule.track).toHaveBeenCalledWith('page_view', null);
+  });
+
+  it('throws if event is missing', () => {
+    expect(() => DashX.track(null)).toThrow('event is required');
+  });
+
+  it('throws if event is not a string', () => {
+    expect(() => DashX.track(42)).toThrow(
+      'event is required and must be a string'
+    );
+  });
+});
+
+// --- screen ---
+
+describe('screen', () => {
+  it('calls native screen with name and data', () => {
+    DashX.screen('Home', { section: 'top' });
+    expect(mockNativeModule.screen).toHaveBeenCalledWith('Home', {
+      section: 'top',
+    });
+  });
+
+  it('calls native screen with null data when omitted', () => {
+    DashX.screen('Settings');
+    expect(mockNativeModule.screen).toHaveBeenCalledWith('Settings', null);
+  });
+
+  it('throws if screenName is missing', () => {
+    expect(() => DashX.screen(null)).toThrow('screenName is required');
+  });
+});
+
+// --- fetchRecord ---
+
+describe('fetchRecord', () => {
+  it('calls native fetchRecord with urn and options', () => {
+    mockNativeModule.fetchRecord.mockResolvedValue({ id: '123' });
+    const result = DashX.fetchRecord('article/123', { preview: true });
+    expect(mockNativeModule.fetchRecord).toHaveBeenCalledWith('article/123', {
+      preview: true,
+    });
+    return expect(result).resolves.toEqual({ id: '123' });
+  });
+
+  it('calls native fetchRecord with empty options when omitted', () => {
+    mockNativeModule.fetchRecord.mockResolvedValue({});
+    DashX.fetchRecord('article/456');
+    expect(mockNativeModule.fetchRecord).toHaveBeenCalledWith(
+      'article/456',
+      {}
+    );
+  });
+
+  it('throws if urn is missing', () => {
+    expect(() => DashX.fetchRecord(null)).toThrow('urn is required');
+  });
+});
+
+// --- searchRecords ---
+
+describe('searchRecords', () => {
+  it('calls native searchRecords with resource and options', () => {
+    mockNativeModule.searchRecords.mockResolvedValue([{ id: '1' }]);
+    const result = DashX.searchRecords('articles', { limit: 10 });
+    expect(mockNativeModule.searchRecords).toHaveBeenCalledWith('articles', {
+      limit: 10,
+    });
+    return expect(result).resolves.toEqual([{ id: '1' }]);
+  });
+
+  it('throws if resource is missing', () => {
+    expect(() => DashX.searchRecords(null)).toThrow('resource is required');
+  });
+});
+
+// --- fetchStoredPreferences ---
+
+describe('fetchStoredPreferences', () => {
+  it('calls native fetchStoredPreferences', () => {
+    mockNativeModule.fetchStoredPreferences.mockResolvedValue({
+      email: true,
+    });
+    const result = DashX.fetchStoredPreferences();
+    expect(mockNativeModule.fetchStoredPreferences).toHaveBeenCalled();
+    return expect(result).resolves.toEqual({ email: true });
+  });
+});
+
+// --- saveStoredPreferences ---
+
+describe('saveStoredPreferences', () => {
+  it('calls native saveStoredPreferences with data', () => {
+    mockNativeModule.saveStoredPreferences.mockResolvedValue({ success: true });
+    const result = DashX.saveStoredPreferences({ email: false });
+    expect(mockNativeModule.saveStoredPreferences).toHaveBeenCalledWith({
+      email: false,
+    });
+    return expect(result).resolves.toEqual({ success: true });
+  });
+
+  it('throws if preferenceData is not an object', () => {
+    expect(() => DashX.saveStoredPreferences(null)).toThrow(
+      'preferenceData is required'
+    );
+  });
+});
+
+// --- subscribe / unsubscribe ---
+
+describe('subscribe', () => {
+  it('calls native subscribe', () => {
+    DashX.subscribe();
+    expect(mockNativeModule.subscribe).toHaveBeenCalled();
+  });
+});
+
+describe('unsubscribe', () => {
+  it('calls native unsubscribe', () => {
+    DashX.unsubscribe();
+    expect(mockNativeModule.unsubscribe).toHaveBeenCalled();
+  });
+});
+
+// --- setLogLevel ---
+
+describe('setLogLevel', () => {
+  it('calls native setLogLevel with level', () => {
+    DashX.setLogLevel(2);
+    expect(mockNativeModule.setLogLevel).toHaveBeenCalledWith(2);
+  });
+
+  it('throws if level is not a number', () => {
+    expect(() => DashX.setLogLevel('debug')).toThrow(
+      'level must be a number'
+    );
+  });
+});
+
+// --- onMessageReceived ---
+
+describe('onMessageReceived', () => {
+  it('throws if callback is not a function', () => {
+    expect(() => DashX.onMessageReceived('not a function')).toThrow(
+      'callback must be a function'
+    );
+  });
+
+  it('registers a listener for messageReceived events', () => {
+    const callback = jest.fn();
+    const subscription = DashX.onMessageReceived(callback);
+    expect(mockAddListener).toHaveBeenCalledWith('messageReceived', callback);
+    expect(subscription).toBeDefined();
+  });
+});
+
+// --- uploadAsset ---
+
+describe('uploadAsset', () => {
+  it('calls native uploadAsset with filePath, resource, attribute', () => {
+    mockNativeModule.uploadAsset.mockResolvedValue({ status: 'ready' });
+    const result = DashX.uploadAsset('/path/to/file.jpg', 'products', 'image');
+    expect(mockNativeModule.uploadAsset).toHaveBeenCalledWith(
+      '/path/to/file.jpg',
+      'products',
+      'image'
+    );
+    return expect(result).resolves.toEqual({ status: 'ready' });
+  });
+
+  it('throws if filePath is missing', () => {
+    expect(() => DashX.uploadAsset(null, 'r', 'a')).toThrow('filePath must be a string');
+  });
+
+  it('throws if resource is missing', () => {
+    expect(() => DashX.uploadAsset('/path', null, 'a')).toThrow('resource must be a string');
+  });
+
+  it('throws if attribute is missing', () => {
+    expect(() => DashX.uploadAsset('/path', 'r', null)).toThrow('attribute must be a string');
+  });
+});
+
+// --- fetchAsset ---
+
+describe('fetchAsset', () => {
+  it('calls native fetchAsset with assetId', () => {
+    mockNativeModule.fetchAsset.mockResolvedValue({ status: 'ready' });
+    const result = DashX.fetchAsset('asset-123');
+    expect(mockNativeModule.fetchAsset).toHaveBeenCalledWith('asset-123');
+    return expect(result).resolves.toEqual({ status: 'ready' });
+  });
+
+  it('throws if assetId is missing', () => {
+    expect(() => DashX.fetchAsset(null)).toThrow('assetId must be a string');
+  });
+});
+
+// --- requestNotificationPermission / getNotificationPermissionStatus ---
+
+describe('requestNotificationPermission', () => {
+  it('calls native requestNotificationPermission', () => {
+    mockNativeModule.requestNotificationPermission.mockResolvedValue(2);
+    const result = DashX.requestNotificationPermission();
+    expect(mockNativeModule.requestNotificationPermission).toHaveBeenCalled();
+    return expect(result).resolves.toBe(2);
+  });
+});
+
+describe('getNotificationPermissionStatus', () => {
+  it('calls native getNotificationPermissionStatus', () => {
+    mockNativeModule.getNotificationPermissionStatus.mockResolvedValue(1);
+    const result = DashX.getNotificationPermissionStatus();
+    expect(mockNativeModule.getNotificationPermissionStatus).toHaveBeenCalled();
+    return expect(result).resolves.toBe(1);
+  });
+});
+
+// --- onLinkReceived ---
+
+describe('onLinkReceived', () => {
+  it('throws if callback is not a function', () => {
+    expect(() => DashX.onLinkReceived('not a function')).toThrow(
+      'callback must be a function'
+    );
+  });
+
+  it('registers a listener for linkReceived events', () => {
+    const callback = jest.fn();
+    const subscription = DashX.onLinkReceived(callback);
+    expect(mockAddListener).toHaveBeenCalledWith('linkReceived', callback);
+    expect(subscription).toBeDefined();
+  });
+});

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Mon Mar 23 22:47:55 IST 2026
+gradle.version=7.2

package/android/build.gradle

@@ -55,5 +55,5 @@ dependencies {
     // Ensure Firebase Messaging types are available for FCM service subclass
     implementation 'com.google.firebase:firebase-messaging-ktx:23.1.2'
 
-    implementation "com.dashx:dashx-android:1.1.4"
+    implementation "com.dashx:dashx-android:1.1.5"
 }

package/babel.config.js

@@ -1,3 +1,3 @@
 module.exports = {
-  presets: ['module:metro-react-native-babel-preset'],
+  presets: ['module:@react-native/babel-preset'],
 };

package/index.d.ts

@@ -1,5 +1,14 @@
 import { EmitterSubscription } from 'react-native';
 
+/**
+ * Error codes returned by native SDKs in promise rejections.
+ * Consistent across iOS and Android.
+ */
+export enum DashXErrorCode {
+  /** An unspecified error occurred. */
+  EUNSPECIFIED = 'EUNSPECIFIED',
+}
+
 export interface ConfigureOptions {
   publicKey: string;
   baseURI?: string;
@@ -28,6 +37,7 @@ export interface SearchRecordsOptions {
   filter?: Record<string, unknown>;
   order?: Record<string, unknown>[];
   limit?: number;
+  page?: number;
   preview?: boolean;
   language?: string;
   fields?: Record<string, unknown>[];
@@ -35,6 +45,23 @@ export interface SearchRecordsOptions {
   exclude?: Record<string, unknown>[];
 }
 
+export interface AssetData {
+  status?: string;
+  url?: string;
+  playbackIds?: { id?: string; policy?: string }[];
+}
+
+export interface AssetResponse {
+  status?: string;
+  data?: { asset?: AssetData };
+}
+
+/**
+ * Mirrors UNAuthorizationStatus integer values:
+ * 0 = notDetermined, 1 = denied, 2 = authorized, 3 = provisional, 4 = ephemeral
+ */
+export type NotificationPermissionStatus = 0 | 1 | 2 | 3 | 4;
+
 export interface NotificationMessage {
   [key: string]: unknown;
 }
@@ -123,6 +150,49 @@ export interface DashXInstance {
   onMessageReceived(
     callback: (message: NotificationMessage) => void
   ): EmitterSubscription;
+
+  /**
+   * Upload a local file to DashX. Returns an AssetResponse with the asset status and URL.
+   * @param filePath Absolute path to the local file.
+   */
+  uploadAsset(
+    filePath: string,
+    resource: string,
+    attribute: string
+  ): Promise<AssetResponse>;
+
+  /**
+   * Fetch details of a previously uploaded asset by its ID.
+   */
+  fetchAsset(assetId: string): Promise<AssetResponse>;
+
+  /**
+   * Enable automatic app lifecycle event tracking (iOS only).
+   */
+  enableLifecycleTracking(): void;
+
+  /**
+   * Enable IDFA/ATT ad tracking and request the App Tracking Transparency permission (iOS only).
+   */
+  enableAdTracking(): void;
+
+  /**
+   * Request push notification permission from the user.
+   * Resolves with a NotificationPermissionStatus integer.
+   */
+  requestNotificationPermission(): Promise<NotificationPermissionStatus>;
+
+  /**
+   * Get the current push notification permission status without prompting.
+   * Resolves with a NotificationPermissionStatus integer.
+   */
+  getNotificationPermissionStatus(): Promise<NotificationPermissionStatus>;
+
+  /**
+   * Register a listener for deep link / universal link events dispatched by the SDK.
+   * Returns a subscription that can be removed via `.remove()`.
+   */
+  onLinkReceived(callback: (url: string) => void): EmitterSubscription;
 }
 
 declare const DashX: DashXInstance;

package/index.js

@@ -40,7 +40,9 @@ const DashX = {
       throw new Error('DashX.configure: options must be an object');
     }
     if (!options.publicKey || typeof options.publicKey !== 'string') {
-      throw new Error('DashX.configure: publicKey is required and must be a string');
+      throw new Error(
+        'DashX.configure: publicKey is required and must be a string'
+      );
     }
     return getNativeDashX().configure(options);
   },
@@ -54,10 +56,14 @@ const DashX = {
 
   setIdentity(uid, token) {
     if (!uid || typeof uid !== 'string') {
-      throw new Error('DashX.setIdentity: uid is required and must be a string');
+      throw new Error(
+        'DashX.setIdentity: uid is required and must be a string'
+      );
     }
     if (!token || typeof token !== 'string') {
-      throw new Error('DashX.setIdentity: token is required and must be a string');
+      throw new Error(
+        'DashX.setIdentity: token is required and must be a string'
+      );
     }
     return getNativeDashX().setIdentity(uid, token);
   },
@@ -75,14 +81,18 @@ const DashX = {
 
   screen(screenName, data) {
     if (!screenName || typeof screenName !== 'string') {
-      throw new Error('DashX.screen: screenName is required and must be a string');
+      throw new Error(
+        'DashX.screen: screenName is required and must be a string'
+      );
     }
     return getNativeDashX().screen(screenName, data || null);
   },
 
   fetchRecord(urn, options = {}) {
     if (!urn || typeof urn !== 'string') {
-      throw new Error('DashX.fetchRecord: urn is required and must be a string (e.g. "article/123")');
+      throw new Error(
+        'DashX.fetchRecord: urn is required and must be a string (e.g. "article/123")'
+      );
     }
     if (options !== null && typeof options !== 'object') {
       throw new Error('DashX.fetchRecord: options must be an object');
@@ -92,7 +102,9 @@ const DashX = {
 
   searchRecords(resource, options = {}) {
     if (!resource || typeof resource !== 'string') {
-      throw new Error('DashX.searchRecords: resource is required and must be a string');
+      throw new Error(
+        'DashX.searchRecords: resource is required and must be a string'
+      );
     }
     if (options !== null && typeof options !== 'object') {
       throw new Error('DashX.searchRecords: options must be an object');
@@ -134,6 +146,51 @@ const DashX = {
     }
     return getEventEmitter().addListener('messageReceived', callback);
   },
+
+  uploadAsset(filePath, resource, attribute) {
+    if (!filePath || typeof filePath !== 'string') {
+      throw new Error('DashX.uploadAsset: filePath must be a string');
+    }
+    if (!resource || typeof resource !== 'string') {
+      throw new Error('DashX.uploadAsset: resource must be a string');
+    }
+    if (!attribute || typeof attribute !== 'string') {
+      throw new Error('DashX.uploadAsset: attribute must be a string');
+    }
+    return getNativeDashX().uploadAsset(filePath, resource, attribute);
+  },
+
+  fetchAsset(assetId) {
+    if (!assetId || typeof assetId !== 'string') {
+      throw new Error('DashX.fetchAsset: assetId must be a string');
+    }
+    return getNativeDashX().fetchAsset(assetId);
+  },
+
+  enableLifecycleTracking() {
+    if (Platform.OS !== 'ios') return;
+    return getNativeDashX().enableLifecycleTracking();
+  },
+
+  enableAdTracking() {
+    if (Platform.OS !== 'ios') return;
+    return getNativeDashX().enableAdTracking();
+  },
+
+  requestNotificationPermission() {
+    return getNativeDashX().requestNotificationPermission();
+  },
+
+  getNotificationPermissionStatus() {
+    return getNativeDashX().getNotificationPermissionStatus();
+  },
+
+  onLinkReceived(callback) {
+    if (typeof callback !== 'function') {
+      throw new Error('DashX.onLinkReceived: callback must be a function');
+    }
+    return getEventEmitter().addListener('linkReceived', callback);
+  },
 };
 
 export default DashX;