@primer-io/react-native 2.30.0 → 2.30.2

package/src/HeadlessUniversalCheckout/Managers/PaymentMethodManagers/RawDataManager.ts

@@ -7,160 +7,176 @@ import type { PrimerInputElementType } from '../../../models/PrimerInputElementT
 const { RNTPrimerHeadlessUniversalCheckoutRawDataManager } = NativeModules;
 const eventEmitter = new NativeEventEmitter(RNTPrimerHeadlessUniversalCheckoutRawDataManager);
 
-type EventType =
-    | 'onMetadataChange'
-    | 'onValidation';
+type EventType = 'onMetadataChange' | 'onValidation';
 
-const eventTypes: EventType[] = [
-    'onMetadataChange',
-    'onValidation'
-];
+const eventTypes: EventType[] = ['onMetadataChange', 'onValidation'];
 
 export interface RawDataManagerProps {
-    paymentMethodType: string;
-    onMetadataChange?: (metadata: any) => void;
-    onValidation?: (isValid: boolean, errors: PrimerError[] | undefined) => void;
+  paymentMethodType: string;
+  onMetadataChange?: (metadata: any) => void;
+  onValidation?: (isValid: boolean, errors: PrimerError[] | undefined) => void;
 }
 
 class PrimerHeadlessUniversalCheckoutRawDataManager {
-
-    options?: RawDataManagerProps
-
-    subscriptions: EventSubscription[] = []
-
-    ///////////////////////////////////////////
-    // Init
-    ///////////////////////////////////////////
-    constructor() { }
-
-    ///////////////////////////////////////////
-    // API
-    ///////////////////////////////////////////
-
-    async configure(options: RawDataManagerProps): Promise<{ initializationData: PrimerInitializationData } | void> {
-        return new Promise(async (resolve, reject) => {
-            try {
-                this.options = options;
-                await this.configureListeners();
-                const data = await RNTPrimerHeadlessUniversalCheckoutRawDataManager.configure(options.paymentMethodType);
-                if (data) {
-                    resolve(data);
-                } else {
-                    resolve();
-                }
-            } catch (err) {
-                reject(err);
-            }
-        });
-    }
-
-    async configureListeners(): Promise<void> {
-        //@ts-ignore
+  options?: RawDataManagerProps;
+
+  subscriptions: EventSubscription[] = [];
+
+  ///////////////////////////////////////////
+  // Init
+  ///////////////////////////////////////////
+  constructor() {}
+
+  ///////////////////////////////////////////
+  // API
+  ///////////////////////////////////////////
+
+  async configure(options: RawDataManagerProps): Promise<{ initializationData: PrimerInitializationData } | void> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        this.options = options;
+        await this.configureListeners();
+        const data = await RNTPrimerHeadlessUniversalCheckoutRawDataManager.configure(options.paymentMethodType);
+        if (data) {
+          resolve(data);
+        } else {
+          resolve();
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  async configureListeners(): Promise<void> {
+    //@ts-ignore
+    if (this.options?.onMetadataChange) {
+      const sub = await this.addListener('onMetadataChange', (data) => {
         if (this.options?.onMetadataChange) {
-            const sub = await this.addListener("onMetadataChange", (data) => {
-                if (this.options?.onMetadataChange) {
-                    this.options.onMetadataChange(data);
-                }
-            });
-            this.subscriptions.push(sub);
+          this.options.onMetadataChange(data);
         }
+      });
+      this.subscriptions.push(sub);
+    }
 
+    if (this.options?.onValidation) {
+      const sub = await this.addListener('onValidation', (data) => {
         if (this.options?.onValidation) {
-            const sub = await this.addListener("onValidation", (data) => {
-                if (this.options?.onValidation) {
-                    this.options.onValidation(data.isValid, data.errors);
-                }
-            });
-            this.subscriptions.push(sub);
+          this.options.onValidation(data.isValid, data.errors);
         }
+      });
+      this.subscriptions.push(sub);
     }
-
-    async getRequiredInputElementTypes(): Promise<PrimerInputElementType[]> {
-        return new Promise(async (resolve, reject) => {
-            if (this.options?.paymentMethodType) {
-                try {
-                    const data = await RNTPrimerHeadlessUniversalCheckoutRawDataManager.listRequiredInputElementTypes();
-                    const inputElementTypes: PrimerInputElementType[] = data.inputElementTypes;
-                    resolve(inputElementTypes);
-                } catch (err) {
-                    reject(err);
-                }
-            } else {
-                const err = new PrimerError("manager-not-configured", undefined, "HeadlessUniversalCheckoutRawDataManager has not been configured", "Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.", undefined);
-                reject(err);
-            }
-        });
-    }
-
-    setRawData(rawData: RawData): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            if (this.options?.paymentMethodType) {
-                try {
-                    await RNTPrimerHeadlessUniversalCheckoutRawDataManager.setRawData(JSON.stringify(rawData));
-                    resolve();
-                } catch (err) {
-                    reject(err);
-                }
-            } else {
-                const err = new PrimerError("manager-not-configured", undefined, "HeadlessUniversalCheckoutRawDataManager has not been configured", "Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.", undefined);
-                reject(err);
-            }
-        });
-    }
-
-    submit(): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            if (this.options?.paymentMethodType) {
-                try {
-                    await RNTPrimerHeadlessUniversalCheckoutRawDataManager.submit();
-                    resolve();
-                } catch (err) {
-                    reject(err);
-                }
-            } else {
-                const err = new PrimerError("manager-not-configured", undefined, "HeadlessUniversalCheckoutRawDataManager has not been configured", "Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.", undefined);
-                reject(err);
-            }
-        });
-    }
-
-    cleanUp(): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            if (this.options?.paymentMethodType) {
-                try {
-                    await RNTPrimerHeadlessUniversalCheckoutRawDataManager.cleanUp();
-                    resolve();
-                } catch (err) {
-                    reject(err);
-                }
-            } else {
-                const err = new PrimerError("manager-not-configured", undefined, "HeadlessUniversalCheckoutRawDataManager has not been configured", "Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.", undefined);
-                reject(err);
-            }
-        });
-    }
-
-
-
-    ///////////////////////////////////////////
-    // HELPERS
-    ///////////////////////////////////////////
-
-    async addListener(eventType: EventType, listener: (...args: any[]) => any): Promise<EmitterSubscription> {
-        return eventEmitter.addListener(eventType, listener);
-    }
-
-    removeListener(subscription: EmitterSubscription): void {
-        return subscription.remove();
-    }
-
-    removeAllListenersForEvent(eventType: EventType) {
-        eventEmitter.removeAllListeners(eventType);
-    }
-
-    removeAllListeners() {
-        eventTypes.forEach((eventType) => this.removeAllListenersForEvent(eventType));
-    }
+  }
+
+  async getRequiredInputElementTypes(): Promise<PrimerInputElementType[]> {
+    return new Promise(async (resolve, reject) => {
+      if (this.options?.paymentMethodType) {
+        try {
+          const data = await RNTPrimerHeadlessUniversalCheckoutRawDataManager.listRequiredInputElementTypes();
+          const inputElementTypes: PrimerInputElementType[] = data.inputElementTypes;
+          resolve(inputElementTypes);
+        } catch (err) {
+          reject(err);
+        }
+      } else {
+        const err = new PrimerError(
+          'manager-not-configured',
+          undefined,
+          'HeadlessUniversalCheckoutRawDataManager has not been configured',
+          'Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.',
+          undefined
+        );
+        reject(err);
+      }
+    });
+  }
+
+  setRawData(rawData: RawData): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      if (this.options?.paymentMethodType) {
+        try {
+          await RNTPrimerHeadlessUniversalCheckoutRawDataManager.setRawData(JSON.stringify(rawData));
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      } else {
+        const err = new PrimerError(
+          'manager-not-configured',
+          undefined,
+          'HeadlessUniversalCheckoutRawDataManager has not been configured',
+          'Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.',
+          undefined
+        );
+        reject(err);
+      }
+    });
+  }
+
+  submit(): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      if (this.options?.paymentMethodType) {
+        try {
+          await RNTPrimerHeadlessUniversalCheckoutRawDataManager.submit();
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      } else {
+        const err = new PrimerError(
+          'manager-not-configured',
+          undefined,
+          'HeadlessUniversalCheckoutRawDataManager has not been configured',
+          'Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.',
+          undefined
+        );
+        reject(err);
+      }
+    });
+  }
+
+  cleanUp(): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      if (this.options?.paymentMethodType) {
+        try {
+          await RNTPrimerHeadlessUniversalCheckoutRawDataManager.cleanUp();
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      } else {
+        const err = new PrimerError(
+          'manager-not-configured',
+          undefined,
+          'HeadlessUniversalCheckoutRawDataManager has not been configured',
+          'Call HeadlessUniversalCheckoutRawDataManager.configure before calling this function.',
+          undefined
+        );
+        reject(err);
+      }
+    });
+  }
+
+  ///////////////////////////////////////////
+  // HELPERS
+  ///////////////////////////////////////////
+
+  async addListener(eventType: EventType, listener: (...args: any[]) => any): Promise<EmitterSubscription> {
+    return eventEmitter.addListener(eventType, listener);
+  }
+
+  removeListener(subscription: EmitterSubscription): void {
+    return subscription.remove();
+  }
+
+  removeAllListenersForEvent(eventType: EventType) {
+    eventEmitter.removeAllListeners(eventType);
+  }
+
+  removeAllListeners() {
+    eventTypes.forEach((eventType) => this.removeAllListenersForEvent(eventType));
+  }
 }
 
 export default PrimerHeadlessUniversalCheckoutRawDataManager;

