@internetarchive/donation-form 1.0.2 → 1.0.3-alpha-webdev7960.0

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

@@ -1,97 +1,97 @@
-import { PromisedSingleton } from '@internetarchive/promised-singleton';
-import { BraintreeManagerInterface } from '../../braintree-interfaces';
-import { ApplePaySessionManagerInterface } from './apple-pay-session-manager';
-import { DonationType, DonationPaymentInfo } from '@internetarchive/donation-form-data-models';
-import { ApplePaySessionDataSource } from './apple-pay-session-datasource';
-import { ApplePayHandlerInterface } from './apple-pay-interface';
-
-export class ApplePayHandler implements ApplePayHandlerInterface {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  instance: PromisedSingleton<any | undefined>;
-
-  constructor(options: {
-    braintreeManager: BraintreeManagerInterface;
-    applePayClient: braintree.ApplePay;
-    applePaySessionManager: ApplePaySessionManagerInterface;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    instancePromisedSingleton?: PromisedSingleton<any | undefined>;
-  }) {
-    this.braintreeManager = options.braintreeManager;
-    this.applePayClient = options.applePayClient;
-    this.applePaySessionManager = options.applePaySessionManager;
-
-    this.instance =
-      options.instancePromisedSingleton ??
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      new PromisedSingleton<any | undefined>({
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        generator: async (): Promise<any | undefined> => {
-          if (!this.applePaySessionManager.canMakePayments()) {
-            return undefined;
-          }
-
-          const braintreeClient = await this.braintreeManager.instance.get();
-          const instance = await this.applePayClient.create({
-            client: braintreeClient,
-          });
-
-          return instance;
-        },
-      });
-  }
-
-  private braintreeManager: BraintreeManagerInterface;
-
-  private applePaySessionManager: ApplePaySessionManagerInterface;
-
-  private applePayClient: braintree.ApplePay;
-
-  async isAvailable(): Promise<boolean> {
-    try {
-      const instance = await this.instance.get();
-      return !!instance;
-    } catch (err) {
-      return false;
-    }
-  }
-
-  // In order to trigger the Apple Pay flow, you HAVE to pass in the event
-  // that triggered the launch. Notice we're not actually using the event
-  // but ApplePay won't launch without it.
-  async createPaymentRequest(
-    e: Event,
-    donationInfo: DonationPaymentInfo,
-  ): Promise<ApplePaySessionDataSource> {
-    const applePayInstance = await this.instance.get();
-
-    let label = 'Internet Archive Monthly';
-    if (donationInfo.donationType === DonationType.OneTime) {
-      label = 'Internet Archive';
-    }
-
-    const paymentRequest = applePayInstance.createPaymentRequest({
-      total: {
-        label: label,
-        amount: donationInfo.total,
-      },
-      requiredBillingContactFields: ['postalAddress'],
-      requiredShippingContactFields: ['name', 'email'],
-    });
-    const session = this.applePaySessionManager.createNewPaymentSession(paymentRequest);
-
-    const sessionDataSource = new ApplePaySessionDataSource({
-      donationInfo: donationInfo,
-      session: session,
-      applePayInstance: applePayInstance,
-      braintreeManager: this.braintreeManager,
-    });
-
-    session.onvalidatemerchant = sessionDataSource.onvalidatemerchant.bind(sessionDataSource);
-    session.onpaymentauthorized = sessionDataSource.onpaymentauthorized.bind(sessionDataSource);
-    session.oncancel = sessionDataSource.oncancel.bind(sessionDataSource);
-
-    session.begin();
-
-    return sessionDataSource;
-  }
-}
+import { PromisedSingleton } from '@internetarchive/promised-singleton';
+import { BraintreeManagerInterface } from '../../braintree-interfaces';
+import { ApplePaySessionManagerInterface } from './apple-pay-session-manager';
+import { DonationType, DonationPaymentInfo } from '@internetarchive/donation-form-data-models';
+import { ApplePaySessionDataSource } from './apple-pay-session-datasource';
+import { ApplePayHandlerInterface } from './apple-pay-interface';
+
+export class ApplePayHandler implements ApplePayHandlerInterface {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  instance: PromisedSingleton<any | undefined>;
+
+  constructor(options: {
+    braintreeManager: BraintreeManagerInterface;
+    applePayClient: braintree.ApplePay;
+    applePaySessionManager: ApplePaySessionManagerInterface;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    instancePromisedSingleton?: PromisedSingleton<any | undefined>;
+  }) {
+    this.braintreeManager = options.braintreeManager;
+    this.applePayClient = options.applePayClient;
+    this.applePaySessionManager = options.applePaySessionManager;
+
+    this.instance =
+      options.instancePromisedSingleton ??
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      new PromisedSingleton<any | undefined>({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        generator: async (): Promise<any | undefined> => {
+          if (!this.applePaySessionManager.canMakePayments()) {
+            return undefined;
+          }
+
+          const braintreeClient = await this.braintreeManager.instance.get();
+          const instance = await this.applePayClient.create({
+            client: braintreeClient,
+          });
+
+          return instance;
+        },
+      });
+  }
+
+  private braintreeManager: BraintreeManagerInterface;
+
+  private applePaySessionManager: ApplePaySessionManagerInterface;
+
+  private applePayClient: braintree.ApplePay;
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      const instance = await this.instance.get();
+      return !!instance;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  // In order to trigger the Apple Pay flow, you HAVE to pass in the event
+  // that triggered the launch. Notice we're not actually using the event
+  // but ApplePay won't launch without it.
+  async createPaymentRequest(
+    e: Event,
+    donationInfo: DonationPaymentInfo,
+  ): Promise<ApplePaySessionDataSource> {
+    const applePayInstance = await this.instance.get();
+
+    let label = 'Internet Archive Monthly';
+    if (donationInfo.donationType === DonationType.OneTime) {
+      label = 'Internet Archive';
+    }
+
+    const paymentRequest = applePayInstance.createPaymentRequest({
+      total: {
+        label: label,
+        amount: donationInfo.total,
+      },
+      requiredBillingContactFields: ['postalAddress'],
+      requiredShippingContactFields: ['name', 'email'],
+    });
+    const session = this.applePaySessionManager.createNewPaymentSession(paymentRequest);
+
+    const sessionDataSource = new ApplePaySessionDataSource({
+      donationInfo: donationInfo,
+      session: session,
+      applePayInstance: applePayInstance,
+      braintreeManager: this.braintreeManager,
+    });
+
+    session.onvalidatemerchant = sessionDataSource.onvalidatemerchant.bind(sessionDataSource);
+    session.onpaymentauthorized = sessionDataSource.onpaymentauthorized.bind(sessionDataSource);
+    session.oncancel = sessionDataSource.oncancel.bind(sessionDataSource);
+
+    session.begin();
+
+    return sessionDataSource;
+  }
+}

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

