react-native-nami-sdk 2.0.5 → 3.0.9

package/src/Nami.d.ts

@@ -0,0 +1,112 @@
+export const Nami: {
+  configure: (
+    config: NamiConfiguration,
+    resultCallback?: (resultObject: { success: boolean }) => void
+  ) => void;
+};
+
+export type NamiConfiguration = {
+  "appPlatformID-apple": string;
+  "appPlatformID-android": string;
+  logLevel: string;
+  namiLanguageCode?: NamiLanguageCodes;
+  bypassStore?: boolean;
+};
+
+export type NamiLanguageCodes =
+  | "af"
+  | "ar"
+  | "ar-dz"
+  | "ast"
+  | "az"
+  | "bg"
+  | "be"
+  | "bn"
+  | "br"
+  | "bs"
+  | "ca"
+  | "cs"
+  | "cy"
+  | "da"
+  | "de"
+  | "dsb"
+  | "el"
+  | "en"
+  | "en-au"
+  | "en-gb"
+  | "eo"
+  | "es"
+  | "es-ar"
+  | "es-co"
+  | "es-mx"
+  | "es-ni"
+  | "es-ve"
+  | "et"
+  | "eu"
+  | "fa"
+  | "fi"
+  | "fr"
+  | "fy"
+  | "ga"
+  | "gd"
+  | "gl"
+  | "he"
+  | "hi"
+  | "hr"
+  | "hsb"
+  | "hu"
+  | "hy"
+  | "ia"
+  | "id"
+  | "ig"
+  | "io"
+  | "is"
+  | "it"
+  | "ja"
+  | "ka"
+  | "kab"
+  | "kk"
+  | "km"
+  | "kn"
+  | "ko"
+  | "ky"
+  | "lb"
+  | "lt"
+  | "lv"
+  | "mk"
+  | "ml"
+  | "mn"
+  | "mr"
+  | "my"
+  | "nb"
+  | "ne"
+  | "nl"
+  | "nn"
+  | "os"
+  | "pa"
+  | "pl"
+  | "pt"
+  | "pt-br"
+  | "ro"
+  | "ru"
+  | "sk"
+  | "sl"
+  | "sq"
+  | "sr"
+  | "sr-latn"
+  | "sv"
+  | "sw"
+  | "ta"
+  | "te"
+  | "tg"
+  | "th"
+  | "tk"
+  | "tr"
+  | "tt"
+  | "udm"
+  | "uk"
+  | "ur"
+  | "uz"
+  | "vi"
+  | "zh-hans"
+  | "zh-hant";

package/src/Nami.js

@@ -0,0 +1,10 @@
+import { NativeModules } from "react-native";
+
+export const { NamiBridge } = NativeModules;
+
+export const Nami = {
+  ...NamiBridge,
+  configure(configureObj, resultCallback) {
+    NamiBridge.configure(configureObj, resultCallback ?? (() => {}));
+  },
+};

package/src/NamiCampaignManager.d.ts

