@idonatedev/idonate-sdk 1.1.0-dev13 → 1.1.0-dev14

package/dist/esm/idonate-client.js

@@ -0,0 +1,256 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ClientError, } from './types';
+import { buildDonationResult, buildCashPaymentPayload } from './typeAdapters';
+import { CLIENT_HEADERS, SDK_VERSION } from './constants';
+import { parseResponse } from './util';
+import ApplePay from './apple-pay';
+import ConfigHandler from './config-handler';
+import { SpreedlyTokenizer } from './tokenize/SpreedlyTokenizer';
+import * as shared from './shared';
+import { v4 as uuidv4 } from 'uuid';
+import { handleCFChallenge } from './cloudflare-challenge-handler';
+import { Tokenizer, } from './tokenize';
+const clientDefaults = {
+    enableSandboxMode: false,
+    overrideBaseUrl: undefined,
+    enableDelay: false,
+    secondsToDelay: 0,
+};
+export default class iDonateClient {
+    get organizationId() {
+        if (!this.currentOrganizationId) {
+            throw new Error('organizationId undefined');
+        }
+        return this.currentOrganizationId;
+    }
+    constructor(clientKey, embedId, options) {
+        var _a;
+        this.clientKey = clientKey;
+        this.embedId = embedId;
+        this.currentOrganizationId = clientKey;
+        this.options = Object.assign({}, clientDefaults, options);
+        this.allowTransaction = false;
+        this.config = new ConfigHandler(this.options);
+        const configEntries = Object.entries(this.config);
+        for (const [key, value] of configEntries) {
+            const descriptor = Object.getOwnPropertyDescriptor(this, key);
+            if (!descriptor || descriptor.set !== undefined) {
+                try {
+                    this[key] = value;
+                }
+                catch (e) {
+                }
+            }
+        }
+        if (this.options.enableDelay && this.options.secondsToDelay) {
+            const delay = this.options.secondsToDelay * 1000;
+            setTimeout(() => {
+                this.allowTransaction = true;
+            }, delay);
+        }
+        else {
+            this.allowTransaction = true;
+        }
+        if (this.options.enableSandboxMode && console !== undefined) {
+            console.info(`[Sandbox] iDonate SDK Configuration (v${SDK_VERSION}):`, JSON.parse(JSON.stringify(this)));
+        }
+        try {
+            const { pcScriptBase, pcScriptId } = this.config;
+            if (!pcScriptBase || !pcScriptId) {
+                throw new Error('missing config');
+            }
+            const uuid = uuidv4();
+            const script = window.document.createElement('script');
+            script.setAttribute('src', pcScriptBase + '/' + uuid + '.js');
+            script.setAttribute('id', pcScriptId);
+            let appended = false;
+            const appendScript = () => {
+                var _a;
+                try {
+                    if (appended)
+                        return;
+                    window.document.body.append(script);
+                    appended = true;
+                }
+                catch (e) {
+                    (_a = console === null || console === void 0 ? void 0 : console.warn) === null || _a === void 0 ? void 0 : _a.call(console, 'not appended');
+                }
+            };
+            appendScript();
+            window.addEventListener('DOMContentLoaded', () => {
+                window.document.body.append(script);
+            });
+        }
+        catch (e) {
+            (_a = console === null || console === void 0 ? void 0 : console.warn) === null || _a === void 0 ? void 0 : _a.call(console, 'Warning, partial initialization: ', String(e));
+        }
+        if (!this.currentOrganizationId) {
+            this.setOrganizationId(this.clientKey);
+        }
+    }
+    createDonation(donation) {
+        if (!this.allowTransaction) {
+            throw new Error('Wow, that was fast - try again');
+        }
+        if (!donation.embedId) {
+            donation.embedId = this.embedId;
+        }
+        const payload = buildCashPaymentPayload(this.organizationId, donation);
+        const fetchCall = (clearanceToken) => fetch(`${this.config.embedApiBaseUrl}/donate/cash-payment`, {
+            method: 'POST',
+            headers: Object.assign(Object.assign(Object.assign({}, CLIENT_HEADERS), (clearanceToken ? { 'cf-validation-token': clearanceToken } : {})), { 'User-Agent': CLIENT_HEADERS['User-Agent'] + ' source:' + this.config.client }),
+            body: JSON.stringify(payload),
+            credentials: 'include',
+        });
+        return (fetchCall()
+            .then((response) => __awaiter(this, void 0, void 0, function* () {
+            if (response.headers.get('cf-mitigated') === 'challenge') {
+                const clearance = yield handleCFChallenge(response, this);
+                return fetchCall(clearance === null || clearance === void 0 ? void 0 : clearance.token);
+            }
+            return response;
+        }))
+            .then((response) => parseResponse(response, { throwErrors: true }))
+            .then((response) => buildDonationResult(response)));
+    }
+    createTransaction(donation) {
+        return this.createDonation(donation).then((result) => {
+            var _a;
+            return {
+                transactionId: (_a = result.transaction) === null || _a === void 0 ? void 0 : _a.id,
+                _raw_response: result._raw_response,
+            };
+        });
+    }
+    createPaymentMethod(paymentMethod) {
+        if (!paymentMethod.embedId) {
+            paymentMethod.embedId = this.embedId;
+        }
+        return shared.createPaymentMethod(paymentMethod, this.config);
+    }
+    setOrganizationId(organizationId) {
+        this.currentOrganizationId = organizationId;
+    }
+    waitForDonationResult(donationId, afterEachCheck) {
+        function isReady(response) {
+            return !!response.processed && !!response.transaction;
+        }
+        return new Promise((resolve, reject) => {
+            setTimeout(() => {
+                let pollHandle;
+                pollHandle = setInterval(() => {
+                    fetch(`${this.config.embedApiBaseUrl}/donate/cash-payment/${donationId}/payment_status`, {
+                        method: 'GET',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                    })
+                        .then((response) => response.json())
+                        .then((rawResponse) => rawResponse.result)
+                        .then((response) => {
+                        if (isReady(response)) {
+                            if (pollHandle) {
+                                clearInterval(pollHandle);
+                                pollHandle = null;
+                            }
+                            if (response.error) {
+                                reject(new ClientError(response.error));
+                            }
+                            resolve(buildDonationResult({
+                                _raw_response: Object.assign({ campaign: null, designation: {}, donor: {}, form_data: {}, id: null, schedule: {}, transaction: {} }, response),
+                            }));
+                        }
+                        else {
+                        }
+                        afterEachCheck === null || afterEachCheck === void 0 ? void 0 : afterEachCheck();
+                    })
+                        .catch((e) => {
+                        if (pollHandle) {
+                            clearInterval(pollHandle);
+                            pollHandle = null;
+                        }
+                        reject(e);
+                    });
+                }, 2000);
+            }, 2000);
+        });
+    }
+    tokenizeCardConnectApplePay(applePayRequest) {
+        const applePay = new ApplePay(applePayRequest);
+        let merchantSessionId = '';
+        const promiseStart = applePay.begin();
+        return new Promise((resolve, reject) => {
+            promiseStart
+                .then((session) => {
+                session.onvalidatemerchant = (event) => {
+                    const validationPayload = {
+                        apple_pay_url: this.config.applePayUrl,
+                        organization_id: this.organizationId,
+                    };
+                    applePay
+                        .createSession(validationPayload, this.config.embedApiBaseUrl)
+                        .then((merchantSession) => {
+                        merchantSessionId =
+                            merchantSession.result.merchantSessionIdentifier;
+                        session.completeMerchantValidation(merchantSession.result);
+                    })
+                        .catch((err) => {
+                        session.abort();
+                        reject(err);
+                    });
+                };
+                session.onpaymentauthorized = (event) => {
+                    applePay
+                        .tokenizeWithCardConnect(event.payment, this.config.cardConnectBaseUrl)
+                        .then((data) => {
+                        var _a, _b;
+                        const unifiedContact = Object.assign(Object.assign({}, event.payment.billingContact), { email: (_a = event.payment.shippingContact) === null || _a === void 0 ? void 0 : _a.emailAddress, phone: (_b = event.payment.shippingContact) === null || _b === void 0 ? void 0 : _b.phoneNumber });
+                        const result = {
+                            applePaySession: session,
+                            cardConnectResponse: data,
+                            billingContact: unifiedContact,
+                            merchantSessionId,
+                        };
+                        resolve(result);
+                    })
+                        .catch((err) => {
+                        session.abort();
+                        reject(err);
+                    });
+                };
+                session.oncancel = (event) => {
+                    reject(new Error('Apple Pay has been closed'));
+                };
+            })
+                .catch((err) => reject(err));
+        });
+    }
+    createTokenizer(gateway, container) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Tokenizer.create(gateway, container, {
+                organizationId: this.organizationId,
+                embedId: this.embedId,
+                clientConfig: this.config,
+            });
+        });
+    }
+    tokenizeSpreedlyPayPal(data) {
+        return SpreedlyTokenizer.tokenizePayPal(data, this.config);
+    }
+    selectGateway(availableGateways, paymentType, preferredGatewayId) {
+        if (preferredGatewayId) {
+            const preferred = availableGateways.find((g) => g.id === preferredGatewayId);
+            if (preferred)
+                return preferred;
+        }
+        return availableGateways[0];
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,11 @@
+import * as tokenize from './tokenize';
+import * as util from './util';
+import * as recaptcha from './recaptcha';
+import * as constants from './constants';
+import * as shared from './shared';
+import iDonateClient from './idonate-client';
+import ConfigHandler from './config-handler';
+import ApplePay from './apple-pay';
+import GooglePay from './google-pay';
+export * from './types';
+export { tokenize, util, shared, iDonateClient as Client, ConfigHandler, recaptcha, constants, ApplePay, GooglePay, };

package/dist/esm/index.js

@@ -0,0 +1,11 @@
+import * as tokenize from './tokenize';
+import * as util from './util';
+import * as recaptcha from './recaptcha';
+import * as constants from './constants';
+import * as shared from './shared';
+import iDonateClient from './idonate-client';
+import ConfigHandler from './config-handler';
+import ApplePay from './apple-pay';
+import GooglePay from './google-pay';
+export * from './types';
+export { tokenize, util, shared, iDonateClient as Client, ConfigHandler, recaptcha, constants, ApplePay, GooglePay, };

package/dist/esm/recaptcha.d.ts

@@ -0,0 +1,12 @@
+export declare function injectScript(callback?: () => void): void;
+export declare class RecaptchaElement {
+    private readonly container;
+    private readonly params;
+    private widgetId;
+    private executeResolveQueue;
+    private resolvedToken;
+    constructor(container: string, params: ReCaptchaV2.Parameters);
+    render(): Promise<void>;
+    resolveToken(): Promise<string>;
+}
+export declare function wrapElement(container: string, sitekey: string, extraParams?: any): RecaptchaElement;

package/dist/esm/recaptcha.js

@@ -0,0 +1,89 @@
+function resolveLib() {
+    const startWait = new Date();
+    return new Promise((resolve, reject) => {
+        function poll() {
+            if (window.grecaptcha !== undefined &&
+                window.grecaptcha.render !== undefined) {
+                resolve(window.grecaptcha);
+            }
+            else {
+                const elapsedMs = new Date().valueOf() - startWait.valueOf();
+                if (elapsedMs > 15000) {
+                    reject(new Error('grecaptcha not loaded after 15 seconds'));
+                }
+                else {
+                    setTimeout(poll, 250);
+                }
+            }
+        }
+        poll();
+    });
+}
+export function injectScript(callback) {
+    if (window.grecaptcha !== undefined) {
+        throw new Error('grecaptcha is already defined');
+    }
+    const script = document.createElement('script');
+    script.src = 'https://www.google.com/recaptcha/api.js?render=explicit';
+    script.async = true;
+    script.defer = true;
+    script.onload = callback || null;
+    if (document.readyState === 'interactive' ||
+        document.readyState === 'complete') {
+        document.body.appendChild(script);
+    }
+    else {
+        window.addEventListener('DOMContentLoaded', () => {
+            document.body.appendChild(script);
+        });
+    }
+}
+export class RecaptchaElement {
+    constructor(container, params) {
+        this.container = container;
+        this.params = params;
+        this.executeResolveQueue = [];
+    }
+    render() {
+        if (this.widgetId !== undefined) {
+            console.warn('rendering an already-rendered widget');
+        }
+        return resolveLib().then((lib) => {
+            this.widgetId = lib.render(this.container, Object.assign(Object.assign({}, this.params), { callback: (token) => {
+                    var _a;
+                    this.resolvedToken = token;
+                    (_a = this.executeResolveQueue.pop()) === null || _a === void 0 ? void 0 : _a(token);
+                }, 'expired-callback': () => {
+                    this.resolvedToken = undefined;
+                } }));
+        });
+    }
+    resolveToken() {
+        return new Promise((resolve, reject) => {
+            resolveLib()
+                .then((lib) => {
+                if (this.params.size !== 'invisible') {
+                    const response = lib.getResponse();
+                    return response
+                        ? resolve(response)
+                        : reject(new Error('checkbox recaptcha is not checked'));
+                }
+                this.executeResolveQueue.push(resolve);
+                if (this.resolvedToken !== undefined) {
+                    this.resolvedToken = undefined;
+                    lib.reset(this.widgetId);
+                }
+                lib.execute(this.widgetId);
+            })
+                .catch((e) => {
+                reject(e);
+            });
+        });
+    }
+}
+export function wrapElement(container, sitekey, extraParams) {
+    const params = Object.assign(Object.assign({}, (extraParams || {})), { sitekey });
+    const captcha = new RecaptchaElement(container, params);
+    captcha.render();
+    return captcha;
+}

package/dist/esm/shared.d.ts

@@ -0,0 +1,3 @@
+import { CreatePaymentMethodRequest, CreatePaymentMethodResult } from './types';
+import ConfigHandler from './config-handler';
+export declare function createPaymentMethod(paymentMethod: CreatePaymentMethodRequest, config: ConfigHandler): Promise<CreatePaymentMethodResult>;

package/dist/esm/shared.js

@@ -0,0 +1,13 @@
+import { buildCreatePaymentMethodPayload, buildCreatePaymentMethodResult, } from './typeAdapters';
+import { CLIENT_HEADERS } from './constants';
+import { parseResponse } from './util';
+export function createPaymentMethod(paymentMethod, config) {
+    const payload = buildCreatePaymentMethodPayload(paymentMethod);
+    return fetch(`${config.embedApiBaseUrl}/payment/payment-methods`, {
+        method: 'POST',
+        headers: CLIENT_HEADERS,
+        body: JSON.stringify(payload),
+    })
+        .then((response) => parseResponse(response, { throwErrors: true }))
+        .then((response) => buildCreatePaymentMethodResult(response));
+}

package/dist/esm/test-utils.d.ts

@@ -0,0 +1,81 @@
+export declare const createMockFetch: (response: any, options?: {
+    ok?: boolean;
+    status?: number;
+}) => jest.Mock<any, any, any>;
+export declare const createMockFetchError: (message: string) => jest.Mock<any, any, any>;
+export declare const createMockFetchWithImplementation: (implementation: (url: string, options?: any) => Promise<any>) => jest.Mock<any, any, any>;
+export declare const setupFetchMock: () => jest.Mock<any, any, any>;
+export declare const setupDocumentMock: () => {
+    mockScript: {
+        src: string;
+        async: boolean;
+        defer: boolean;
+    };
+    mockAppendChild: jest.Mock<any, any, any>;
+    mockCreateElement: jest.Mock<any, [], any>;
+};
+export declare const setupApplePayEnvironment: (options?: {
+    canMakePayments?: boolean;
+    supportsVersion?: boolean;
+}) => {
+    mockSession: {
+        begin: jest.Mock<any, any, any>;
+        abort: jest.Mock<any, any, any>;
+        completeMerchantValidation: jest.Mock<any, any, any>;
+        completePayment: jest.Mock<any, any, any>;
+    };
+    ApplePaySessionMock: any;
+};
+export declare const setupGooglePayEnvironment: (options?: {
+    autoLoad?: boolean;
+}) => {
+    mockPaymentsClient: {
+        isReadyToPay: jest.Mock<any, any, any>;
+        loadPaymentData: jest.Mock<any, any, any>;
+    };
+    googlePayMock: {
+        payments: {
+            api: {
+                PaymentsClient: jest.Mock<{
+                    isReadyToPay: jest.Mock<any, any, any>;
+                    loadPaymentData: jest.Mock<any, any, any>;
+                }, [], any>;
+            };
+        };
+    };
+};
+export declare const setupRecaptchaEnvironment: () => {
+    render: jest.Mock<any, any, any>;
+    reset: jest.Mock<any, any, any>;
+    execute: jest.Mock<any, any, any>;
+    getResponse: jest.Mock<any, any, any>;
+};
+export declare const createTestContact: (overrides?: {}) => {
+    salutation: string;
+    firstName: string;
+    lastName: string;
+    company: string;
+    email: string;
+    primaryPhone: string;
+};
+export declare const createTestAddress: (overrides?: {}) => {
+    address1: string;
+    address2: string;
+    city: string;
+    state: string;
+    zip: string;
+    country: string;
+};
+export declare const createTestCreditCard: (overrides?: {}) => {
+    cardNumber: string;
+    expirationMonth: string;
+    expirationYear: string;
+    verificationValue: string;
+};
+export declare const createTestBankAccount: (overrides?: {}) => {
+    accountNumber: string;
+    routingNumber: string;
+    accountType: "checking";
+    accountHolderType: "personal";
+};
+export declare const cleanupWindowMocks: () => void;

package/dist/esm/test-utils.js

@@ -0,0 +1,94 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export const createMockFetch = (response, options = {}) => {
+    return jest.fn().mockResolvedValue({
+        ok: options.ok !== false,
+        status: options.status || 200,
+        json: () => __awaiter(void 0, void 0, void 0, function* () { return response; }),
+        text: () => __awaiter(void 0, void 0, void 0, function* () { return JSON.stringify(response); }),
+    });
+};
+export const createMockFetchError = (message) => {
+    return jest.fn().mockRejectedValue(new Error(message));
+};
+export const createMockFetchWithImplementation = (implementation) => {
+    return jest.fn().mockImplementation(implementation);
+};
+export const setupFetchMock = () => {
+    const mockFetch = jest.fn();
+    global.fetch = mockFetch;
+    return mockFetch;
+};
+export const setupDocumentMock = () => {
+    const mockScript = {
+        src: '',
+        async: false,
+        defer: false,
+    };
+    const mockAppendChild = jest.fn();
+    const mockCreateElement = jest.fn(() => mockScript);
+    Object.defineProperty(document, 'createElement', {
+        value: mockCreateElement,
+        writable: true,
+    });
+    Object.defineProperty(document.body, 'appendChild', {
+        value: mockAppendChild,
+        writable: true,
+    });
+    return { mockScript, mockAppendChild, mockCreateElement };
+};
+export const setupApplePayEnvironment = (options = {}) => {
+    const mockSession = {
+        begin: jest.fn(),
+        abort: jest.fn(),
+        completeMerchantValidation: jest.fn(),
+        completePayment: jest.fn(),
+    };
+    const ApplePaySessionMock = jest.fn(() => mockSession);
+    ApplePaySessionMock.canMakePayments = jest.fn(() => options.canMakePayments !== false);
+    ApplePaySessionMock.supportsVersion = jest.fn(() => options.supportsVersion !== false);
+    window.ApplePaySession = ApplePaySessionMock;
+    return { mockSession, ApplePaySessionMock };
+};
+export const setupGooglePayEnvironment = (options = {}) => {
+    const mockPaymentsClient = {
+        isReadyToPay: jest.fn(),
+        loadPaymentData: jest.fn(),
+    };
+    const googlePayMock = {
+        payments: {
+            api: {
+                PaymentsClient: jest.fn(() => mockPaymentsClient),
+            },
+        },
+    };
+    if (options.autoLoad) {
+        window.google = googlePayMock;
+    }
+    return { mockPaymentsClient, googlePayMock };
+};
+export const setupRecaptchaEnvironment = () => {
+    const mockGrecaptcha = {
+        render: jest.fn().mockReturnValue(123),
+        reset: jest.fn(),
+        execute: jest.fn(),
+        getResponse: jest.fn().mockReturnValue(null),
+    };
+    return mockGrecaptcha;
+};
+export const createTestContact = (overrides = {}) => (Object.assign({ salutation: 'Mr', firstName: 'John', lastName: 'Doe', company: 'Test Corp', email: 'test@example.com', primaryPhone: '555-1234' }, overrides));
+export const createTestAddress = (overrides = {}) => (Object.assign({ address1: '123 Test St', address2: 'Suite 100', city: 'Test City', state: 'NY', zip: '10001', country: 'US' }, overrides));
+export const createTestCreditCard = (overrides = {}) => (Object.assign({ cardNumber: '4111111111111111', expirationMonth: '12', expirationYear: '2025', verificationValue: '123' }, overrides));
+export const createTestBankAccount = (overrides = {}) => (Object.assign({ accountNumber: '1234567890', routingNumber: '021000021', accountType: 'checking', accountHolderType: 'personal' }, overrides));
+export const cleanupWindowMocks = () => {
+    delete window.ApplePaySession;
+    delete window.google;
+    delete window.grecaptcha;
+};

package/dist/esm/tokenize/CardConnectTokenizer.d.ts

@@ -0,0 +1,51 @@
+import { Tokenizer } from './Tokenizer';
+import { PaymentData, PaymentToken, ValidationResult, PaymentGateway, TokenizerContainer } from './types';
+import { TokenizeCardConnectBankAccountResult } from '../types';
+import ConfigHandler from '../config-handler';
+export declare class CardConnectTokenizer extends Tokenizer {
+    private iframeUrl;
+    private containerId;
+    private layout;
+    private iframe;
+    private messageHandler?;
+    private expectedOrigin;
+    private isReady;
+    private currentValidationState;
+    private containerEl?;
+    private routingNumberEl?;
+    private accountNumberEl?;
+    private accountTypeEl?;
+    private enableTestMode;
+    private cachedTokenResult?;
+    private tokenizationPromise?;
+    private tokenizationResolve?;
+    private tokenizationReject?;
+    private constructor();
+    static create(gateway: PaymentGateway, container: TokenizerContainer, config: {
+        organizationId: string;
+        embedId: string;
+        clientConfig: ConfigHandler;
+    }): Promise<CardConnectTokenizer>;
+    private createInternalElements;
+    private createCreditCardFields;
+    private createBankAccountFields;
+    private init;
+    tokenize(paymentData: PaymentData): Promise<PaymentToken>;
+    private tokenizeCardInternal;
+    private tokenizeBankAccountInternal;
+    validate(): Promise<ValidationResult>;
+    private validateCardInternal;
+    private validateBankAccountInternal;
+    clear(): void;
+    focus(field: 'cardNumber' | 'cvv' | 'expiry' | 'routingNumber' | 'accountNumber'): void;
+    destroy(): void;
+    hasToken(): boolean;
+    getToken(): PaymentToken | null;
+    get tokenizationMode(): 'auto' | 'manual';
+    private handleMessage;
+    private handleValidationMessage;
+    private static generateIframeUrl;
+    private static createIframe;
+    private static generateCardConnectCss;
+    static tokenizeBankAccount(routingNumber: string, accountNumber: string, config: ConfigHandler): Promise<TokenizeCardConnectBankAccountResult>;
+}