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

package/src/utils/notificationPermissions.ts

@@ -0,0 +1,48 @@
+import { Platform, PermissionsAndroid } from 'react-native';
+import PushNotification from 'react-native-push-notification';
+
+export type NotificationPermissionStatus = 'granted' | 'denied' | 'default';
+
+/**
+ * Request push notification permissions
+ */
+export async function requestNotificationPermission(): Promise<NotificationPermissionStatus> {
+  if (Platform.OS === 'ios') {
+    return new Promise((resolve) => {
+      PushNotification.requestPermissions((permissions: any) => {
+        resolve(permissions.alert ? 'granted' : 'denied');
+      });
+    });
+  } else if (Platform.OS === 'android') {
+    if (Platform.Version >= 33) {
+      const granted = await PermissionsAndroid.request(
+        PermissionsAndroid.PERMISSIONS.POST_NOTIFICATIONS
+      );
+      return granted === PermissionsAndroid.RESULTS.GRANTED ? 'granted' : 'denied';
+    }
+    return 'granted'; // Granted by default on older Android versions
+  }
+  return 'denied';
+}
+
+/**
+ * Check current notification permission status
+ */
+export async function checkNotificationPermission(): Promise<NotificationPermissionStatus> {
+  return new Promise((resolve) => {
+    PushNotification.checkPermissions((permissions: any) => {
+      if (permissions.alert === true || permissions.alert === 1) {
+        resolve('granted');
+      } else {
+        resolve('denied');
+      }
+    });
+  });
+}
+
+/**
+ * Check if notifications are supported
+ */
+export function isNotificationSupported(): boolean {
+  return true;
+}

package/src/utils/priceFormatting.ts

@@ -0,0 +1,119 @@
+/**
+ * Utilities for formatting prices and subscription periods
+ */
+
+/**
+ * Format a price with currency
+ */
+export function formatPrice(
+  price: number,
+  currency: string = 'USD',
+  locale: string = 'en-US'
+): string {
+  try {
+    const formatter = new Intl.NumberFormat(locale, {
+      style: 'currency',
+      currency: currency,
+    });
+    return formatter.format(price);
+  } catch (error) {
+    return `${price} ${currency}`;
+  }
+}
+
+/**
+ * Format a subscription period
+ */
+export function formatSubscriptionPeriod(
+  duration: number,
+  period: string,
+  locale: string = 'en-US'
+): string {
+  const periodUnit = period.toLowerCase();
+  
+  // Handle singular vs plural
+  if (duration === 1) {
+    switch (periodUnit) {
+      case 'day':
+        return 'daily';
+      case 'week':
+        return 'weekly';
+      case 'month':
+        return 'monthly';
+      case 'year':
+        return 'yearly';
+      default:
+        return `${duration} ${period}`;
+    }
+  }
+  
+  // Plural
+  const pluralPeriod = (() => {
+    switch (periodUnit) {
+      case 'day':
+        return 'days';
+      case 'week':
+        return 'weeks';
+      case 'month':
+        return 'months';
+      case 'year':
+        return 'years';
+      default:
+        return `${period}s`;
+    }
+  })();
+  
+  return `${duration} ${pluralPeriod}`;
+}
+
+/**
+ * Format intro pricing info
+ */
+export function formatIntroPricing(
+  introPrice: number | null | undefined,
+  introDuration: number | null | undefined,
+  introPeriod: string | null | undefined,
+  introCycles: number | null | undefined,
+  currency: string = 'USD',
+  locale: string = 'en-US'
+): string | null {
+  if (!introDuration || !introPeriod) {
+    return null;
+  }
+  
+  const periodText = formatSubscriptionPeriod(introDuration, introPeriod, locale);
+  
+  // Free trial
+  if (introPrice === 0) {
+    return `${periodText} free trial`;
+  }
+  
+  // Intro price
+  if (introPrice != null) {
+    const priceText = formatPrice(introPrice, currency, locale);
+    if (introCycles) {
+      return `${priceText} for ${introCycles} ${periodText}`;
+    }
+    return `${priceText} for ${periodText}`;
+  }
+  
+  return null;
+}
+
+/**
+ * Helper to get package type display name
+ */
+export function getPackageTypeDisplayName(packageType: string): string {
+  const typeMap: Record<string, string> = {
+    monthly: 'Monthly',
+    annual: 'Annual',
+    six_month: '6 Months',
+    three_month: '3 Months',
+    two_month: '2 Months',
+    weekly: 'Weekly',
+    lifetime: 'Lifetime',
+    custom: 'Custom',
+  };
+  
+  return typeMap[packageType] || packageType;
+}