package/src/HeadlessUniversalCheckout/Managers/PaymentMethodManagers/Utils/EventType.ts

@@ -1,10 +1,10 @@
 export type EventType = 'onStep' | 'onError' | 'onInvalid' | 'onValid' | 'onValidating' | 'onValidationError';
 
 export const eventTypes: EventType[] = [
-    'onStep',
-    'onError',
-    'onInvalid',
-    'onValid',
-    'onValidating',
-    'onValidationError'
-];
+  'onStep',
+  'onError',
+  'onInvalid',
+  'onValid',
+  'onValidating',
+  'onValidationError',
+];

package/src/HeadlessUniversalCheckout/Managers/VaultManager.ts

@@ -8,104 +8,113 @@ import { PrimerValidationErrorResult } from 'src/models/PrimerValidationErrorRes
 const { RNPrimerHeadlessUniversalCheckoutVaultManager } = NativeModules;
 
 class PrimerHeadlessUniversalCheckoutVaultManager {
+  ///////////////////////////////////////////
+  // Init
+  ///////////////////////////////////////////
+  constructor() {}
 
-    ///////////////////////////////////////////
-    // Init
-    ///////////////////////////////////////////
-    constructor() { }
+  ///////////////////////////////////////////
+  // Native API
+  ///////////////////////////////////////////
 
-    ///////////////////////////////////////////
-    // Native API
-    ///////////////////////////////////////////
-
-    async configure(): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            try {
-                await RNPrimerHeadlessUniversalCheckoutVaultManager.configure();
-                resolve();
-            } catch (err) {
-                console.error(err);
-                reject(err);
-            }
-        });
-    }
+  async configure(): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await RNPrimerHeadlessUniversalCheckoutVaultManager.configure();
+        resolve();
+      } catch (err) {
+        console.error(err);
+        reject(err);
+      }
+    });
+  }
 
