@teardown/react-native 2.0.29 → 2.0.32

package/docs/adapters/notifications/index.mdx

@@ -4,7 +4,7 @@ description: Push notification adapters for token registration and management.
 icon: Bell
 ---
 
-Notification adapters handle push notification token registration and management with your push notification provider.
+Notification adapters handle push notification token registration, permission requests, and notification event handling with your push notification provider.
 
 ## Available Adapters
 
@@ -16,40 +16,94 @@ Notification adapters handle push notification token registration and management
 
 ## Usage
 
-Notification adapters are optional and used separately from the core SDK:
+Notification adapters are passed to `TeardownCore` to enable push notification support:
 
 ```typescript
-import { ExpoNotificationsAdapter } from '@teardown/react-native/expo-notifications';
+import { TeardownCore } from '@teardown/react-native';
+import { ExpoNotificationsAdapter } from '@teardown/react-native/expo';
+import { ExpoDeviceAdapter } from '@teardown/react-native/adapters/expo';
+import { MMKVStorageAdapter } from '@teardown/react-native/adapters/mmkv';
+
+const teardown = new TeardownCore({
+  org_id: 'your-org-id',
+  project_id: 'your-project-id',
+  api_key: 'your-api-key',
+  storageAdapter: new MMKVStorageAdapter(),
+  deviceAdapter: new ExpoDeviceAdapter(),
+  notificationAdapter: new ExpoNotificationsAdapter(), // Optional
+});
+
+// Access notifications via core
+if (teardown.notifications) {
+  const token = await teardown.notifications.getToken();
+}
+```
+
+## Adapter Interface
+
+All notification adapters extend the abstract `NotificationAdapter` class:
+
+```typescript
+abstract class NotificationAdapter {
+  /** The notification platform this adapter supports (APNS, FCM, EXPO) */
+  abstract get platform(): NotificationPlatformEnum;
 
-const notificationsAdapter = new ExpoNotificationsAdapter();
+  /** Get the current push notification token */
+  abstract getToken(): Promise<string | null>;
 
-// Get push token
-const token = await notificationsAdapter.getToken();
+  /** Request push notification permissions from the user */
+  abstract requestPermissions(): Promise<PermissionStatus>;
 
-// Register token with your backend
-await registerPushToken(token);
+  /** Subscribe to token refresh events */
+  abstract onTokenRefresh(listener: (token: string) => void): Unsubscribe;
+
+  /** Subscribe to foreground notification events */
+  abstract onNotificationReceived(listener: (notification: PushNotification) => void): Unsubscribe;
+
+  /** Subscribe to notification opened events (user taps) */
+  abstract onNotificationOpened(listener: (notification: PushNotification) => void): Unsubscribe;
+
+  /** Subscribe to data-only message events (silent/background push) */
+  abstract onDataMessage(listener: (message: DataMessage) => void): Unsubscribe;
+}
 ```
 
-## Adapter Interface
+### PermissionStatus
+
+```typescript
+interface PermissionStatus {
+  /** Whether notifications permission is granted */
+  granted: boolean;
+  /** Whether the user can be prompted again (iOS specific) */
+  canAskAgain: boolean;
+}
+```
 
-All notification adapters implement:
+### PushNotification
 
 ```typescript
-interface NotificationsAdapter {
-  /** Get the push notification token */
-  getToken(): Promise<string | null>;
+interface PushNotification {
+  title?: string;
+  body?: string;
+  data?: Record<string, unknown>;
+}
+```
 
-  /** Request notification permissions */
-  requestPermissions(): Promise<boolean>;
+### DataMessage
 
-  /** Check if notifications are enabled */
-  isEnabled(): Promise<boolean>;
+```typescript
+interface DataMessage {
+  data: Record<string, unknown>;
+}
+```
 
-  /** Subscribe to incoming notifications */
-  onNotification(handler: (notification: Notification) => void): () => void;
+### NotificationPlatformEnum
 