@@ -0,0 +1,57 @@
+import { EmitterSubscription } from "react-native";
+import { NamiPurchase } from "./NamiPurchaseManager";
+import { NamiPaywallAction } from "./NamiPaywallManager";
+
+export const NamiCampaignManager: {
+  allCampaigns: () => Promise<Array<NamiCampaign>>;
+  isCampaignAvailable: (label?: string) => boolean;
+  launch: (
+    label?: string,
+    resultCallback?: (success: boolean, error?: LaunchCampaignError) => void,
+    actionCallback?: (
+      action: NamiPaywallAction,
+      skuId?: string,
+      purchaseError?: string,
+      purchases?: NamiPurchase[],
+      campaignId?: string,
+      campaignLabel?: string,
+      paywallId?: string
+    ) => void
+  ) => void;
+  refresh: () => void;
+  registerAvailableCampaignsHandler: (
+    callback: (availableCampaigns: NamiCampaign[]) => void
+  ) => EmitterSubscription["remove"];
+};
+
+export type NamiCampaign = {
+  id: string;
+  rule: string;
+  segment: string;
+  paywall: string;
+  type: NamiCampaignRuleType;
+  value?: string | null;
+};
+
+export enum NamiCampaignRuleType {
+  DEFAULT = "default",
+  LABEL = "label",
+  UNKNOWN = "unknown",
+}
+
+export enum LaunchCampaignError {
+  DEFAULT_CAMPAIGN_NOT_FOUND = 0,
+  LABELED_CAMPAIGN_NOT_FOUND = 1,
+  CAMPAIGN_DATA_NOT_FOUND = 2,
+  PAYWALL_ALREADY_DISPLAYED = 3,
+  SDK_NOT_INITIALIZED = 4,
+}
+
+export enum LaunchCampaignResultAction {
+  FAILURE = "FAILURE",
+  SUCCESS = "SUCCESS",
+}
+
+export type FailureResultObject = {
+  error: string;
+};

package/src/NamiCampaignManager.js

@@ -0,0 +1,54 @@
+import { NativeModules, NativeEventEmitter } from "react-native";
+
+export const { RNNamiCampaignManager } = NativeModules;
+
+export const NamiCampaignManager = {
+  launchSubscription: undefined,
+  emitter: new NativeEventEmitter(RNNamiCampaignManager),
+  ...RNNamiCampaignManager,
+  launch(label, resultCallback, actionCallback) {
+    this.launchSubscription?.remove();
+    this.launchSubscription = this.emitter.addListener(
+      "ResultCampaign",
+      (body) => {
+        var action = body.action;
+
+        if (action.startsWith("NAMI_")) {
+          action = action.substring(5, action.length);
+        }
+
+        var skuId = body.skuId;
+        var purchaseError = body.purchaseError;
+        var purchases = body.purchases;
+        var campaignId = body.campaignId;
+        var campaignLabel = body.campaignLabel;
+        var paywallId = body.paywallId;
+        actionCallback(
+          action,
+          skuId,
+          purchaseError,
+          purchases,
+          campaignId,
+          campaignLabel,
+          paywallId
+        );
+      }
+    );
+    RNNamiCampaignManager.launch(
+      label ?? null,
+      resultCallback ?? (() => {}),
+      actionCallback ?? (() => {})
+    );
+  },
+  isCampaignAvailable: (label) => {
+    return RNNamiCampaignManager.isCampaignAvailable(label ?? null);
+  },
+  registerAvailableCampaignsHandler(callback) {
+    const subscription = this.emitter.addListener(
+      "AvailableCampaignsChanged",
+      callback
+    );
+    RNNamiCampaignManager.registerAvailableCampaignsHandler();
+    return subscription.remove;
+  },
+};

package/src/NamiCustomerManager.d.ts

@@ -0,0 +1,41 @@
+import { EmitterSubscription } from "react-native";
+
+export const NamiCustomerManager: {
+  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,
+    callback?: (success: boolean, error?: number) => void
+  ) => void;
+  logout: (callback?: (success: boolean, error?: number) => void) => 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;
+};
+
+export type CustomerJourneyState = {
+  formerSubscriber: boolean;
+  inGracePeriod: boolean;
+  inTrialPeriod: boolean;
+  inIntroOfferPeriod: boolean;
+  isCancelled: boolean;
+  inPause: boolean;
+  inAccountHold: boolean;
+};
+
+export type AccountStateAction = "login" | "logout";

package/src/NamiCustomerManager.js