@@ -1,21 +1,21 @@
-import { PromisedSingleton } from '@internetarchive/promised-singleton';
-import { Unsubscribe } from 'nanoevents';
-import { HostedFieldName } from './hosted-field-container';
-
-export interface CreditCardHandlerEvents {
-  hostedFieldsRetry: (retryNumber: number) => void;
-  hostedFieldsFailed: (error: unknown) => void;
-}
-
-export interface CreditCardHandlerInterface {
-  instance: PromisedSingleton<braintree.HostedFields | undefined>;
-  tokenizeHostedFields(): Promise<braintree.HostedFieldsTokenizePayload | undefined>;
-  markFieldErrors(fields: HostedFieldName[]): void;
-  removeFieldErrors(fields: HostedFieldName[]): void;
-  showErrorMessage(message?: string): void;
-  hideErrorMessage(): void;
-  on<E extends keyof CreditCardHandlerEvents>(
-    event: E,
-    callback: CreditCardHandlerEvents[E],
-  ): Unsubscribe;
-}
+import { PromisedSingleton } from '@internetarchive/promised-singleton';
+import { Unsubscribe } from 'nanoevents';
+import { HostedFieldName } from './hosted-field-container';
+
+export interface CreditCardHandlerEvents {
+  hostedFieldsRetry: (retryNumber: number) => void;
+  hostedFieldsFailed: (error: unknown) => void;
+}
+
+export interface CreditCardHandlerInterface {
+  instance: PromisedSingleton<braintree.HostedFields | undefined>;
+  tokenizeHostedFields(): Promise<braintree.HostedFieldsTokenizePayload | undefined>;
+  markFieldErrors(fields: HostedFieldName[]): void;
+  removeFieldErrors(fields: HostedFieldName[]): void;
+  showErrorMessage(message?: string): void;
+  hideErrorMessage(): void;
+  on<E extends keyof CreditCardHandlerEvents>(
+    event: E,
+    callback: CreditCardHandlerEvents[E],
+  ): Unsubscribe;
+}

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

