react-native-nami-sdk 3.0.24 → 3.0.26

package/src/NamiCampaignManager.ts

@@ -0,0 +1,143 @@
+import {
+  NativeModules,
+  NativeEventEmitter,
+  EmitterSubscription,
+} from 'react-native';
+import {
+  LaunchCampaignError,
+  NamiCampaign,
+  NamiPaywallAction,
+  NamiPurchase,
+  PaywallLaunchContext,
+} from './types';
+
+export const { RNNamiCampaignManager } = NativeModules;
+
+export enum NamiCampaignManagerEvents {
+  ResultCampaign = 'ResultCampaign',
+  AvailableCampaignsChanged = 'AvailableCampaignsChanged',
+}
+
+const searchString_Nami = 'NAMI_';
+
+interface ICampaignManager {
+  launchSubscription: EmitterSubscription | undefined;
+  emitter: NativeEventEmitter;
+  allCampaigns: () => Promise<Array<NamiCampaign>>;
+  isCampaignAvailable(campaignSource: string | null): Promise<boolean>;
+  launch: (
+    label?: string,
+    withUrl?: string,
+    context?: PaywallLaunchContext,
+    resultCallback?: (success: boolean, error?: LaunchCampaignError) => void,
+    actionCallback?: (
+      action: NamiPaywallAction,
+      campaignId: string,
+      paywallId: string,
+      campaignName?: string,
+      campaignType?: string,
+      campaignLabel?: string,
+      campaignUrl?: string,
+      paywallName?: string,
+      segmentId?: string,
+      externalSegmentId?: string,
+      deeplinkUrl?: string,
+      skuId?: string,
+      componentChangeId?: string,
+      componentChangeName?: string,
+      purchaseError?: string,
+      purchases?: NamiPurchase[],
+    ) => void,
+  ) => void;
+  refresh: () => void;
+  registerAvailableCampaignsHandler: (
+    callback: (availableCampaigns: NamiCampaign[]) => void,
+  ) => EmitterSubscription['remove'];
+}
+
+export const NamiCampaignManager: ICampaignManager = {
+  launchSubscription: undefined,
+  emitter: new NativeEventEmitter(RNNamiCampaignManager),
+  ...RNNamiCampaignManager,
+  launch(label, withUrl, context, resultCallback, actionCallback) {
+    if (this.launchSubscription) {
+      this.launchSubscription.remove();
+    }
+
+    this.launchSubscription = this.emitter.addListener(
+      NamiCampaignManagerEvents.ResultCampaign,
+      body => {
+        body.action = body.action.startsWith(searchString_Nami)
+          ? body.action.substring(5, body.action.length)
+          : body.action;
+
+        const {
+          action,
+          campaignId,
+          paywallId,
+          campaignName,
+          campaignType,
+          campaignLabel,
+          campaignUrl,
+          paywallName,
+          segmentId,
+          externalSegmentId,
+          deeplinkUrl,
+          skuId,
+          componentChangeId,
+          componentChangeName,
+          purchaseError,
+          purchases,
+        } = body;
+        if (actionCallback) {
+          actionCallback(
+            action,
+            campaignId,
+            paywallId,
+            campaignName,
+            campaignType,
+            campaignLabel,
+            campaignUrl,
+            paywallName,
+            segmentId,
+            externalSegmentId,
+            deeplinkUrl,
+            skuId,
+            componentChangeId,
+            componentChangeName,
+            purchaseError,
+            purchases,
+          );
+        }
+      },
+    );
+    RNNamiCampaignManager.launch(
+      label ?? null,
+      withUrl ?? null,
+      context ?? null,
+      resultCallback ?? (() => {}),
+      actionCallback ?? (() => {}),
+    );
+  },
+
+  isCampaignAvailable: campaignSource => {
+    return RNNamiCampaignManager.isCampaignAvailable(campaignSource ?? null);
+  },
+
+  registerAvailableCampaignsHandler(callback) {
+    if (typeof callback !== 'function') {
+      throw new Error('Expected callback to be a function.');
+    }
+    const subscription = this.emitter.addListener(
+      NamiCampaignManagerEvents.AvailableCampaignsChanged,
+      callback,
+    );
+
+    RNNamiCampaignManager.registerAvailableCampaignsHandler();
+    return () => {
+      if (subscription) {
+        subscription.remove();
+      }
+    };
+  },
+};