@@ -0,0 +1,43 @@
+import { NativeModules, NativeEventEmitter, Platform } from "react-native";
+
+export const { RNNamiCustomerManager } = NativeModules;
+
+export const NamiCustomerManager = {
+  emitter: new NativeEventEmitter(RNNamiCustomerManager),
+  ...RNNamiCustomerManager,
+  login: (customerId, callback) => {
+    if (Platform.OS === "ios") {
+      RNNamiCustomerManager.login(customerId, callback ?? (() => {}));
+    } else {
+      RNNamiCustomerManager.login(customerId);
+    }
+  },
+  logout: (callback) => {
+    if (Platform.OS === "ios") {
+      RNNamiCustomerManager.logout(callback ?? (() => {}));
+    } else {
+      RNNamiCustomerManager.logout();
+    }
+  },
+  registerJourneyStateHandler(callback) {
+    const subscription = this.emitter.addListener(
+      "JourneyStateChanged",
+      callback
+    );
+    RNNamiCustomerManager.registerJourneyStateHandler();
+    return subscription.remove;
+  },
+  registerAccountStateHandler(callback) {
+    const subscription = this.emitter.addListener(
+      "AccountStateChanged",
+      (body) => {
+        var action = body.action.toLowerCase();
+        var error = body.error;
+        var success = body.success;
+        callback(action, success, error);
+      }
+    );
+    RNNamiCustomerManager.registerAccountStateHandler();
+    return subscription.remove;
+  },
+};

package/src/NamiEntitlementManager.d.ts

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

package/src/NamiEntitlementManager.js

@@ -0,0 +1,23 @@
+import { NativeModules, NativeEventEmitter, Platform } from "react-native";
+
+export const { RNNamiEntitlementManager } = NativeModules;
+
+export const NamiEntitlementManager = {
+  emitter: new NativeEventEmitter(RNNamiEntitlementManager),
+  ...RNNamiEntitlementManager,
+  refresh(resultCallback) {
+    if (Platform.OS === "android") {
+      RNNamiEntitlementManager.refresh(resultCallback ?? (() => {}));
+    } else {
+      RNNamiEntitlementManager.refresh();
+    }
+  },
+  registerActiveEntitlementsHandler(callback) {
+    const subscription = this.emitter.addListener(
+      "EntitlementsChanged",
+      callback
+    );
+    RNNamiEntitlementManager.registerActiveEntitlementsHandler();
+    return subscription.remove;
+  },
+};

package/src/NamiMLManager.d.ts

@@ -0,0 +1,5 @@
+export const NamiMLManager: {
+    coreAction: (label: string) => void;
+    enterCoreContent: (label: string | string[]) => void;
+    exitCoreContent: (label: string | string[]) => void;
+};

package/src/NamiMLManager.js

@@ -0,0 +1,7 @@
+import { NativeModules } from "react-native";
+
+export const { NamiMLManagerBridge } = NativeModules;
+
+export const NamiMLManager = {
+ ...NamiMLManagerBridge
+};

package/src/NamiPaywallManager.d.ts

