@internetarchive/donation-form 0.5.17 → 0.5.18-alpha.1

package/src/braintree-manager/payment-providers/venmo.ts

@@ -1,67 +1,67 @@
-import { PromisedSingleton } from '@internetarchive/promised-singleton';
-
-import { BraintreeManagerInterface } from '../braintree-interfaces';
-import { VenmoHandlerInterface } from './venmo-interface';
-
-export class VenmoHandler implements VenmoHandlerInterface {
-  instance: PromisedSingleton<braintree.Venmo>;
-
-  constructor(options: {
-    braintreeManager: BraintreeManagerInterface;
-    venmoClient: braintree.Venmo;
-    venmoProfileId: string;
-    instancePromisedSingleton?: PromisedSingleton<braintree.Venmo>;
-  }) {
-    this.braintreeManager = options.braintreeManager;
-    this.venmoClient = options.venmoClient;
-    this.venmoProfileId = options.venmoProfileId;
-
-    this.instance =
-      options.instancePromisedSingleton ??
-      new PromisedSingleton<braintree.Venmo>({
-        generator: (): Promise<braintree.Venmo> =>
-          this.braintreeManager.instance.get().then(braintreeInstance => {
-            return this.venmoClient.create({
-              client: braintreeInstance,
-              profileId: this.venmoProfileId,
-            });
-          }),
-      });
-  }
-
-  private braintreeManager: BraintreeManagerInterface;
-
-  private venmoClient: braintree.Venmo;
-
-  private venmoProfileId: string;
-
-  async isBrowserSupported(): Promise<boolean> {
-    if (this.isMobileFirefox()) {
-      return false;
-    }
-    const instance = await this.instance.get();
-    return instance?.isBrowserSupported() ?? false;
-  }
-
-  async startPayment(): Promise<braintree.VenmoTokenizePayload> {
-    const instance = await this.instance.get();
-    return instance?.tokenize();
-  }
-
-  /**
-   * Venmo does not work in mobile Firefox, but their browser detector returns supported for it.
-   *
-   * On iOS, it opens the Venmo app, but returns you to Safari.
-   * On Android, it takes you to the "Download Venmo" page.
-   *
-   * @private
-   * @returns {boolean}
-   * @memberof VenmoHandler
-   */
-  private isMobileFirefox(): boolean {
-    const isFirefoxIos = navigator.userAgent.indexOf('FxiOS') !== -1;
-    const isFirefox = navigator.userAgent.indexOf('Firefox') !== -1;
-    const isMobile = navigator.userAgent.indexOf('Mobile') !== -1;
-    return (isFirefox || isFirefoxIos) && isMobile;
-  }
-}
+import { PromisedSingleton } from '@internetarchive/promised-singleton';
+
+import { BraintreeManagerInterface } from '../braintree-interfaces';
+import { VenmoHandlerInterface } from './venmo-interface';
+
+export class VenmoHandler implements VenmoHandlerInterface {
+  instance: PromisedSingleton<braintree.Venmo>;
+
+  constructor(options: {
+    braintreeManager: BraintreeManagerInterface;
+    venmoClient: braintree.Venmo;
+    venmoProfileId: string;
+    instancePromisedSingleton?: PromisedSingleton<braintree.Venmo>;
+  }) {
+    this.braintreeManager = options.braintreeManager;
+    this.venmoClient = options.venmoClient;
+    this.venmoProfileId = options.venmoProfileId;
+
+    this.instance =
+      options.instancePromisedSingleton ??
+      new PromisedSingleton<braintree.Venmo>({
+        generator: (): Promise<braintree.Venmo> =>
+          this.braintreeManager.instance.get().then(braintreeInstance => {
+            return this.venmoClient.create({
+              client: braintreeInstance,
+              profileId: this.venmoProfileId,
+            });
+          }),
+      });
+  }
+
+  private braintreeManager: BraintreeManagerInterface;
+
+  private venmoClient: braintree.Venmo;
+
+  private venmoProfileId: string;
+
+  async isBrowserSupported(): Promise<boolean> {
+    if (this.isMobileFirefox()) {
+      return false;
+    }
+    const instance = await this.instance.get();
+    return instance?.isBrowserSupported() ?? false;
+  }
+
+  async startPayment(): Promise<braintree.VenmoTokenizePayload> {
+    const instance = await this.instance.get();
+    return instance?.tokenize();
+  }
+
+  /**
+   * Venmo does not work in mobile Firefox, but their browser detector returns supported for it.
+   *
+   * On iOS, it opens the Venmo app, but returns you to Safari.
+   * On Android, it takes you to the "Download Venmo" page.
+   *
+   * @private
+   * @returns {boolean}
+   * @memberof VenmoHandler
+   */
+  private isMobileFirefox(): boolean {
+    const isFirefoxIos = navigator.userAgent.indexOf('FxiOS') !== -1;
+    const isFirefox = navigator.userAgent.indexOf('Firefox') !== -1;
+    const isMobile = navigator.userAgent.indexOf('Mobile') !== -1;
+    return (isFirefox || isFirefoxIos) && isMobile;
+  }
+}