package/src/NamiCustomerManager.ts

@@ -0,0 +1,89 @@
+import {
+  NativeModules,
+  NativeEventEmitter,
+  EmitterSubscription,
+} from 'react-native';
+import { AccountStateAction, CustomerJourneyState } from './types';
+
+export const { RNNamiCustomerManager } = NativeModules;
+
+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: INamiCustomerManager = {
+  ...RNNamiCustomerManager,
+  emitter: new NativeEventEmitter(RNNamiCustomerManager),
+  login: customerId => {
+    RNNamiCustomerManager.login(customerId);
+  },
+  logout: () => {
+    RNNamiCustomerManager.logout();
+  },
+  registerJourneyStateHandler: (
+    callback: (journeyState: CustomerJourneyState) => void,
+  ) => {
+    const subscription = NamiCustomerManager.emitter.addListener(
+      NamiCustomerManagerEvents.JourneyStateChanged,
+      callback,
+    );
+    RNNamiCustomerManager.registerJourneyStateHandler();
+    return () => {
+      if (subscription) {
+        subscription.remove();
+      }
+    };
+  },
+  registerAccountStateHandler: (
+    callback: (
+      action: AccountStateAction,
+      success: boolean,
+      error?: number,
+    ) => void,
+  ) => {
+    const subscription = NamiCustomerManager.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);
+      },
+    );
+    RNNamiCustomerManager.registerAccountStateHandler();
+    return () => {
+      if (subscription) {
+        subscription.remove();
+      }
+    };
+  },
+};

package/src/NamiEntitlementManager.d.ts

@@ -1,16 +1,15 @@
-import { EmitterSubscription } from "react-native";
-import { NamiPurchase } from "./NamiPurchaseManager";
-import { NamiSKU } from "./types";
+import { EmitterSubscription } from 'react-native';
+import { NamiPurchase, NamiSKU } from './types';
 
 export const NamiEntitlementManager: {
   active: () => Promise<Array<NamiEntitlement>>;
   isEntitlementActive: (label?: string) => boolean;
   refresh: (
-    resultCallback?: (entitlements?: NamiEntitlement[]) => void
+    resultCallback?: (entitlements?: NamiEntitlement[]) => void,
   ) => void;
   registerActiveEntitlementsHandler: (
-    callback: (activeEntitlements: NamiEntitlement[]) => void
-  ) => EmitterSubscription["remove"];
+    callback: (activeEntitlements: NamiEntitlement[]) => void,
+  ) => EmitterSubscription['remove'];
 };
 
 export type NamiEntitlement = {

package/src/NamiEntitlementManager.ts

@@ -0,0 +1,58 @@
+import {
+  NativeModules,
+  NativeEventEmitter,
+  Platform,
+  EmitterSubscription,
+} from 'react-native';
+import { NamiEntitlement } from './types';
+
+export const { RNNamiEntitlementManager } = NativeModules;
+
+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'];
+}
+
+export const NamiEntitlementManager: INamiEntitlementManager = {
+  ...RNNamiEntitlementManager,
+  emitter: new NativeEventEmitter(RNNamiEntitlementManager),
+  refresh: (
+    resultCallback?: (
+      entitlements?: INamiEntitlementManager['NamiEntitlement'][],
+    ) => void,
+  ) => {
+    if (Platform.OS === 'android') {
+      RNNamiEntitlementManager.refresh(resultCallback ?? (() => {}));
+    } else {
+      RNNamiEntitlementManager.refresh();
+    }
+  },
+  registerActiveEntitlementsHandler: (
+    callback: (
+      activeEntitlements: INamiEntitlementManager['NamiEntitlement'][],
+    ) => void,
+  ) => {
+    let subscription: EmitterSubscription =
+      NamiEntitlementManager.emitter.addListener(
+        NamiEntitlementManagerEvents.EntitlementsChanged,
+        callback,
+      );
+    RNNamiEntitlementManager.registerActiveEntitlementsHandler();
+    return () => {
+      if (subscription) {
+        subscription.remove();
+      }
+    };
+  },
+};