@@ -0,0 +1,82 @@
+import { EmitterSubscription } from "react-native";
+import { NamiSKU } from "./types";
+
+export const NamiPaywallManager: {
+  buySkuCompleteIos: (purchaseSuccess: PurchaseSuccessIos) => void;
+  buySkuCompleteAmazon: (purchaseSuccess: PurchaseSuccessAmazon) => void;
+  buySkuCompleteGooglePlay: (
+    purchaseSuccess: PurchaseSuccessGooglePlay
+  ) => void;
+  dismiss: (animated: boolean, callback: () => void) => void;
+  displayedViewController: () => void;
+  renderCustomUiHandler: () => any;
+  registerBuySkuHandler: (
+    callback: (sku: NamiSKU) => void
+  ) => EmitterSubscription["remove"];
+  registerCloseHandler: (
+    blockDismiss: boolean,
+    callback: (resultObject: { blockingPaywallClosed: boolean }) => void
+  ) => EmitterSubscription["remove"];
+};
+
+export type PurchaseSuccessIos = {
+  product: PurchaseSuccessProduct;
+  transactionID: string;
+  originalTransactionID: string;
+  originalPurchaseDate: number;
+  purchaseDate: number;
+  expiresDate?: number;
+  price: string;
+  currencyCode: string;
+  locale: string;
+};
+
+export type PurchaseSuccessGooglePlay = {
+  product: PurchaseSuccessProduct;
+  orderId: string;
+  purchaseDate: number;
+  expiresDate?: number;
+  purchaseToken: string;
+  purchaseSource: "CAMPAIGN" | "MARKETPLACE" | "UNKNOWN";
+};
+
+export type PurchaseSuccessAmazon = {
+  product: PurchaseSuccessProduct;
+  purchaseDate: number;
+  expiresDate?: number;
+  purchaseSource: "CAMPAIGN" | "MARKETPLACE" | "UNKNOWN";
+  receiptId: string;
+  localizedPrice: string;
+  userId: string;
+  marketplace: string;
+};
+
+export type PurchaseSuccessProduct = {
+  id: string;
+  platformID: string;
+  skuId: string;
+  languageCode: string;
+  name: string;
+  featured: boolean;
+  storeId: string;
+  type: number;
+  isFeatured: boolean;
+  namiID: string;
+};
+
+export enum NamiPaywallAction {
+  BUY_SKU = "BUY_SKU",
+  SELECT_SKU = "SELECT_SKU",
+  RESTORE_PURCHASES = "RESTORE_PURCHASES",
+  SIGN_IN = "SIGN_IN",
+  CLOSE_PAYWALL = "CLOSE_PAYWALL",
+  SHOW_PAYWALL = "SHOW_PAYWALL",
+  PURCHASE_SELECTED_SKU = "PURCHASE_SELECTED_SKU",
+  PURCHASE_SUCCESS = "PURCHASE_SUCCESS",
+  PURCHASE_FAILED = "PURCHASE_FAILED",
+  PURCHASE_CANCELLED = "PURCHASE_CANCELLED",
+  PURCHASE_PENDING = "PURCHASE_PENDING",
+  PURCHASE_UNKNOWN = "PURCHASE_UNKNOWN",
+  PURCHASE_DEFERRED = "PURCHASE_DEFERRED",
+  SHOW_PAYWALL = "SHOW_PAYWALL",
+}

package/src/NamiPaywallManager.js

@@ -0,0 +1,37 @@
+import { NativeModules, NativeEventEmitter } from "react-native";
+
+const { NamiPaywallManagerBridge, RNNamiPaywallManager } = NativeModules;
+
+export const NamiPaywallManager = {
+  paywallEmitter: new NativeEventEmitter(RNNamiPaywallManager),
+  ...RNNamiPaywallManager,
+  ...NamiPaywallManagerBridge,
+  buySkuCompleteIos(purchaseSuccess) {
+    RNNamiPaywallManager.buySkuComplete(purchaseSuccess);
+  },
+  buySkuCompleteAmazon(purchaseSuccess) {
+    RNNamiPaywallManager.buySkuComplete(purchaseSuccess, "Amazon");
+  },
+  buySkuCompleteGooglePlay(purchaseSuccess) {
+    RNNamiPaywallManager.buySkuComplete(purchaseSuccess, "GooglePlay");
+  },
+  registerBuySkuHandler(callback) {
+    var subscription = this.paywallEmitter.addListener(
+      "RegisterBuySKU",
+      callback
+    );
+    RNNamiPaywallManager.registerBuySkuHandler();
+    return subscription.remove;
+  },
+  registerCloseHandler(blockDismiss, callback) {
+    var subscription;
+    subscription = this.paywallEmitter.addListener(
+      "BlockingPaywallClosed",
+      () => {
+        subscription.remove();
+        callback();
+      }
+    );
+    RNNamiPaywallManager.registerCloseHandler(blockDismiss);
+  },
+};

package/src/NamiPurchaseManager.d.ts

