@stripe/stripe-react-native 0.44.0 → 0.45.0

package/src/specs/NativeCardField.ts

@@ -0,0 +1,51 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import type {
+  DirectEventHandler,
+  Int32,
+} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import type {
+  Details,
+  Placeholders,
+  Styles,
+} from '../types/components/CardFieldInput';
+import type { UnsafeMixed } from './utils';
+
+type CardChangeEvent = Readonly<{
+  card: UnsafeMixed<Details>;
+}>;
+
+export type FocusChangeEvent = Readonly<{
+  focusedField: string;
+}>;
+
+export interface NativeProps extends ViewProps {
+  autofocus: boolean;
+  cardStyle: UnsafeMixed<Styles>;
+  countryCode?: string;
+  dangerouslyGetFullCardDetails: boolean;
+  disabled: boolean;
+  onBehalfOf?: string;
+  onCardChange?: DirectEventHandler<CardChangeEvent>;
+  onFocusChange?: DirectEventHandler<FocusChangeEvent>;
+  placeholders: UnsafeMixed<Placeholders>;
+  postalCodeEnabled: boolean;
+  preferredNetworks?: ReadonlyArray<Int32>;
+}
+
+type ComponentType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  blur: (viewRef: React.ElementRef<ComponentType>) => void;
+  focus: (viewRef: React.ElementRef<ComponentType>) => void;
+  clear: (viewRef: React.ElementRef<ComponentType>) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['blur', 'focus', 'clear'],
+});
+
+export default codegenNativeComponent<NativeProps>(
+  'CardField'
+) as ComponentType;

package/src/specs/NativeCardForm.ts

@@ -0,0 +1,43 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import type {
+  DirectEventHandler,
+  Int32,
+} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import type { CardFormView } from '../types';
+import type { UnsafeMixed } from './utils';
+
+interface FormCompleteEvent {
+  card: UnsafeMixed<CardFormView.Details>;
+}
+
+export interface FocusChangeEvent {
+  focusedField: 'CardNumber' | 'Cvc' | 'ExpiryDate' | 'PostalCode' | null;
+}
+
+export interface NativeProps extends ViewProps {
+  autofocus: boolean;
+  cardStyle: UnsafeMixed<CardFormView.Styles>;
+  dangerouslyGetFullCardDetails: boolean;
+  defaultValues: UnsafeMixed<CardFormView.DefaultValues>;
+  disabled: boolean;
+  onFocusChange?: DirectEventHandler<FocusChangeEvent>;
+  onFormComplete?: DirectEventHandler<FormCompleteEvent>;
+  placeholders: UnsafeMixed<CardFormView.Placeholders>;
+  postalCodeEnabled: boolean;
+  preferredNetworks?: Int32[];
+}
+
+type ComponentType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  blur: (viewRef: React.ElementRef<ComponentType>) => void;
+  focus: (viewRef: React.ElementRef<ComponentType>) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['blur', 'focus'],
+});
+
+export default codegenNativeComponent<NativeProps>('CardForm') as ComponentType;

package/src/specs/NativeEmbeddedPaymentElement.ts

@@ -0,0 +1,37 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import type {
+  DirectEventHandler,
+  Double,
+} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import { EmbeddedPaymentElementConfiguration } from '../types/EmbeddedPaymentElement';
+import { IntentConfiguration } from '../types/PaymentSheet';
+import type { UnsafeMixed } from './utils';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+
+type OnEmbeddedPaymentElementDidUpdateHeightEvent = Readonly<{
+  height: Double;
+}>;
+
+export interface NativeProps extends ViewProps {
+  configuration: UnsafeMixed<EmbeddedPaymentElementConfiguration>;
+  intentConfiguration: UnsafeMixed<IntentConfiguration>;
+  onEmbeddedPaymentElementDidUpdateHeight?: DirectEventHandler<OnEmbeddedPaymentElementDidUpdateHeightEvent>;
+}
+
+export interface NativeCommands {
+  confirm: (viewRef: React.ElementRef<HostComponent<NativeProps>>) => void;
+  clearPaymentOption: (
+    viewRef: React.ElementRef<HostComponent<NativeProps>>
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['confirm', 'clearPaymentOption'],
+});
+
+type ComponentType = HostComponent<NativeProps>;
+
+export default codegenNativeComponent<NativeProps>(
+  'EmbeddedPaymentElementView'
+) as ComponentType;

package/src/specs/NativeGooglePayButton.ts