package/src/utils/shareSheet.ts

@@ -0,0 +1,55 @@
+import { Share } from 'react-native';
+
+export interface ShareData {
+  title?: string;
+  message?: string;
+  url?: string;
+}
+
+export interface ShareResult {
+  success: boolean;
+  error?: string;
+}
+
+/**
+ * Share content using native share sheet
+ */
+export async function share(data: ShareData): Promise<ShareResult> {
+  try {
+    const shareOptions: any = {};
+    
+    if (data.message) {
+      shareOptions.message = data.message;
+    }
+    
+    if (data.url) {
+      shareOptions.url = data.url;
+    }
+    
+    if (data.title) {
+      shareOptions.title = data.title;
+    }
+    
+    const result = await Share.share(shareOptions);
+    
+    if (result.action === Share.sharedAction) {
+      return { success: true };
+    } else if (result.action === Share.dismissedAction) {
+      return { success: false, error: 'Share cancelled' };
+    }
+    
+    return { success: true };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Share failed',
+    };
+  }
+}
+
+/**
+ * Check if sharing is supported
+ */
+export function isShareSupported(): boolean {
+  return true;
+}

package/src/utils/subscriptionUpgrade.ts

@@ -0,0 +1,183 @@
+/**
+ * Subscription Upgrade/Downgrade Utilities
+ * 
+ * Provides methods for managing subscription plan changes
+ * via the upgrade-subscription edge function.
+ * 
+ * URLs are resolved through ApiClient → BillDogConfiguration.apiBaseUrl (api.billdog.io).
+ */
+
+import { ApiClient } from './ApiClient';
+
+// MARK: - Types
+
+/** Proration behavior options */
+export type ProrationBehavior = 'create_prorations' | 'none' | 'always_invoice';
+
+/** Billing cycle anchor options */
+export type BillingCycleAnchor = 'now' | 'unchanged';
+
+/** Options for configuring subscription upgrade/downgrade */
+export interface SubscriptionUpgradeOptions {
+  /** Customer ID (optional if already identified) */
+  customerId?: string;
+  /** App user ID (alternative identifier) */
+  appUserId?: string;
+  /** Specific web purchase ID to upgrade */
+  webPurchaseId?: string;
+  /** How proration should be handled */
+  prorationBehavior?: ProrationBehavior;
+  /** When the new billing cycle should start */
+  billingCycleAnchor?: BillingCycleAnchor;
+}
+
+/** Preview of subscription change costs */
+export interface ProrationPreview {
+  /** Current subscription price ID */
+  currentPriceId: string;
+  /** New price ID after upgrade/downgrade */
+  newPriceId: string;
+  /** Amount due immediately (in cents) */
+  immediateAmountCents: number;
+  /** Human-readable immediate amount */
+  formattedImmediateAmount: string;
+  /** Prorated credit amount (in cents) */
+  proratedCreditCents: number;
+  /** Prorated charge amount (in cents) */
+  proratedChargeCents: number;
+  /** Next billing date (ISO 8601 string) */
+  nextBillingDate: string | null;
+  /** Currency code */
+  currency: string;
+  /** Whether this is an upgrade or downgrade */
+  isUpgrade: boolean;
+}
+
+/** Result of a subscription upgrade/downgrade operation */
+export interface SubscriptionUpgradeResult {
+  /** Whether the operation succeeded */
+  success: boolean;
+  /** Stripe subscription ID */
+  subscriptionId?: string;
+  /** Type of change: "upgrade" or "downgrade" */
+  upgradeType: string;
+  /** Previous price ID */
+  oldPriceId?: string;
+  /** New price ID */
+  newPriceId: string;
+  /** Current period start date (ISO 8601 string) */
+  currentPeriodStart?: string;
+  /** Current period end date (ISO 8601 string) */
+  currentPeriodEnd?: string;
+  /** Applied proration behavior */
+  prorationBehavior: string;
+  /** Error message if failed */
+  errorMessage?: string;
+}
+
+// MARK: - API Functions
+
+/**
+ * Preview a subscription upgrade/downgrade before executing.
+ * Shows prorated amounts and billing changes without making changes.
+ * 
+ * @param newPriceId - The Stripe price ID to change to
+ * @param options - Upgrade options
+ * @param apiKey - @deprecated Resolved from BillDogConfiguration if omitted
+ */
+export async function previewSubscriptionUpgrade(
+  apiKey: string | undefined,
+  newPriceId: string,
+  options?: SubscriptionUpgradeOptions
+): Promise<ProrationPreview> {
+  const data = await ApiClient.post('upgrade-subscription', {
+    new_price_id: newPriceId,
+    preview: true,
+    customer_id: options?.customerId,
+    app_user_id: options?.appUserId,
+    web_purchase_id: options?.webPurchaseId,
+    proration_behavior: options?.prorationBehavior ?? 'create_prorations',
+    billing_cycle_anchor: options?.billingCycleAnchor ?? 'unchanged',
+  }, {
+    apiKey: apiKey || undefined,
+  });
+
+  const preview = data.preview;
+
+  return {
+    currentPriceId: preview.current_price_id || '',
+    newPriceId: preview.new_price_id || '',
+    immediateAmountCents: preview.immediate_amount_cents || 0,
+    formattedImmediateAmount: preview.formatted_immediate_amount || '$0.00',
+    proratedCreditCents: preview.prorated_credit_cents || 0,
+    proratedChargeCents: preview.prorated_charge_cents || 0,
+    nextBillingDate: preview.next_billing_date || null,
+    currency: preview.currency || 'usd',
+    isUpgrade: preview.is_upgrade ?? true,
+  };
+}
+
+/**
+ * Upgrade a subscription to a higher-tier plan
+ */
+export async function upgradeSubscription(
+  apiKey: string | undefined,
+  newPriceId: string,
+  options?: SubscriptionUpgradeOptions
+): Promise<SubscriptionUpgradeResult> {
+  return executeSubscriptionChange(apiKey, newPriceId, options);
+}
+
+/**
+ * Downgrade a subscription to a lower-tier plan
+ */
+export async function downgradeSubscription(
+  apiKey: string | undefined,
+  newPriceId: string,
+  options?: SubscriptionUpgradeOptions
+): Promise<SubscriptionUpgradeResult> {
+  return executeSubscriptionChange(apiKey, newPriceId, options);
+}
+
+/**
+ * Internal function to execute subscription change
+ */
+async function executeSubscriptionChange(
+  apiKey: string | undefined,
+  newPriceId: string,
+  options?: SubscriptionUpgradeOptions
+): Promise<SubscriptionUpgradeResult> {
+  try {
+    const data = await ApiClient.post('upgrade-subscription', {
+      new_price_id: newPriceId,
+      preview: false,
+      customer_id: options?.customerId,
+      app_user_id: options?.appUserId,
+      web_purchase_id: options?.webPurchaseId,
+      proration_behavior: options?.prorationBehavior ?? 'create_prorations',
+      billing_cycle_anchor: options?.billingCycleAnchor ?? 'unchanged',
+    }, {
+      apiKey: apiKey || undefined,
+    });
+
+    return {
+      success: data.success ?? false,
+      subscriptionId: data.subscription_id,
+      upgradeType: data.upgrade_type || 'upgrade',
+      oldPriceId: data.old_price_id,
+      newPriceId: data.new_price_id || newPriceId,
+      currentPeriodStart: data.current_period_start,
+      currentPeriodEnd: data.current_period_end,
+      prorationBehavior: data.proration_behavior || 'create_prorations',
+      errorMessage: data.error,
+    };
+  } catch (err: any) {
+    return {
+      success: false,
+      upgradeType: 'unknown',
+      newPriceId: newPriceId,
+      prorationBehavior: options?.prorationBehavior ?? 'create_prorations',
+      errorMessage: err.message || `Failed to change subscription`,
+    };
+  }
+}

