@idonatedev/idonate-sdk 1.0.16 → 1.1.0-dev0

package/dist/tokenize/tokenizer-utils.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExpiryDate = parseExpiryDate;
+exports.formatExpiryInput = formatExpiryInput;
+exports.withTimeout = withTimeout;
+exports.getConnectedBorderRadius = getConnectedBorderRadius;
+exports.addFocusHandlers = addFocusHandlers;
+exports.createFieldContainer = createFieldContainer;
+exports.createInputElement = createInputElement;
+exports.validateRoutingNumber = validateRoutingNumber;
+exports.validateAccountNumber = validateAccountNumber;
+exports.maskAccountNumber = maskAccountNumber;
+exports.createAccountTypeSelect = createAccountTypeSelect;
+exports.validateInstitutionNumber = validateInstitutionNumber;
+exports.validateTransitNumber = validateTransitNumber;
+exports.validateCanadianAccountNumber = validateCanadianAccountNumber;
+exports.formatCanadianRoutingNumber = formatCanadianRoutingNumber;
+function parseExpiryDate(value) {
+    const parts = value.split('/');
+    if (parts.length !== 2)
+        return null;
+    const month = parts[0];
+    const year = parts[1];
+    if (month.length !== 2 || year.length !== 2)
+        return null;
+    return {
+        month,
+        year: '20' + year,
+    };
+}
+function formatExpiryInput(value) {
+    let digits = value.replace(/\D/g, '');
+    digits = digits.substring(0, 4);
+    if (digits.length >= 2) {
+        return digits.substring(0, 2) + '/' + digits.substring(2, 4);
+    }
+    return digits;
+}
+function withTimeout(promise, timeoutMs, errorMessage) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(errorMessage)), timeoutMs)),
+    ]);
+}
+function getConnectedBorderRadius(baseRadius, position, isConnected) {
+    if (!isConnected)
+        return baseRadius;
+    switch (position) {
+        case 'left':
+            return `${baseRadius} 0 0 ${baseRadius}`;
+        case 'middle':
+            return '0';
+        case 'right':
+            return `0 ${baseRadius} ${baseRadius} 0`;
+        default:
+            return baseRadius;
+    }
+}
+function addFocusHandlers(element, styles, onFocus, onBlur) {
+    element.addEventListener('focus', () => {
+        if (styles.focus) {
+            Object.assign(element.style, styles.focus);
+        }
+        onFocus === null || onFocus === void 0 ? void 0 : onFocus();
+    });
+    element.addEventListener('blur', () => {
+        element.style.borderColor = '';
+        element.style.outline = 'none';
+        element.style.boxShadow = 'none';
+        onBlur === null || onBlur === void 0 ? void 0 : onBlur();
+    });
+}
+function createFieldContainer(id, flex, minWidth, maxWidth) {
+    const div = document.createElement('div');
+    div.id = id;
+    div.style.flex = flex;
+    div.style.display = 'flex';
+    if (minWidth)
+        div.style.minWidth = minWidth;
+    if (maxWidth)
+        div.style.maxWidth = maxWidth;
+    return div;
+}
+function createInputElement(id, type, placeholder, maxLength) {
+    const input = document.createElement('input');
+    input.id = id;
+    input.type = type;
+    input.placeholder = placeholder;
+    if (maxLength)
+        input.maxLength = maxLength;
+    return input;
+}
+function validateRoutingNumber(routingNumber) {
+    const cleaned = routingNumber.replace(/\D/g, '');
+    if (cleaned.length !== 9) {
+        return false;
+    }
+    const digits = cleaned.split('').map(Number);
+    const checksum = (digits[0] * 3 +
+        digits[1] * 7 +
+        digits[2] * 1 +
+        digits[3] * 3 +
+        digits[4] * 7 +
+        digits[5] * 1 +
+        digits[6] * 3 +
+        digits[7] * 7 +
+        digits[8] * 1) %
+        10;
+    return checksum === 0;
+}
+function validateAccountNumber(accountNumber) {
+    const cleaned = accountNumber.replace(/\D/g, '');
+    if (cleaned.length < 4 || cleaned.length > 17) {
+        return false;
+    }
+    return /^\d+$/.test(cleaned);
+}
+function maskAccountNumber(accountNumber) {
+    const cleaned = accountNumber.replace(/\D/g, '');
+    if (cleaned.length <= 4) {
+        return cleaned;
+    }
+    const lastFour = cleaned.slice(-4);
+    const masked = '*'.repeat(cleaned.length - 4) + lastFour;
+    return masked;
+}
+function createAccountTypeSelect(id) {
+    const select = document.createElement('select');
+    select.id = id;
+    const checkingOption = document.createElement('option');
+    checkingOption.value = 'checking';
+    checkingOption.text = 'Checking';
+    const savingsOption = document.createElement('option');
+    savingsOption.value = 'savings';
+    savingsOption.text = 'Savings';
+    select.appendChild(checkingOption);
+    select.appendChild(savingsOption);
+    return select;
+}
+function validateInstitutionNumber(institutionNumber) {
+    const cleaned = institutionNumber.replace(/\D/g, '');
+    return cleaned.length === 3;
+}
+function validateTransitNumber(transitNumber) {
+    const cleaned = transitNumber.replace(/\D/g, '');
+    return cleaned.length === 5;
+}
+function validateCanadianAccountNumber(accountNumber) {
+    const cleaned = accountNumber.replace(/\D/g, '');
+    return cleaned.length >= 7;
+}
+function formatCanadianRoutingNumber(institutionNumber, transitNumber) {
+    const institution = institutionNumber.replace(/\D/g, '').padStart(3, '0');
+    const transit = transitNumber.replace(/\D/g, '').padStart(5, '0');
+    return '0' + institution + transit;
+}

