@primer-io/react-native 0.16.2 → 2.1.0

package/src/headless_checkout/types.ts

@@ -1,18 +1,32 @@
+import type { PrimerCheckoutData } from '../models/PrimerCheckoutData';
+import type { PrimerCheckoutPaymentMethodData } from '../models/PrimerCheckoutPaymentMethodData';
+import type { 
+  PrimerTokenizationHandler, 
+  PrimerResumeHandler, 
+  PrimerPaymentCreationHandler, 
+  PrimerErrorHandler
+} from '../models/PrimerInterfaces';
+import type { PrimerClientSession } from '../models/PrimerClientSession';
+import type { PrimerPaymentMethodTokenData } from '../models/PrimerPaymentMethodTokenData'; 
+import type { PrimerError } from '../models/PrimerError';
+
 export interface PrimerHeadlessUniversalCheckoutStartResponse {
   paymentMethodTypes: string[];
 }
 
-export interface PrimerError {
-  errorId: string;
-  description: string;
-  recoverySuggestion?: string;
-}
-
 export interface PrimerHeadlessUniversalCheckoutCallbacks {
-  onPreparationStarted?: () => void;
-  onPaymentMethodPresented?: () => void;
-  onTokenizeStart?: () => void;
-  onTokenizeSuccess?: (paymentMethod: any) => void;
-  onResumeSuccess?: (resumeToken: string) => void;
-  onFailure?: (error: PrimerError) => void;
+  // Common
+  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 | undefined) => void;
+
+  // Only on HUC
+  onPrepareStart?: (paymentMethodType: string) => void;
+  onTokenizeStart?: (paymentMethodType: string) => void;
+  onPaymentMethodShow?: (paymentMethodType: string) => void;
+  onAvailablePaymentMethodTypesLoad?: (paymentMethodTypes: string[]) => void;
 }

package/src/index.tsx

@@ -1,8 +1,36 @@
-import PrimerHeadlessUniversalCheckout from './headless_checkout/PrimerHeadlessUniversalCheckout';
-import type { IPrimer } from './models/primer';
-import { PrimerNativeMapping } from './Primer';
-export * from './PrimerInput';
-
-const Primer: IPrimer = PrimerNativeMapping;
-
-export { Primer, PrimerHeadlessUniversalCheckout as HeadlessUniversalCheckout };
+export {
+    Primer
+} from './Primer';
+export {
+    PrimerSettings
+} from './models/PrimerSettings';
+export {
+    PrimerSessionIntent
+} from './models/PrimerSessionIntent';
+export { 
+    PrimerPaymentCreationHandler,
+    PrimerTokenizationHandler,
+    PrimerResumeHandler,
+    PrimerErrorHandler,
+} from './models/PrimerInterfaces';
+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';
+export {
+    PrimerHeadlessUniversalCheckout
+} from './headless_checkout/PrimerHeadlessUniversalCheckout';

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/PrimerInterfaces.ts

@@ -0,0 +1,36 @@
+import type { PrimerSessionIntent } from "./PrimerSessionIntent";
+import type { PrimerSettings } from "./PrimerSettings";
+
+export interface IPrimer {
+  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;
+  dispose(): 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/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,108 @@
+import type { 
+  PrimerErrorHandler, 
+  PrimerPaymentCreationHandler, 
+  PrimerResumeHandler, 
+  PrimerTokenizationHandler 
+} from "./PrimerInterfaces";
+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;
+
+  // Common
+  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;
+  // PrimerErrorHandler will be undefined on the HUC flow.
+  onError?: (error: PrimerError, checkoutData: PrimerCheckoutData | null, handler: PrimerErrorHandler | undefined) => void;
+  
+  // Only on main SDK
+  onDismiss?: () => void;
+
+  // Only on HUC
+  onPrepareStart?: (paymentMethod: string) => void;
+  onTokenizeStart?: (paymentMethod: string) => void;
+  onPaymentMethodShow?: (paymentMethod: string) => void;
+  onAvailablePaymentMethodsLoad?: (paymentMethods: string[]) => 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;
+}

package/src/models/{primer-theme.ts → PrimerTheme.ts}

@@ -1,5 +1,5 @@
 export type PrimerTheme = IPrimerTheme;
-interface IPrimerTheme {
+export interface IPrimerTheme {
   colors?: ColorTheme;
   darkModeColors?: ColorTheme;
 }

package/src/utils/index.ts

@@ -1,4 +1,4 @@
-import type { RgbaColor } from 'src/models/primer-theme';
+import type { RgbaColor } from "../models/PrimerTheme";
 
 export function toRgbColor(hex: string): RgbaColor | null {
   // Make sure it looks like a proper color hex string