@@ -1,130 +1,130 @@
-import { PromisedSingleton } from '@internetarchive/promised-singleton';
-import { BraintreeManagerInterface } from '../../braintree-interfaces';
-import { HostedFieldConfiguration } from './hosted-field-configuration';
-import { HostedFieldName } from './hosted-field-container';
-import { CreditCardHandlerEvents, CreditCardHandlerInterface } from './credit-card-interface';
-import { createNanoEvents, Unsubscribe } from 'nanoevents';
-import { DonationFormError } from '../../../donation-form-error';
-
-export class CreditCardHandler implements CreditCardHandlerInterface {
-  on<E extends keyof CreditCardHandlerEvents>(
-    event: E,
-    callback: CreditCardHandlerEvents[E],
-  ): Unsubscribe {
-    return this.emitter.on(event, callback);
-  }
-
-  instance = new PromisedSingleton<braintree.HostedFields | undefined>({
-    generator: async (): Promise<braintree.HostedFields | undefined> => {
-      const braintreeClient = await this.braintreeManager.instance.get();
-      const hostedFields = await this.createHostedFields(braintreeClient);
-      return hostedFields;
-    },
-  });
-
-  private emitter = createNanoEvents<CreditCardHandlerEvents>();
-
-  private maxRetryCount: number;
-
-  private loadTimeout: number;
-
-  constructor(options: {
-    braintreeManager: BraintreeManagerInterface;
-    hostedFieldClient: braintree.HostedFields;
-    hostedFieldConfig: HostedFieldConfiguration;
-    maxRetryCount?: number;
-    loadTimeout?: number;
-  }) {
-    this.braintreeManager = options.braintreeManager;
-    this.hostedFieldClient = options.hostedFieldClient;
-    this.hostedFieldConfig = options.hostedFieldConfig;
-    this.maxRetryCount = options.maxRetryCount ?? 2;
-    this.loadTimeout = (options.loadTimeout ?? 6) * 1000;
-  }
-
-  private braintreeManager: BraintreeManagerInterface;
-  private hostedFieldClient: braintree.HostedFields;
-  private hostedFieldConfig: HostedFieldConfiguration;
-
-  private async createHostedFields(
-    braintreeClient: braintree.Client,
-    retryCount = 0,
-  ): Promise<braintree.HostedFields | undefined> {
-    // we mainly want to do this for retry events, but it doesn't
-    // hurt to do it on the first try
-    this.hostedFieldConfig.hostedFieldContainer.resetHostedFields();
-    try {
-      // The hosted fields have a 60 second timeout internally, but braintree
-      // support recommended setting a shorter timeout because 99% of users
-      // load the hosted fields in under 4 seconds and 99.9% with 18 seconds.
-      // What we're doing here is creating a "timeout" promise
-      // and a "create hosted fields" promise and doing a `Promise.race()` to
-      // resolve when the first one finishes. If the timeout finishes first,
-      // we throw an error to trigger the retry logic. If the hosted fields
-      // finishes first, we cancel the timeout promise since we're done.
-      let timeout: number;
-
-      const timeoutPromise = new Promise<void>((resolve, reject) => {
-        timeout = window.setTimeout(() => {
-          const error = new DonationFormError('Timeout loading Hosted Fields');
-          reject(error);
-        }, this.loadTimeout);
-      });
-
-      const hostedFieldsPromise = new Promise<braintree.HostedFields | undefined>(
-        async (resolve, reject) => {
-          try {
-            const fields = await this.hostedFieldClient.create({
-              client: braintreeClient,
-              styles: this.hostedFieldConfig.hostedFieldStyle,
-              fields: this.hostedFieldConfig.hostedFieldFieldOptions,
-            });
-            // clear the timeout when this finishes so we don't also get the timeout rejection
-            window.clearTimeout(timeout);
-            resolve(fields);
-          } catch (error) {
-            if (error instanceof Error && error.message.includes('Hosted Fields timed out')) {
-              // this is the timeout error, so we don't need to do anything
-            } else {
-              // this is some other error. reject so it bubbles up to Sentry
-              reject(error);
-            }
-          }
-        },
-      );
-
-      const result = await Promise.race([timeoutPromise, hostedFieldsPromise]);
-
-      return result as braintree.HostedFields;
-    } catch (error) {
-      if (retryCount >= this.maxRetryCount) {
-        this.emitter.emit('hostedFieldsFailed', error);
-        throw error;
-      }
-      const newRetryCount = retryCount + 1;
-      this.emitter.emit('hostedFieldsRetry', newRetryCount);
-      return this.createHostedFields(braintreeClient, newRetryCount);
-    }
-  }
-
-  async tokenizeHostedFields(): Promise<braintree.HostedFieldsTokenizePayload | undefined> {
-    const hostedFields = await this.instance.get();
-    return hostedFields?.tokenize();
-  }
-
-  markFieldErrors(fields: HostedFieldName[]): void {
-    this.hostedFieldConfig.hostedFieldContainer.markFieldErrors(fields);
-  }
-
-  removeFieldErrors(fields: HostedFieldName[]): void {
-    this.hostedFieldConfig.hostedFieldContainer.removeFieldErrors(fields);
-  }
-
-  showErrorMessage(message?: string): void {
-    this.hostedFieldConfig.hostedFieldContainer.showErrorMessage(message);
-  }
-
-  hideErrorMessage(): void {
-    this.hostedFieldConfig.hostedFieldContainer.hideErrorMessage();
-  }
-}
+import { PromisedSingleton } from '@internetarchive/promised-singleton';
+import { BraintreeManagerInterface } from '../../braintree-interfaces';
+import { HostedFieldConfiguration } from './hosted-field-configuration';
+import { HostedFieldName } from './hosted-field-container';
+import { CreditCardHandlerEvents, CreditCardHandlerInterface } from './credit-card-interface';
+import { createNanoEvents, Unsubscribe } from 'nanoevents';
+import { DonationFormError } from '../../../donation-form-error';
+
+export class CreditCardHandler implements CreditCardHandlerInterface {
+  on<E extends keyof CreditCardHandlerEvents>(
+    event: E,
+    callback: CreditCardHandlerEvents[E],
+  ): Unsubscribe {
+    return this.emitter.on(event, callback);
+  }
+
+  instance = new PromisedSingleton<braintree.HostedFields | undefined>({
+    generator: async (): Promise<braintree.HostedFields | undefined> => {
+      const braintreeClient = await this.braintreeManager.instance.get();
+      const hostedFields = await this.createHostedFields(braintreeClient);
+      return hostedFields;
+    },
+  });
+
+  private emitter = createNanoEvents<CreditCardHandlerEvents>();
+
+  private maxRetryCount: number;
+
+  private loadTimeout: number;
+
+  constructor(options: {
+    braintreeManager: BraintreeManagerInterface;
+    hostedFieldClient: braintree.HostedFields;
+    hostedFieldConfig: HostedFieldConfiguration;
+    maxRetryCount?: number;
+    loadTimeout?: number;
+  }) {
+    this.braintreeManager = options.braintreeManager;
+    this.hostedFieldClient = options.hostedFieldClient;
+    this.hostedFieldConfig = options.hostedFieldConfig;
+    this.maxRetryCount = options.maxRetryCount ?? 2;
+    this.loadTimeout = (options.loadTimeout ?? 6) * 1000;
+  }
+
+  private braintreeManager: BraintreeManagerInterface;
+  private hostedFieldClient: braintree.HostedFields;
+  private hostedFieldConfig: HostedFieldConfiguration;
+
+  private async createHostedFields(
+    braintreeClient: braintree.Client,
+    retryCount = 0,
+  ): Promise<braintree.HostedFields | undefined> {
+    // we mainly want to do this for retry events, but it doesn't
+    // hurt to do it on the first try
+    this.hostedFieldConfig.hostedFieldContainer.resetHostedFields();
+    try {
+      // The hosted fields have a 60 second timeout internally, but braintree
+      // support recommended setting a shorter timeout because 99% of users
+      // load the hosted fields in under 4 seconds and 99.9% with 18 seconds.
+      // What we're doing here is creating a "timeout" promise
+      // and a "create hosted fields" promise and doing a `Promise.race()` to
+      // resolve when the first one finishes. If the timeout finishes first,
+      // we throw an error to trigger the retry logic. If the hosted fields
+      // finishes first, we cancel the timeout promise since we're done.
+      let timeout: number;
+
+      const timeoutPromise = new Promise<void>((resolve, reject) => {
+        timeout = window.setTimeout(() => {
+          const error = new DonationFormError('Timeout loading Hosted Fields');
+          reject(error);
+        }, this.loadTimeout);
+      });
+
+      const hostedFieldsPromise = new Promise<braintree.HostedFields | undefined>(
+        async (resolve, reject) => {
+          try {
+            const fields = await this.hostedFieldClient.create({
+              client: braintreeClient,
+              styles: this.hostedFieldConfig.hostedFieldStyle,
+              fields: this.hostedFieldConfig.hostedFieldFieldOptions,
+            });
+            // clear the timeout when this finishes so we don't also get the timeout rejection
+            window.clearTimeout(timeout);
+            resolve(fields);
+          } catch (error) {
+            if (error instanceof Error && error.message.includes('Hosted Fields timed out')) {
+              // this is the timeout error, so we don't need to do anything
+            } else {
+              // this is some other error. reject so it bubbles up to Sentry
+              reject(error);
+            }
+          }
+        },
+      );
+
+      const result = await Promise.race([timeoutPromise, hostedFieldsPromise]);
+
+      return result as braintree.HostedFields;
+    } catch (error) {
+      if (retryCount >= this.maxRetryCount) {
+        this.emitter.emit('hostedFieldsFailed', error);
+        throw error;
+      }
+      const newRetryCount = retryCount + 1;
+      this.emitter.emit('hostedFieldsRetry', newRetryCount);
+      return this.createHostedFields(braintreeClient, newRetryCount);
+    }
+  }
+
+  async tokenizeHostedFields(): Promise<braintree.HostedFieldsTokenizePayload | undefined> {
+    const hostedFields = await this.instance.get();
+    return hostedFields?.tokenize();
+  }
+
+  markFieldErrors(fields: HostedFieldName[]): void {
+    this.hostedFieldConfig.hostedFieldContainer.markFieldErrors(fields);
+  }
+
+  removeFieldErrors(fields: HostedFieldName[]): void {
+    this.hostedFieldConfig.hostedFieldContainer.removeFieldErrors(fields);
+  }
+
+  showErrorMessage(message?: string): void {
+    this.hostedFieldConfig.hostedFieldContainer.showErrorMessage(message);
+  }
+
+  hideErrorMessage(): void {
+    this.hostedFieldConfig.hostedFieldContainer.hideErrorMessage();
+  }
+}