@@ -0,0 +1,20 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import type {
+  WithDefault,
+  Int32,
+} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+
+export interface NativeProps extends ViewProps {
+  // Make sure to use a different default value here to make
+  // sure onAfterUpdateTransaction gets called on Android.
+  type?: WithDefault<Int32, -1>;
+  appearance: Int32;
+  borderRadius?: Int32;
+}
+
+type ComponentType = HostComponent<NativeProps>;
+
+export default codegenNativeComponent<NativeProps>(
+  'GooglePayButton'
+) as ComponentType;

package/src/specs/NativeStripeContainer.ts

@@ -0,0 +1,12 @@
+import type { HostComponent, ViewProps } from 'react-native';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+
+export interface NativeProps extends ViewProps {
+  keyboardShouldPersistTaps: boolean;
+}
+
+type ComponentType = HostComponent<NativeProps>;
+
+export default codegenNativeComponent<NativeProps>(
+  'StripeContainer'
+) as ComponentType;

package/src/specs/NativeStripeSdkModule.ts

@@ -0,0 +1,219 @@
+import { TurboModuleRegistry } from 'react-native';
+import type { TurboModule } from 'react-native/Libraries/TurboModule/RCTExport';
+import type {
+  EventEmitter,
+  Int32,
+} from 'react-native/Libraries/Types/CodegenTypes';
+import type {
+  CanAddCardToWalletParams,
+  CanAddCardToWalletResult,
+  ConfirmPaymentResult,
+  ConfirmPaymentSheetPaymentResult,
+  ConfirmSetupIntentResult,
+  CreatePaymentMethodResult,
+  CreateTokenForCVCUpdateResult,
+  CreateTokenResult,
+  CustomerAdapter,
+  CustomerSheetError,
+  CustomerSheetInitParams,
+  CustomerSheetPresentParams,
+  CustomerSheetResult,
+  FinancialConnections,
+  HandleNextActionForSetupResult,
+  HandleNextActionResult,
+  InitialiseParams,
+  InitPaymentSheetResult,
+  IsCardInWalletResult,
+  OpenApplePaySetupResult,
+  PaymentIntent,
+  PaymentMethod,
+  PaymentSheet,
+  PlatformPay,
+  PresentPaymentSheetResult,
+  RetrievePaymentIntentResult,
+  RetrieveSetupIntentResult,
+  SetupIntent,
+  StripeError,
+  Token,
+  VerifyMicrodepositsParams,
+} from '../types';
+import type {
+  EmbeddedPaymentElementConfiguration,
+  EmbeddedPaymentElementResult,
+} from '../types/EmbeddedPaymentElement';
+import type { FinancialConnectionsEvent } from '../types/FinancialConnections';
+import type { IntentConfiguration } from '../types/PaymentSheet';
+import type { UnsafeObject } from './utils';
+
+type CustomerSheetInitResult = UnsafeObject<{
+  error?: StripeError<CustomerSheetError>;
+}>;
+
+export interface Spec extends TurboModule {
+  initialise(params: UnsafeObject<InitialiseParams>): Promise<void>;
+  createPaymentMethod(
+    params: UnsafeObject<PaymentMethod.CreateParams>,
+    options: UnsafeObject<PaymentMethod.CreateOptions>
+  ): Promise<CreatePaymentMethodResult>;
+  handleNextAction(
+    paymentIntentClientSecret: string,
+    returnURL?: string | null
+  ): Promise<HandleNextActionResult>;
+  handleNextActionForSetup(
+    setupIntentClientSecret: string,
+    returnURL?: string | null
+  ): Promise<HandleNextActionForSetupResult>;
+  confirmPayment(
+    paymentIntentClientSecret: string,
+    params?: UnsafeObject<PaymentIntent.ConfirmParams>,
+    options?: UnsafeObject<PaymentIntent.ConfirmOptions>
+  ): Promise<ConfirmPaymentResult>;
+  confirmSetupIntent(
+    paymentIntentClientSecret: string,
+    params: UnsafeObject<SetupIntent.ConfirmParams>,
+    options: UnsafeObject<SetupIntent.ConfirmOptions>
+  ): Promise<ConfirmSetupIntentResult>;
+  retrievePaymentIntent(
+    clientSecret: string
+  ): Promise<RetrievePaymentIntentResult>;
+  retrieveSetupIntent(clientSecret: string): Promise<RetrieveSetupIntentResult>;
+  initPaymentSheet(
+    params: UnsafeObject<PaymentSheet.SetupParams>
+  ): Promise<InitPaymentSheetResult>;
+  intentCreationCallback(
+    result: UnsafeObject<PaymentSheet.IntentCreationCallbackParams>
+  ): Promise<void>;
+  presentPaymentSheet(
+    options: UnsafeObject<PaymentSheet.PresentOptions>
+  ): Promise<PresentPaymentSheetResult>;
+  confirmPaymentSheetPayment(): Promise<ConfirmPaymentSheetPaymentResult>;
+  createTokenForCVCUpdate(cvc: string): Promise<CreateTokenForCVCUpdateResult>;
+  handleURLCallback(url: string): Promise<boolean>;
+  createToken(
+    params: UnsafeObject<Token.CreateParams>
+  ): Promise<CreateTokenResult>;
+  openApplePaySetup(): Promise<OpenApplePaySetupResult>;
+  verifyMicrodeposits(
+    isPaymentIntent: boolean,
+    clientSecret: string,
+    params: UnsafeObject<VerifyMicrodepositsParams>
+  ): Promise<ConfirmSetupIntentResult | ConfirmPaymentResult>;
+  collectBankAccount(
+    isPaymentIntent: boolean,
+    clientSecret: string,
+    params: UnsafeObject<
+      Omit<PaymentMethod.CollectBankAccountParams, 'onEvent'>
+    >
+  ): Promise<ConfirmSetupIntentResult | ConfirmPaymentResult>;
+  getConstants(): { API_VERSIONS: { CORE: string; ISSUING: string } };
+  canAddCardToWallet(
+    params: UnsafeObject<CanAddCardToWalletParams>
+  ): Promise<CanAddCardToWalletResult>;
+  isCardInWallet(
+    params: UnsafeObject<{ cardLastFour: string }>
+  ): Promise<IsCardInWalletResult>;
+  collectBankAccountToken(
+    clientSecret: string,
+    params: UnsafeObject<PaymentMethod.CollectBankAccountTokenParams>
+  ): Promise<FinancialConnections.TokenResult>;
+  collectFinancialConnectionsAccounts(
+    clientSecret: string,
+    params: UnsafeObject<FinancialConnections.CollectFinancialConnectionsAccountsParams>
+  ): Promise<FinancialConnections.SessionResult>;
+  resetPaymentSheetCustomer(): Promise<null>;
+  isPlatformPaySupported(
+    params: UnsafeObject<{ googlePay?: PlatformPay.IsGooglePaySupportedParams }>
+  ): Promise<boolean>;
+  createPlatformPayPaymentMethod(
+    params: UnsafeObject<PlatformPay.PaymentMethodParams>,
+    usesDeprecatedTokenFlow: boolean
+  ): Promise<PlatformPay.PaymentMethodResult | PlatformPay.TokenResult>;
+  dismissPlatformPay(): Promise<boolean>;
+  updatePlatformPaySheet(
+    summaryItems: ReadonlyArray<UnsafeObject<PlatformPay.CartSummaryItem>>,
+    shippingMethods: ReadonlyArray<UnsafeObject<PlatformPay.ShippingMethod>>,
+    errors: ReadonlyArray<PlatformPay.ApplePaySheetError>
+  ): Promise<void>;
+  confirmPlatformPay(
+    clientSecret: string,
+    params: UnsafeObject<PlatformPay.ConfirmParams>,
+    isPaymentIntent: boolean
+  ): Promise<
+    PlatformPay.ConfirmPaymentResult | PlatformPay.ConfirmSetupIntentResult
+  >;
+  configureOrderTracking(
+    orderTypeIdentifier: string,
+    orderIdentifier: string,
+    webServiceUrl: string,
+    authenticationToken: string
+  ): Promise<void>;
+  initCustomerSheet(
+    params: UnsafeObject<CustomerSheetInitParams>,
+    customerAdapterOverrides: UnsafeObject<{
+      [Property in keyof CustomerAdapter]: boolean;
+    }>
+  ): Promise<CustomerSheetInitResult>;
+  presentCustomerSheet(
+    params: UnsafeObject<CustomerSheetPresentParams>
+  ): Promise<CustomerSheetResult>;
+  retrieveCustomerSheetPaymentOptionSelection(): Promise<CustomerSheetResult>;
+  customerAdapterFetchPaymentMethodsCallback(
+    paymentMethods: ReadonlyArray<Object>
+  ): Promise<void>;
+  customerAdapterAttachPaymentMethodCallback(
+    paymentMethod: Object
+  ): Promise<void>;
+  customerAdapterDetachPaymentMethodCallback(
+    paymentMethod: Object
+  ): Promise<void>;
+  customerAdapterSetSelectedPaymentOptionCallback(): Promise<void>;
+  customerAdapterFetchSelectedPaymentOptionCallback(
+    paymentOption: string | null
+  ): Promise<void>;
+  customerAdapterSetupIntentClientSecretForCustomerAttachCallback(
+    clientSecret: string
+  ): Promise<void>;
+  createEmbeddedPaymentElement(
+    intentConfig: UnsafeObject<IntentConfiguration>,
+    configuration: UnsafeObject<EmbeddedPaymentElementConfiguration>
+  ): Promise<void>;
+  confirmEmbeddedPaymentElement(
+    viewTag: Int32
+  ): Promise<EmbeddedPaymentElementResult>;
+  updateEmbeddedPaymentElement(
+    intentConfig: UnsafeObject<IntentConfiguration>
+  ): Promise<void>;
+  clearEmbeddedPaymentOption(viewTag: Int32): Promise<void>;
+
+  // Events
+  onConfirmHandlerCallback: EventEmitter<{
+    paymentMethod: UnsafeObject<PaymentMethod.Result>;
+    shouldSavePaymentMethod: boolean;
+  }>;
+  onFinancialConnectionsEvent: EventEmitter<
+    UnsafeObject<FinancialConnectionsEvent>
+  >;
+  onOrderTrackingCallback: EventEmitter<void>;
+  onCustomerAdapterFetchPaymentMethodsCallback: EventEmitter<void>;
+  onCustomerAdapterAttachPaymentMethodCallback: EventEmitter<{
+    paymentMethodId: string;
+  }>;
+  onCustomerAdapterDetachPaymentMethodCallback: EventEmitter<{
+    paymentMethodId: string;
+  }>;
+  onCustomerAdapterSetSelectedPaymentOptionCallback: EventEmitter<{
+    paymentOption: string;
+  }>;
+  onCustomerAdapterFetchSelectedPaymentOptionCallback: EventEmitter<void>;
+  onCustomerAdapterSetupIntentClientSecretForCustomerAttachCallback: EventEmitter<void>;
+  embeddedPaymentElementDidUpdateHeight: EventEmitter<UnsafeObject<any>>;
+  embeddedPaymentElementWillPresent: EventEmitter<void>;
+  embeddedPaymentElementDidUpdatePaymentOption: EventEmitter<UnsafeObject<any>>;
+  embeddedPaymentElementFormSheetConfirmComplete: EventEmitter<
+    UnsafeObject<any>
+  >;
+  embeddedPaymentElementRowSelectionImmediateAction: EventEmitter<void>;
+  embeddedPaymentElementLoadingFailed: EventEmitter<UnsafeObject<any>>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('StripeSdk');

package/src/specs/utils.ts

@@ -0,0 +1,22 @@
+import type { ImageSourcePropType } from 'react-native';
+
+/**
+ * Allows using types that codegen doesn't support, which will be generated
+ * as mixed, but keeping the TS type for type-checking.
+ *
+ * Note that for some reason this only works for native components, not for turbo modules.
+ */
+export type UnsafeMixed<T> = T;
+
+/**
+ * Allows using types that codegen doesn't support, which will be generated
+ * as object, but keeping the TS type for type-checking.
+ *
+ * Note that for some reason this only works for turbo modules, not for native components.
+ */
+export type UnsafeObject<T> = T;
+
+/**
+ * Codegen checks for a type named image source, but rn typescript exports it as ImageSourcePropType.
+ */
+export type ImageSource = ImageSourcePropType;

package/src/types/CustomerSheet.ts

@@ -47,10 +47,6 @@ export type CustomerSheetInitParams = {
    *  If false, the customer can't delete if they only have one saved payment method remaining.
    */
   allowsRemovalOfLastSavedPaymentMethod?: boolean;
-  /** (Private Preview) This parameter is expected to be removed once we GA this feature
-   * When using customerSessions, allow users to update their saved cards
-   */
-  updatePaymentMethodEnabled?: boolean;
   /**
    * By default, CustomerSheet will accept all supported cards by Stripe.
    * You can specify card brands CustomerSheet should block or allow payment for by providing an array of those card brands.
@@ -127,7 +123,7 @@ export interface CustomerAdapter {
   /** Creates a SetupIntent configured to attach a new payment method to a customer,
    * then returns the client secret for the created SetupIntent.
    */
-  setupIntentClientSecretForCustomerAttach?(): Promise<String>;
+  setupIntentClientSecretForCustomerAttach?(): Promise<string>;
 }
 
 export type CustomerPaymentOption =