-    async fetchVaultedPaymentMethods(): Promise<VaultedPaymentMethod[]> {
-        return new Promise(async (resolve, reject) => {
-            try {
-                const data: PrimerVaultedPaymentMethodResult =
-                    await RNPrimerHeadlessUniversalCheckoutVaultManager.fetchVaultedPaymentMethods();
-                const paymentMethods: VaultedPaymentMethod[] = data.paymentMethods;
-                const mappedPaymentMethods = sanitizePaymentMethods(paymentMethods);
-                resolve(mappedPaymentMethods);
-            } catch (err) {
-                console.error(err);
-                reject(err);
-            }
-        });
-    }
+  async fetchVaultedPaymentMethods(): Promise<VaultedPaymentMethod[]> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const data: PrimerVaultedPaymentMethodResult =
+          await RNPrimerHeadlessUniversalCheckoutVaultManager.fetchVaultedPaymentMethods();
+        const paymentMethods: VaultedPaymentMethod[] = data.paymentMethods;
+        const mappedPaymentMethods = sanitizePaymentMethods(paymentMethods);
+        resolve(mappedPaymentMethods);
+      } catch (err) {
+        console.error(err);
+        reject(err);
+      }
+    });
+  }
 
-    async deleteVaultedPaymentMethod(vaultedPaymentMethodId: string): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            try {
-                await RNPrimerHeadlessUniversalCheckoutVaultManager.deleteVaultedPaymentMethod(vaultedPaymentMethodId);
-                resolve();
-            } catch (err) {
-                console.error(err);
-                reject(err);
-            }
-        });
-    }
+  async deleteVaultedPaymentMethod(vaultedPaymentMethodId: string): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        await RNPrimerHeadlessUniversalCheckoutVaultManager.deleteVaultedPaymentMethod(vaultedPaymentMethodId);
+        resolve();
+      } catch (err) {
+        console.error(err);
+        reject(err);
+      }
+    });
+  }
 