package/src/braintree-manager/payment-providers-interface.ts

@@ -1,25 +1,25 @@
-import { PromisedSingleton } from '@internetarchive/promised-singleton';
-import { ApplePayHandlerInterface } from './payment-providers/apple-pay/apple-pay-interface';
-import {
-  CreditCardHandlerEvents,
-  CreditCardHandlerInterface,
-} from './payment-providers/credit-card/credit-card-interface';
-import { VenmoHandlerInterface } from './payment-providers/venmo-interface';
-import { PayPalHandlerInterface } from './payment-providers/paypal/paypal-interface';
-import { GooglePayHandlerInterface } from './payment-providers/google-pay-interface';
-import { Unsubscribe } from 'nanoevents';
-
-// this will bubble up child events
-export type PaymentProvidersEvents = CreditCardHandlerEvents;
-
-export interface PaymentProvidersInterface {
-  on<E extends keyof PaymentProvidersEvents>(
-    event: E,
-    callback: PaymentProvidersEvents[E],
-  ): Unsubscribe;
-  creditCardHandler: PromisedSingleton<CreditCardHandlerInterface>;
-  applePayHandler: PromisedSingleton<ApplePayHandlerInterface>;
-  venmoHandler: PromisedSingleton<VenmoHandlerInterface | undefined>;
-  paypalHandler: PromisedSingleton<PayPalHandlerInterface>;
-  googlePayHandler: PromisedSingleton<GooglePayHandlerInterface>;
-}
+import { PromisedSingleton } from '@internetarchive/promised-singleton';
+import { ApplePayHandlerInterface } from './payment-providers/apple-pay/apple-pay-interface';
+import {
+  CreditCardHandlerEvents,
+  CreditCardHandlerInterface,
+} from './payment-providers/credit-card/credit-card-interface';
+import { VenmoHandlerInterface } from './payment-providers/venmo-interface';
+import { PayPalHandlerInterface } from './payment-providers/paypal/paypal-interface';
+import { GooglePayHandlerInterface } from './payment-providers/google-pay-interface';
+import { Unsubscribe } from 'nanoevents';
+
+// this will bubble up child events
+export type PaymentProvidersEvents = CreditCardHandlerEvents;
+
+export interface PaymentProvidersInterface {
+  on<E extends keyof PaymentProvidersEvents>(
+    event: E,
+    callback: PaymentProvidersEvents[E],
+  ): Unsubscribe;
+  creditCardHandler: PromisedSingleton<CreditCardHandlerInterface>;
+  applePayHandler: PromisedSingleton<ApplePayHandlerInterface>;
+  venmoHandler: PromisedSingleton<VenmoHandlerInterface | undefined>;
+  paypalHandler: PromisedSingleton<PayPalHandlerInterface>;
+  googlePayHandler: PromisedSingleton<GooglePayHandlerInterface>;
+}

package/src/braintree-manager/payment-providers.ts

