@primer-io/react-native 2.45.0 → 3.0.0-beta.0

package/src/Primer.ts

@@ -25,7 +25,7 @@ import type { PrimerImplementedRNCallbacks } from './models/PrimerImplementedRNC
 const tokenizationHandler: PrimerTokenizationHandler = {
   handleFailure: async (errorMessage: string) => {
     try {
-      RNPrimer.handleTokenizationFailure(errorMessage);
+      await RNPrimer.handleTokenizationFailure(errorMessage);
     } catch (err) {
       console.error(err);
     }
@@ -33,7 +33,7 @@ const tokenizationHandler: PrimerTokenizationHandler = {
 
   handleSuccess: async () => {
     try {
-      RNPrimer.handleTokenizationSuccess();
+      await RNPrimer.handleTokenizationSuccess();
     } catch (err) {
       console.error(err);
     }
@@ -41,7 +41,7 @@ const tokenizationHandler: PrimerTokenizationHandler = {
 
   continueWithNewClientToken: async (newClientToken: string) => {
     try {
-      RNPrimer.handleTokenizationNewClientToken(newClientToken);
+      await RNPrimer.handleTokenizationNewClientToken(newClientToken);
     } catch (err) {
       console.error(err);
     }
@@ -53,7 +53,7 @@ const tokenizationHandler: PrimerTokenizationHandler = {
 const resumeHandler: PrimerResumeHandler = {
   handleFailure: async (errorMessage: string) => {
     try {
-      RNPrimer.handleResumeFailure(errorMessage);
+      await RNPrimer.handleResumeFailure(errorMessage);
     } catch (err) {
       console.error(err);
     }
@@ -61,7 +61,7 @@ const resumeHandler: PrimerResumeHandler = {
 
   handleSuccess: async () => {
     try {
-      RNPrimer.handleResumeSuccess();
+      await RNPrimer.handleResumeSuccess();
     } catch (err) {
       console.error(err);
     }
@@ -69,7 +69,7 @@ const resumeHandler: PrimerResumeHandler = {
 
   continueWithNewClientToken: async (newClientToken: string) => {
     try {
-      RNPrimer.handleResumeWithNewClientToken(newClientToken);
+      await RNPrimer.handleResumeWithNewClientToken(newClientToken);
     } catch (err) {
       console.error(err);
     }
@@ -81,7 +81,7 @@ const resumeHandler: PrimerResumeHandler = {
 const paymentCreationHandler: PrimerPaymentCreationHandler = {
   abortPaymentCreation: async (errorMessage: string) => {
     try {
-      RNPrimer.handlePaymentCreationAbort(errorMessage);
+      await RNPrimer.handlePaymentCreationAbort(errorMessage);
     } catch (err) {
       console.error(err);
     }
@@ -89,7 +89,7 @@ const paymentCreationHandler: PrimerPaymentCreationHandler = {
 
   continuePaymentCreation: async () => {
     try {
-      RNPrimer.handlePaymentCreationContinue();
+      await RNPrimer.handlePaymentCreationContinue();
     } catch (err) {
       console.error(err);
     }
@@ -101,7 +101,7 @@ const paymentCreationHandler: PrimerPaymentCreationHandler = {
 const errorHandler: PrimerErrorHandler = {
   showErrorMessage: async (errorMessage: string) => {
     try {
-      RNPrimer.showErrorMessage(errorMessage || '');
+      await RNPrimer.showErrorMessage(errorMessage || '');
     } catch (err) {
       console.error(err);
     }
@@ -309,13 +309,13 @@ export const Primer: IPrimer = {
     RNPrimerHeadlessUniversalCheckout.removeAllListeners();
     RNPrimer.removeAllListeners();
     primerSettings = undefined;
-    RNPrimer.dismiss();
+    void RNPrimer.dismiss();
   },
 
   dismiss(): void {
     RNPrimerHeadlessUniversalCheckout.removeAllListeners();
     RNPrimer.removeAllListeners();
     primerSettings = undefined;
-    RNPrimer.dismiss();
+    void RNPrimer.dismiss();
   },
 };

package/src/RNPrimer.ts

@@ -1,4 +1,5 @@
 import type { PrimerSettings } from './models/PrimerSettings';
+import type { PrimerImplementedRNCallbacks } from './models/PrimerImplementedRNCallbacks';
 import type { EventSubscription } from 'react-native';
 import NativePrimer from './specs/NativePrimer';
 
@@ -222,7 +223,7 @@ const RNPrimer = {
   },
 
   // HELPERS
-  setImplementedRNCallbacks: (implementedRNCallbacks: any): Promise<void> => {
+  setImplementedRNCallbacks: (implementedRNCallbacks: PrimerImplementedRNCallbacks): Promise<void> => {
     return new Promise(async (resolve, reject) => {
       try {
         await NativePrimer.setImplementedRNCallbacks(JSON.stringify(implementedRNCallbacks));
@@ -232,6 +233,51 @@ const RNPrimer = {
       }
     });
   },
+
+  // ANALYTICS BRIDGE
+  setupAnalyticsLoggingBridge: (clientToken: string): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await NativePrimer.setupAnalyticsLoggingBridge(clientToken);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  trackAnalyticsEvent: (eventName: string, metadata?: string): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await NativePrimer.trackAnalyticsEvent(eventName, metadata);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  sendLog: (message: string, event: string, initDurationMs?: number): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await NativePrimer.sendLog(message, event, initDurationMs);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
+
+  sendErrorLog: (message: string, event?: string, errorMessage?: string, stack?: string): Promise<void> => {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await NativePrimer.sendErrorLog(message, event, errorMessage, stack);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  },
 };
 
 export default RNPrimer;

package/src/index.tsx

@@ -97,8 +97,17 @@ import { NativeResourceView } from './HeadlessUniversalCheckout/Components/Nativ
 export { NativeResourceView };
 import { PrimerGooglePayButtonConstants } from './HeadlessUniversalCheckout/Components/NativeResourceView';
 export { PrimerGooglePayButtonConstants };
-import { PrimerGooglePayButton } from './HeadlessUniversalCheckout/Components/PrimerGooglePayButton';
-export { PrimerGooglePayButton };
+export { usePrimerPaymentMethod } from './Components';
+export type {
+  UsePrimerPaymentMethodReturn,
+  NativeUiPaymentMethod,
+  CardPaymentMethod,
+  UnsupportedPaymentMethod,
+  PaymentMethodAvailabilityError,
+} from './Components';
+// The bare, context-free native button (the pre-3.0 `PrimerGooglePayButton`) stays available for
+// Headless consumers that render it outside a `<PrimerCheckoutProvider>`.
+export { PrimerGooglePayButton as PrimerGooglePayNativeButton } from './HeadlessUniversalCheckout/Components/PrimerGooglePayButton';
 import type { UserDetailsRetrieved, UserDetailsCollected, AchStep } from './models/ach/AchSteps';
 export type { UserDetailsRetrieved as CollectUserDetails, UserDetailsCollected, AchStep };
 import type { AchFirstName, AchLastName, AchEmailAddress, AchValidatableData } from './models/ach/AchCollectableData';
@@ -130,6 +139,97 @@ export type { BanksLoading, BanksRetrieved, BanksStep };
 import type { NamedComponentValidatableData } from './models/NamedComponentValidatableData';
 export type { NamedComponentValidatableData };
 
+export { PrimerCheckoutProvider } from './Components';
+export { usePrimerCheckout } from './Components';
+export { usePrimerPaymentMethods } from './Components';
+export { usePrimerVaultManager } from './Components';
+export type { VaultedPaymentMethodItem, UsePrimerVaultManagerReturn } from './Components';
+export type {
+  PrimerCheckoutProviderProps,
+  PrimerCheckoutContextValue,
+  PaymentOutcome,
+  CardFormState,
+} from './Components';
+export type {
+  PaymentMethodItem,
+  PaymentMethodSurcharge,
+  UsePrimerPaymentMethodsOptions,
+  UsePrimerPaymentMethodsReturn,
+} from './Components';
+export { usePrimerCardForm } from './Components';
+export type { UseCardFormOptions, UsePrimerCardFormReturn, CardFormErrors, CardFormField } from './Components';
+export { usePrimerCardNetwork } from './Components';
+export type { UseCardNetworkReturn } from './Components';
+export { usePrimerCardNetworkSelection } from './Components';
+export type { CardNetworkDetails, CardNetworkId, UsePrimerCardNetworkSelectionReturn } from './Components';
+export { PrimerCardNetworkSelector } from './Components';
+export type { PrimerCardNetworkSelectorProps } from './Components';
+export { usePrimerBillingAddressForm } from './Components';
+export type {
+  UsePrimerBillingAddressFormOptions,
+  UsePrimerBillingAddressFormReturn,
+  BillingAddressFormErrors,
+  BillingAddressField,
+  PrimerBillingAddressFormProps,
+} from './Components';
+export { PrimerPaymentMethodList } from './Components';
+export type { PrimerPaymentMethodListProps } from './Components';
+export { PrimerCheckoutSheet } from './Components';
+export type { PrimerCheckoutSheetProps } from './Components';
+export { PrimerCardForm } from './Components';
+export type { PrimerCardFormProps } from './Components';
+export { PrimerCardFormProvider } from './Components';
+export { PrimerAcceptedCardNetworks } from './Components';
+export type { PrimerAcceptedCardNetworksProps } from './Components';
+export { PrimerBillingAddressForm } from './Components';
+export {
+  PrimerTextInput,
+  PrimerCardNumberInput,
+  PrimerExpiryDateInput,
+  PrimerCVVInput,
+  PrimerCardholderNameInput,
+} from './Components';
+export type {
+  PrimerTextInputTheme,
+  PrimerTextInputProps,
+  PrimerTextInputRef,
+  CardInputTheme,
+  PrimerCardInputProps,
+  PrimerCardNumberInputProps,
+  PrimerExpiryDateInputProps,
+  PrimerCVVInputProps,
+  PrimerCardholderNameInputProps,
+} from './Components';
+export { PrimerAnalytics } from './Components/analytics';
+
+export { usePrimerLocalization } from './Components/internal/localization';
+export type { TranslationParams, LocalizationResult } from './Components/internal/localization';
+
+export { usePrimerTheme } from './Components/internal/theme';
+export type {
+  PrimerTokens,
+  PrimerColorTokens,
+  PrimerSpacingTokens,
+  PrimerTypographyTokens,
+  PrimerTypographyStyle,
+  PrimerRadiusTokens,
+  PrimerBorderTokens,
+  PrimerThemeOverride,
+} from './Components/internal/theme';
+
+export {
+  PrimerLoadingScreen,
+  PrimerSuccessScreen,
+  PrimerErrorScreen,
+  PrimerStatusScreenLayout,
+} from './Components/status';
+export type {
+  PrimerLoadingScreenProps,
+  PrimerSuccessScreenProps,
+  PrimerErrorScreenProps,
+  PrimerStatusScreenLayoutProps,
+} from './Components/status';
+
 // must be exported in order to support the old architecture
 const nativeModule = require('./specs/NativePrimer').default;
 export default nativeModule;

package/src/models/PrimerCheckoutData.ts

@@ -12,9 +12,12 @@ export type PrimerCheckoutDataPayment = IPrimerCheckoutDataPayment;
 interface IPrimerCheckoutDataPayment {
   id?: string;
   orderId?: string;
+  status?: PrimerPaymentStatus;
   paymentFailureReason?: PrimerPaymentErrorCode;
 }
 
+export type PrimerPaymentStatus = 'SUCCESS' | 'FAILED' | 'PENDING';
+
 enum PrimerPaymentErrorCode {
   FAILED = 'payment-failed',
   CANCELLED_BY_CUSTOMER = 'cancelled-by-customer',

package/src/models/PrimerClientSession.ts

@@ -8,6 +8,36 @@ interface IPrimerClientSession {
   lineItems?: IPrimerLineItem[];
   orderDetails?: IPrimerOrder;
   customer?: IPrimerCustomer;
+  checkoutModules?: IPrimerCheckoutModule[];
+  paymentMethodOptions?: Record<string, IPrimerClientSessionPaymentMethodOption>;
+}
+
+export type PrimerCheckoutModule = IPrimerCheckoutModule;
+
+interface IPrimerCheckoutModule {
+  type: string;
+  options?: Record<string, boolean>;
+}
+
+export type PrimerClientSessionPaymentMethodOption = IPrimerClientSessionPaymentMethodOption;
+
+interface IPrimerClientSessionPaymentMethodOption {
+  // Top-level surcharge (e.g. PAYPAL, APPLE_PAY). Not set on PAYMENT_CARD — see `networks`.
+  surcharge?: IPrimerClientSessionSurcharge;
+  // PAYMENT_CARD only: per-card-network surcharges (VISA, MASTERCARD, …).
+  networks?: Record<string, IPrimerClientSessionPaymentMethodNetwork>;
+}
+
+export type PrimerClientSessionPaymentMethodNetwork = IPrimerClientSessionPaymentMethodNetwork;
+
+interface IPrimerClientSessionPaymentMethodNetwork {
+  surcharge?: IPrimerClientSessionSurcharge;
+}
+
+export type PrimerClientSessionSurcharge = IPrimerClientSessionSurcharge;
+
+interface IPrimerClientSessionSurcharge {
+  amount?: number;
 }
 
 export type PrimerLineItem = IPrimerLineItem;

package/src/models/PrimerHeadlessUniversalCheckoutPaymentMethod.ts

@@ -1,5 +1,8 @@
+export type PrimerPaymentMethodManagerCategoryName = 'NATIVE_UI' | 'RAW_DATA' | 'CARD_COMPONENTS';
+export type PrimerSessionIntentName = 'CHECKOUT' | 'VAULT';
+
 export interface IPrimerHeadlessUniversalCheckoutPaymentMethod {
   paymentMethodType: string;
-  paymentMethodManagerCategories: ('NATIVE_UI' | 'RAW_DATA' | 'CARD_COMPONENTS')[];
-  supportedPrimerSessionIntents: ('CHECKOUT' | 'VAULT')[];
+  paymentMethodManagerCategories: PrimerPaymentMethodManagerCategoryName[];
+  supportedPrimerSessionIntents: PrimerSessionIntentName[];
 }

package/src/models/PrimerRawData.ts

@@ -5,6 +5,7 @@ export interface PrimerCardData extends PrimerRawData {
   expiryDate: string;
   cvv: string;
   cardholderName?: string;
+  cardNetwork?: string;
 }
 
 export interface PrimerPhoneNumberData extends PrimerRawData {

package/src/models/PrimerSettings.ts

@@ -3,6 +3,7 @@ import type { PrimerCheckoutAdditionalInfo } from './PrimerCheckoutAdditionalInf
 import type { PrimerCheckoutPaymentMethodData } from './PrimerCheckoutPaymentMethodData';
 import type { PrimerClientSession } from './PrimerClientSession';
 import type { PrimerPaymentMethodTokenData } from './PrimerPaymentMethodTokenData';
+import type { IPrimerHeadlessUniversalCheckoutPaymentMethod } from './PrimerHeadlessUniversalCheckoutPaymentMethod';
 import type { PrimerError } from './PrimerError';
 import type { IPrimerTheme } from './PrimerTheme';
 import type {
@@ -47,7 +48,7 @@ interface IPrimerSettings {
   onDismiss?: () => void;
 
   headlessUniversalCheckoutCallbacks?: {
-    onAvailablePaymentMethodsLoad?: (availablePaymentMethods: any[]) => void;
+    onAvailablePaymentMethodsLoad?: (availablePaymentMethods: IPrimerHeadlessUniversalCheckoutPaymentMethod[]) => void;
     onTokenizationStart?: (paymentMethodType: string) => void;
     onTokenizationSuccess?: (
       paymentMethodTokenData: PrimerPaymentMethodTokenData,

package/src/specs/NativePrimer.ts

@@ -31,6 +31,12 @@ export interface Spec extends TurboModule {
 
   setImplementedRNCallbacks(implementedRNCallbacks: string): Promise<void>;
 
+  // Analytics bridge
+  setupAnalyticsLoggingBridge(clientToken: string): Promise<void>;
+  trackAnalyticsEvent(eventName: string, metadata?: string): Promise<void>;
+  sendLog(message: string, event: string, initDurationMs?: number): Promise<void>;
+  sendErrorLog(message: string, event?: string, errorMessage?: string, stack?: string): Promise<void>;
+
   // Backward compat
   addListener(eventName?: string): void;
   removeListeners(count?: number): void;

package/src/specs/NativePrimerViewUtils.ts

@@ -0,0 +1,8 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  getBottomSafeAreaInset(): Promise<number>;
+}
+
+export default TurboModuleRegistry.get<Spec>('PrimerViewUtils');

package/src/utils/debounce.ts

@@ -0,0 +1,33 @@
+export type DebouncedFunction<T extends (...args: any[]) => any> = ((...args: Parameters<T>) => void) & {
+  cancel: () => void;
+  flush: () => void;
+};
+
+export function debounce<T extends (...args: any[]) => any>(fn: T, delay: number): DebouncedFunction<T> {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let lastArgs: Parameters<T> | null = null;
+  const debounced = (...args: Parameters<T>) => {
+    lastArgs = args;
+    if (timer != null) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      fn(...args);
+    }, delay);
+  };
+  debounced.cancel = () => {
+    if (timer != null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  debounced.flush = () => {
+    if (timer != null) {
+      clearTimeout(timer);
+      timer = null;
+      fn(...lastArgs!);
+    }
+  };
+  return debounced;
+}

package/src/utils/index.ts

@@ -25,12 +25,3 @@ export function toRgbColor(hex: string): RgbaColor | null {
     alpha: 1,
   };
 }
-
-export function parseCallback<T>(data: any, callback: (val: T) => void) {
-  try {
-    const error = JSON.parse(data) as T;
-    callback(error);
-  } catch (e) {
-    console.log('failed to parse json', e);
-  }
-}