-    async validate(vaultedPaymentMethodId: string, additionalData: VaultedPaymentMethodAdditionalData): Promise<ValidationError[]> {
-        return new Promise(async (resolve, reject) => {
-            try {
-                const data: PrimerValidationErrorResult =
-                    await RNPrimerHeadlessUniversalCheckoutVaultManager.validate(vaultedPaymentMethodId, JSON.stringify(additionalData));
-                const errors: ValidationError[] = data.validationErrors;
-                resolve(errors);
-            } catch (err) {
-                console.error(err);
-                reject(err);
-            }
-        });
-    }
+  async validate(
+    vaultedPaymentMethodId: string,
+    additionalData: VaultedPaymentMethodAdditionalData
+  ): Promise<ValidationError[]> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const data: PrimerValidationErrorResult = await RNPrimerHeadlessUniversalCheckoutVaultManager.validate(
+          vaultedPaymentMethodId,
+          JSON.stringify(additionalData)
+        );
+        const errors: ValidationError[] = data.validationErrors;
+        resolve(errors);
+      } catch (err) {
+        console.error(err);
+        reject(err);
+      }
+    });
+  }
 
-    async startPaymentFlow(vaultedPaymentMethodId: string, additionalData?: VaultedPaymentMethodAdditionalData): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            try {
-                if(additionalData) {
-                    await RNPrimerHeadlessUniversalCheckoutVaultManager.startPaymentFlowWithAdditionalData(vaultedPaymentMethodId, JSON.stringify(additionalData));
-                } else {
-                    await RNPrimerHeadlessUniversalCheckoutVaultManager.startPaymentFlow(vaultedPaymentMethodId);
-                }
-                resolve();
-            } catch (err) {
-                console.error(err);
-                reject(err);
-            }
-        });
-    }
+  async startPaymentFlow(
+    vaultedPaymentMethodId: string,
+    additionalData?: VaultedPaymentMethodAdditionalData
+  ): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (additionalData) {
+          await RNPrimerHeadlessUniversalCheckoutVaultManager.startPaymentFlowWithAdditionalData(
+            vaultedPaymentMethodId,
+            JSON.stringify(additionalData)
+          );
+        } else {
+          await RNPrimerHeadlessUniversalCheckoutVaultManager.startPaymentFlow(vaultedPaymentMethodId);
+        }
+        resolve();
+      } catch (err) {
+        console.error(err);
+        reject(err);
+      }
+    });
+  }
 }
 
 // Convert accountNumberLastFourDigits to accountNumberLast4Digits when present
 // Overcomes an iOS limitation of toJsonObject()
 function sanitizePaymentMethods(paymentMethods: VaultedPaymentMethod[]): VaultedPaymentMethod[] {
-    return paymentMethods.map(method => {
-        const unwrappedInstrumentData = method.paymentInstrumentData as any;
-        if (unwrappedInstrumentData?.accountNumberLastFourDigits !== undefined) {
-            const { accountNumberLastFourDigits, ...rest } = unwrappedInstrumentData;
-            return {
-                ...method,
-                paymentInstrumentData: {
-                    ...rest,
-                    accountNumberLast4Digits: accountNumberLastFourDigits
-                }
-            };
-        }
-        return method;
-    });
+  return paymentMethods.map((method) => {
+    const unwrappedInstrumentData = method.paymentInstrumentData as any;
+    if (unwrappedInstrumentData?.accountNumberLastFourDigits !== undefined) {
+      const { accountNumberLastFourDigits, ...rest } = unwrappedInstrumentData;
+      return {
+        ...method,
+        paymentInstrumentData: {
+          ...rest,
+          accountNumberLast4Digits: accountNumberLastFourDigits,
+        },
+      };
+    }
+    return method;
+  });
 }
 
-
 export default PrimerHeadlessUniversalCheckoutVaultManager;