package/src/braintree-manager/payment-providers/credit-card/hosted-field-configuration.ts

@@ -1,19 +1,19 @@
-import { HostedFieldContainerInterface } from './hosted-field-container';
-
-export class HostedFieldConfiguration {
-  hostedFieldStyle: Record<string, Record<string, string>>;
-
-  hostedFieldFieldOptions: braintree.HostedFieldFieldOptions;
-
-  hostedFieldContainer: HostedFieldContainerInterface;
-
-  constructor(options: {
-    hostedFieldStyle: Record<string, Record<string, string>>;
-    hostedFieldFieldOptions: braintree.HostedFieldFieldOptions;
-    hostedFieldContainer: HostedFieldContainerInterface;
-  }) {
-    this.hostedFieldFieldOptions = options.hostedFieldFieldOptions;
-    this.hostedFieldStyle = options.hostedFieldStyle;
-    this.hostedFieldContainer = options.hostedFieldContainer;
-  }
-}
+import { HostedFieldContainerInterface } from './hosted-field-container';
+
+export class HostedFieldConfiguration {
+  hostedFieldStyle: Record<string, Record<string, string>>;
+
+  hostedFieldFieldOptions: braintree.HostedFieldFieldOptions;
+
+  hostedFieldContainer: HostedFieldContainerInterface;
+
+  constructor(options: {
+    hostedFieldStyle: Record<string, Record<string, string>>;
+    hostedFieldFieldOptions: braintree.HostedFieldFieldOptions;
+    hostedFieldContainer: HostedFieldContainerInterface;
+  }) {
+    this.hostedFieldFieldOptions = options.hostedFieldFieldOptions;
+    this.hostedFieldStyle = options.hostedFieldStyle;
+    this.hostedFieldContainer = options.hostedFieldContainer;
+  }
+}