package/src/valueUtils.ts

@@ -0,0 +1,108 @@
+/**
+ * ValueUtils — Shared primitive utilities for BillDog React Native SDK
+ *
+ * Canonical source for type coercion, comparison, and nested path walking.
+ * Used by dynamicValues.ts, xFlowTags.ts, and other modules.
+ *
+ * stringify/toNumber implement the canonical xFlow grammar (§5 of
+ * src/schemas/xflow-grammar.md): null/undefined → "", non-numeric → 0.
+ */
+
+/**
+ * Walk a dot-separated path on a nested object.
+ *
+ * Flat-key-first (grammar §4): a literal key matching the whole path wins
+ * over dotted traversal, so a variable stored under the literal key
+ * "user.name" resolves before descending into `user`.
+ */
+export function getNestedValue(obj: any, path: string): any {
+  if (obj && typeof obj === 'object' && path in obj) return obj[path];
+  return path.split('.').reduce((current, key) => current?.[key], obj);
+}
+
+/**
+ * Numeric-first equality for dynamic value conditions, matching native `ValueUtils.isEqual` (iOS +
+ * Android) and the web/renderer copies. Both-null → true; if BOTH operands coerce to a number, compare
+ * numerically (so `10.0` equals `"10"`); otherwise string-compare. The string-only version this replaced
+ * diverged from the device the moment a fractional or typed value was involved.
+ */
+/**
+ * STRUCTURAL equality — the counterpart to `isEqual`, mirroring the split native
+ * `ValueUtils` already makes (`isDeepEqual` vs `valuesEqual` on Android).
+ *
+ * Do NOT confuse the two. `isEqual` coerces (`1` equals `"1"`) because DV CONDITIONS
+ * must; state identity must not, or PaywallStateManager would swallow a genuine
+ * `1` → `"1"` transition that Android/iOS emit. This mirrors Android's
+ * `ValueUtils.isDeepEqual`: numbers compare numerically, arrays/objects compare
+ * structurally, everything else is strict.
+ */
+export function isDeepEqual(a: any, b: any): boolean {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a === 'number' && typeof b === 'number') return a === b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => isDeepEqual(v, b[i]));
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (typeof a === 'object' && typeof b === 'object') {
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    return ak.length === bk.length && ak.every((k) => isDeepEqual(a[k], b[k]));
+  }
+  return false;
+}
+
+export function isEqual(a: any, b: any): boolean {
+  if (a == null && b == null) return true;
+  if (a == null || b == null) return false;
+  const an = toNumberOrNull(a);
+  const bn = toNumberOrNull(b);
+  if (an !== null && bn !== null) return an === bn;
+  return stringify(a) === stringify(b);
+}
+
+/**
+ * Check if a value is truthy (non-null, non-empty, non-zero).
+ */
+export function isTruthy(value: any): boolean {
+  if (value === null || value === undefined) return false;
+  if (value === false) return false;
+  if (value === '' || value === 0) return false;
+  return true;
+}
+
+/** Canonical stringify — null/undefined → "" (grammar §5.1). */
+export function stringify(value: any): string {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'string') return value;
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') return String(value);
+  try {
+    return JSON.stringify(value) ?? '';
+  } catch {
+    return String(value);
+  }
+}
+
+/** Canonical numeric coercion — non-numeric → 0, never NaN (grammar §5.2). */
+export function toNumber(value: any): number {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : 0;
+  if (typeof value === 'string' && value.trim() !== '') {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : 0;
+  }
+  return 0;
+}
+
+/**
+ * Number-or-null, matching native `toDoubleOrNull`. Used by `isEqual` to decide whether to compare
+ * numerically. Booleans return null so `true` never numeric-equals `1` (they string-compare instead).
+ */
+export function toNumberOrNull(value: any): number | null {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  if (typeof value === 'string' && value.trim() !== '') {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}