-  /** Subscribe to notification responses (user taps) */
-  onNotificationResponse(handler: (response: NotificationResponse) => void): () => void;
+```typescript
+enum NotificationPlatformEnum {
+  APNS = "APNS",  // Apple Push Notification Service
+  FCM = "FCM",    // Firebase Cloud Messaging
+  EXPO = "EXPO",  // Expo Push Notifications
 }
 ```
 
@@ -64,37 +118,64 @@ interface NotificationsAdapter {
 
 ## Custom Adapter
 
-Implement the `NotificationsAdapter` interface:
+Extend the `NotificationAdapter` abstract class:
 
 ```typescript
-import type { NotificationsAdapter, Notification, NotificationResponse } from '@teardown/react-native';
+import {
+  NotificationAdapter,
+  NotificationPlatformEnum,
+  type PermissionStatus,
+  type PushNotification,
+  type DataMessage,
+  type Unsubscribe,
+} from '@teardown/react-native';
+
+class CustomNotificationsAdapter extends NotificationAdapter {
+  get platform(): NotificationPlatformEnum {
+    return NotificationPlatformEnum.FCM;
+  }
 
-class CustomNotificationsAdapter implements NotificationsAdapter {
   async getToken(): Promise<string | null> {
-    // Return push token from your notification library
     return await myNotificationLib.getToken();
   }
 
-  async requestPermissions(): Promise<boolean> {
-    // Request notification permissions
-    return await myNotificationLib.requestPermission();
+  async requestPermissions(): Promise<PermissionStatus> {
+    const granted = await myNotificationLib.requestPermission();
+    return { granted, canAskAgain: !granted };
   }
 
-  async isEnabled(): Promise<boolean> {
-    // Check if notifications are enabled
-    return await myNotificationLib.areNotificationsEnabled();
+  onTokenRefresh(listener: (token: string) => void): Unsubscribe {
+    const subscription = myNotificationLib.onTokenRefresh(listener);
+    return () => subscription.remove();
   }
 
-  onNotification(handler: (notification: Notification) => void): () => void {
-    // Subscribe to incoming notifications
-    const subscription = myNotificationLib.onNotification(handler);
-    return () => subscription.remove();
+  onNotificationReceived(listener: (notification: PushNotification) => void): Unsubscribe {
+    const subscription = myNotificationLib.onMessage((msg) => {
+      listener({
+        title: msg.notification?.title,
+        body: msg.notification?.body,
+        data: msg.data,
+      });
+    });
+    return () => subscription();
   }
 
-  onNotificationResponse(handler: (response: NotificationResponse) => void): () => void {
-    // Subscribe to notification taps
-    const subscription = myNotificationLib.onNotificationOpened(handler);
-    return () => subscription.remove();
+  onNotificationOpened(listener: (notification: PushNotification) => void): Unsubscribe {
+    const subscription = myNotificationLib.onNotificationOpened((msg) => {
+      listener({
+        title: msg.notification?.title,
+        body: msg.notification?.body,
+        data: msg.data,
+      });
+    });
+    return () => subscription();
+  }
+
+  onDataMessage(listener: (message: DataMessage) => void): Unsubscribe {
+    const subscription = myNotificationLib.onDataMessage((msg) => {
+      listener({ data: msg.data ?? {} });
+    });
+    return () => subscription();
   }
 }
 ```

package/docs/adapters/notifications/wix.mdx

@@ -21,74 +21,104 @@ cd ios && pod install
 ## Usage
 
 ```typescript
-import { WixNotificationsAdapter } from '@teardown/react-native/wix-notifications';
-
-const notifications = new WixNotificationsAdapter();
-
-// Request permissions
-const granted = await notifications.requestPermissions();
+import { TeardownCore } from '@teardown/react-native';
+import { WixNotificationsAdapter } from '@teardown/react-native/wix';
+import { DeviceInfoAdapter } from '@teardown/react-native/adapters/device-info';
+import { AsyncStorageAdapter } from '@teardown/react-native/adapters/async-storage';
+
+const teardown = new TeardownCore({
+  org_id: 'your-org-id',
+  project_id: 'your-project-id',
+  api_key: 'your-api-key',
+  storageAdapter: new AsyncStorageAdapter(),
+  deviceAdapter: new DeviceInfoAdapter(),
+  notificationAdapter: new WixNotificationsAdapter(),
+});
 
-if (granted) {
-  // Get push token
-  const token = await notifications.getToken();
-  console.log('Push token:', token);
+// Access via NotificationsClient
+if (teardown.notifications) {
+  const status = await teardown.notifications.requestPermissions();
+  if (status.granted) {
+    const token = await teardown.notifications.getToken();
+    console.log('Push token:', token);
+  }
 }
 ```
 
 ## Import Path
 
 ```typescript
-import { WixNotificationsAdapter } from '@teardown/react-native/wix-notifications';
+import { WixNotificationsAdapter } from '@teardown/react-native/wix';
 ```
 
 ## API
 
+All methods are accessed via `NotificationsClient`, not directly on the adapter.
+
+### requestPermissions()
+
+Request notification permissions:
+
+```typescript
+const status = await teardown.notifications.requestPermissions();
+// Returns: { granted: boolean, canAskAgain: boolean }
+```
+
 ### getToken()
 
 Get the device push token:
 
 ```typescript
-const token = await notifications.getToken();
+const token = await teardown.notifications.getToken();
 // Returns: device token string or null
 ```
 
-### requestPermissions()
+### onNotificationReceived()
 
-Request notification permissions:
+Subscribe to foreground notifications:
 
 ```typescript
-const granted = await notifications.requestPermissions();
-// Returns: true if granted, false otherwise
+const unsubscribe = teardown.notifications.onNotificationReceived((notification) => {
+  console.log('Received:', notification.title);
+});
+
+// Cleanup
+unsubscribe();
 ```
 
-### isEnabled()
+### onNotificationOpened()
 
-Check if notifications are enabled:
+Subscribe to notification taps:
 
 ```typescript
-const enabled = await notifications.isEnabled();
+const unsubscribe = teardown.notifications.onNotificationOpened((notification) => {
+  console.log('User tapped:', notification.title);
+});
+
+// Cleanup
+unsubscribe();
 ```
 
-### onNotification()
+### onTokenRefresh()
 
-Subscribe to incoming notifications:
+Subscribe to token changes:
 
 ```typescript
-const unsubscribe = notifications.onNotification((notification) => {
-  console.log('Received:', notification.title);
+const unsubscribe = teardown.notifications.onTokenChange((token) => {
+  console.log('New token:', token);
 });
 
 // Cleanup
 unsubscribe();
 ```
 
-### onNotificationResponse()
+### onDataMessage()
 
-Subscribe to notification opens:
+Subscribe to data-only messages (silent push):
 
 ```typescript
-const unsubscribe = notifications.onNotificationResponse((response) => {
-  console.log('User tapped:', response.notification.title);
+const unsubscribe = teardown.notifications.onDataMessage((message) => {
+  console.log('Data message:', message.data);
 });
 
 // Cleanup
@@ -128,6 +158,10 @@ unsubscribe();
 import com.wix.reactnativenotifications.RNNotificationsPackage;
 ```
 
+## Platform
+
+Returns `NotificationPlatformEnum.APNS` on iOS, `NotificationPlatformEnum.FCM` on Android.
+
 ## When to Use
 
 - Existing projects using react-native-notifications

package/docs/advanced.mdx

@@ -31,6 +31,86 @@ export const teardown = new TeardownCore({
 });
 ```
 
+## Push Notifications Setup
+
+Enable push notifications by providing a notification adapter:
+
+```typescript
+import { TeardownCore } from '@teardown/react-native';
+import { ExpoNotificationsAdapter, ExpoDeviceAdapter } from '@teardown/react-native/expo';
+import { MMKVStorageAdapter } from '@teardown/react-native/adapters/mmkv';
+
+const teardown = new TeardownCore({
+  org_id: 'your-org-id',
+  project_id: 'your-project-id',
+  api_key: 'your-api-key',
+  storageAdapter: new MMKVStorageAdapter(),
+  deviceAdapter: new ExpoDeviceAdapter(),
+  notificationAdapter: new ExpoNotificationsAdapter(), // Enable notifications
+});
+
+// Request permissions and get token
+if (teardown.notifications) {
+  const status = await teardown.notifications.requestPermissions();
+  if (status.granted) {
+    const token = await teardown.notifications.getToken();
+    // Token is automatically sent with identify() calls
+  }
+}
+```
+
+### Handle Notifications
+
+```typescript
+const { core } = useTeardown();
+
+useEffect(() => {
+  if (!core.notifications) return;
+
+  const unsubs = [
+    core.notifications.onNotificationReceived((notification) => {
+      // Foreground notification
+      console.log('Notification:', notification.title);
+    }),
+    core.notifications.onNotificationOpened((notification) => {
+      // User tapped notification
+      navigateToScreen(notification.data?.screen);
+    }),
+    core.notifications.onDataMessage((message) => {
+      // Silent/data message
+      syncData(message.data);
+    }),
+  ];
+
+  return () => unsubs.forEach(unsub => unsub());
+}, [core.notifications]);
+```
+
+## Event Tracking
+
+Track custom events:
+
+```typescript
+const { core } = useTeardown();
+
+// Track single event
+await core.events.track({
+  event_name: 'purchase_completed',
+  event_type: 'action',
+  properties: {
+    product_id: 'abc123',
+    amount: 99.99,
+    currency: 'USD',
+  },
+});
+
+// Track multiple events
+await core.events.trackBatch([
+  { event_name: 'cart_viewed', event_type: 'screen_view' },
+  { event_name: 'item_added', properties: { item_id: 'xyz' } },
+]);
+```
+
 ## Disable Force Update Checking
 
 For debugging or testing:
@@ -133,12 +213,24 @@ export const useTeardown = () => ({
   core: {
     identity: {
       identify: jest.fn().mockResolvedValue({ success: true, data: mockSession }),
-      reset: jest.fn(),
+      signOut: jest.fn().mockResolvedValue({ success: true, data: undefined }),
+      signOutAll: jest.fn().mockResolvedValue({ success: true, data: undefined }),
       getSessionState: () => mockSession,
     },
     forceUpdate: {
       getVersionStatus: () => ({ type: 'up_to_date' }),
     },
+    events: {
+      track: jest.fn().mockResolvedValue({ success: true, data: undefined }),
+      trackBatch: jest.fn().mockResolvedValue({ success: true, data: undefined }),
+    },
+    notifications: {
+      requestPermissions: jest.fn().mockResolvedValue({ granted: true, canAskAgain: true }),
+      getToken: jest.fn().mockResolvedValue('mock-push-token'),
+      onNotificationReceived: jest.fn().mockReturnValue(() => {}),
+      onNotificationOpened: jest.fn().mockReturnValue(() => {}),
+      onDataMessage: jest.fn().mockReturnValue(() => {}),
+    },
   },
 });
 
@@ -148,6 +240,7 @@ export const useForceUpdate = () => ({
   isUpdateRequired: false,
   isUpdateRecommended: false,
   isUpdateAvailable: false,
+  releaseNotes: null,
 });
 ```
 
@@ -187,8 +280,11 @@ console.log('Device ID:', await core.device.getDeviceId());
 For debugging or logout:
 
 ```typescript
-core.identity.reset();
-// This clears session data and device association
+// Sign out - clears session, keeps device ID
+await core.identity.signOut();
+
+// Full reset - clears session AND device ID (fresh install state)
+await core.identity.signOutAll();
 ```
 
 ## Performance