package/dist/tokenize/types.d.ts

@@ -0,0 +1,149 @@
+export type PaymentMethodType = 'credit_card' | 'bank_account' | 'paypal' | 'apple_pay' | 'google_pay';
+export type PaymentMethodMode = 'credit_card' | 'bank_account';
+export interface PaymentGateway {
+    id: string;
+    backend_name: string;
+    gateway_type?: string;
+    name: string;
+    config?: {
+        environment_key?: string;
+        base_url?: string;
+        merchant_id?: string;
+        [key: string]: any;
+    };
+}
+export interface TokenizerContainer {
+    containerId: string;
+    styling?: TokenizerStyling;
+    mode?: PaymentMethodMode;
+    bankCountry?: 'US' | 'CA';
+    enableTestMode?: boolean;
+}
+export interface TokenizerStylingComplete {
+    input: {
+        height: string;
+        padding: string;
+        fontSize: string;
+        fontFamily: string;
+        border: string;
+        borderRadius: string;
+        backgroundColor: string;
+        color: string;
+        boxSizing: string;
+        width: string;
+        lineHeight?: string;
+        transition: string;
+    };
+    focus: {
+        borderColor: string;
+        outline: string;
+        boxShadow: string;
+    };
+    error: {
+        borderColor: string;
+        color?: string;
+        backgroundColor?: string;
+    };
+    container: {
+        display: string;
+        gap: string;
+        alignItems: string;
+    };
+}
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type TokenizerStyling = DeepPartial<TokenizerStylingComplete>;
+export interface CardData {
+    firstName: string;
+    lastName: string;
+    expiryMonth: string;
+    expiryYear: string;
+    email?: string;
+    phone?: string;
+    address?: {
+        line1?: string;
+        line2?: string;
+        city?: string;
+        state?: string;
+        postalCode?: string;
+        country?: string;
+    };
+}
+export interface BankAccountData {
+    routingNumber: string;
+    accountNumber: string;
+    accountType: 'checking' | 'savings';
+    accountHolderType: 'personal' | 'business';
+    firstName: string;
+    lastName: string;
+    email?: string;
+    phone?: string;
+    address?: {
+        line1?: string;
+        line2?: string;
+        city?: string;
+        state?: string;
+        postalCode?: string;
+        country?: string;
+    };
+}
+export interface CanadianBankAccountData extends Omit<BankAccountData, 'routingNumber'> {
+    institutionNumber: string;
+    transitNumber: string;
+}
+export type PaymentData = CardData | BankAccountData | CanadianBankAccountData;
+export interface PaymentToken {
+    token: string;
+    lastFour: string;
+    cardType?: CardType;
+    accountType?: 'checking' | 'savings';
+    paymentMethodType?: PaymentMethodMode;
+    expiresAt?: Date;
+    provider?: string;
+}
+export type CardType = 'visa' | 'mastercard' | 'amex' | 'discover' | 'diners' | 'jcb' | 'unknown';
+export type TokenizerEvent = 'ready' | 'focus' | 'blur' | 'change' | 'validation' | 'cardTypeChange' | 'error' | 'tokenization';
+export interface ValidationState {
+    isValid: boolean;
+    cardNumber?: {
+        isValid: boolean;
+        isEmpty: boolean;
+        error?: string;
+    };
+    cvv?: {
+        isValid: boolean;
+        isEmpty: boolean;
+        error?: string;
+    };
+    expiry?: {
+        isValid: boolean;
+        isEmpty: boolean;
+        error?: string;
+    };
+    routingNumber?: {
+        isValid: boolean;
+        isEmpty: boolean;
+        error?: string;
+    };
+    accountNumber?: {
+        isValid: boolean;
+        isEmpty: boolean;
+        error?: string;
+    };
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationError[];
+}
+export interface ValidationError {
+    field: 'cardNumber' | 'cvv' | 'expiry' | 'routingNumber' | 'accountNumber';
+    message: string;
+    code?: string;
+}
+export declare class TokenizationError extends Error {
+    errors: ValidationError[];
+    code?: string;
+    constructor(errors: any[] | string, code?: string);
+}
+export {};

