@rnw-community/react-native-payments/dist/esm/class/change-event-dispatcher/change-event-dispatcher.js

Accept Payments with Apple Pay and Android Pay using the Payment Request API.

import { emptyFn, isDefined, wait } from '@rnw-community/shared';
import { changeEventTimeoutMs } from '../../constant/change-event-timeout-ms.js';
import { PaymentsErrorEnum } from '../../enum/payments-error.enum.js';
import { DOMException } from '../../error/dom.exception.js';
import { warnChangeEventError } from '../../util/warn-change-event-error.util.js';
import { PaymentMethodChangeEvent } from '../payment-method-change-event/payment-method-change-event.js';
import { PaymentRequestUpdateEvent } from '../payment-request-update-event/payment-request-update-event.js';
export class ChangeEventDispatcher {
    constructor(type, payload, isRequestActive) {
        this.answer = null;
        this.isOpen = true;
        this.releaseAbandoned = emptyFn;
        this.abandoned = new Promise(resolve => {
            this.releaseAbandoned = () => {
                resolve(null);
            };
        });
        this.handleUpdateWith = (detailsUpdate) => {
            if (!this.isOpen || !this.isRequestActive()) {
                throw new DOMException(PaymentsErrorEnum.InvalidStateError);
            }
            detailsUpdate.catch(emptyFn);
            this.answer = detailsUpdate;
        };
        this.isRequestActive = isRequestActive;
        this.event =
            type === 'paymentmethodchange'
                ? new PaymentMethodChangeEvent(payload.methodName ?? '', payload.methodDetails ?? null, this.handleUpdateWith)
                : new PaymentRequestUpdateEvent(type, this.handleUpdateWith);
    }
    async dispatch(listeners) {
        const deadline = wait(changeEventTimeoutMs).then(() => null);
        await Promise.race([this.callListeners(listeners), this.abandoned, deadline]);
        this.isOpen = false;
        return await this.resolveAnswer(deadline);
    }
    abandon() {
        this.isOpen = false;
        this.releaseAbandoned();
    }
    async callListeners(listeners) {
        for (const listener of [...listeners]) {
            if (this.event.isAnswered) {
                return;
            }
            if (listeners.includes(listener)) {
                // eslint-disable-next-line no-await-in-loop
                await this.callListener(listener);
            }
        }
    }
    async callListener(listener) {
        try {
            await listener(this.event);
        }
        catch (error) {
            warnChangeEventError(error);
        }
    }
    async resolveAnswer(deadline) {
        if (!isDefined(this.answer)) {
            return null;
        }
        return await Promise.race([this.answer, this.abandoned, deadline]);
    }
}
//# sourceMappingURL=change-event-dispatcher.js.map