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

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

@@ -0,0 +1,144 @@
+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;
+    layout?: 'single-line' | 'two-line';
+}
+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;
+        flexWrap?: string;
+        rowGap?: 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;
+    email?: string;
+    phone?: string;
+    address?: {
+        line1?: string;
+        line2?: string;
+        city?: string;
+        state?: string;
+        postalCode?: string;
+        country?: string;
+    };
+}
+export interface BankAccountData {
+    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 BankAccountData {
+}
+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' | 'tokenReady';
+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/esm/tokenize/types.js

@@ -0,0 +1,26 @@
+export 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,
+                },
+            ];
+        }
+    }
+}

package/dist/esm/typeAdapters.d.ts

@@ -0,0 +1,29 @@
+import { CreatePaymentMethodRequest, CreatePaymentMethodResult, CreateDonationRequest, CreateDonationResult, ClientResponse, ClientError, CashPaymentPayload } from './types';
+export declare function buildCashPaymentPayload(organizationId: string, input: CreateDonationRequest): CashPaymentPayload;
+export declare function buildDonationResult(response: ClientResponse): CreateDonationResult;
+export declare function buildCreatePaymentMethodPayload(input: CreatePaymentMethodRequest): {
+    gateway_id: string | undefined;
+    backend_name: import("./types").BackendName | undefined;
+    payment_method_type: import("./types").PaymentMethodType;
+    payment_method_token: string;
+    donor_id: string | undefined;
+    first_name: string;
+    last_name: string;
+    company: string;
+    email: string | undefined;
+    phone: string;
+    country: string;
+    address1: string;
+    address2: string | undefined;
+    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 type SpreedlyResponse = any;
+export declare function unpackSpreedlyResponse(response: any): Promise<SpreedlyResponse>;
+export declare function extractSpreedlyToken(spreedlyData: SpreedlyResponse): string;

package/dist/esm/typeAdapters.js

@@ -0,0 +1,188 @@
+import { ClientError, } from './types';
+export function buildCashPaymentPayload(organizationId, input) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+    const billingAddress = {
+        country: input.billingAddress.country,
+        address1: input.billingAddress.address1,
+        address2: input.billingAddress.address2,
+        city: input.billingAddress.city,
+        state: input.billingAddress.state,
+        zip_code: input.billingAddress.zip,
+    };
+    const billingContact = {
+        title: input.billingContact.salutation,
+        first_name: input.billingContact.firstName,
+        middle_name: input.billingContact.middleName,
+        last_name: input.billingContact.lastName,
+        company_name: input.billingContact.company,
+        email: input.billingContact.email,
+        home_phone: input.billingContact.primaryPhone,
+        timezone: new Intl.DateTimeFormat().resolvedOptions().timeZone,
+    };
+    const payment = {
+        payment_method_id: input.paymentMethodId,
+        gateway_id: input.paymentGatewayId,
+        amount: input.paymentAmount,
+        type: 'cash',
+        frequency: input.recurringFrequency,
+        start_date: input.recurringStart,
+        end_date: input.recurringEnd,
+        retain_on_success: input.retainPaymentMethod,
+    };
+    const donationOptions = {
+        organization_id: organizationId,
+        campaign_id: input.campaignId,
+        reference_code: input.referenceCode,
+        double_the_donation_company_id: input.corporateMatchingId,
+        donor_id: input.donorId,
+        hide_name: input.anonymousOptIn,
+        show_name_to_fundraiser: input.showNameToFundraiserOptIn,
+        email_opt_in: input.emailOptIn,
+        donor_paid_fee: input.donorPaidFeeAmount,
+        designation_note: input.designationNote,
+        gift_id: input.giftId,
+        gift_extra: input.giftExtra,
+        gift_skipped: input.giftSkipped,
+        p2p_fundraiser_id: input.p2pFundraiserId,
+        p2p_fundraiser_comment: input.p2pFundraiserComment,
+        organization_event_id: input.organizationEventId,
+        advocate_id: input.advocateId,
+        advocacy_program_id: input.advocacyProgramId,
+        advocacy_team_id: input.advocacyTeamId,
+        page_id: input.landingPageId,
+        embed_id: input.embedId,
+        tribute_definition_id: (_a = input.tribute) === null || _a === void 0 ? void 0 : _a.tributeDefinitionId,
+        tribute_recipient_first_name: (_b = input.tribute) === null || _b === void 0 ? void 0 : _b.tributeFirstName,
+        tribute_recipient_last_name: (_c = input.tribute) === null || _c === void 0 ? void 0 : _c.tributeLastName,
+        tribute_address1: (_d = input.tribute) === null || _d === void 0 ? void 0 : _d.tributeAddress1,
+        tribute_address2: (_e = input.tribute) === null || _e === void 0 ? void 0 : _e.tributeAddress2,
+        tribute_city: (_f = input.tribute) === null || _f === void 0 ? void 0 : _f.tributeCity,
+        tribute_state: (_g = input.tribute) === null || _g === void 0 ? void 0 : _g.tributeState,
+        tribute_postal_code: (_h = input.tribute) === null || _h === void 0 ? void 0 : _h.tributePostalCode,
+        tribute_country: (_j = input.tribute) === null || _j === void 0 ? void 0 : _j.tributeCountry,
+        tribute_from_name: (_k = input.tribute) === null || _k === void 0 ? void 0 : _k.tributeFromName,
+        tribute_recipient_email: (_l = input.tribute) === null || _l === void 0 ? void 0 : _l.tributeRecipientEmail,
+        honorees: (_m = input.tribute) === null || _m === void 0 ? void 0 : _m.honorees,
+        tribute_send_card: (_o = input.tribute) === null || _o === void 0 ? void 0 : _o.tributeSendCard,
+        tribute_include_amount: (_p = input.tribute) === null || _p === void 0 ? void 0 : _p.tributeIncludeAmount,
+        tribute_skipped: (_q = input.tribute) === null || _q === void 0 ? void 0 : _q.tributeSkipped,
+        tribute_type: (_r = input.tribute) === null || _r === void 0 ? void 0 : _r.tributeType,
+        useOnBillingAddress: (_s = input.tribute) === null || _s === void 0 ? void 0 : _s.useOnBillingAddress,
+        embed_referer: window.location.href,
+        converted_to_recurring: input.convertedToRecurring,
+    };
+    if (input.designations) {
+        donationOptions.designations = input.designations;
+    }
+    else {
+        donationOptions.designations = [];
+    }
+    if (input.designationId) {
+        donationOptions.designations.push({
+            id: input.designationId,
+            amount: input.paymentAmount,
+        });
+    }
+    const utmFields = {};
+    if (input.utm) {
+        if (input.utm.campaign) {
+            utmFields.utm_campaign = input.utm.campaign;
+        }
+        if (input.utm.content) {
+            utmFields.utm_content = input.utm.content;
+        }
+        if (input.utm.medium) {
+            utmFields.utm_medium = input.utm.medium;
+        }
+        if (input.utm.source) {
+            utmFields.utm_source = input.utm.source;
+        }
+        if (input.utm.term) {
+            utmFields.utm_term = input.utm.term;
+        }
+    }
+    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 });
+}
+export function buildDonationResult(response) {
+    let campaign;
+    let designation;
+    let donor;
+    let schedule;
+    let transaction;
+    if (response._raw_response.transaction) {
+        transaction = response._raw_response.transaction;
+    }
+    if (response._raw_response.schedule) {
+        schedule = response._raw_response.schedule;
+    }
+    if (response._raw_response.donor) {
+        donor = response._raw_response.donor;
+    }
+    if (response._raw_response.designation) {
+        designation = response._raw_response.designation;
+    }
+    if (response._raw_response.campaign) {
+        campaign = response._raw_response.campaign;
+    }
+    return Object.assign(Object.assign({}, response), { campaign,
+        designation,
+        donor,
+        schedule,
+        transaction });
+}
+export function buildCreatePaymentMethodPayload(input) {
+    return {
+        gateway_id: input.paymentGatewayId,
+        backend_name: input.backendName,
+        payment_method_type: input.paymentMethodType,
+        payment_method_token: input.paymentMethodToken,
+        donor_id: input.donorId,
+        first_name: input.contact.firstName,
+        last_name: input.contact.lastName,
+        company: input.contact.company,
+        email: input.contact.email,
+        phone: input.contact.primaryPhone,
+        country: input.address.country,
+        address1: input.address.address1,
+        address2: input.address.address2,
+        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,
+    };
+}
+export function collapseClientErrors(errors) {
+    return new ClientError(errors.map((err) => err.message).join(`\n `), {
+        _rawPayload: errors,
+    });
+}
+export function buildCreatePaymentMethodResult(response) {
+    return Object.assign(Object.assign({}, response), { paymentMethodId: response._raw_response.result.id });
+}
+export function unpackSpreedlyResponse(response) {
+    return response.json().then((data) => {
+        if (data.errors) {
+            throw new ClientError(data.errors
+                .map((spreedlyError) => spreedlyError.message)
+                .join(`\n  `), data);
+        }
+        return data;
+    });
+}
+export function extractSpreedlyToken(spreedlyData) {
+    if (!spreedlyData.transaction || !spreedlyData.transaction.payment_method) {
+        throw new ClientError('Payment Method not tokenized.');
+    }
+    return spreedlyData.transaction.payment_method.token;
+}