react-native-nami-sdk 3.3.0-beta.7 → 3.3.0

package/src/NamiCustomerManager.ts

@@ -1,84 +1,66 @@
 import {
+  TurboModuleRegistry,
   NativeModules,
   NativeEventEmitter,
   EmitterSubscription,
 } from 'react-native';
-import { AccountStateAction, CustomerJourneyState } from './types';
+import type { Spec } from '../specs/NativeNamiCustomerManager';
+import type {
+  AccountStateAction,
+  CustomerJourneyState,
+  NamiAccountStateEvent,
+} from './types';
 
-export const { RNNamiCustomerManager } = NativeModules;
+const RNNamiCustomerManager: Spec =
+  TurboModuleRegistry.getEnforcing?.<Spec>('RNNamiCustomerManager') ??
+  NativeModules.RNNamiCustomerManager;
+
+const emitter = new NativeEventEmitter(NativeModules.RNNamiCustomerManager);
 
 export enum NamiCustomerManagerEvents {
   JourneyStateChanged = 'JourneyStateChanged',
   AccountStateChanged = 'AccountStateChanged',
 }
 
-export interface INamiCustomerManager {
-  emitter: NativeEventEmitter;
-  setCustomerAttribute: (key: string, value: string) => void;
-  getCustomerAttribute: (key: string) => Promise<string | undefined>;
-  clearCustomerAttribute: (key: string) => void;
-  clearAllCustomerAttributes: () => void;
-  journeyState: () => Promise<CustomerJourneyState | undefined>;
-  isLoggedIn: () => Promise<boolean>;
-  loggedInId: () => Promise<string | undefined>;
-  deviceId: () => Promise<string>;
-  login: (customerId: string) => void;
-  logout: () => void;
-  registerJourneyStateHandler: (
-    callback: (journeyState: CustomerJourneyState) => void,
-  ) => EmitterSubscription['remove'];
-  registerAccountStateHandler: (
-    callback: (
-      action: AccountStateAction,
-      success: boolean,
-      error?: number,
-    ) => void,
-  ) => EmitterSubscription['remove'];
-  clearCustomerDataPlatformId: () => void;
-  setCustomerDataPlatformId: (platformId: string) => void;
-  setAnonymousMode: (anonymousMode: boolean) => void;
-  inAnonymousMode: () => Promise<boolean>;
-}
+export const NamiCustomerManager = {
+  emitter,
+
+  login: (customerId: string) => RNNamiCustomerManager.login(customerId),
 
-export const NamiCustomerManager: INamiCustomerManager = {
-  ...RNNamiCustomerManager,
-  emitter: new NativeEventEmitter(RNNamiCustomerManager),
-  login: customerId => {
-    RNNamiCustomerManager.login(customerId);
+  logout: () => RNNamiCustomerManager.logout(),
+
+  setCustomerAttribute: (key: string, value: string) =>
+    RNNamiCustomerManager.setCustomerAttribute(key, value),
+
+  getCustomerAttribute: async (key: string): Promise<string | undefined> => {
+    const value = await RNNamiCustomerManager.getCustomerAttribute(key);
+    return value ?? undefined;
   },
-  logout: () => {
-    RNNamiCustomerManager.logout();
+
+  clearCustomerAttribute: (key: string) =>
+    RNNamiCustomerManager.clearCustomerAttribute(key),
+
+  clearAllCustomerAttributes: () =>
+    RNNamiCustomerManager.clearAllCustomerAttributes(),
+
+  journeyState: async (): Promise<CustomerJourneyState> =>
+    RNNamiCustomerManager.journeyState() as Promise<CustomerJourneyState>,
+
+  isLoggedIn: async (): Promise<boolean> => RNNamiCustomerManager.isLoggedIn(),
+
+  loggedInId: async (): Promise<string | undefined> => {
+    const id = await RNNamiCustomerManager.loggedInId();
+    return id ?? undefined;
   },
-  setCustomerDataPlatformId: platformId => {
+  setCustomerDataPlatformId: (platformId) => {
     RNNamiCustomerManager.setCustomerDataPlatformId(platformId);
   },
   clearCustomerDataPlatformId: () => {
     RNNamiCustomerManager.clearCustomerDataPlatformId();
   },
-  setAnonymousMode: anonymousMode => {
+  setAnonymousMode: (anonymousMode) => {
     RNNamiCustomerManager.setAnonymousMode(anonymousMode);
   },
-  setCustomerAttribute: (key, value) => {
-    RNNamiCustomerManager.setCustomerAttribute(key, value);
-  },
-  clearCustomerAttribute: key => {
-    RNNamiCustomerManager.clearCustomerAttribute(key);
-  },
-  clearAllCustomerAttributes: () => {
-    RNNamiCustomerManager.clearAllCustomerAttributes();
-  },
-  getCustomerAttribute: async key => {
-    return RNNamiCustomerManager.getCustomerAttribute(key);
-  },
-  journeyState: async () => {
-    return RNNamiCustomerManager.journeyState();
-  },
-  isLoggedIn: async () => {
-    return RNNamiCustomerManager.isLoggedIn();
-  },
-  loggedInId: async () => {
-    return RNNamiCustomerManager.loggedInId();
-  },
   deviceId: async () => {
     return RNNamiCustomerManager.deviceId();
   },
@@ -86,40 +68,32 @@ export const NamiCustomerManager: INamiCustomerManager = {
     return RNNamiCustomerManager.inAnonymousMode();
   },
   registerJourneyStateHandler: (
-    callback: (journeyState: CustomerJourneyState) => void,
-  ) => {
-    const subscription = NamiCustomerManager.emitter.addListener(
+    callback: (state: CustomerJourneyState) => void,
+  ): EmitterSubscription['remove'] => {
+    const subscription = emitter.addListener(
       NamiCustomerManagerEvents.JourneyStateChanged,
       callback,
     );
-    RNNamiCustomerManager.registerJourneyStateHandler();
-    return () => {
-      if (subscription) {
-        subscription.remove();
-      }
-    };
+    RNNamiCustomerManager.registerJourneyStateHandler?.();
+    return () => subscription.remove();
   },
+
   registerAccountStateHandler: (
     callback: (
       action: AccountStateAction,
       success: boolean,
       error?: number,
     ) => void,
-  ) => {
-    const subscription = NamiCustomerManager.emitter.addListener(
+  ): EmitterSubscription['remove'] => {
+    const subscription = emitter.addListener(
       NamiCustomerManagerEvents.AccountStateChanged,
-      (body: any) => {
-        const action: AccountStateAction = body.action.toLowerCase();
-        const error: number | undefined = body.error;
-        const success: boolean = body.success;
-        callback(action, success, error);
+      (body: NamiAccountStateEvent) => {
+        const action: AccountStateAction =
+          body.action.toLowerCase() as AccountStateAction;
+        callback(action, body.success, body.error);
       },
     );
-    RNNamiCustomerManager.registerAccountStateHandler();
-    return () => {
-      if (subscription) {
-        subscription.remove();
-      }
-    };
+    RNNamiCustomerManager.registerAccountStateHandler?.();
+    return () => subscription.remove();
   },
 };

package/src/NamiEntitlementManager.ts

@@ -1,53 +1,66 @@
 import {
+  TurboModuleRegistry,
   NativeModules,
   NativeEventEmitter,
-  Platform,
   EmitterSubscription,
 } from 'react-native';
-import { NamiEntitlement } from './types';
+import type { Spec } from '../specs/NativeNamiEntitlementManager';
+import type { NamiEntitlement } from './types';
+import { parsePurchaseDates } from './transformers';
 
-export const { RNNamiEntitlementManager } = NativeModules;
+const RNNamiEntitlementManager: Spec =
+  TurboModuleRegistry.getEnforcing?.<Spec>('RNNamiEntitlementManager') ??
+  NativeModules.RNNamiEntitlementManager;
+
+const emitter = new NativeEventEmitter(NativeModules.RNNamiEntitlementManager);
 
 export enum NamiEntitlementManagerEvents {
   EntitlementsChanged = 'EntitlementsChanged',
 }
 
-export interface INamiEntitlementManager {
-  emitter: NativeEventEmitter;
-  active: () => Promise<Array<NamiEntitlement>>;
-  isEntitlementActive: (label?: string) => boolean;
-  refresh: (
-    resultCallback?: (entitlements?: NamiEntitlement[]) => void,
-  ) => void;
-  registerActiveEntitlementsHandler: (
-    callback: (activeEntitlements: NamiEntitlement[]) => void,
-  ) => EmitterSubscription['remove'];
-  clearProvisionalEntitlementGrants: () => void;
+function parseEntitlements(entitlements: any[]): NamiEntitlement[] {
+  return entitlements.map((ent) => ({
+    ...ent,
+    activePurchases: ent.activePurchases.map(parsePurchaseDates),
+    relatedSkus: ent.relatedSkus ?? [],
+    purchasedSkus: ent.purchasedSkus ?? [],
+  }));
 }
 
-export const NamiEntitlementManager: INamiEntitlementManager = {
-  ...RNNamiEntitlementManager,
-  emitter: new NativeEventEmitter(RNNamiEntitlementManager),
-  refresh: (resultCallback?: (entitlements?: NamiEntitlement[]) => void) => {
-    if (Platform.OS === 'android') {
-      RNNamiEntitlementManager.refresh(resultCallback ?? (() => {}));
-    } else {
-      RNNamiEntitlementManager.refresh();
-    }
+export const NamiEntitlementManager = {
+  emitter,
+
+  active: async (): Promise<NamiEntitlement[]> => {
+    const raw = await RNNamiEntitlementManager.active();
+    return parseEntitlements(raw);
+  },
+
+  isEntitlementActive: async (entitlementId: string): Promise<boolean> => {
+    return await RNNamiEntitlementManager.isEntitlementActive(entitlementId);
   },
+
+  refresh: (
+    callback: (entitlements: NamiEntitlement[]) => void,
+  ): EmitterSubscription['remove'] => {
+    const subscription = emitter.addListener(
+      NamiEntitlementManagerEvents.EntitlementsChanged,
+      callback,
+    );
+    RNNamiEntitlementManager.refresh?.();
+    return () => subscription.remove();
+  },
+
   registerActiveEntitlementsHandler: (
-    callback: (activeEntitlements: NamiEntitlement[]) => void,
-  ) => {
-    let subscription: EmitterSubscription =
-      NamiEntitlementManager.emitter.addListener(
-        NamiEntitlementManagerEvents.EntitlementsChanged,
-        callback,
-      );
-    RNNamiEntitlementManager.registerActiveEntitlementsHandler();
-    return () => {
-      if (subscription) {
-        subscription.remove();
-      }
-    };
+    callback: (entitlements: NamiEntitlement[]) => void,
+  ): EmitterSubscription['remove'] => {
+    const subscription = emitter.addListener(
+      NamiEntitlementManagerEvents.EntitlementsChanged,
+      callback,
+    );
+    RNNamiEntitlementManager.registerActiveEntitlementsHandler?.();
+    return () => subscription.remove();
   },
+
+  clearProvisionalEntitlementGrants: (): void =>
+    RNNamiEntitlementManager.clearProvisionalEntitlementGrants(),
 };

package/src/NamiFlowManager.ts

@@ -1,66 +1,56 @@
 import {
+  TurboModuleRegistry,
   NativeModules,
   NativeEventEmitter,
-  EmitterSubscription,
 } from 'react-native';
+import type { Spec } from '../specs/NativeNamiFlowManager';
+import type { NamiFlowHandoffPayload } from '../src/types';
 
-const { RNNamiFlowManager } = NativeModules;
+const RNNamiFlowManager: Spec =
+  TurboModuleRegistry.getEnforcing?.<Spec>('RNNamiFlowManager') ??
+  NativeModules.RNNamiFlowManager;
 
-export enum NamiFlowManagerEvents {
-  RegisterStepHandoff = 'RegisterStepHandoff',
-}
+const emitter = new NativeEventEmitter(NativeModules.RNNamiFlowManager);
 
-export interface INamiFlowManager {
-  registerStepHandoff: (
-    callback: (handoffTag: string, handoffData?: { [key: string]: any }) => void,
-  ) => () => void;
-  resume: () => void;
-  registerEventHandler: (
-    handler: (payload: { [key: string]: any }) => void
-  ) => void;
+export enum NamiFlowManagerEvents {
+  Handoff = 'Handoff',
+  FlowEvent = 'FlowEvent',
 }
 
-const flowEmitter = new NativeEventEmitter(RNNamiFlowManager);
-
-export const NamiFlowManager: INamiFlowManager = {
-  registerStepHandoff: (callback) => {
-    console.log('[NamiFlowManager] Registering handoff listener...');
+export const NamiFlowManager = {
+  emitter,
 
-    const subscription: EmitterSubscription = flowEmitter.addListener(
-      NamiFlowManagerEvents.RegisterStepHandoff,
-      (event: { handoffTag: string; handoffData?: { [key: string]: any } }) => {
+  registerStepHandoff: (
+    callback: (
+      handoffTag: string,
+      handoffData?: Record<string, unknown>,
+    ) => void,
+  ): (() => void) => {
+    console.info('[NamiFlowManager] Registering step handoff listener...');
+
+    const sub = emitter.addListener(
+      NamiFlowManagerEvents.Handoff,
+      (event: NamiFlowHandoffPayload) => {
         console.info('[NamiFlowManager] Received handoff event:', event);
         callback(event.handoffTag, event.handoffData);
-      }
+      },
     );
 
-    if (RNNamiFlowManager?.registerStepHandoff) {
-      RNNamiFlowManager.registerStepHandoff();
-    } else {
-      console.warn('[NamiFlowManager] Native method registerStepHandoff is not available.');
-    }
+    RNNamiFlowManager.registerStepHandoff?.();
 
-    return () => {
-      subscription.remove();
-    };
+    return () => sub.remove();
   },
 
-  resume: () => {
-    if (RNNamiFlowManager?.resume) {
-        console.info('[NamiFlowManager] resume from handoff requested');
-      RNNamiFlowManager.resume();
-    } else {
-      console.warn('[NamiFlowManager] Native method resume is not available.');
-    }
+  resume: (): void => {
+    console.info('[NamiFlowManager] resume from handoff requested');
+    RNNamiFlowManager.resume?.();
   },
 
-  registerEventHandler: (handler) => {
-    if (RNNamiFlowManager?.registerEventHandler) {
-      RNNamiFlowManager.registerEventHandler((payload: { [key: string]: any }) => {
-        handler(payload);
-      });
-    } else {
-      console.warn('[NamiFlowManager] Native method registerEventHandler is not available.');
-    }
+  registerEventHandler: (
+    callback: (payload: Record<string, unknown>) => void,
+  ): (() => void) => {
+    const sub = emitter.addListener(NamiFlowManagerEvents.FlowEvent, callback);
+    RNNamiFlowManager.registerEventHandler?.();
+    return () => sub.remove();
   },
 };

package/src/NamiPaywallManager.ts

@@ -1,175 +1,120 @@
 import {
+  TurboModuleRegistry,
   NativeModules,
   NativeEventEmitter,
-  EmitterSubscription,
 } from 'react-native';
-import {
-  NamiPurchaseSuccessAmazon,
+import type { Spec } from '../specs/NativeNamiPaywallManager';
+import type {
+  NamiPurchaseDetails,
   NamiPurchaseSuccessApple,
+  NamiPurchaseSuccessAmazon,
   NamiPurchaseSuccessGooglePlay,
   NamiSKU,
-} from './types';
+} from '../src/types';
+const RNNamiPaywallManager: Spec =
+  TurboModuleRegistry.getEnforcing?.<Spec>('RNNamiPaywallManager') ??
+  NativeModules.RNNamiPaywallManager;
+
+const emitter = new NativeEventEmitter(NativeModules.RNNamiPaywallManager);
 
 export enum NamiPaywallManagerEvents {
-  RegisterBuySKU = 'RegisterBuySKU',
-  PaywallCloseRequested = 'PaywallCloseRequested',
-  PaywallSignInRequested = 'PaywallSignInRequested',
-  PaywallRestoreRequested = 'PaywallRestoreRequested',
-  PaywallDeeplinkAction = 'PaywallDeeplinkAction',
+  BuySku = 'RegisterBuySKU',
+  Close = 'PaywallCloseRequested',
+  SignIn = 'PaywallSignInRequested',
+  Restore = 'PaywallRestoreRequested',
+  DeeplinkAction = 'PaywallDeeplinkAction',
 }
 
-export enum ServicesEnum {
-  Amazon = 'Amazon',
-  GooglePlay = 'GooglePlay',
-}
+export const NamiPaywallManager = {
+  emitter,
 
-export interface INamiPaywallManager {
-  paywallEmitter: NativeEventEmitter;
-  buySkuCompleteApple: (purchaseSuccess: NamiPurchaseSuccessApple) => void;
-  buySkuCompleteAmazon: (purchaseSuccess: NamiPurchaseSuccessAmazon) => void;
-  buySkuCompleteGooglePlay: (
-    purchaseSuccess: NamiPurchaseSuccessGooglePlay,
-  ) => void;
-  buySkuCancel: () => void;
-  registerBuySkuHandler: (
-    callback: (sku: NamiSKU) => void,
-  ) => EmitterSubscription['remove'];
-  registerCloseHandler: (callback: () => void) => EmitterSubscription['remove'];
-  registerSignInHandler: (
-    callback: () => void,
-  ) => EmitterSubscription['remove'];
-  registerRestoreHandler: (
-    callback: () => void,
-  ) => EmitterSubscription['remove'];
-  registerDeeplinkActionHandler: (
-    callback: (url: string) => void,
-  ) => EmitterSubscription['remove'];
-  dismiss: () => Promise<boolean>;
-  show: () => void;
-  hide: () => void;
-  isHidden: () => Promise<boolean>;
-  isPaywallOpen: () => Promise<boolean>;
-  setProductDetails: (productDetails: string, allowOffers: boolean) => void;
-  setAppSuppliedVideoDetails: (url: string, name?: string) => void;
-  allowUserInteraction: (allowed: boolean) => void;
-}
+  // New unified purchase success handler
+  buySkuComplete: (purchase: NamiPurchaseDetails): void => {
+    RNNamiPaywallManager.buySkuComplete(purchase);
+  },
 
-const { NamiPaywallManagerBridge, RNNamiPaywallManager } = NativeModules;
+  // Compatibility shims
+  buySkuCompleteApple: (purchase: NamiPurchaseSuccessApple): void => {
+    RNNamiPaywallManager.buySkuCompleteApple(purchase);
+  },
 
-export const NamiPaywallManager: INamiPaywallManager = {
-  paywallEmitter: new NativeEventEmitter(RNNamiPaywallManager),
-  ...RNNamiPaywallManager,
-  ...NamiPaywallManagerBridge,
-  buySkuCompleteApple: (purchaseSuccess: NamiPurchaseSuccessApple) => {
-    RNNamiPaywallManager.buySkuComplete(purchaseSuccess);
+  buySkuCompleteAmazon: (purchase: NamiPurchaseSuccessAmazon): void => {
+    RNNamiPaywallManager.buySkuCompleteAmazon(purchase);
   },
-  buySkuCompleteAmazon: (purchaseSuccess: NamiPurchaseSuccessAmazon) => {
-    RNNamiPaywallManager.buySkuComplete(purchaseSuccess, ServicesEnum.Amazon);
+
+  buySkuCompleteGooglePlay: (purchase: NamiPurchaseSuccessGooglePlay): void => {
+    RNNamiPaywallManager.buySkuCompleteGooglePlay(purchase);
   },
-  buySkuCompleteGooglePlay: (
-    purchaseSuccess: NamiPurchaseSuccessGooglePlay,
-  ) => {
-    RNNamiPaywallManager.buySkuComplete(
-      purchaseSuccess,
-      ServicesEnum.GooglePlay,
-    );
+
+  registerBuySkuHandler: (callback: (sku: NamiSKU) => void): (() => void) => {
+    const sub = emitter.addListener(NamiPaywallManagerEvents.BuySku, callback);
+    RNNamiPaywallManager.registerBuySkuHandler?.();
+    return () => sub.remove();
   },
-  buySkuCancel: () => {
-    RNNamiPaywallManager.buySkuCancel();
+
+  registerCloseHandler: (callback: () => void): (() => void) => {
+    const sub = emitter.addListener(NamiPaywallManagerEvents.Close, callback);
+    RNNamiPaywallManager.registerCloseHandler?.();
+    return () => sub.remove();
   },
-  registerBuySkuHandler: (callback: (sku: NamiSKU) => void) => {
-    let subscription = NamiPaywallManager.paywallEmitter.addListener(
-      NamiPaywallManagerEvents.RegisterBuySKU,
-      sku => {
-        callback(sku);
-      },
-    );
-    RNNamiPaywallManager.registerBuySkuHandler();
-    return () => {
-      if (subscription) {
-        subscription.remove();
-      }
-    };
-  },
-  registerCloseHandler: (callback: (body: any) => void) => {
-    let subscription = NamiPaywallManager.paywallEmitter.addListener(
-      NamiPaywallManagerEvents.PaywallCloseRequested,
-      body => {
-        callback(body);
-      },
-    );
-    RNNamiPaywallManager.registerCloseHandler();
-    return () => {
-      if (subscription) {
-        subscription.remove();
-      }
-    };
-  },
-  registerSignInHandler(callback) {
-    let subscription = NamiPaywallManager.paywallEmitter.addListener(
-      NamiPaywallManagerEvents.PaywallSignInRequested,
-      () => {
-        callback();
-      },
-    );
-    RNNamiPaywallManager.registerSignInHandler();
-
-    return () => {
-      if (subscription) {
-        subscription.remove();
-      }
-    };
-  },
-  registerRestoreHandler(callback) {
-    let subscription = NamiPaywallManager.paywallEmitter.addListener(
-      NamiPaywallManagerEvents.PaywallRestoreRequested,
-      () => {
-        callback();
-      },
-    );
-    RNNamiPaywallManager.registerRestoreHandler();
-    return () => {
-      if (subscription) {
-        subscription.remove();
-      }
-    };
-  },
-  registerDeeplinkActionHandler: (callback: (url: string) => void) => {
-    let subscription = NamiPaywallManager.paywallEmitter.addListener(
-      NamiPaywallManagerEvents.PaywallDeeplinkAction,
-      url => {
-        callback(url);
-      },
+
+  registerSignInHandler: (callback: () => void): (() => void) => {
+    const sub = emitter.addListener(NamiPaywallManagerEvents.SignIn, callback);
+    RNNamiPaywallManager.registerSignInHandler?.();
+    return () => sub.remove();
+  },
+
+  registerRestoreHandler: (callback: () => void): (() => void) => {
+    const sub = emitter.addListener(NamiPaywallManagerEvents.Restore, callback);
+    RNNamiPaywallManager.registerRestoreHandler?.();
+    return () => sub.remove();
+  },
+
+  registerDeeplinkActionHandler: (
+    callback: (url: string) => void,
+  ): (() => void) => {
+    const sub = emitter.addListener(
+      NamiPaywallManagerEvents.DeeplinkAction,
+      callback,
     );
-    RNNamiPaywallManager.registerDeeplinkActionHandler();
-    return () => {
-      if (subscription) {
-        subscription.remove();
-      }
-    };
+    RNNamiPaywallManager.registerDeeplinkActionHandler?.();
+    return () => sub.remove();
   },
-  dismiss: () => {
-    return RNNamiPaywallManager.dismiss();
+
+  dismiss: async (): Promise<boolean> => {
+    await RNNamiPaywallManager.dismiss();
+    return true;
   },
-  show: () => {
+
+  show: (): void => {
     RNNamiPaywallManager.show();
   },
-  hide: () => {
+
+  hide: (): void => {
     RNNamiPaywallManager.hide();
   },
-  isHidden: () => {
+
+  isHidden: async (): Promise<boolean> => {
     return RNNamiPaywallManager.isHidden();
   },
-  isPaywallOpen: () => {
+
+  isPaywallOpen: async (): Promise<boolean> => {
     return RNNamiPaywallManager.isPaywallOpen();
   },
-  setProductDetails: (productDetails: string, allowOffers: boolean) => {
+
+  buySkuCancel: (): void => {
+    RNNamiPaywallManager.buySkuCancel();
+  },
+
+  setProductDetails: (productDetails: string, allowOffers?: boolean): void => {
     RNNamiPaywallManager.setProductDetails(productDetails, allowOffers);
   },
-  setAppSuppliedVideoDetails: (url: string, name?: string) => {
+
+  setAppSuppliedVideoDetails: (url: string, name?: string): void => {
     RNNamiPaywallManager.setAppSuppliedVideoDetails(url, name);
   },
-  allowUserInteraction: (allowed: boolean) => {
+
+  allowUserInteraction: (allowed: boolean): void => {
     RNNamiPaywallManager.allowUserInteraction(allowed);
   },
 };