@primer-io/react-native 0.15.8 → 2.0.0

package/src/RNPrimer.ts

@@ -1,18 +1,19 @@
 import { NativeEventEmitter, NativeModules } from 'react-native';
-import type { PrimerSettings } from './models/primer-settings';
-import type { PrimerTheme } from './models/primer-theme';
+import type { PrimerSessionIntent } from './models/PrimerSessionIntent';
+import type { PrimerSettings } from './models/PrimerSettings';
 
 const { NativePrimer } = NativeModules;
 const eventEmitter = new NativeEventEmitter(NativePrimer);
 
 type EventType =
-  | 'onClientTokenCallback'
-  | 'onClientSessionActions'
-  | 'onTokenizeSuccessCallback'
-  | 'onVaultSuccess'
-  | 'onResumeSuccess'
-  | 'onCheckoutDismissed'
+  | 'onCheckoutComplete'
+  | 'onBeforeClientSessionUpdate'
+  | 'onClientSessionUpdate'
+  | 'onBeforePaymentCreate'
   | 'onError'
+  | 'onDismiss'
+  | 'onTokenizeSuccess'
+  | 'onResumeSuccess'
   | 'detectImplementedRNCallbacks';
 
 export interface IPrimerError {
@@ -21,10 +22,23 @@ export interface IPrimerError {
   recoverySuggestion?: string
 }
 
+const eventTypes: EventType[] = [
+  'onCheckoutComplete',
+  'onBeforeClientSessionUpdate',
+  'onClientSessionUpdate',
+  'onBeforePaymentCreate',
+  'onError',
+  'onDismiss',
+  'onTokenizeSuccess',
+  'onResumeSuccess',
+  'detectImplementedRNCallbacks'
+];
+
 const RNPrimer = {
   ///////////////////////////////////////////
   // Event Emitter
   ///////////////////////////////////////////
+
   addListener: (eventType: EventType, listener: (...args: any[]) => any) => {
     eventEmitter.addListener(eventType, listener);
   },
@@ -38,35 +52,16 @@ const RNPrimer = {
   },
 
   removeAllListeners() {
-    eventEmitter.removeAllListeners('onClientTokenCallback');
-    eventEmitter.removeAllListeners('onClientSessionActions');
-    eventEmitter.removeAllListeners('onTokenizeSuccessCallback');
-    eventEmitter.removeAllListeners('onVaultSuccess');
-    eventEmitter.removeAllListeners('onResumeSuccess');
-    eventEmitter.removeAllListeners('onCheckoutDismissed');
-    eventEmitter.removeAllListeners('onError');
-    eventEmitter.removeAllListeners('detectImplementedRNCallbacks');
+    eventTypes.forEach((eventType) => RNPrimer.removeAllListenersForEvent(eventType));
   },
 
   ///////////////////////////////////////////
   // Native API
   ///////////////////////////////////////////
-  configure: (
-    settings: PrimerSettings | null,
-    theme: PrimerTheme | null
-  ): Promise<void> => {
+  configure: (settings: PrimerSettings | undefined): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
-        if (settings === null && theme === null) {
-          // Do nothing, SDK will use default settings and theme.
-        } else if (settings && theme === null) {
-          await NativePrimer.configureWithSettings(JSON.stringify(settings));
-        } else if (settings === null && theme) {
-          await NativePrimer.configureWithTheme(JSON.stringify(theme));
-        } else {
-          await NativePrimer.configureWithSettings(JSON.stringify(settings));
-          await NativePrimer.configureWithTheme(JSON.stringify(theme));
-        }
+        await NativePrimer.configure(JSON.stringify(settings) || "");
         resolve();
       } catch (err) {
         reject(err);
@@ -74,14 +69,10 @@ const RNPrimer = {
     });
   },
 
-  showUniversalCheckout: (clientToken: string | undefined): Promise<void> => {
+  showUniversalCheckout: (clientToken: string): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
-        if (clientToken) {
-          await NativePrimer.showUniversalCheckoutWithClientToken(clientToken);
-        } else {
-          await NativePrimer.showUniversalCheckout();
-        }
+        await NativePrimer.showUniversalCheckoutWithClientToken(clientToken);
         resolve();
       } catch (err) {
         reject(err);
@@ -92,11 +83,7 @@ const RNPrimer = {
   showVaultManager: (clientToken: string | undefined): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
-        if (clientToken) {
-          await NativePrimer.showVaultManager(clientToken);
-        } else {
-          await NativePrimer.showVaultManager();
-        }
+        await NativePrimer.showVaultManagerWithClientToken(clientToken);
         resolve();
       } catch (err) {
         reject(err);
@@ -105,13 +92,41 @@ const RNPrimer = {
   },
 
   showPaymentMethod: (
-    clientToken: string,
     paymentMethodType: string,
-    intent: "checkout" | "vault"
+    intent: PrimerSessionIntent,
+    clientToken: string
   ): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
-        await NativePrimer.showPaymentMethod(clientToken, paymentMethodType, intent);
+        await NativePrimer.showPaymentMethod(paymentMethodType, intent, clientToken);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  dismiss: (): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await NativePrimer.dismiss();
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  ///////////////////////////////////////////
+  // DECISION HANDLERS
+  ///////////////////////////////////////////
+
+  // Tokenization Handlers
+
+  handleTokenizationNewClientToken: (newClientToken: string): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await NativePrimer.handleTokenizationNewClientToken(newClientToken);
         resolve();
       } catch (err) {
         reject(err);
@@ -119,10 +134,10 @@ const RNPrimer = {
     });
   },
 
-  handleNewClientToken: (clientToken: string | undefined): Promise<void> => {
+  handleTokenizationSuccess: (): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
-        await NativePrimer.handleNewClientToken(clientToken);
+        await NativePrimer.handleTokenizationSuccess();
         resolve();
       } catch (err) {
         reject(err);
@@ -130,10 +145,10 @@ const RNPrimer = {
     });
   },
 