@@ -1,147 +1,147 @@
-import { PromisedSingleton } from '@internetarchive/promised-singleton';
-
-import { CreditCardHandler } from './payment-providers/credit-card/credit-card';
-import { ApplePayHandler } from './payment-providers/apple-pay/apple-pay';
-import { VenmoHandler } from './payment-providers/venmo';
-import { PayPalHandler } from './payment-providers/paypal/paypal';
-import { ApplePaySessionManager } from './payment-providers/apple-pay/apple-pay-session-manager';
-import { PaymentClientsInterface } from './payment-clients';
-import { GooglePayHandler } from './payment-providers/google-pay';
-import { BraintreeManagerInterface, HostingEnvironment } from './braintree-interfaces';
-import { HostedFieldConfiguration } from './payment-providers/credit-card/hosted-field-configuration';
-import { PaymentProvidersEvents, PaymentProvidersInterface } from './payment-providers-interface';
-import { ApplePayHandlerInterface } from './payment-providers/apple-pay/apple-pay-interface';
-import { CreditCardHandlerInterface } from './payment-providers/credit-card/credit-card-interface';
-import { VenmoHandlerInterface } from './payment-providers/venmo-interface';
-import { PayPalHandlerInterface } from './payment-providers/paypal/paypal-interface';
-import { GooglePayHandlerInterface } from './payment-providers/google-pay-interface';
-import { createNanoEvents, Unsubscribe } from 'nanoevents';
-
-/**
- * The PaymentProviders class contains the IA-specific handlers for each of the
- * different payment providers.
- *
- * They are generally data-focused, as opposed to UI-focused, but there
- * is some cross-polination between PaymentProviders and FlowHandlers.
- *
- * @export
- * @class PaymentProviders
- * @implements {PaymentProvidersInterface}
- */
-export class PaymentProviders implements PaymentProvidersInterface {
-  on<E extends keyof PaymentProvidersEvents>(
-    event: E,
-    callback: PaymentProvidersEvents[E],
-  ): Unsubscribe {
-    return this.emitter.on(event, callback);
-  }
-
-  creditCardHandler = new PromisedSingleton<CreditCardHandlerInterface>({
-    generator: async (): Promise<CreditCardHandlerInterface> => {
-      const client = await this.paymentClients.hostedFields.get();
-      const handler = new CreditCardHandler({
-        braintreeManager: this.braintreeManager,
-        hostedFieldClient: client,
-        hostedFieldConfig: this.hostedFieldConfig,
-      });
-
-      handler.on('hostedFieldsRetry', (retryNumber: number) => {
-        this.emitter.emit('hostedFieldsRetry', retryNumber);
-      });
-
-      handler.on('hostedFieldsFailed', (error: unknown) => {
-        this.emitter.emit('hostedFieldsFailed', error);
-      });
-
-      return handler;
-    },
-  });
-
-  applePayHandler = new PromisedSingleton<ApplePayHandlerInterface>({
-    generator: async (): Promise<ApplePayHandlerInterface> => {
-      const client = await this.paymentClients.applePay.get();
-      const applePaySessionManager = new ApplePaySessionManager();
-      return new ApplePayHandler({
-        braintreeManager: this.braintreeManager,
-        applePayClient: client,
-        applePaySessionManager: applePaySessionManager,
-      });
-    },
-  });
-
-  venmoHandler = new PromisedSingleton<VenmoHandlerInterface | undefined>({
-    generator: async (): Promise<VenmoHandlerInterface | undefined> => {
-      const client = await this.paymentClients.venmo.get();
-      if (!this.venmoProfileId) {
-        return undefined;
-      }
-      return new VenmoHandler({
-        braintreeManager: this.braintreeManager,
-        venmoClient: client,
-        venmoProfileId: this.venmoProfileId,
-      });
-    },
-  });
-
-  paypalHandler = new PromisedSingleton<PayPalHandlerInterface>({
-    generator: async (): Promise<PayPalHandlerInterface> => {
-      const paypalLibrary = this.paymentClients.paypalLibrary.get();
-      const client = this.paymentClients.payPal.get();
-
-      const values = await Promise.all([client, paypalLibrary]);
-      const handler = new PayPalHandler({
-        braintreeManager: this.braintreeManager,
-        paypalClient: values[0],
-        paypalButton: values[1].Button,
-        hostingEnvironment: this.hostingEnvironment,
-      });
-      return handler;
-    },
-  });
-
-  googlePayHandler = new PromisedSingleton<GooglePayHandlerInterface>({
-    generator: async (): Promise<GooglePayHandlerInterface> => {
-      const googlePaymentsClient = this.paymentClients.googlePaymentsClient.get();
-      const braintreeClient = this.paymentClients.googlePayBraintreeClient.get();
-
-      const values = await Promise.all([braintreeClient, googlePaymentsClient]);
-      const handler = new GooglePayHandler({
-        braintreeManager: this.braintreeManager,
-        googlePayMerchantId: this.googlePayMerchantId,
-        googlePayBraintreeClient: values[0],
-        googlePaymentsClient: values[1],
-      });
-      return handler;
-    },
-  });
-
-  private braintreeManager: BraintreeManagerInterface;
-
-  private venmoProfileId?: string;
-
-  private googlePayMerchantId?: string;
-
-  private hostedFieldConfig: HostedFieldConfiguration;
-
-  private hostingEnvironment: HostingEnvironment = HostingEnvironment.Development;
-
-  private paymentClients: PaymentClientsInterface;
-
-  private emitter = createNanoEvents<PaymentProvidersEvents>();
-
-  constructor(options: {
-    braintreeManager: BraintreeManagerInterface;
-    paymentClients: PaymentClientsInterface;
-    venmoProfileId?: string;
-    googlePayMerchantId?: string;
-    hostingEnvironment: HostingEnvironment;
-    hostedFieldConfig: HostedFieldConfiguration;
-  }) {
-    this.braintreeManager = options.braintreeManager;
-    this.venmoProfileId = options.venmoProfileId;
-    this.googlePayMerchantId = options.googlePayMerchantId;
-    this.paymentClients = options.paymentClients;
-    this.hostingEnvironment = options.hostingEnvironment;
-    this.hostedFieldConfig = options.hostedFieldConfig;
-  }
-}
+import { PromisedSingleton } from '@internetarchive/promised-singleton';
+
+import { CreditCardHandler } from './payment-providers/credit-card/credit-card';
+import { ApplePayHandler } from './payment-providers/apple-pay/apple-pay';
+import { VenmoHandler } from './payment-providers/venmo';
+import { PayPalHandler } from './payment-providers/paypal/paypal';
+import { ApplePaySessionManager } from './payment-providers/apple-pay/apple-pay-session-manager';
+import { PaymentClientsInterface } from './payment-clients';
+import { GooglePayHandler } from './payment-providers/google-pay';
+import { BraintreeManagerInterface, HostingEnvironment } from './braintree-interfaces';
+import { HostedFieldConfiguration } from './payment-providers/credit-card/hosted-field-configuration';
+import { PaymentProvidersEvents, PaymentProvidersInterface } from './payment-providers-interface';
+import { ApplePayHandlerInterface } from './payment-providers/apple-pay/apple-pay-interface';
+import { CreditCardHandlerInterface } from './payment-providers/credit-card/credit-card-interface';
+import { VenmoHandlerInterface } from './payment-providers/venmo-interface';
+import { PayPalHandlerInterface } from './payment-providers/paypal/paypal-interface';
+import { GooglePayHandlerInterface } from './payment-providers/google-pay-interface';
+import { createNanoEvents, Unsubscribe } from 'nanoevents';
+
+/**
+ * The PaymentProviders class contains the IA-specific handlers for each of the
+ * different payment providers.
+ *
+ * They are generally data-focused, as opposed to UI-focused, but there
+ * is some cross-polination between PaymentProviders and FlowHandlers.
+ *
+ * @export
+ * @class PaymentProviders
+ * @implements {PaymentProvidersInterface}
+ */
+export class PaymentProviders implements PaymentProvidersInterface {
+  on<E extends keyof PaymentProvidersEvents>(
+    event: E,
+    callback: PaymentProvidersEvents[E],
+  ): Unsubscribe {
+    return this.emitter.on(event, callback);
+  }
+
+  creditCardHandler = new PromisedSingleton<CreditCardHandlerInterface>({
+    generator: async (): Promise<CreditCardHandlerInterface> => {
+      const client = await this.paymentClients.hostedFields.get();
+      const handler = new CreditCardHandler({
+        braintreeManager: this.braintreeManager,
+        hostedFieldClient: client,
+        hostedFieldConfig: this.hostedFieldConfig,
+      });
+
+      handler.on('hostedFieldsRetry', (retryNumber: number) => {
+        this.emitter.emit('hostedFieldsRetry', retryNumber);
+      });
+
+      handler.on('hostedFieldsFailed', (error: unknown) => {
+        this.emitter.emit('hostedFieldsFailed', error);
+      });
+
+      return handler;
+    },
+  });
+
+  applePayHandler = new PromisedSingleton<ApplePayHandlerInterface>({
+    generator: async (): Promise<ApplePayHandlerInterface> => {
+      const client = await this.paymentClients.applePay.get();
+      const applePaySessionManager = new ApplePaySessionManager();
+      return new ApplePayHandler({
+        braintreeManager: this.braintreeManager,
+        applePayClient: client,
+        applePaySessionManager: applePaySessionManager,
+      });
+    },
+  });
+
+  venmoHandler = new PromisedSingleton<VenmoHandlerInterface | undefined>({
+    generator: async (): Promise<VenmoHandlerInterface | undefined> => {
+      const client = await this.paymentClients.venmo.get();
+      if (!this.venmoProfileId) {
+        return undefined;
+      }
+      return new VenmoHandler({
+        braintreeManager: this.braintreeManager,
+        venmoClient: client,
+        venmoProfileId: this.venmoProfileId,
+      });
+    },
+  });
+
+  paypalHandler = new PromisedSingleton<PayPalHandlerInterface>({
+    generator: async (): Promise<PayPalHandlerInterface> => {
+      const paypalLibrary = this.paymentClients.paypalLibrary.get();
+      const client = this.paymentClients.payPal.get();
+
+      const values = await Promise.all([client, paypalLibrary]);
+      const handler = new PayPalHandler({
+        braintreeManager: this.braintreeManager,
+        paypalClient: values[0],
+        paypalButton: values[1].Button,
+        hostingEnvironment: this.hostingEnvironment,
+      });
+      return handler;
+    },
+  });
+
+  googlePayHandler = new PromisedSingleton<GooglePayHandlerInterface>({
+    generator: async (): Promise<GooglePayHandlerInterface> => {
+      const googlePaymentsClient = this.paymentClients.googlePaymentsClient.get();
+      const braintreeClient = this.paymentClients.googlePayBraintreeClient.get();
+
+      const values = await Promise.all([braintreeClient, googlePaymentsClient]);
+      const handler = new GooglePayHandler({
+        braintreeManager: this.braintreeManager,
+        googlePayMerchantId: this.googlePayMerchantId,
+        googlePayBraintreeClient: values[0],
+        googlePaymentsClient: values[1],
+      });
+      return handler;
+    },
+  });
+
+  private braintreeManager: BraintreeManagerInterface;
+
+  private venmoProfileId?: string;
+
+  private googlePayMerchantId?: string;
+
+  private hostedFieldConfig: HostedFieldConfiguration;
+
+  private hostingEnvironment: HostingEnvironment = HostingEnvironment.Development;
+
+  private paymentClients: PaymentClientsInterface;
+
+  private emitter = createNanoEvents<PaymentProvidersEvents>();
+
+  constructor(options: {
+    braintreeManager: BraintreeManagerInterface;
+    paymentClients: PaymentClientsInterface;
+    venmoProfileId?: string;
+    googlePayMerchantId?: string;
+    hostingEnvironment: HostingEnvironment;
+    hostedFieldConfig: HostedFieldConfiguration;
+  }) {
+    this.braintreeManager = options.braintreeManager;
+    this.venmoProfileId = options.venmoProfileId;
+    this.googlePayMerchantId = options.googlePayMerchantId;
+    this.paymentClients = options.paymentClients;
+    this.hostingEnvironment = options.hostingEnvironment;
+    this.hostedFieldConfig = options.hostedFieldConfig;
+  }
+}