@connexup/react-native-square-mobile-payment-sdk 0.1.0

package/src/payment/index.ts

@@ -0,0 +1,161 @@
+import type {
+  CardInputMethod,
+  MobilePaymentPayment,
+  PaymentFlowListener,
+  PaymentFlowStatusChangedEvent,
+  PaymentHandle,
+  PaymentParameters,
+  PaymentSource,
+  PromptParameters,
+  Spec,
+} from './NativeMobilePaymentPayment';
+import {
+  createMobilePaymentError,
+  createMobilePaymentErrorFromCallback,
+} from '../util';
+import { NativeMobilePaymentPayment } from './NativeMobilePaymentPayment';
+import type { EventSubscription } from 'react-native';
+
+class MobilePaymentPaymentImpl implements MobilePaymentPayment {
+  private readonly paymentManage: Spec;
+  private paymentFlowSubscription?: EventSubscription | null;
+
+  constructor(paymentManage: Spec) {
+    this.paymentManage = paymentManage;
+  }
+
+  async startPayment(
+    paymentParameters: PaymentParameters,
+    promptParameters: PromptParameters,
+    callback?: PaymentFlowListener
+  ): Promise<PaymentHandle> {
+    this.paymentFlowSubscription?.remove();
+    this.paymentFlowSubscription = null;
+    const listener = (event: PaymentFlowStatusChangedEvent) => {
+      switch (event.name) {
+        case 'didStart':
+          if (callback?.didStart) {
+            callback.didStart(event?.payment ?? null);
+          }
+          break;
+        case 'didFinish':
+          if (callback?.didFinish) {
+            callback.didFinish(event.payment!);
+          }
+          // this.paymentFlowSubscription?.remove();
+          break;
+        case 'didFail':
+          if (callback?.didFail) {
+            callback.didFail(
+              event?.payment ?? null,
+              createMobilePaymentErrorFromCallback(event.error)
+            );
+          }
+          // this.paymentFlowSubscription?.remove();
+          break;
+        case 'didCancel':
+          if (callback?.didCancel) {
+            callback.didCancel(event?.payment ?? null);
+          }
+          // this.paymentFlowSubscription?.remove();
+          break;
+        case 'willFinish':
+          if (callback?.willFinish) {
+            callback.willFinish(event?.payment ?? null);
+          }
+          break;
+        case 'willCancel':
+          if (callback?.willCancel) {
+            callback.willCancel(event?.payment ?? null);
+          }
+          break;
+      }
+    };
+    this.paymentFlowSubscription = this.paymentManage.onPaymentFlowStatusChange(
+      (event) => {
+        listener(event);
+      }
+    );
+    try {
+      await this.paymentManage.startPayment(
+        paymentParameters,
+        promptParameters
+      );
+      return new PaymentHandleImpl(this.paymentManage);
+    } catch (e) {
+      this.paymentFlowSubscription?.remove();
+      this.paymentFlowSubscription = null;
+      throw createMobilePaymentError(e);
+    }
+  }
+
+  availableCardInputMethods(): CardInputMethod[] {
+    try {
+      return this.paymentManage.availableCardInputMethods();
+    } catch (e) {
+      throw createMobilePaymentError(e);
+    }
+  }
+
+  addAvailableCardInputMethodsChangeListener(
+    listener: (methods: CardInputMethod[]) => void
+  ): EventSubscription {
+    return this.paymentManage.onAvailableCardInputMethodsChange(listener);
+  }
+}
+
+class PaymentHandleImpl implements PaymentHandle {
+  private readonly paymentManage: Spec;
+
+  constructor(paymentManage: Spec) {
+    this.paymentManage = paymentManage;
+  }
+
+  additionalPaymentMethods(): ReturnType<Spec['additionalPaymentMethods']> {
+    try {
+      return this.paymentManage.additionalPaymentMethods();
+    } catch (e) {
+      throw createMobilePaymentError(e);
+    }
+  }
+
+  async cancelPayment(): ReturnType<Spec['cancelCurrentPayment']> {
+    try {
+      return await this.paymentManage.cancelCurrentPayment();
+    } catch (e) {
+      throw createMobilePaymentError(e);
+    }
+  }
+
+  isPaymentCancelable(): ReturnType<Spec['isCurrentPaymentCancelable']> {
+    try {
+      return this.paymentManage.isCurrentPaymentCancelable();
+    } catch (e) {
+      throw createMobilePaymentError(e);
+    }
+  }
+
+  payment(): ReturnType<Spec['currentPayment']> {
+    try {
+      return this.paymentManage.currentPayment();
+    } catch (e) {
+      throw createMobilePaymentError(e);
+    }
+  }
+
+  async triggerPaymentWithPaymentSource(
+    paymentSource: PaymentSource
+  ): ReturnType<Spec['triggerPaymentWithAdditionalPaymentMethod']> {
+    try {
+      return await this.paymentManage.triggerPaymentWithAdditionalPaymentMethod(
+        paymentSource
+      );
+    } catch (e) {
+      throw createMobilePaymentError(e);
+    }
+  }
+}
+
+export const mobilePaymentPayment = new MobilePaymentPaymentImpl(
+  NativeMobilePaymentPayment
+);