-  handleError: (err: IPrimerError): Promise<void> => {
+  handleTokenizationFailure: (errorMessage: string | null): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
-        await NativePrimer.handleError(JSON.stringify(err));
+        await NativePrimer.handleTokenizationFailure(errorMessage || "");
         resolve();
       } catch (err) {
         reject(err);
@@ -141,6 +156,78 @@ const RNPrimer = {
     });
   },
 
+    // Resume Handlers
+
+    handleResumeWithNewClientToken: (newClientToken: string): Promise<void> => {
+      return new Promise(async (resolve, reject) => {
+        try {
+          await NativePrimer.handleResumeWithNewClientToken(newClientToken);
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    },
+
+    handleResumeSuccess: (): Promise<void> => {
+      return new Promise(async (resolve, reject) => {
+        try {
+          await NativePrimer.handleResumeSuccess();
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    },
+
+    handleResumeFailure: (errorMessage: string | null): Promise<void> => {
+      return new Promise(async (resolve, reject) => {
+        try {
+          await NativePrimer.handleTokenizationFailure(errorMessage || "");
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    },
+
+  // Payment Creation Handlers
+
+  handlePaymentCreationAbort: (errorMessage: string | null): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await NativePrimer.handlePaymentCreationAbort(errorMessage || "");
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  handlePaymentCreationContinue: (): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await NativePrimer.handlePaymentCreationContinue();
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+    // Error Handler
+
+    showErrorMessage: (errorMessage: string | null): Promise<void> => {
+      return new Promise(async (resolve, reject) => {
+        try {
+          await NativePrimer.showErrorMessage(errorMessage || "");
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      });
+    },
+
   handleSuccess: (): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
@@ -163,9 +250,6 @@ const RNPrimer = {
     });
   },
 
-  dispose: (): void => {
-
-  }
 };
 
 export default RNPrimer;

package/src/index.tsx

@@ -1,7 +1,34 @@
-import type { IPrimer } from './models/primer';
-import { PrimerNativeMapping } from './Primer';
-// import type { IPrimerConfig as PrimerConfig } from './models/primer-config';
 
-const Primer: IPrimer = PrimerNativeMapping;
-
-export { Primer };
+export {
+    Primer
+} from './Primer';
+export {
+    PrimerSettings
+} from './models/PrimerSettings';
+export {
+    PrimerSessionIntent
+} from './models/PrimerSessionIntent';
+export { 
+    PrimerPaymentCreationHandler,
+    PrimerTokenizationHandler,
+    PrimerResumeHandler,
+    PrimerErrorHandler,
+} from './models/Primer';
+export { PrimerPaymentMethodTokenData } from './models/PrimerPaymentMethodTokenData';
+export { 
+    PrimerClientSession,
+    PrimerOrder,
+    PrimerLineItem,
+    PrimerCustomer,
+    PrimerAddress,
+} from './models/PrimerClientSession';
+export { 
+    PrimerCheckoutData,
+    PrimerCheckoutDataPayment,
+} from './models/PrimerCheckoutData';
+export { 
+    PrimerCheckoutPaymentMethodData
+} from './models/PrimerCheckoutPaymentMethodData';
+export { 
+    PrimerError
+} from './models/PrimerError';

package/src/models/Primer.ts

@@ -0,0 +1,35 @@
+import type { PrimerSessionIntent } from "./PrimerSessionIntent";
+import type { PrimerSettings } from "./PrimerSettings";
+
+export interface Primer {
+  configure(settings: PrimerSettings): Promise<void>;
+  showUniversalCheckout(clientToken: string): Promise<void>;
+  showVaultManager(clientToken: string): Promise<void>;
+  showPaymentMethod(
+    paymentMethodType: string,
+    intent: PrimerSessionIntent,
+    clientToken: string
+  ): Promise<void>
+  dismiss(): void;
+}
+
+export interface PrimerPaymentCreationHandler {
+  abortPaymentCreation(errorMessage: string | null): void;
+  continuePaymentCreation(): void;
+}
+
+export interface PrimerTokenizationHandler {
+  handleSuccess(): void;
+  handleFailure(errorMessage: string | null): void;
+  continueWithNewClientToken(newClientToken: string): void;
+}
+
+export interface PrimerResumeHandler {
+  handleSuccess(): void;
+  handleFailure(errorMessage: string | null): void;
+  continueWithNewClientToken(newClientToken: string): void;
+}
+
+export interface PrimerErrorHandler {
+  showErrorMessage(errorMessage: string | null): void;
+}

package/src/models/PrimerCheckoutData.ts

@@ -0,0 +1,18 @@
+export type PrimerCheckoutData = IPrimerCheckoutData;
+
+interface IPrimerCheckoutData {
+    payment: IPrimerCheckoutDataPayment;
+}
+
+export type PrimerCheckoutDataPayment = IPrimerCheckoutDataPayment;
+
+interface IPrimerCheckoutDataPayment {
+    id?: string;
+    orderId?: string;
+    paymentFailureReason?: PrimerPaymentErrorCode;
+}
+
+enum PrimerPaymentErrorCode {
+    FAILED = 'payment-failed',
+    CANCELLED_BY_CUSTOMER = 'cancelled-by-customer',
+}

package/src/models/PrimerCheckoutPaymentMethodData.ts

@@ -0,0 +1,5 @@
+export type PrimerCheckoutPaymentMethodData = IPrimerCheckoutPaymentMethodData;
+
+interface IPrimerCheckoutPaymentMethodData {
+    paymentMethodType: string;
+}

package/src/models/PrimerClientSession.ts

@@ -0,0 +1,53 @@
+export type PrimerClientSession = IPrimerClientSession;
+
+interface IPrimerClientSession {
+    customerId?: string;
+    orderId?: string;
+    currencyCode?: string;
+    totalAmount?: number;
+    lineItems?: IPrimerLineItem[];
+    orderDetails?: IPrimerOrder;
+    customer?: IPrimerCustomer;
+}
+
+export type PrimerLineItem = IPrimerLineItem;
+
+interface IPrimerLineItem {
+    itemId?: string;
+    itemDescription?: string;
+    amount?: number;
+    discountAmount?: number;
+    quantity?: number;
+    taxCode?: string;
+    taxAmount?: number;
+}
+
+export type PrimerOrder = IPrimerOrder;
+
+interface IPrimerOrder {
+    countryCode?: string;
+}
+
+export type PrimerCustomer = IPrimerCustomer;
+
+interface IPrimerCustomer {
+    emailAddress?: string;
+    mobileNumber?: string;
+    firstName?: string;
+    lastName?: string;
+    billingAddress?: IPrimerAddress;
+    shippingAddress?: IPrimerAddress;
+}
+
+export type PrimerAddress = IPrimerAddress;
+
+interface IPrimerAddress {
+    firstName?: string;
+    lastName?: string;
+    addressLine1?: string;
+    addressLine2?: string;
+    postalCode?: string;
+    city?: string;
+    state?: string;
+    countryCode?: string;
+}

package/src/models/{utils/countryCode.ts → PrimerCountryCode.ts}

@@ -246,4 +246,4 @@ var countries = [
   'ZW',
 ] as const;
 
-export type CountryCode = typeof countries[number];
+export type PrimerCountryCode = typeof countries[number];

package/src/models/{utils/currencyCode.ts → PrimerCurrencyCode.ts}

@@ -179,4 +179,4 @@ const currencies = [
   'ZMW',
 ] as const;
 
-export type CurrencyCode = typeof currencies[number];
+export type PrimerCurrencyCode = typeof currencies[number];

package/src/models/PrimerError.ts

@@ -0,0 +1,20 @@
+export interface IPrimerError {
+  errorId: string;
+  description?: string;
+  recoverySuggestion?: string;
+}
+
+
+export class PrimerError extends Error {
+
+  errorId: string;
+  description: string;
+  recoverySuggestion?: string;
+
+  constructor(errorId: string, description: string, recoverySuggestion: string | undefined) {
+      super(description);
+      this.errorId = errorId;
+      this.description = description;
+      this.recoverySuggestion = recoverySuggestion;
+  }
+}

package/src/models/PrimerPaymentMethodTokenData.ts

@@ -0,0 +1,130 @@
+export type PrimerPaymentMethodTokenData = IPrimerPaymentMethodTokenData;
+
+export interface IPrimerPaymentMethodTokenData {
+  analyticsId?: string;
+  id?: string;
+  isVaulted?: boolean;
+  paymentInstrumentData: IPrimerPaymentInstrumentData;
+  paymentInstrumentType: string;
+  token: string;
+  tokenType?: PrimerTokenType;
+  threeDSecureAuthentication?: IPrimerThreeDSAuthenticationData;
+  vaultData?: IPrimerVaultData;
+}
+
+export enum PrimerTokenType {
+  SINGLE_USE = 'SINGLE_USE',
+  MULTI_USE = 'MULTI_USE',
+}
+
+export interface IPrimerThreeDSAuthenticationData {
+  challengeIssued?: boolean;
+  protocolVersion?: string;
+  reasonCode?: string;
+  reasonText?: string;
+  responseCode?: string;
+}
+
+export interface IPrimerVaultData {
+  customerId?: string;
+}
+
+export interface IPrimerPaymentInstrumentData {
+  paypalBillingAgreementId?: string;
+  first6Digits?: string;
+  last4Digits?: string;
+  expirationMonth?: string;
+  expirationYear?: string;
+  cardholderName?: string;
+  network?: string;
+  isNetworkTokenized?: boolean;
+  klarnaCustomerToken?: string;
+
+  sessionData?: IKlarnaSessionData;
+  externalPayerInfo?: IExternalPayerInfo;
+  shippingAddress?: IShippingAddress;
+  binData?: IBinData;
+
+  gocardlessMandateId?: string;
+  authorizationToken?: string;
+  hashedIdentifier?: string;
+  mcc?: string;
+  mnc?: string;
+  mx?: string;
+  currencyCode?: string;
+  productId?: string;
+}
+
+export interface IKlarnaSessionData {
+  recurringDescription?: string;
+  purchaseCountry?: string;
+  purchaseCurrency?: string;
+  locale?: string;
+  orderAmount?: string;
+  orderLines?: IKlarnaSessionOrderLines[];
+  billingAddress?: IKlarnaBillingAddress;
+  tokenDetails?: IKlarnaSessionDataTokenDetails;
+}
+
+export interface IKlarnaSessionOrderLines {
+  type?: string;
+  name?: string;
+  quantity?: number;
+  unitPrice?: number;
+  totalAmount?: number;
+  totalDiscountAmount?: number;
+}
+
+export interface IKlarnaBillingAddress {
+  addressLine1?: string;
+  addressLine2?: string;
+  addressLine3?: string;
+  city?: string;
+  countryCode?: string;
+  email?: string;
+  firstName?: string;
+  lastName?: string;
+  phoneNumber?: string;
+  postalCode?: string;
+  state?: string;
+  title?: string;
+}
+
+export interface IKlarnaSessionDataTokenDetails {
+  brand?: string;
+  maskedNumber?: string;
+  type: string;
+  expiryDate?: string;
+}
+
+export interface IExternalPayerInfo {
+  externalPayerId?: string;
+  email?: string;
+  firstName?: string;
+  lastName?: string;
+}
+
+export interface IShippingAddress {
+  firstName?: string;
+  lastName?: string;
+  addressLine1?: string;
+  addressLine2?: string;
+  city?: string;
+  state?: string;
+  countryCode?: string;
+  postalCode?: string;
+}
+
+export interface IBinData {
+  network?: string;
+  issuerCountryCode?: string;
+  issuerName?: string;
+  issuerCurrencyCode?: string;
+  regionalRestriction?: string;
+  accountNumberType?: string;
+  accountFundingType?: string;
+  prepaidReloadableIndicator?: string;
+  productUsageType?: string;
+  productCode?: string;
+  productName?: string;
+}

package/src/models/PrimerSessionIntent.ts

@@ -0,0 +1,4 @@
+export enum PrimerSessionIntent {
+  CHECKOUT = 'CHECKOUT',
+  VAULT = 'VAULT'
+}

package/src/models/PrimerSettings.ts

@@ -0,0 +1,93 @@
+import type { PrimerErrorHandler, PrimerPaymentCreationHandler, PrimerResumeHandler, PrimerTokenizationHandler } from "./Primer";
+import type { PrimerCheckoutData } from "./PrimerCheckoutData";
+import type { PrimerCheckoutPaymentMethodData } from "./PrimerCheckoutPaymentMethodData";
+import type { PrimerClientSession } from "./PrimerClientSession";
+import type { PrimerPaymentMethodTokenData } from "./PrimerPaymentMethodTokenData";
+import type { PrimerError } from "./PrimerError";
+import type { IPrimerTheme } from "./PrimerTheme";
+
+export type PrimerSettings = IPrimerSettings;
+
+interface IPrimerSettings {
+  paymentHandling?: 'AUTO' | 'MANUAL';
+  localeData?: IPrimerLocaleData;
+  paymentMethodOptions?: IPrimerPaymentMethodOptions;
+  uiOptions?: IPrimerUIOptions;
+  debugOptions?: IPrimerDebugOptions;
+
+  onBeforeClientSessionUpdate?: () => void;
+  onClientSessionUpdate?: (clientSession: PrimerClientSession) => void;
+  onBeforePaymentCreate?: (checkoutPaymentMethodData: PrimerCheckoutPaymentMethodData, handler: PrimerPaymentCreationHandler) => void;
+  onCheckoutComplete?: (checkoutData: PrimerCheckoutData) => void;
+  onTokenizeSuccess?: (paymentMethodTokenData: PrimerPaymentMethodTokenData, handler: PrimerTokenizationHandler) => void;
+  onResumeSuccess?: (resumeToken: string, handler: PrimerResumeHandler) => void;
+  onError?: (error: PrimerError, checkoutData: PrimerCheckoutData | null, handler: PrimerErrorHandler) => void;
+  onDismiss?: () => void;
+}
+
+//----------------------------------------
+
+interface IPrimerLocaleData {
+  languageCode?: string
+  localeCode?: string
+}
+
+//----------------------------------------
+
+interface IPrimerPaymentMethodOptions {
+  iOS?: {
+    urlScheme?: string;
+  }
+  android?: {
+    redirectScheme?: string;
+  },
+  apayaOptions?: IPrimerApayaOptions;
+  applePayOptions?: IPrimerApplePayOptions;
+  cardPaymentOptions?: IPrimerCardPaymentOptions;
+  goCardlessOptions?: IPrimerGoCardlessOptions;
+  googlePayOptions?: IPrimerGooglePayOptions;
+  klarnaOptions?: IPrimerKlarnaOptions;
+}
+
+interface IPrimerApayaOptions {
+  webViewTitle: string;
+}
+
+interface IPrimerApplePayOptions {
+  merchantIdentifier: string;
+  merchantName: string;
+}
+
+interface IPrimerCardPaymentOptions {
+  is3DSOnVaultingEnabled: boolean;
+}
+
+interface IPrimerGoCardlessOptions {
+  businessName?: string;
+  businessAddress?: string;
+}
+
+interface IPrimerGooglePayOptions {
+  merchantName?: string;
+  allowedCardNetworks?: string[];
+}
+
+interface IPrimerKlarnaOptions {
+  recurringPaymentDescription?: string;
+  webViewTitle?: string;
+}
+
+//----------------------------------------
+
+interface IPrimerUIOptions {
+  isInitScreenEnabled?: boolean;
+  isSuccessScreenEnabled?: boolean;
+  isErrorScreenEnabled?: boolean;
+  theme?: IPrimerTheme;
+}
+
+//----------------------------------------
+
+interface IPrimerDebugOptions {
+  is3DSSanityCheckEnabled?: boolean;
+}