package/src/NamiMLManager.ts

@@ -0,0 +1,13 @@
+import { NativeModules } from 'react-native';
+
+export const { NamiMLManagerBridge } = NativeModules;
+
+export interface INamiMLManager {
+  coreAction: (label: string) => void;
+  enterCoreContent: (label: string | string[]) => void;
+  exitCoreContent: (label: string | string[]) => void;
+}
+
+export const NamiMLManager: INamiMLManager = {
+  ...NamiMLManagerBridge,
+};

package/src/NamiPaywallManager.ts

@@ -0,0 +1,141 @@
+import {
+  NativeModules,
+  NativeEventEmitter,
+  EmitterSubscription,
+} from 'react-native';
+import {
+  NamiPurchaseSuccessAmazon,
+  NamiPurchaseSuccessApple,
+  NamiPurchaseSuccessGooglePlay,
+  NamiSKU,
+} from './types';
+
+export enum NamiPaywallManagerEvents {
+  RegisterBuySKU = 'RegisterBuySKU',
+  PaywallCloseRequested = 'PaywallCloseRequested',
+  PaywallSignInRequested = 'PaywallSignInRequested',
+  PaywallRestoreRequested = 'PaywallRestoreRequested',
+}
+
+export enum ServicesEnum {
+  Amazon = 'Amazon',
+  GooglePlay = 'GooglePlay',
+}
+
+export interface INamiPaywallManager {
+  paywallEmitter: NativeEventEmitter;
+  buySkuCompleteApple: (purchaseSuccess: NamiPurchaseSuccessApple) => void;
+  buySkuCompleteAmazon: (purchaseSuccess: NamiPurchaseSuccessAmazon) => void;
+  buySkuCompleteGooglePlay: (
+    purchaseSuccess: NamiPurchaseSuccessGooglePlay,
+  ) => void;
+  registerBuySkuHandler: (
+    callback: (sku: NamiSKU) => void,
+  ) => EmitterSubscription['remove'];
+  registerCloseHandler: (callback: () => void) => EmitterSubscription['remove'];
+  registerSignInHandler: (
+    callback: () => void,
+  ) => EmitterSubscription['remove'];
+  registerRestoreHandler: (
+    callback: () => void,
+  ) => EmitterSubscription['remove'];
+  dismiss: (animated?: boolean) => void;
+  show: () => void;
+  hide: () => void;
+  isHidden: () => Promise<void>;
+}
+
+const { NamiPaywallManagerBridge, RNNamiPaywallManager } = NativeModules;
+
+export const NamiPaywallManager: INamiPaywallManager = {
+  paywallEmitter: new NativeEventEmitter(RNNamiPaywallManager),
+  ...RNNamiPaywallManager,
+  ...NamiPaywallManagerBridge,
+  buySkuCompleteApple: (purchaseSuccess: NamiPurchaseSuccessApple) => {
+    RNNamiPaywallManager.buySkuComplete(purchaseSuccess);
+  },
+  buySkuCompleteAmazon: (purchaseSuccess: NamiPurchaseSuccessAmazon) => {
+    RNNamiPaywallManager.buySkuComplete(purchaseSuccess, ServicesEnum.Amazon);
+  },
+  buySkuCompleteGooglePlay: (
+    purchaseSuccess: NamiPurchaseSuccessGooglePlay,
+  ) => {
+    RNNamiPaywallManager.buySkuComplete(
+      purchaseSuccess,
+      ServicesEnum.GooglePlay,
+    );
+  },
+  registerBuySkuHandler: (callback: (sku: NamiSKU) => void) => {
+    let subscription;
+    subscription = NamiPaywallManager.paywallEmitter.addListener(
+      NamiPaywallManagerEvents.RegisterBuySKU,
+      sku => {
+        callback(sku);
+      },
+    );
+    RNNamiPaywallManager.registerBuySkuHandler();
+    return () => {
+      if (subscription) {
+        subscription.remove();
+      }
+    };
+  },
+  registerCloseHandler: (callback: (body: any) => void) => {
+    let subscription;
+    subscription = NamiPaywallManager.paywallEmitter.addListener(
+      NamiPaywallManagerEvents.PaywallCloseRequested,
+      body => {
+        callback(body);
+      },
+    );
+    RNNamiPaywallManager.registerCloseHandler();
+    return () => {
+      if (subscription) {
+        subscription.remove();
+      }
+    };
+  },
+  registerSignInHandler(callback) {
+    let subscription;
+    subscription = NamiPaywallManager.paywallEmitter.addListener(
+      NamiPaywallManagerEvents.PaywallSignInRequested,
+      body => {
+        callback(body);
+      },
+    );
+    RNNamiPaywallManager.registerSignInHandler();
+
+    return () => {
+      if (subscription) {
+        subscription.remove();
+      }
+    };
+  },
+  registerRestoreHandler(callback) {
+    let subscription;
+    subscription = NamiPaywallManager.paywallEmitter.addListener(
+      NamiPaywallManagerEvents.PaywallRestoreRequested,
+      body => {
+        callback(body);
+      },
+    );
+    RNNamiPaywallManager.registerRestoreHandler();
+    return () => {
+      if (subscription) {
+        subscription.remove();
+      }
+    };
+  },
+  dismiss: (animated?: boolean) => {
+    RNNamiPaywallManager.dismiss(animated ?? true);
+  },
+  show: () => {
+    RNNamiPaywallManager.show();
+  },
+  hide: () => {
+    RNNamiPaywallManager.hide();
+  },
+  isHidden: () => {
+    return RNNamiPaywallManager.isHidden();
+  },
+};

