@idonatedev/idonate-sdk 1.1.0-dev8 → 1.2.0-dev0

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,4 @@
+import { CreatePaymentMethodRequest, CreatePaymentMethodResult, EmbedConfig } from './types';
+import ConfigHandler from './config-handler';
+export declare function createPaymentMethod(paymentMethod: CreatePaymentMethodRequest, config: ConfigHandler): Promise<CreatePaymentMethodResult>;
+export declare function fetchEmbedConfig(embedId: string, config: ConfigHandler): Promise<EmbedConfig>;

package/dist/esm/shared.js

@@ -0,0 +1,21 @@
+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));
+}
+export function fetchEmbedConfig(embedId, config) {
+    return fetch(`${config.embedApiBaseUrl}/config/${embedId}`, {
+        method: 'GET',
+        headers: CLIENT_HEADERS,
+    })
+        .then((response) => parseResponse(response, { throwErrors: true }))
+        .then((response) => response._raw_response.result);
+}

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>;
+}