@@ -0,0 +1,57 @@
+import { EmitterSubscription } from "react-native";
+import { NamiSKU } from "./types";
+import { NamiEntitlement } from "./NamiEntitlementManager";
+
+export const NamiPurchaseManager: {
+  allPurchases: () => NamiPurchase[];
+  anySkuPurchased: (skuIds: string[]) => boolean;
+  consumePurchasedSku: (skuId: string) => void;
+  clearBypassStorePurchases: () => void;
+  presentCodeRedemptionSheet: () => void;
+  restorePurchases: () => void;
+  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 type NamiPurchase = {
+  sku?: NamiSKU;
+  skuId: string;
+  transactionIdentifier?: string;
+  expires?: Date;
+  purchaseInitiatedTimestamp: Date;
+  purchaseSource?: "CAMPAIGN" | "MARKETPLACE" | "UNKNOWN";
+};
+
+export enum NamiPurchaseState {
+  PURCHASED = "PURCHASED",
+  FAILED = "FAILED",
+  CANCELLED = "CANCELLEDd",
+  PENDING = "PENDING",
+  UNKNOWN = "UNKNOWN",
+}
+
+export type NamiRestorePurchasesState = "started" | "finished" | "error";
+
+export type NamiPurchasesState =
+  | "pending"
+  | "purchased"
+  | "consumed"
+  | "resubscribed"
+  | "unsubscribed"
+  | "deferred"
+  | "failed"
+  | "cancelled"
+  | "unknown";

package/src/NamiPurchaseManager.js

@@ -0,0 +1,37 @@
+import { NativeModules, NativeEventEmitter, Platform } from "react-native";
+
+const { NamiPurchaseManagerBridge, RNNamiPurchaseManager } = NativeModules;
+
+export const NamiPurchaseManager = {
+  emitter: new NativeEventEmitter(RNNamiPurchaseManager),
+  ...NamiPurchaseManagerBridge,
+  ...RNNamiPurchaseManager,
+  registerPurchasesChangedHandler(callback) {
+    const subscription = this.emitter.addListener(
+      "PurchasesChanged",
+      (body) => {
+        var purchases = body.purchases;
+        var purchaseState = body.purchaseState.toLowerCase();
+        var error = body.error;
+        callback(purchaseState, purchases, error);
+      }
+    );
+    RNNamiPurchaseManager.registerPurchasesChangedHandler();
+    return subscription.remove;
+  },
+  registerRestorePurchasesHandler(callback) {
+    if (Platform.OS === "ios") {
+      const subscription = this.emitter.addListener(
+        "RestorePurchasesStateChanged",
+        (body) => {
+          var state = body.state.toLowerCase();
+          var newPurchases = body.newPurchases;
+          var oldPurchases = body.oldPurchases;
+          callback(state, newPurchases, oldPurchases);
+        }
+      );
+      RNNamiPurchaseManager.registerRestorePurchasesHandler();
+      return subscription.remove;
+    }
+  },
+};

package/src/types.ts

@@ -0,0 +1,36 @@
+export type NamiSKU = {
+  name: string;
+  skuId: string;
+  product?: SKProduct;
+  type: NamiSKUType;
+};
+
+export enum NamiPurchaseState {
+  PENDING = "pending",
+  PURCHASED = "purchased",
+  CONSUMED = "consumed",
+  RESUBSCRIBED = "resubscribed",
+  UNSUBSCRIBED = "unsubscribed",
+  DEFERRED = "deferred",
+  FAILED = "failed",
+  CANCELLED = "cancelled",
+  UNKNOWN = "unknown",
+}
+
+export enum NamiRestorePurchasesState {
+  STARTED = "started",
+  FINISHED = "finished",
+  ERROR = "error",
+}
+
+export type NamiSKUType = "unknown" | "one_time_purchase" | "subscription";
+
+export type SKProduct = {
+  localizedDescription: string;
+  localizedMultipliedPrice: string;
+  localizedPrice: string;
+  localizedTitle: string;
+  price: string;
+  priceCurrency: string;
+  priceLanguage: string;
+};