package/src/NamiPurchaseManager.d.ts

@@ -1,5 +1,5 @@
-import { EmitterSubscription } from "react-native";
-import { NamiSKU } from "./types";
+import { EmitterSubscription } from 'react-native';
+import { NamiSKU } from './types';
 
 export const NamiPurchaseManager: {
   allPurchases: () => NamiPurchase[];
@@ -10,24 +10,24 @@ export const NamiPurchaseManager: {
     callback: (
       purchaseState: NamiPurchasesState,
       purchases: NamiPurchase[],
-      error: string
-    ) => void
-  ) => EmitterSubscription["remove"];
+      error: string,
+    ) => void,
+  ) => EmitterSubscription['remove'];
   skuPurchased: (skuId: string) => boolean;
   registerPurchasesChangedHandler: (
     callback: (
       purchaseState: NamiPurchasesState,
       purchases: NamiPurchase[],
-      error: string
-    ) => void
-  ) => EmitterSubscription["remove"];
+      error: string,
+    ) => void,
+  ) => EmitterSubscription['remove'];
   registerRestorePurchasesHandler: (
     callback: (
       state: NamiRestorePurchasesState,
       newPurchases: NamiPurchase[],
-      oldPurchases: NamiPurchase[]
-    ) => void
-  ) => EmitterSubscription["remove"];
+      oldPurchases: NamiPurchase[],
+    ) => void,
+  ) => EmitterSubscription['remove'];
 };
 
 export type NamiPurchase = {
@@ -36,26 +36,26 @@ export type NamiPurchase = {
   transactionIdentifier?: string;
   expires?: Date;
   purchaseInitiatedTimestamp: Date;
-  purchaseSource?: "CAMPAIGN" | "MARKETPLACE" | "UNKNOWN";
+  purchaseSource?: 'CAMPAIGN' | 'MARKETPLACE' | 'UNKNOWN';
 };
 
 export enum NamiPurchaseState {
-  PURCHASED = "PURCHASED",
-  FAILED = "FAILED",
-  CANCELLED = "CANCELLEDd",
-  PENDING = "PENDING",
-  UNKNOWN = "UNKNOWN",
+  PURCHASED = 'PURCHASED',
+  FAILED = 'FAILED',
+  CANCELLED = 'CANCELLEDd',
+  PENDING = 'PENDING',
+  UNKNOWN = 'UNKNOWN',
 }
 
-export type NamiRestorePurchasesState = "started" | "finished" | "error";
+export type NamiRestorePurchasesState = 'started' | 'finished' | 'error';
 
 export type NamiPurchasesState =
-  | "pending"
-  | "purchased"
-  | "consumed"
-  | "resubscribed"
-  | "unsubscribed"
-  | "deferred"
-  | "failed"
-  | "cancelled"
-  | "unknown";
+  | 'pending'
+  | 'purchased'
+  | 'consumed'
+  | 'resubscribed'
+  | 'unsubscribed'
+  | 'deferred'
+  | 'failed'
+  | 'cancelled'
+  | 'unknown';

package/src/NamiPurchaseManager.ts

@@ -0,0 +1,100 @@
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+import { EmitterSubscription } from 'react-native';
+import {
+  NamiPurchase,
+  NamiPurchasesState,
+  NamiRestorePurchasesState,
+} from './types';
+
+export const { NamiPurchaseManagerBridge, RNNamiPurchaseManager } =
+  NativeModules;
+
+export enum NamiPurchaseManagerEvents {
+  PurchasesChanged = 'PurchasesChanged',
+  RestorePurchasesStateChanged = 'RestorePurchasesStateChanged',
+}
+
+export interface INamiPurchaseManager {
+  emitter: NativeEventEmitter;
+  allPurchases: () => NamiPurchase[];
+  anySkuPurchased: (skuIds: string[]) => boolean;
+  consumePurchasedSku: (skuId: string) => void;
+  presentCodeRedemptionSheet: () => void;
+  restorePurchases: (
+    callback: (
+      purchaseState: NamiPurchasesState,
+      purchases: NamiPurchase[],
+      error: string,
+    ) => void,
+  ) => EmitterSubscription['remove'];
+  skuPurchased: (skuId: string) => boolean;
+  registerPurchasesChangedHandler: (
+    callback: (
+      purchaseState: NamiPurchasesState,
+      purchases: NamiPurchase[],
+      error: string,
+    ) => void,
+  ) => EmitterSubscription['remove'];
+  registerRestorePurchasesHandler: (
+    callback: (
+      state: NamiRestorePurchasesState,
+      newPurchases: NamiPurchase[],
+      oldPurchases: NamiPurchase[],
+    ) => void,
+  ) => EmitterSubscription['remove'];
+}
+
+export const NamiPurchaseManager: INamiPurchaseManager = {
+  emitter: new NativeEventEmitter(RNNamiPurchaseManager),
+  ...NamiPurchaseManagerBridge,
+  ...RNNamiPurchaseManager,
+  registerPurchasesChangedHandler: (
+    callback: (
+      purchaseState: NamiPurchasesState,
+      purchases: NamiPurchase[],
+      error: string,
+    ) => void,
+  ) => {
+    const subscription = NamiPurchaseManager.emitter.addListener(
+      NamiPurchaseManagerEvents.PurchasesChanged,
+      body => {
+        let purchases = body.purchases;
+        let purchaseState =
+          body.purchaseState.toLowerCase() as NamiPurchasesState;
+        let error = body.error;
+        callback(purchaseState, purchases, error);
+      },
+    );
+    RNNamiPurchaseManager.registerPurchasesChangedHandler();
+    return () => {
+      if (subscription) {
+        subscription.remove();
+      }
+    };
+  },
+  registerRestorePurchasesHandler: (
+    callback: (
+      state: NamiRestorePurchasesState,
+      newPurchases: NamiPurchase[],
+      oldPurchases: NamiPurchase[],
+    ) => void,
+  ) => {
+    if (Platform.OS === 'ios') {
+      const subscription = NamiPurchaseManager.emitter.addListener(
+        NamiPurchaseManagerEvents.RestorePurchasesStateChanged,
+        body => {
+          let state = body.state.toLowerCase() as NamiRestorePurchasesState;
+          let newPurchases = body.newPurchases;
+          let oldPurchases = body.oldPurchases;
+          callback(state, newPurchases, oldPurchases);
+        },
+      );
+      RNNamiPurchaseManager.registerRestorePurchasesHandler();
+      return () => {
+        if (subscription) {
+          subscription.remove();
+        }
+      };
+    }
+  },
+};