@billdog.io/react-native 1.0.0-beta.2

package/src/murmur.ts

@@ -0,0 +1,102 @@
+/**
+ * MurmurHash3 (x86_32) — the ONE canonical deterministic bucketing hash.
+ *
+ * React Native port of the backend canonical `murmurhash3`
+ * (`supabase/functions/_shared/edge-serving/pure.ts`) and the dashboard copy
+ * (`src/lib/murmur.ts`). Used to derive the render-time `user.seed` Dynamic
+ * Values variable so a user buckets IDENTICALLY on every surface.
+ *
+ * RN-SPECIFIC: uses a manual UTF-8 encoder instead of `TextEncoder`, because
+ * Hermes historically ships without `TextEncoder`. The bytes it produces are
+ * identical to `TextEncoder().encode(...)` for the fixture inputs (incl.
+ * surrogate-pair emoji), so it stays pinned to the same corpus.
+ *
+ * CONTRACT (do not change without regenerating the fixture on ALL ports):
+ *   user.seed = murmurhash3(appUserId) % 1000   → range 0..999
+ *
+ * Conformance-pinned to `native-sdks/_test-fixtures/conformance/core_user_seed.json`.
+ * Never validated against another SDK port.
+ */
+
+/** UTF-8 encode without depending on TextEncoder (Hermes-safe). */
+function utf8Bytes(str: string): number[] {
+  const bytes: number[] = [];
+  for (let i = 0; i < str.length; i++) {
+    let code = str.charCodeAt(i);
+    if (code < 0x80) {
+      bytes.push(code);
+    } else if (code < 0x800) {
+      bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+    } else if (code >= 0xd800 && code <= 0xdbff) {
+      // High surrogate — must be followed by a low surrogate.
+      const lo = str.charCodeAt(i + 1);
+      if (lo >= 0xdc00 && lo <= 0xdfff) {
+        i++;
+        code = 0x10000 + ((code - 0xd800) << 10) + (lo - 0xdc00);
+        bytes.push(
+          0xf0 | (code >> 18),
+          0x80 | ((code >> 12) & 0x3f),
+          0x80 | ((code >> 6) & 0x3f),
+          0x80 | (code & 0x3f),
+        );
+      } else {
+        // Lone high surrogate → U+FFFD replacement char, matching TextEncoder.
+        bytes.push(0xef, 0xbf, 0xbd);
+      }
+    } else if (code >= 0xdc00 && code <= 0xdfff) {
+      // Lone low surrogate → U+FFFD, matching TextEncoder.
+      bytes.push(0xef, 0xbf, 0xbd);
+    } else {
+      bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+    }
+  }
+  return bytes;
+}
+
+export function murmurhash3(key: string, seed = 0): number {
+  const keyBytes = utf8Bytes(key);
+  let h1 = seed;
+  const c1 = 0xcc9e2d51;
+  const c2 = 0x1b873593;
+  const blocks = Math.floor(keyBytes.length / 4);
+  for (let i = 0; i < blocks; i++) {
+    let k1 = keyBytes[i * 4] | (keyBytes[i * 4 + 1] << 8) | (keyBytes[i * 4 + 2] << 16) | (keyBytes[i * 4 + 3] << 24);
+    k1 = Math.imul(k1, c1);
+    k1 = (k1 << 15) | (k1 >>> 17);
+    k1 = Math.imul(k1, c2);
+    h1 ^= k1;
+    h1 = (h1 << 13) | (h1 >>> 19);
+    h1 = Math.imul(h1, 5) + 0xe6546b64;
+  }
+  let k1 = 0;
+  const offset = blocks * 4;
+  switch (keyBytes.length % 4) {
+    case 3:
+      k1 ^= keyBytes[offset + 2] << 16;
+    /* falls through */
+    case 2:
+      k1 ^= keyBytes[offset + 1] << 8;
+    /* falls through */
+    case 1:
+      k1 ^= keyBytes[offset];
+      k1 = Math.imul(k1, c1);
+      k1 = (k1 << 15) | (k1 >>> 17);
+      k1 = Math.imul(k1, c2);
+      h1 ^= k1;
+  }
+  h1 ^= keyBytes.length;
+  h1 ^= h1 >>> 16;
+  h1 = Math.imul(h1, 0x85ebca6b);
+  h1 ^= h1 >>> 13;
+  h1 = Math.imul(h1, 0xc2b2ae35);
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+
+export const USER_SEED_MODULUS = 1000;
+
+/** Canonical `user.seed` derivation: 0..999 bucket from a stable user id. */
+export function userSeedBucket(appUserId: string | null | undefined): number {
+  if (!appUserId) return 0;
+  return murmurhash3(appUserId) % USER_SEED_MODULUS;
+}

package/src/notifications/LiveActivitiesManager.ts

@@ -0,0 +1,140 @@
+import { NativeModules, Platform } from 'react-native';
+
+const { BillDogLiveActivities } = NativeModules;
+
+export interface LiveActivityConfig {
+  activityType: string;
+  attributes: Record<string, any>;
+  contentState: Record<string, any>;
+  staleDate?: Date;
+  dismissalDate?: Date;
+}
+
+export interface LiveActivityUpdate {
+  contentState: Record<string, any>;
+  staleDate?: Date;
+}
+
+/**
+ * Manager for iOS Live Activities
+ * Only available on iOS 16.1+
+ */
+export class LiveActivitiesManager {
+  private static instance: LiveActivitiesManager;
+
+  private constructor() {}
+
+  static getInstance(): LiveActivitiesManager {
+    if (!LiveActivitiesManager.instance) {
+      LiveActivitiesManager.instance = new LiveActivitiesManager();
+    }
+    return LiveActivitiesManager.instance;
+  }
+
+  /**
+   * Check if Live Activities are supported
+   */
+  isSupported(): boolean {
+    return Platform.OS === 'ios' && Platform.Version >= '16.2' && !!BillDogLiveActivities;
+  }
+
+  /**
+   * Check if Live Activities are enabled by the user
+   */
+  async areActivitiesEnabled(): Promise<boolean> {
+    if (!this.isSupported()) {
+      return false;
+    }
+
+    try {
+      return await BillDogLiveActivities.areActivitiesEnabled();
+    } catch (error) {
+      console.error('[LiveActivitiesManager] Error checking enabled status:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Start a new Live Activity
+   * Returns the activity ID
+   */
+  async startActivity(config: LiveActivityConfig): Promise<string> {
+    if (!this.isSupported()) {
+      throw new Error('Live Activities are not supported on this platform');
+    }
+
+    try {
+      const activityId = await BillDogLiveActivities.startActivity(
+        config.activityType,
+        config.attributes,
+        config.contentState,
+        config.staleDate?.toISOString(),
+        config.dismissalDate?.toISOString()
+      );
+
+      return activityId;
+    } catch (error) {
+      console.error('[LiveActivitiesManager] Error starting activity:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Update an existing Live Activity
+   */
+  async updateActivity(activityId: string, update: LiveActivityUpdate): Promise<void> {
+    if (!this.isSupported()) {
+      throw new Error('Live Activities are not supported on this platform');
+    }
+
+    try {
+      await BillDogLiveActivities.updateActivity(
+        activityId,
+        update.contentState,
+        update.staleDate?.toISOString()
+      );
+    } catch (error) {
+      console.error('[LiveActivitiesManager] Error updating activity:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * End a Live Activity
+   */
+  async endActivity(
+    activityId: string,
+    finalState?: Record<string, any>,
+    dismissalPolicy: 'default' | 'immediate' | 'after' = 'default'
+  ): Promise<void> {
+    if (!this.isSupported()) {
+      throw new Error('Live Activities are not supported on this platform');
+    }
+
+    try {
+      await BillDogLiveActivities.endActivity(activityId, finalState, dismissalPolicy);
+    } catch (error) {
+      console.error('[LiveActivitiesManager] Error ending activity:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get all active Live Activities
+   * Returns array of activity IDs
+   */
+  async getActiveActivities(): Promise<string[]> {
+    if (!this.isSupported()) {
+      return [];
+    }
+
+    try {
+      return await BillDogLiveActivities.getActiveActivities();
+    } catch (error) {
+      console.error('[LiveActivitiesManager] Error getting active activities:', error);
+      return [];
+    }
+  }
+}
+
+export const liveActivities = LiveActivitiesManager.getInstance();

package/src/notifications/NotificationScheduler.ts

@@ -0,0 +1,292 @@
+import { Platform, PermissionsAndroid } from 'react-native';
+import PushNotification from 'react-native-push-notification';
+import PushNotificationIOS from '@react-native-community/push-notification-ios';
+import { ApiClient } from '../utils/ApiClient';
+
+/**
+ * Handles scheduling and managing trial reminder notifications for React Native.
+ * 
+ * All API calls route through `ApiClient` → `BillDogConfiguration.apiBaseUrl`
+ * (the single branded host, `https://api.billdog.io/v1`).
+ */
+export class NotificationScheduler {
+  private static instance: NotificationScheduler;
+
+  private constructor() {
+    this.configure();
+  }
+
+  public static getInstance(): NotificationScheduler {
+    if (!NotificationScheduler.instance) {
+      NotificationScheduler.instance = new NotificationScheduler();
+    }
+    return NotificationScheduler.instance;
+  }
+
+  private configure() {
+    PushNotification.configure({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- callback shape comes from the optional, untyped react-native-push-notification peer dep
+      onNotification: (notification: any) => {
+        console.log('Notification received:', notification);
+        if (Platform.OS === 'ios') {
+          notification.finish(PushNotificationIOS.FetchResult.NoData);
+        }
+      },
+      permissions: {
+        alert: true,
+        badge: true,
+        sound: true,
+      },
+      popInitialNotification: true,
+      requestPermissions: false,
+    });
+
+    if (Platform.OS === 'android') {
+      PushNotification.createChannel(
+        {
+          channelId: 'trial-reminders',
+          channelName: 'Trial Reminders',
+          channelDescription: 'Notifications about your trial subscription',
+          importance: 4,
+          vibrate: true,
+        },
+        (created: boolean) => console.log(`Channel created: ${created}`)
+      );
+    }
+  }
+
+  public async requestPermissions(): Promise<boolean> {
+    if (Platform.OS === 'ios') {
+      return new Promise((resolve) => {
+        PushNotification.requestPermissions((permissions: any) => {
+          resolve(permissions.alert === true);
+        });
+      });
+    } else if (Platform.OS === 'android') {
+      if (Platform.Version >= 33) {
+        const granted = await PermissionsAndroid.request(
+          PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS
+        );
+        return granted === PermissionsAndroid.RESULTS.GRANTED;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  public async checkPermissions(): Promise<boolean> {
+    return new Promise((resolve) => {
+      PushNotification.checkPermissions((permissions: any) => {
+        resolve(permissions.alert === true || permissions.alert === 1);
+      });
+    });
+  }
+
+  /**
+   * Schedule a trial reminder notification.
+   * 
+   * @param apiKey - @deprecated Resolved from BillDogConfiguration if omitted
+   */
+  public async scheduleTrialNotification(
+    subscription: Subscription,
+    config: NotificationConfig,
+    apiKey?: string
+  ): Promise<void> {
+    if (!subscription.isTrial) {
+      console.warn('⚠️ Not a trial subscription, skipping notification');
+      throw new Error('Not a trial subscription');
+    }
+
+    if (!subscription.expiresAt || new Date(subscription.expiresAt) < new Date()) {
+      console.warn('⚠️ Trial already expired, skipping notification');
+      throw new Error('Trial already expired');
+    }
+
+    if (!subscription.purchasedAt) {
+      console.warn('⚠️ Missing trial start date, skipping notification');
+      throw new Error('Missing trial start date');
+    }
+
+    const purchaseDate = new Date(subscription.purchasedAt);
+    const notificationDate = new Date(purchaseDate);
+    notificationDate.setDate(notificationDate.getDate() + config.dayOfTrial);
+
+    if (notificationDate < new Date()) {
+      console.warn(
+        `⚠️ Notification date is in the past (Day ${config.dayOfTrial} was ${notificationDate}), skipping`
+      );
+      throw new Error('Notification date in the past');
+    }
+
+    if (notificationDate > new Date(subscription.expiresAt)) {
+      console.warn('⚠️ Notification date is after trial expiration, skipping');
+      throw new Error('Notification date after expiration');
+    }
+
+    if (subscription.notificationScheduledAt) {
+      console.warn(
+        `⚠️ Notification already scheduled at ${subscription.notificationScheduledAt}`
+      );
+      throw new Error('Notification already scheduled');
+    }
+
+    const hasPermission = await this.checkPermissions();
+    if (!hasPermission) {
+      if (config.requestPermissions) {
+        const granted = await this.requestPermissions();
+        if (!granted) {
+          throw new Error('Notification permission denied');
+        }
+      } else {
+        throw new Error('Notification permission not granted');
+      }
+    }
+
+    PushNotification.localNotificationSchedule({
+      id: `trial_reminder_${subscription.id}`,
+      channelId: 'trial-reminders',
+      title: config.title,
+      message: config.body,
+      date: notificationDate,
+      allowWhileIdle: true,
+      userInfo: {
+        subscription_id: subscription.id,
+        notification_type: 'trial_reminder',
+        day_of_trial: config.dayOfTrial,
+      },
+      ...(config.subtitle && Platform.OS === 'ios' ? { subtitle: config.subtitle } : {}),
+      ...(config.sound ? { soundName: config.sound } : {}),
+      ...(config.badge ? { number: config.badge } : {}),
+    });
+
+    // Update subscription via ApiClient
+    await this.updateSubscriptionNotificationStatus(
+      subscription.id,
+      { scheduledAt: new Date() },
+      apiKey
+    );
+
+    console.log(
+      `✅ Scheduled trial reminder notification for Day ${config.dayOfTrial} at ${notificationDate}`
+    );
+  }
+
+  public async cancelNotification(
+    subscriptionId: string,
+    apiKey?: string
+  ): Promise<void> {
+    PushNotification.cancelLocalNotification(`trial_reminder_${subscriptionId}`);
+
+    await this.updateSubscriptionNotificationStatus(
+      subscriptionId,
+      { cancelledAt: new Date() },
+      apiKey
+    );
+
+    console.log('✅ Cancelled trial reminder notification');
+  }
+
+  public async getScheduledNotifications(): Promise<any[]> {
+    return new Promise((resolve) => {
+      PushNotification.getScheduledLocalNotifications((notifications: any[]) => {
+        resolve(notifications);
+      });
+    });
+  }
+
+  /**
+   * Update subscription notification status via ApiClient.
+   */
+  private async updateSubscriptionNotificationStatus(
+    subscriptionId: string,
+    updates: {
+      scheduledAt?: Date;
+      sentAt?: Date;
+      cancelledAt?: Date;
+    },
+    apiKey?: string
+  ): Promise<void> {
+    const body: Record<string, string> = {};
+
+    if (updates.scheduledAt) {
+      body.notification_scheduled_at = updates.scheduledAt.toISOString();
+    }
+    if (updates.sentAt) {
+      body.notification_sent_at = updates.sentAt.toISOString();
+    }
+    if (updates.cancelledAt) {
+      body.notification_cancelled_at = updates.cancelledAt.toISOString();
+    }
+
+    if (Object.keys(body).length === 0) return;
+
+    try {
+      await ApiClient.post('update-subscription-notification', {
+        subscription_id: subscriptionId,
+        ...body,
+      }, {
+        apiKey,
+      });
+    } catch (error) {
+      console.warn('⚠️ Failed to update subscription status:', error);
+    }
+  }
+}
+
+/**
+ * Type definitions
+ */
+export interface NotificationConfig {
+  enabled: boolean;
+  dayOfTrial: number;
+  title: string;
+  subtitle?: string;
+  body: string;
+  requestPermissions: boolean;
+  removeNotificationEnabled?: boolean;
+  sound?: string;
+  badge?: number;
+}
+
+export interface Subscription {
+  id: string;
+  isTrial: boolean;
+  purchasedAt?: string;
+  expiresAt?: string;
+  notificationScheduledAt?: string;
+  notificationSentAt?: string;
+  notificationCancelledAt?: string;
+}
+
+// Convenience exports
+export const requestNotificationPermissions = () =>
+  NotificationScheduler.getInstance().requestPermissions();
+
+export const checkNotificationPermissions = () =>
+  NotificationScheduler.getInstance().checkPermissions();
+
+export const scheduleTrialNotification = (
+  subscription: Subscription,
+  config: NotificationConfig,
+  apiKey?: string
+) =>
+  NotificationScheduler.getInstance().scheduleTrialNotification(
+    subscription,
+    config,
+    apiKey
+  );
+
+export const cancelTrialNotification = (
+  subscriptionId: string,
+  apiKey?: string
+) =>
+  NotificationScheduler.getInstance().cancelNotification(
+    subscriptionId,
+    apiKey
+  );
+
+export const getScheduledNotifications = () =>
+  NotificationScheduler.getInstance().getScheduledNotifications();
+
+// Re-export device token registration
+export { useDeviceToken, registerDeviceToken } from './useDeviceToken';

package/src/notifications/PurchaseNotificationHandler.ts

@@ -0,0 +1,67 @@
+import PushNotification from 'react-native-push-notification';
+import { ApiClient } from '../utils/ApiClient';
+
+export interface PurchaseNotificationConfig {
+  /** @deprecated Use BillDogConfiguration.configure({ apiKey }) instead */
+  apiKey?: string;
+}
+
+export interface PurchaseDetails {
+  subscriptionId: string;
+  userId: string;
+  projectId: string;
+  productId: string;
+  platform: 'ios' | 'android';
+}
+
+/**
+ * Handles notification cancellation when purchases are completed.
+ * 
+ * Resolves API endpoint from BillDogConfiguration by default.
+ */
+export class PurchaseNotificationHandler {
+  /** @deprecated */
+  private apiKey?: string;
+
+  constructor(config: PurchaseNotificationConfig = {}) {
+    this.apiKey = config.apiKey;
+  }
+
+  async handlePurchaseCompleted(details: PurchaseDetails): Promise<boolean> {
+    try {
+      this.cancelLocalNotification(details.subscriptionId);
+      await this.cancelRemoteNotification(details);
+      return true;
+    } catch (error) {
+      console.error('[PurchaseNotificationHandler] Error handling purchase:', error);
+      throw error;
+    }
+  }
+
+  private cancelLocalNotification(subscriptionId: string): void {
+    const notificationId = `trial-reminder-${subscriptionId}`;
+    PushNotification.cancelLocalNotification(notificationId);
+    PushNotification.cancelAllLocalNotifications();
+    console.log('[PurchaseNotificationHandler] Cancelled local notification:', notificationId);
+  }
+
+  private async cancelRemoteNotification(details: PurchaseDetails): Promise<void> {
+    try {
+      const result = await ApiClient.post('handle-purchase-notification', {
+        subscriptionId: details.subscriptionId,
+        userId: details.userId,
+        projectId: details.projectId,
+        productId: details.productId,
+        platform: details.platform,
+        purchaseDate: new Date().toISOString(),
+      }, {
+        apiKey: this.apiKey,
+      });
+
+      console.log('[PurchaseNotificationHandler] Successfully updated backend:', result);
+    } catch (error) {
+      console.error('[PurchaseNotificationHandler] Error updating backend:', error);
+      throw error;
+    }
+  }
+}