@idonatedev/idonate-sdk 1.0.16 → 1.1.0-dev0

package/dist/recaptcha.js

@@ -1,27 +1,18 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapElement = exports.RecaptchaElement = exports.injectScript = void 0;
+exports.RecaptchaElement = void 0;
+exports.injectScript = injectScript;
+exports.wrapElement = wrapElement;
 function resolveLib() {
-    var startWait = new Date();
-    return new Promise(function (resolve, reject) {
+    const startWait = new Date();
+    return new Promise((resolve, reject) => {
         function poll() {
             if (window.grecaptcha !== undefined &&
                 window.grecaptcha.render !== undefined) {
                 resolve(window.grecaptcha);
             }
             else {
-                var elapsedMs = new Date().valueOf() - startWait.valueOf();
+                const elapsedMs = new Date().valueOf() - startWait.valueOf();
                 if (elapsedMs > 15000) {
                     reject(new Error('grecaptcha not loaded after 15 seconds'));
                 }
@@ -37,68 +28,68 @@ function injectScript(callback) {
     if (window.grecaptcha !== undefined) {
         throw new Error('grecaptcha is already defined');
     }
-    var script = document.createElement('script');
+    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') {
+    if (document.readyState === 'interactive' ||
+        document.readyState === 'complete') {
         document.body.appendChild(script);
     }
     else {
-        window.addEventListener('DOMContentLoaded', function () {
+        window.addEventListener('DOMContentLoaded', () => {
             document.body.appendChild(script);
         });
     }
 }
-exports.injectScript = injectScript;
-var RecaptchaElement = (function () {
-    function RecaptchaElement(container, params) {
+class RecaptchaElement {
+    constructor(container, params) {
         this.container = container;
         this.params = params;
         this.executeResolveQueue = [];
     }
-    RecaptchaElement.prototype.render = function () {
-        var _this = this;
+    render() {
         if (this.widgetId !== undefined) {
             console.warn('rendering an already-rendered widget');
         }
-        return resolveLib().then(function (lib) {
-            _this.widgetId = lib.render(_this.container, __assign(__assign({}, _this.params), { callback: function (token) {
+        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': function () {
-                    _this.resolvedToken = undefined;
+                    this.resolvedToken = token;
+                    (_a = this.executeResolveQueue.pop()) === null || _a === void 0 ? void 0 : _a(token);
+                }, 'expired-callback': () => {
+                    this.resolvedToken = undefined;
                 } }));
         });
-    };
-    RecaptchaElement.prototype.resolveToken = function () {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            resolveLib().then(function (lib) {
-                if (_this.params.size !== 'invisible') {
-                    var response = lib.getResponse();
-                    return response ? resolve(response) : reject(new Error('checkbox recaptcha is not checked'));
+    }
+    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);
+                this.executeResolveQueue.push(resolve);
+                if (this.resolvedToken !== undefined) {
+                    this.resolvedToken = undefined;
+                    lib.reset(this.widgetId);
                 }
-                lib.execute(_this.widgetId);
-            }).catch(function (e) {
+                lib.execute(this.widgetId);
+            })
+                .catch((e) => {
                 reject(e);
             });
         });
-    };
-    return RecaptchaElement;
-}());
+    }
+}
 exports.RecaptchaElement = RecaptchaElement;
 function wrapElement(container, sitekey, extraParams) {
-    var params = __assign(__assign({}, (extraParams || {})), { sitekey: sitekey });
-    var captcha = new RecaptchaElement(container, params);
+    const params = Object.assign(Object.assign({}, (extraParams || {})), { sitekey });
+    const captcha = new RecaptchaElement(container, params);
     captcha.render();
     return captcha;
 }
-exports.wrapElement = wrapElement;

package/dist/shared.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPaymentMethod = void 0;
-var typeAdapters_1 = require("./typeAdapters");
-var constants_1 = require("./constants");
-var util_1 = require("./util");
+exports.createPaymentMethod = createPaymentMethod;
+const typeAdapters_1 = require("./typeAdapters");
+const constants_1 = require("./constants");
+const util_1 = require("./util");
 function createPaymentMethod(paymentMethod, config) {
-    var payload = typeAdapters_1.buildCreatePaymentMethodPayload(paymentMethod);
-    return fetch(config.embedApiBaseUrl + "/payment/payment-methods", {
+    const payload = (0, typeAdapters_1.buildCreatePaymentMethodPayload)(paymentMethod);
+    return fetch(`${config.embedApiBaseUrl}/payment/payment-methods`, {
         method: 'POST',
         headers: constants_1.CLIENT_HEADERS,
         body: JSON.stringify(payload),
     })
-        .then(function (response) { return util_1.parseResponse(response, { throwErrors: true }); })
-        .then(function (response) { return typeAdapters_1.buildCreatePaymentMethodResult(response); });
+        .then((response) => (0, util_1.parseResponse)(response, { throwErrors: true }))
+        .then((response) => (0, typeAdapters_1.buildCreatePaymentMethodResult)(response));
 }
-exports.createPaymentMethod = createPaymentMethod;

package/dist/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/test-utils.js

@@ -0,0 +1,110 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanupWindowMocks = exports.createTestBankAccount = exports.createTestCreditCard = exports.createTestAddress = exports.createTestContact = exports.setupRecaptchaEnvironment = exports.setupGooglePayEnvironment = exports.setupApplePayEnvironment = exports.setupDocumentMock = exports.setupFetchMock = exports.createMockFetchWithImplementation = exports.createMockFetchError = exports.createMockFetch = void 0;
+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); }),
+    });
+};
+exports.createMockFetch = createMockFetch;
+const createMockFetchError = (message) => {
+    return jest.fn().mockRejectedValue(new Error(message));
+};
+exports.createMockFetchError = createMockFetchError;
+const createMockFetchWithImplementation = (implementation) => {
+    return jest.fn().mockImplementation(implementation);
+};
+exports.createMockFetchWithImplementation = createMockFetchWithImplementation;
+const setupFetchMock = () => {
+    const mockFetch = jest.fn();
+    global.fetch = mockFetch;
+    return mockFetch;
+};
+exports.setupFetchMock = setupFetchMock;
+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 };
+};
+exports.setupDocumentMock = setupDocumentMock;
+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 };
+};
+exports.setupApplePayEnvironment = setupApplePayEnvironment;
+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 };
+};
+exports.setupGooglePayEnvironment = setupGooglePayEnvironment;
+const setupRecaptchaEnvironment = () => {
+    const mockGrecaptcha = {
+        render: jest.fn().mockReturnValue(123),
+        reset: jest.fn(),
+        execute: jest.fn(),
+        getResponse: jest.fn().mockReturnValue(null),
+    };
+    return mockGrecaptcha;
+};
+exports.setupRecaptchaEnvironment = setupRecaptchaEnvironment;
+const createTestContact = (overrides = {}) => (Object.assign({ salutation: 'Mr', firstName: 'John', lastName: 'Doe', company: 'Test Corp', email: 'test@example.com', primaryPhone: '555-1234' }, overrides));
+exports.createTestContact = createTestContact;
+const createTestAddress = (overrides = {}) => (Object.assign({ address1: '123 Test St', address2: 'Suite 100', city: 'Test City', state: 'NY', zip: '10001', country: 'US' }, overrides));
+exports.createTestAddress = createTestAddress;
+const createTestCreditCard = (overrides = {}) => (Object.assign({ cardNumber: '4111111111111111', expirationMonth: '12', expirationYear: '2025', verificationValue: '123' }, overrides));
+exports.createTestCreditCard = createTestCreditCard;
+const createTestBankAccount = (overrides = {}) => (Object.assign({ accountNumber: '1234567890', routingNumber: '021000021', accountType: 'checking', accountHolderType: 'personal' }, overrides));
+exports.createTestBankAccount = createTestBankAccount;
+const cleanupWindowMocks = () => {
+    delete window.ApplePaySession;
+    delete window.google;
+    delete window.grecaptcha;
+};
+exports.cleanupWindowMocks = cleanupWindowMocks;

package/dist/tokenize/CardConnectTokenizer.d.ts

@@ -0,0 +1,43 @@
+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 iframe;
+    private messageHandler?;
+    private expectedOrigin;
+    private isReady;
+    private currentValidationState;
+    private containerEl?;
+    private routingNumberEl?;
+    private accountNumberEl?;
+    private accountTypeEl?;
+    private enableTestMode;
+    private cachedTokenResult?;
+    private constructor();
+    static create(gateway: PaymentGateway, container: TokenizerContainer, config?: {
+        organizationId: string;
+        embedId: string;
+    }): 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;
+    private handleMessage;
+    private handleValidationMessage;
+    private static generateIframeUrl;
+    private static createIframe;
+    private static generateCardConnectCss;
+    static tokenizeBankAccount(routingNumber: string, accountNumber: string, config: ConfigHandler): Promise<TokenizeCardConnectBankAccountResult>;
+}