package/dist/tokenize/types.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenizationError = void 0;
+class TokenizationError extends Error {
+    constructor(errors, code) {
+        const message = typeof errors === 'string'
+            ? errors
+            : errors.map((e) => e.message || e).join(', ');
+        super(message);
+        this.name = 'TokenizationError';
+        this.code = code;
+        if (Array.isArray(errors)) {
+            this.errors = errors.map((e) => ({
+                field: e.field || e.attribute || 'unknown',
+                message: e.message || e.error || String(e),
+                code: e.code || e.key,
+            }));
+        }
+        else {
+            this.errors = [
+                {
+                    field: 'cardNumber',
+                    message: errors,
+                    code,
+                },
+            ];
+        }
+    }
+}
+exports.TokenizationError = TokenizationError;

package/dist/typeAdapters.d.ts

@@ -3,7 +3,7 @@ export declare function buildCashPaymentPayload(organizationId: string, input: C
 export declare function buildDonationResult(response: ClientResponse): CreateDonationResult;
 export declare function buildCreatePaymentMethodPayload(input: CreatePaymentMethodRequest): {
     gateway_id: string | undefined;
-    backend_name: "spreedly" | "card_connect" | "iats" | undefined;
+    backend_name: import("./types").BackendName | undefined;
     payment_method_type: import("./types").PaymentMethodType;
     payment_method_token: string;
     donor_id: string | undefined;
@@ -18,11 +18,12 @@ export declare function buildCreatePaymentMethodPayload(input: CreatePaymentMeth
     city: string;
     state: string;
     zip_code: string;
+    embed_id: string | undefined;
     recaptcha_token: string;
     recaptcha_type: import("./types").RecaptchaType;
 };
 export declare function collapseClientErrors(errors: ClientError[]): ClientError;
 export declare function buildCreatePaymentMethodResult(response: ClientResponse): CreatePaymentMethodResult;
-export declare type SpreedlyResponse = any;
+export type SpreedlyResponse = any;
 export declare function unpackSpreedlyResponse(response: any): Promise<SpreedlyResponse>;
 export declare function extractSpreedlyToken(spreedlyData: SpreedlyResponse): string;

package/dist/typeAdapters.js

@@ -1,21 +1,16 @@
 "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.extractSpreedlyToken = exports.unpackSpreedlyResponse = exports.buildCreatePaymentMethodResult = exports.collapseClientErrors = exports.buildCreatePaymentMethodPayload = exports.buildDonationResult = exports.buildCashPaymentPayload = void 0;
-var types_1 = require("./types");
+exports.buildCashPaymentPayload = buildCashPaymentPayload;
+exports.buildDonationResult = buildDonationResult;
+exports.buildCreatePaymentMethodPayload = buildCreatePaymentMethodPayload;
+exports.collapseClientErrors = collapseClientErrors;
+exports.buildCreatePaymentMethodResult = buildCreatePaymentMethodResult;
+exports.unpackSpreedlyResponse = unpackSpreedlyResponse;
+exports.extractSpreedlyToken = extractSpreedlyToken;
+const types_1 = require("./types");
 function buildCashPaymentPayload(organizationId, input) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
-    var billingAddress = {
+    const billingAddress = {
         country: input.billingAddress.country,
         address1: input.billingAddress.address1,
         address2: input.billingAddress.address2,
@@ -23,7 +18,7 @@ function buildCashPaymentPayload(organizationId, input) {
         state: input.billingAddress.state,
         zip_code: input.billingAddress.zip,
     };
-    var billingContact = {
+    const billingContact = {
         title: input.billingContact.salutation,
         first_name: input.billingContact.firstName,
         middle_name: input.billingContact.middleName,
@@ -33,7 +28,7 @@ function buildCashPaymentPayload(organizationId, input) {
         home_phone: input.billingContact.primaryPhone,
         timezone: new Intl.DateTimeFormat().resolvedOptions().timeZone,
     };
-    var payment = {
+    const payment = {
         payment_method_id: input.paymentMethodId,
         gateway_id: input.paymentGatewayId,
         amount: input.paymentAmount,
@@ -43,7 +38,7 @@ function buildCashPaymentPayload(organizationId, input) {
         end_date: input.recurringEnd,
         retain_on_success: input.retainPaymentMethod,
     };
-    var donationOptions = {
+    const donationOptions = {
         organization_id: organizationId,
         campaign_id: input.campaignId,
         reference_code: input.referenceCode,
@@ -97,7 +92,7 @@ function buildCashPaymentPayload(organizationId, input) {
             amount: input.paymentAmount,
         });
     }
-    var utmFields = {};
+    const utmFields = {};
     if (input.utm) {
         if (input.utm.campaign) {
             utmFields.utm_campaign = input.utm.campaign;
@@ -115,22 +110,23 @@ function buildCashPaymentPayload(organizationId, input) {
             utmFields.utm_term = input.utm.term;
         }
     }
-    [1, 2, 3, 4, 5].forEach(function (customNoteIndex) {
-        var key = "custom_note_" + customNoteIndex;
-        if (input.customerMeta[key]) {
-            donationOptions[key] = input.customerMeta[key];
-            delete input.customerMeta[key];
-        }
-    });
-    return __assign(__assign(__assign(__assign(__assign(__assign({}, donationOptions), billingAddress), billingContact), payment), utmFields), { customer_meta: input.customerMeta, recaptcha_token: input.recaptchaToken, recaptcha_type: input.recaptchaType });
+    if (input.customerMeta) {
+        [1, 2, 3, 4, 5].forEach((customNoteIndex) => {
+            const key = `custom_note_${customNoteIndex}`;
+            if (input.customerMeta[key]) {
+                donationOptions[key] = input.customerMeta[key];
+                delete input.customerMeta[key];
+            }
+        });
+    }
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, donationOptions), billingAddress), billingContact), payment), utmFields), { customer_meta: input.customerMeta || {}, recaptcha_token: input.recaptchaToken, recaptcha_type: input.recaptchaType });
 }
-exports.buildCashPaymentPayload = buildCashPaymentPayload;
 function buildDonationResult(response) {
-    var campaign;
-    var designation;
-    var donor;
-    var schedule;
-    var transaction;
+    let campaign;
+    let designation;
+    let donor;
+    let schedule;
+    let transaction;
     if (response._raw_response.transaction) {
         transaction = response._raw_response.transaction;
     }
@@ -146,13 +142,12 @@ function buildDonationResult(response) {
     if (response._raw_response.campaign) {
         campaign = response._raw_response.campaign;
     }
-    return __assign(__assign({}, response), { campaign: campaign,
-        designation: designation,
-        donor: donor,
-        schedule: schedule,
-        transaction: transaction });
+    return Object.assign(Object.assign({}, response), { campaign,
+        designation,
+        donor,
+        schedule,
+        transaction });
 }
-exports.buildDonationResult = buildDonationResult;
 function buildCreatePaymentMethodPayload(input) {
     return {
         gateway_id: input.paymentGatewayId,
@@ -171,36 +166,32 @@ function buildCreatePaymentMethodPayload(input) {
         city: input.address.city,
         state: input.address.state,
         zip_code: input.address.zip,
+        embed_id: input.embedId,
         recaptcha_token: input.recaptchaToken,
         recaptcha_type: input.recaptchaType,
     };
 }
-exports.buildCreatePaymentMethodPayload = buildCreatePaymentMethodPayload;
 function collapseClientErrors(errors) {
-    return new types_1.ClientError(errors.map(function (err) { return err.message; }).join("\n "), {
+    return new types_1.ClientError(errors.map((err) => err.message).join(`\n `), {
         _rawPayload: errors,
     });
 }
-exports.collapseClientErrors = collapseClientErrors;
 function buildCreatePaymentMethodResult(response) {
-    return __assign(__assign({}, response), { paymentMethodId: response._raw_response.result.id });
+    return Object.assign(Object.assign({}, response), { paymentMethodId: response._raw_response.result.id });
 }
-exports.buildCreatePaymentMethodResult = buildCreatePaymentMethodResult;
 function unpackSpreedlyResponse(response) {
-    return response.json().then(function (data) {
+    return response.json().then((data) => {
         if (data.errors) {
             throw new types_1.ClientError(data.errors
-                .map(function (spreedlyError) { return spreedlyError.message; })
-                .join("\n  "), data);
+                .map((spreedlyError) => spreedlyError.message)
+                .join(`\n  `), data);
         }
         return data;
     });
 }
-exports.unpackSpreedlyResponse = unpackSpreedlyResponse;
 function extractSpreedlyToken(spreedlyData) {
     if (!spreedlyData.transaction || !spreedlyData.transaction.payment_method) {
         throw new types_1.ClientError('Payment Method not tokenized.');
     }
     return spreedlyData.transaction.payment_method.token;
 }
-exports.extractSpreedlyToken = extractSpreedlyToken;