package/src/reader/NativeMobilePaymentReader.ts

@@ -0,0 +1,463 @@
+import {
+  type CodegenTypes,
+  type TurboModule,
+  TurboModuleRegistry,
+} from 'react-native';
+
+export interface Spec extends TurboModule {
+  isPairingInProgress(): boolean;
+
+  readers(): ReaderInfo[];
+
+  bink(readerId: string): Promise<void>;
+
+  forget(readerId: string): Promise<void>;
+
+  retryConnection(readerId: string): Promise<void>; //only ios
+
+  startPairing(): Promise<void>;
+
+  stopPairing(): Promise<boolean>;
+
+  readonly onReaderChange: CodegenTypes.EventEmitter<ReaderChangeEvent>;
+
+  readonly onReaderPairingStatus: CodegenTypes.EventEmitter<PairingStatusChangeEvent>;
+}
+
+export const NativeMobilePaymentReader = TurboModuleRegistry.getEnforcing<Spec>(
+  'NativeMobilePaymentReader'
+);
+
+export interface ReaderListener {
+  /**
+   * Indicates a reader was added and made available for use.
+   */
+  readerWasAdded?: (reader: ReaderInfo) => void;
+  /**
+   * Indicates a reader was removed and can no longer be used
+   */
+  readerWasRemoved?: (reader: ReaderInfo) => void;
+  /**
+   * Indicates a property of the reader has been updated.
+   */
+  readerDidChange?: (reader: ReaderInfo, change: ReaderChange) => void;
+}
+
+export interface ReaderChangeEvent {
+  name: 'readerWasAdded' | 'readerWasRemoved' | 'readerDidChange';
+  readerInfo: ReaderInfo;
+  readerChange?: ReaderChange;
+}
+
+export interface PairingStatusListener {
+  /**
+   * Indicates that reader pairing started.
+   */
+  didBegin?: () => void;
+  /**
+   * Indicates that reader pairing was successful.
+   */
+  didSucceed?: () => void;
+
+  /**
+   * Indicates that reader pairing failed.
+   */
+  didFail?: (error: any) => void;
+}
+
+export interface PairingStatusChangeEvent {
+  name: 'didBegin' | 'didSucceed' | 'didFail';
+  error?: string;
+}
+
+export interface ReaderInfo {
+  /**
+   * Unique ID for this reader.
+   * iOS:NSUInteger
+   */
+  id: string;
+  /**
+   * Human readable name for this reader.
+   */
+  name: string;
+  /**
+   * Serial number of this reader.
+   */
+  serialNumber?: string;
+  /**
+   *  Model of this reader.
+   */
+  model: ReaderModel;
+  /**
+   * Set of card input methods this reader can support.
+   */
+  supportedInputMethods: CardInputMethod[];
+  /**
+   * Provides additional context about the connection status of the reader.
+   */
+  connectionInfo: ConnectionInfo;
+  /**
+   * Current status of the firmware info.
+   */
+  firmwareInfo?: FirmwareInfo;
+  /**
+   * The current state of the reader.
+   */
+  state: ReaderState;
+
+  status: ReaderStatusInfo;
+
+  connectionType?: ConnectionType;
+
+  /**
+   * Current status of the reader battery.
+   */
+  batteryStatus?: BatteryStatus;
+  /**
+   * True if the reader has lights and supports blinking.
+   */
+  isBlinkable: boolean;
+  /**
+   * True if the a reader’s bluetooth connection can be forgotten.
+   */
+  isForgettable: boolean;
+  /**
+   * True if the a reader’s session can be retried
+   */
+  isConnectionRetryable?: boolean; //only ios
+  /**
+   * Indicates if the reader has a card inserted.
+   */
+  cardInsertionStatus?: CardInsertionStatus; //only ios
+}
+
+export type CardInputMethod = 'SWIPE' | 'CHIP' | 'CONTACTLESS';
+
+export type ReaderModel =
+  | 'MAGSTRIPE'
+  | 'CONTACTLESS_AND_CHIP'
+  | 'STAND' //only ios
+  | 'TAP_TO_PAY'
+  | 'UNKNOWN';
+
+/**
+ * CONNECTION_DID_FAIL
+ * Indicates the connection to the device has failed and .state.failureInfo may have more information
+ */
+export type ReaderChange =
+  | 'STATE_DID_CHANGE'
+  | 'BATTERY_LEVEL_DID_CHANGE'
+  | 'BATTERY_DID_BEGIN_CHARGING'
+  | 'BATTERY_DID_END_CHARGING'
+  | 'FIRMWARE_UPDATE_PERCENT_DID_CHANGE'
+  | 'CONNECTION_STATE_DID_CHANGE'
+  | 'CONNECTION_DID_FAIL'
+  | 'FIRMWARE_UPDATE_DID_FAIL' //only ios
+  | 'CARD_INSERTED' //only ios
+  | 'CARD_REMOVED' //only ios
+  | 'UNKNOWN';
+
+export type ConnectionType = 'USB' | 'BLUETOOTH' | 'AUDIO' | 'EMBEDDED';
+
+export interface ConnectionInfo {
+  /**
+   * Indicates the current state of the connection of a reader.
+   */
+  state: ReaderConnectionStatus;
+  /**
+   * Returns information if the connection failed to connect.
+   */
+  failureInfo?: ReaderConnectionFailureInfo;
+}
+
+export interface ReaderStatusInfo {
+  status: ReaderStatus;
+  title?: string;
+  description?: string;
+  unavailableReason?: ReaderUnavailableReason;
+}
+
+export type ReaderStatus =
+  | 'CONNECTING_TO_DEVICE'
+  | 'CONNECTING_TO_SQUARE'
+  | 'FAULTY'
+  | 'READER_UNAVAILABLE'
+  | 'READY'
+  | 'UNKNOWN';
+
+export type ReaderConnectionStatus =
+  | 'NOT_CONNECTED'
+  | 'CONNECTING'
+  | 'CONNECTED'
+  | 'FAILED_TO_CONNECT'
+  | 'UNKNOWN';
+
+export interface ReaderConnectionFailureInfo {
+  /**
+   * Specific failure reason.
+   */
+  failureReason?: ReaderConnectionFailureReason; //only ios
+  /**
+   * Hint on recovery options while in this failed state.
+   */
+  recoverySuggestion: ReaderConnectionFailureRecoverySuggestion;
+  /**
+   * Localized title for this error suitable to display to a user.
+   */
+  localizedTitle: string;
+  /**
+   * Localized description for this error suitable to display to a user.
+   */
+  localizedDescription: string;
+}
+
+export type ReaderConnectionFailureReason =
+  | 'GENERIC_ERROR'
+  | 'NETWORK_TRANSPORT_ERROR'
+  | 'READER_TIMEOUT'
+  | 'NETWORK_TIMEOUT'
+  | 'SERVER_ERROR'
+  | 'MAX_READERS_CONNECTED'
+  | 'DENIED_BY_SERVER'
+  | 'REVOKED_BY_DEVICE'
+  | 'NOT_CONNECTED_TO_INTERNET'
+  | 'TAP_TO_PAY_ERROR'
+  | 'UNKNOWN';
+
+/**
+ * NO_SUGGESTION.
+ * The .localizedTitle and .localizedDescription fields may provide more information on how to recover.
+ *
+ * RETRY
+ * The connection issue may be transient and we suggest retrying.
+ *
+ * ACTIVATE_ACCOUNT
+ * Reader failed to connect because the user’s account requires activation to process cards.
+ *
+ * CONTACT_SUPPORT
+ * There is a specific issue around your account, reader, or device that may require you to contact Square support.
+ *
+ * REVIEW_TAP_TO_PAY_GUIDELINES
+ * Refer to the Apple Tap to Pay documentation for guidance on resolving this error.
+ *
+ * ENABLE_PASSCODE_TO_USE_TAP_TO_PAY
+ * This error appears when a passcode is not enabled on the device. Set an iPhone passcode to use Tap to Pay on iPhone.
+ */
+export type ReaderConnectionFailureRecoverySuggestion =
+  | 'NO_SUGGESTION'
+  | 'RETRY'
+  | 'ACTIVATE_ACCOUNT'
+  | 'CONTACT_SUPPORT'
+  | 'COUNT' //only android
+  | 'REVIEW_TAP_TO_PAY_GUIDELINES' //only ios
+  | 'ENABLE_PASSCODE_TO_USE_TAP_TO_PAY' // only ios
+  | 'UNKNOWN';
+
+export type ReaderUnavailableReason =
+  | 'INTERNAL_ERROR'
+  | 'BLUETOOTH_DISABLED'
+  | 'BLUETOOTH_FAILURE'
+  | 'SECURE_CONNECTION_TO_SQUARE_FAILURE'
+  | 'SECURE_CONNECTION_NETWORK_FAILURE'
+  | 'OFFLINE_SESSION_EXPIRED'
+  | 'READER_UNAVAILABLE_OFFLINE'
+  | 'OFFLINE_MODE_DISABLED'
+  | 'READER_UPDATE_FAILED'
+  | 'BLOCKING_UPDATE'
+  | 'MERCHANT_SUSPENDED'
+  | 'MERCHANT_INELIGIBLE'
+  | 'MERCHANT_NOT_ACTIVATED'
+  | 'DEVICE_NOT_SUPPORTED'
+  | 'READER_FIRMWARE_UPDATE_REQUIRED'
+  | 'READER_NOT_SUPPORTED'
+  | 'DEVICE_ROOTED'
+  | 'DEVICE_DEVELOPER_MODE'
+  | 'DISABLED'
+  | 'NOT_CONNECTED_TO_INTERNET'
+  | 'REVOKED_BY_DEVICE'
+  | 'MAX_READERS_CONNECTED'
+  | 'READER_TIMEOUT'
+  | 'TAP_TO_PAY_IS_NOT_LINKED'
+  | 'TAP_TO_PAY_ERROR'
+  | 'UNKNOWN';
+
+export interface FirmwareInfo {
+  /**
+   * Indicates the version of the firmware installed on reader
+   */
+  version: string;
+  /**
+   * The firmware update percentage of the reader (from 0 to 100)
+   */
+  updatePercentage?: number;
+  /**
+   * Indicates the failure reason in case the firmware upgrade failed
+   */
+  failureReason?: string; //only ios
+}
+
+/**
+ * DISCONNECTED
+ * The reader is unavailable, but known.
+ * If a reader is not connected to a power supply,
+ * the reader may fall asleep and needs to be woken up by pressing the power button.
+ *
+ * CONNECTING
+ * The reader is actively being connected
+ *
+ * READY
+ * The reader is connected and ready to be used.
+ *
+ * UPDATING_FIRMWARE
+ * The reader is being updated and cannot be used.
+ *
+ * FAILED_TO_CONNECT
+ * Connection to the reader failed; forget it and try again. .connectionState may contain more details.
+ *
+ * DISABLED
+ * This reader is unusable; contact support.
+ */
+export type ReaderState =
+  | 'DISCONNECTED'
+  | 'CONNECTING'
+  | 'READY'
+  | 'UPDATING_FIRMWARE'
+  | 'FAILED_TO_CONNECT'
+  | 'DISABLED'
+  | 'UNKNOWN';
+
+export interface BatteryStatus {
+  /**
+   * A coarse representation of the reader’s battery level
+   */
+  level?: BatteryLevel; // only ios
+  /**
+   * The battery percentage of the reader (from 0 to 100)
+   */
+  percentage: number;
+  /**
+   * Indicates whether or not the battery is charging
+   */
+  isCharging: boolean;
+}
+
+/**
+ * CRITICALLY_LOW
+ * Battery is extremely low. Plug in device immediately.
+ */
+export type BatteryLevel =
+  | 'CRITICALLY_LOW'
+  | 'LOW'
+  | 'MID'
+  | 'HIGH'
+  | 'FULL'
+  | 'UNKNOWN';
+
+/**
+ * UNKNOWN
+ * Indicates card insertion status is unknown (Default for magstripe readers).
+ */
+export type CardInsertionStatus = 'INSERTED' | 'NOT_INSERTED' | 'UNKNOWN';
+
+export const PairingErrorAlreadyInProgress =
+  'PAIRING_ERROR_ALREADY_IN_PROGRESS';
+/**
+ * Reader SDK is not currently authorized with a Square Seller account.
+ */
+export const PairingErrorNotAuthorized = 'PAIRING_ERROR_NOT_AUTHORIZED';
+/**
+ * Reader Pairing not supported in sandbox environment
+ */
+export const PairingErrorNotSupported = 'PAIRING_ERROR_NOT_SUPPORTED';
+export const PairingErrorSandboxNotSupported =
+  'PAIRING_ERROR_SANDBOX_NOT_SUPPORTED';
+export const PairingErrorSimulatorNotSupported =
+  'PAIRING_ERROR_SIMULATOR_NOT_SUPPORTED';
+/**
+ * Pairing did not complete in a reasonable time.
+ */
+export const PairingErrorTimedOut = 'PAIRING_ERROR_TIMED_OUT';
+/**
+ * There is already an active pairing in progress.
+ */
+export const PairingErrorReaderAlreadyPairing =
+  'PAIRING_ERROR_READER_ALREADY_PAIRING';
+/**
+ * Reader was unable to pair.
+ */
+export const PairingErrorFailedToConnect = 'PAIRING_ERROR_FAILED_TO_CONNECT';
+/**
+ * The bluetooth connection on the device is disabled.
+ */
+export const PairingErrorBluetoothDisabled = 'PAIRING_ERROR_BLUETOOTH_DISABLED';
+/**
+ * The SDK is requiring an update to occur.
+ */
+export const PairingErrorUpdateRequired = 'PAIRING_ERROR_UPDATE_REQUIRED';
+/**
+ * Bluetooth permission has not been determined.
+ */
+export const PairingErrorBluetoothPermissionNotDetermined =
+  'PAIRING_ERROR_BLUETOOTH_PERMISSION_NOT_DETERMINED';
+/**
+ * Bluetooth permission is restricted.
+ */
+export const PairingErrorBluetoothPermissionRestricted =
+  'PAIRING_ERROR_BLUETOOTH_PERMISSION_RESTRICTED';
+/**
+ * Bluetooth permission has been denied.
+ */
+export const PairingErrorBluetoothPermissionDenied =
+  'PAIRING_ERROR_BLUETOOTH_PERMISSION_DENIED';
+/**
+ * Bluetooth permission is unknown.
+ */
+export const PairingErrorBluetoothPermissionUnknownCase =
+  'PAIRING_ERROR_BLUETOOTH_PERMISSION_UNKNOWN_CASE';
+/**
+ * Bluetooth is not supported.
+ */
+export const PairingErrorBluetoothNotSupported =
+  'PAIRING_ERROR_BLUETOOTH_NOT_SUPPORTED';
+/**
+ * Bluetooth is not ready.
+ */
+export const PairingErrorBluetoothNotReady =
+  'PAIRING_ERROR_BLUETOOTH_NOT_READY';
+/**
+ * Bluetooth is resetting.
+ */
+export const PairingErrorBluetoothResetting =
+  'PAIRING_ERROR_BLUETOOTH_RESETTING';
+/**
+ * Error displayed when pairing info is removed by the OS.
+ * To fix this force quit the app and then go to iOS bluetooth settings and forget the square reader and then re-pair the Square reader.
+ */
+export const PairingErrorBondingRemoved = 'PAIRING_ERROR_BONDING_REMOVED';
+/**
+ * Bluetooth has encountered an unknown error.
+ */
+export const PairingErrorBluetoothUnknownError =
+  'PAIRING_ERROR_BLUETOOTH_UNKNOWN_ERROR';
+
+/**
+ * App version is incompatible with reader firmware and requires an update.
+ */
+export const PairingErrorPairingErrorAppUpdateRequired =
+  'PAIRING_ERROR_PAIRING_ERROR_APP_UPDATE_REQUIRED';
+
+/**
+ * Unable to create a Bluetooth bond with the reader device.
+ */
+export const PairingErrorBondFailed = 'PAIRING_ERROR_BOND_FAILED';
+
+/**
+ * An internal firmware error occurred on the reader device.
+ */
+export const PairingErrorInternalFirmwareError =
+  'PAIRING_ERROR_INTERNAL_FIRMWARE_ERROR';
+
+/**
+ * An unknown error occurred while attempting to pair with the reader.
+ */
+export const PairingErrorUnknownError = 'PAIRING_ERROR_UNKNOWN_ERROR';