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

package/dist/esm/types.d.ts

@@ -0,0 +1,378 @@
+export declare const ApplePaySessionStatus: {
+    readonly STATUS_SUCCESS: number;
+    readonly STATUS_FAILURE: number;
+};
+export type ApplePayPaymentRequest = ApplePayJS.ApplePayPaymentRequest;
+export type ClientOptions = {
+    enableSandboxMode?: boolean;
+    spreedlyEnvironmentKey?: string;
+    overrideBaseUrl?: string;
+    overrideAuthApiBaseUrl?: string;
+    overrideEmbedApiBaseUrl?: string;
+    overrideDonorApiBaseUrl?: string;
+    overrideCardConnectBaseUrl?: string;
+    overrideApplePayUrl?: string;
+    pcScriptBase?: string;
+    pcScriptId?: string;
+    enableDelay: boolean;
+    secondsToDelay: number;
+    turnstileCdnUrl?: string;
+    turnstileSiteKey?: string;
+    sdkClientName?: string;
+    enableSpreedlySecureTokenization?: boolean;
+    organizationId?: number;
+    embedId?: string;
+};
+export type Address = {
+    address1: string;
+    address2?: string;
+    country: string;
+    city: string;
+    state: string;
+    zip: string;
+};
+export type Contact = {
+    salutation?: string;
+    firstName: string;
+    middleName?: string;
+    lastName: string;
+    fullName?: string;
+    company: string;
+    email?: string;
+    primaryPhone: string;
+};
+export type CreditCard = {
+    cardNumber: string;
+    verificationValue?: string;
+    expirationMonth: string;
+    expirationYear: string;
+};
+export type ACHAccount = {
+    accountNumber: string;
+    routingNumber: string;
+    accountHolderType: 'personal' | 'business';
+    accountType: 'checking' | 'savings';
+};
+export type PaymentMethodType = 'credit_card' | 'bank_account' | 'paypal' | 'apple_pay' | 'google_pay';
+export type RecaptchaType = 'v2' | 'v3' | 'invisible' | 'organization' | 'nonce' | 'bypass';
+export type RecaptchaSecuredRequest = {
+    recaptchaType: RecaptchaType;
+    recaptchaToken: string;
+};
+export type RecurringFrequency = 'once' | 'weekly' | 'twicemonthly' | 'biweekly' | 'monthly' | 'quarterly' | 'semiannually' | 'annually';
+export type UTMData = {
+    campaign?: string;
+    content?: string;
+    medium?: string;
+    source?: string;
+    term?: string;
+};
+export type TributeData = {
+    tributeDefinitionId: string;
+    tributeFirstName: string;
+    tributeLastName: string;
+    tributeAddress1: string;
+    tributeAddress2: string;
+    tributeCity: string;
+    tributeState: string;
+    tributePostalCode: string;
+    tributeCountry: string;
+    tributeFromName: string;
+    tributeType: string;
+    tributeRecipientEmail: string;
+    honorees: {
+        firstname: string;
+        lastname: string;
+        message: string;
+    }[];
+    tributeSendCard: boolean;
+    tributeIncludeAmount: boolean;
+    tributeSkipped: boolean;
+    useOnBillingAddress: boolean;
+};
+export type CreateDonationRequest = RecaptchaSecuredRequest & {
+    paymentGatewayId: string;
+    donorId?: string;
+    paymentMethodId: string;
+    paymentTransactionId?: string;
+    retainPaymentMethod?: boolean;
+    paymentAmount: number;
+    currency: string;
+    billingContact: Contact;
+    billingAddress: Address;
+    referenceCode?: string;
+    designationId?: string;
+    designations?: {
+        id: string;
+        amount: number;
+    }[];
+    designationNote?: string;
+    campaignId?: string;
+    p2pFundraiserId?: string;
+    p2pFundraiserComment?: string;
+    p2pProgramId?: string;
+    organizationEventId?: string;
+    corporateMatchingId?: string;
+    advocateId?: string;
+    advocacyProgramId?: string;
+    advocacyTeamId?: string;
+    landingPageId?: number;
+    customerMeta?: {
+        [key: string]: string;
+    };
+    utm?: UTMData;
+    tribute?: TributeData;
+    recurringFrequency: RecurringFrequency;
+    recurringStart?: Date;
+    recurringEnd?: Date;
+    donorPaidFeeAmount?: number;
+    emailOptIn?: boolean;
+    anonymousOptIn?: boolean;
+    showNameToFundraiserOptIn?: boolean;
+    giftId?: string;
+    giftExtra?: string;
+    giftSkipped?: boolean;
+    embedId?: string;
+    convertedToRecurring?: boolean | undefined;
+};
+export type UtmFields = {
+    utm_campaign?: string;
+    utm_content?: string;
+    utm_medium?: string;
+    utm_source?: string;
+    utm_term?: string;
+};
+export type CashPaymentPayload = {
+    organization_id: string;
+    campaign_id: string;
+    reference_code: string;
+    double_the_donation_company_id: string;
+    donor_id: string;
+    hide_name: boolean;
+    show_name_to_fundraiser: boolean;
+    email_opt_in: boolean;
+    donor_paid_fee: number;
+    designation_note: string;
+    gift_id: string;
+    gift_extra: string;
+    gift_skipped: boolean;
+    p2p_fundraiser_id: string;
+    p2p_fundraiser_comment: string;
+    organization_event_id: string;
+    advocate_id: string;
+    advocacy_program_id: string;
+    advocacy_team_id: string;
+    page_id: number;
+    embed_id: string;
+    tribute_definition_id: string;
+    tribute_recipient_first_name: string;
+    tribute_recipient_last_name: string;
+    tribute_address1: string;
+    tribute_address2: string;
+    tribute_city: string;
+    tribute_state: string;
+    tribute_postal_code: string;
+    tribute_country: string;
+    tribute_from_name: string;
+    tribute_recipient_email: string;
+    honorees: {
+        firstname: string;
+        lastname: string;
+        message: string;
+    }[];
+    tribute_send_card: boolean;
+    tribute_include_amount: boolean;
+    tribute_skipped: boolean;
+    tribute_type: string;
+    useOnBillingAddress: boolean;
+    embed_referer: string;
+    converted_to_recurring: boolean;
+    customer_meta: Record<string, string>;
+    recaptcha_token: string;
+    recaptcha_type: string;
+    designations: {
+        id: string;
+        amount: number;
+    }[];
+    country: string;
+    address1: string;
+    address2: string | undefined;
+    city: string;
+    state: string;
+    zip_code: string;
+    title?: string;
+    first_name: string;
+    middle_name?: string | undefined;
+    last_name: string;
+    company_name: string;
+    email?: string;
+    home_phone: string;
+    timezone: string;
+    payment_method_id: string;
+    gateway_id: string;
+    amount: number;
+    type: 'cash';
+    frequency: RecurringFrequency;
+    start_date: Date | undefined;
+    end_date: Date | undefined;
+    retain_on_success: boolean | undefined;
+} & UtmFields;
+export type ClientErrorDetails = {
+    field?: string;
+    code?: string;
+    suggestion?: string;
+    _rawPayload?: any;
+};
+export declare class ClientError extends Error {
+    message: string;
+    details?: ClientErrorDetails | undefined;
+    constructor(message: string, details?: ClientErrorDetails | undefined);
+}
+export type ClientResponse = {
+    errors: ClientError[];
+    _raw_response?: any;
+};
+export type CreateDonationResult = ClientResponse & {
+    transaction?: Transaction;
+    schedule?: Schedule;
+    donor?: Donor;
+    designation?: Designation;
+    campaign?: Campaign;
+};
+export type CreatePaymentMethodRequest = RecaptchaSecuredRequest & {
+    paymentMethodType: PaymentMethodType;
+    paymentMethodToken: string;
+    donorId?: string;
+    paymentGatewayId?: string;
+    backendName?: BackendName;
+    embedId?: string;
+    contact: Contact;
+    address: Address;
+};
+export type CreatePaymentMethodResult = ClientResponse & {
+    paymentMethodId: string;
+};
+export type Campaign = {
+    title: string;
+};
+export type Designation = {
+    id: string;
+    title: string;
+};
+export type Donor = {
+    id: string;
+    created: string;
+    contact: {
+        created: string;
+        updated: string;
+        title: string;
+    };
+};
+export type TokenizeCardConnectResult = {
+    token: string;
+    message: string;
+    errorcode: number;
+};
+export type BackendName = 'spreedly' | 'card_connect' | 'iats' | 'paypal_checkout';
+export type PaymentGateway = {
+    id: string;
+    name: string;
+    backend_name: BackendName;
+    gateway_type?: string;
+    config?: {
+        [key: string]: any;
+    };
+};
+export interface EmbedConfig {
+    embed_id?: string;
+    organization_id?: string;
+    available_gateways: PaymentGateway[];
+}
+export type PaymentMethod = {
+    id: string;
+    type: PaymentMethodType;
+};
+export type Schedule = {
+    id: string;
+    recurringFrequency: RecurringFrequency;
+};
+export type Transaction = {
+    id: string;
+};
+export type Donation = {
+    id: string;
+    transaction?: Transaction;
+    schedule?: Schedule;
+};
+export type TokenizeCardConnectBankAccountResult = TokenizeCardConnectResult;
+export type TokenizeCardConnectApplePayResult = TokenizeCardConnectResult;
+export type TokenizeCardConnectGooglePayResult = TokenizeCardConnectResult;
+export type ApplePayContact = ApplePayJS.ApplePayPaymentContact & {
+    email?: string;
+    phone?: string;
+};
+export type TokenizeApplePayResult = {
+    applePaySession: ApplePaySession;
+    cardConnectResponse: TokenizeCardConnectApplePayResult;
+    billingContact?: ApplePayContact;
+    merchantSessionId?: string;
+};
+export type MerchantSession = any;
+export type ApplePayMerchantValidationPayload = {
+    apple_pay_url: string;
+    organization_id: string;
+};
+export type GooglePayBaseCardPaymentMethodType = {
+    type: google.payments.api.PaymentMethodType;
+    parameters: google.payments.api.CardParameters;
+};
+export type GooglePayConfig = {
+    paymentDataRequest: Partial<Omit<google.payments.api.PaymentDataRequest, 'transactionInfo'>> & {
+        transactionInfo: Partial<google.payments.api.PaymentDataRequest['transactionInfo']>;
+    };
+    paymentOptions: google.payments.api.PaymentOptions;
+    cardConnectMerchantId: string;
+    baseCardPaymentMethodParameters?: Partial<GooglePayBaseCardPaymentMethodType['parameters']>;
+};
+export interface SpreedlyPaymentMethodPayload {
+    retained?: boolean;
+    metadata?: Record<string, string>;
+}
+export interface SpreedlyPaymentMethodBankAccountPayload extends SpreedlyPaymentMethodPayload {
+    payment_method: {
+        bank_account: ({
+            first_name: string;
+            last_name: string;
+        } | {
+            full_name: string;
+        }) & {
+            bank_routing_number: string;
+            bank_account_number: string;
+            bank_name?: string;
+            bank_account_type?: 'checking' | 'savings';
+            bank_account_holder_type?: 'business' | 'personal';
+        };
+    };
+}
+export interface SpreedlyInstance {
+    init(key: string, opts: {
+        numberEl: string;
+        cvvEl: string;
+    }): void;
+    on(key: string, func: (param1: any | null, param2: any | null, param3: any | null, param4: any | null) => void): void;
+    validate(): void;
+    setPlaceholder(fields: string, placeholder: string): void;
+    setFieldType(fields: string, placeholder: string): void;
+    setStyle(fields: string, placeholder: string): void;
+    setNumberFormat(fields: string): void;
+    reload(): void;
+    tokenizeCreditCard(fields: {
+        first_name: string;
+        last_name: string;
+        month: string;
+        year: string;
+        email?: string;
+        zip?: string;
+    }): void;
+    removeHandlers(): void;
+}

package/dist/esm/types.js

@@ -0,0 +1,14 @@
+export const ApplePaySessionStatus = {
+    STATUS_SUCCESS: typeof ApplePaySession !== 'undefined' ? ApplePaySession.STATUS_SUCCESS : 1,
+    STATUS_FAILURE: typeof ApplePaySession !== 'undefined' ? ApplePaySession.STATUS_FAILURE : 0,
+};
+export class ClientError extends Error {
+    constructor(message, details) {
+        super(message);
+        this.message = message;
+        this.details = details;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ClientError);
+        }
+    }
+}

package/dist/esm/util.d.ts

@@ -0,0 +1,17 @@
+import { ClientResponse } from './types';
+export declare function receiveEmbedData(): Promise<any>;
+export declare function sanitizeString(value: string): string;
+type SanitizeableObject = {
+    [key: string]: SanitizeableObject;
+} | string | boolean | number | SanitizeableObject[];
+export declare function sanitizeArray(array: SanitizeableObject[]): SanitizeableObject[];
+export declare function sanitizeObject(object: SanitizeableObject): SanitizeableObject;
+type Name = {
+    firstName: string;
+    lastName: string;
+};
+export declare function splitName(fullname: string): Name;
+export declare function parseResponse(response: Response, opts?: {
+    throwErrors?: boolean;
+}): Promise<ClientResponse>;
+export {};

package/dist/esm/util.js

@@ -0,0 +1,113 @@
+import { ClientError } from './types';
+import { collapseClientErrors } from './typeAdapters';
+export function receiveEmbedData() {
+    let handler;
+    return new Promise((resolve, reject) => {
+        if (!window.parent) {
+            reject('Cannot receive data without parent');
+        }
+        handler = (evt) => {
+            let data;
+            try {
+                data = JSON.parse(evt.data);
+            }
+            catch (error) {
+                return;
+            }
+            if (data.embedData) {
+                resolve(data.embedData);
+            }
+        };
+        window.addEventListener('message', handler);
+    }).then((data) => {
+        window.removeEventListener('message', handler);
+        return data;
+    });
+}
+export function sanitizeString(value) {
+    if (!value) {
+        return value;
+    }
+    const tmp = document.createElement('div');
+    tmp.innerHTML = value;
+    const scripts = Array.from(tmp.getElementsByTagName('script'));
+    for (const script of scripts) {
+        if (script.parentNode) {
+            script.parentNode.removeChild(script);
+        }
+    }
+    return tmp.innerHTML;
+}
+export function sanitizeArray(array) {
+    return array.map(sanitizeObject);
+}
+export function sanitizeObject(object) {
+    if (object === null || object === undefined) {
+        return object;
+    }
+    else if (Array.isArray(object)) {
+        return sanitizeArray(object);
+    }
+    else if (typeof object === 'string') {
+        return sanitizeString(object);
+    }
+    else if (typeof object === 'object') {
+        const newObject = {};
+        for (const [key, value] of Object.entries(object)) {
+            if (Array.isArray(value)) {
+                newObject[key] = sanitizeArray(value);
+            }
+            else if (typeof value === 'string') {
+                newObject[key] = sanitizeString(value);
+            }
+            else {
+                newObject[key] = sanitizeObject(value);
+            }
+        }
+        return newObject;
+    }
+    else {
+        return object;
+    }
+}
+export function splitName(fullname) {
+    const nameParts = fullname.split(' ');
+    const firstName = nameParts.slice(0, -1).join(' ') || 'NOT GIVEN';
+    const lastName = nameParts.slice(-1).join(' ');
+    const nameObj = {
+        firstName,
+        lastName,
+    };
+    return nameObj;
+}
+export function parseResponse(response, opts) {
+    return response.json().then((json) => {
+        const errors = [];
+        if (response.status !== 200) {
+            if (json.result !== undefined) {
+                Object.keys(json.result).forEach((key) => {
+                    errors.push(new ClientError(key + ':  ' + json.result[key].join('\n  '), {
+                        field: key,
+                    }));
+                });
+            }
+            if (json.messages !== undefined) {
+                json.messages.forEach((msg) => {
+                    if (msg.category === 'error') {
+                        errors.push(new ClientError(msg.message));
+                    }
+                });
+            }
+            else {
+                errors.push(new ClientError(json.message));
+            }
+        }
+        if (opts && opts.throwErrors && errors.length) {
+            throw collapseClientErrors(errors);
+        }
+        return {
+            errors,
+            _raw_response: json,
+        };
+    });
+}

package/dist/idonate-client.d.ts

@@ -1,4 +1,4 @@
-import { ClientOptions, Contact, Address, CreatePaymentMethodRequest, CreatePaymentMethodResult, CreateDonationRequest, CreateDonationResult, TokenizeApplePayResult } from './types';
+import { ClientOptions, Contact, Address, CreatePaymentMethodRequest, CreatePaymentMethodResult, CreateDonationRequest, CreateDonationResult, TokenizeApplePayResult, EmbedConfig } from './types';
 import ConfigHandler from './config-handler';
 import { Tokenizer, PaymentMethodType, PaymentGateway, TokenizerContainer } from './tokenize';
 export default class iDonateClient {
@@ -6,10 +6,12 @@ export default class iDonateClient {
     private readonly embedId;
     private currentOrganizationId;
     private allowTransaction;
+    private embedConfigCache?;
+    private embedConfigPromise?;
     get organizationId(): string;
     readonly options: ClientOptions;
     readonly config: ConfigHandler;
-    constructor(clientKey: string, embedId: string, options?: Partial<ClientOptions>);
+    constructor(clientKey: string, embedId: string | EmbedConfig, options?: Partial<ClientOptions>);
     createDonation(donation: CreateDonationRequest): Promise<CreateDonationResult>;
     createTransaction(donation: CreateDonationRequest): Promise<{
         transactionId: string | undefined;
@@ -25,4 +27,6 @@ export default class iDonateClient {
         address: Address;
     }): Promise<string>;
     selectGateway(availableGateways: PaymentGateway[], paymentType: PaymentMethodType, preferredGatewayId?: string): PaymentGateway | undefined;
+    getEmbedConfig(): Promise<EmbedConfig>;
+    getGateway(gatewayId: string): Promise<PaymentGateway>;
 }

package/dist/idonate-client.js

@@ -72,8 +72,19 @@ class iDonateClient {
     constructor(clientKey, embedId, options) {
         var _a;
         this.clientKey = clientKey;
-        this.embedId = embedId;
-        this.currentOrganizationId = clientKey;
+        if (typeof embedId === 'string') {
+            this.embedId = embedId;
+        }
+        else {
+            this.embedConfigCache = embedId;
+            this.embedId = embedId.embed_id || '';
+            if (embedId.organization_id) {
+                this.currentOrganizationId = embedId.organization_id;
+            }
+        }
+        if (!this.currentOrganizationId) {
+            this.currentOrganizationId = clientKey;
+        }
         this.options = Object.assign({}, clientDefaults, options);
         this.allowTransaction = false;
         this.config = new config_handler_1.default(this.options);
@@ -291,5 +302,32 @@ class iDonateClient {
         }
         return availableGateways[0];
     }
+    getEmbedConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.embedConfigCache) {
+                return this.embedConfigCache;
+            }
+            if (this.embedConfigPromise) {
+                return this.embedConfigPromise;
+            }
+            this.embedConfigPromise = shared
+                .fetchEmbedConfig(this.embedId, this.config)
+                .then((config) => {
+                this.embedConfigCache = config;
+                return config;
+            });
+            return this.embedConfigPromise;
+        });
+    }
+    getGateway(gatewayId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = yield this.getEmbedConfig();
+            const gateway = config.available_gateways.find((g) => g.id === gatewayId);
+            if (!gateway) {
+                throw new Error(`Gateway ${gatewayId} not found in embed configuration. Available: ${config.available_gateways.map((g) => g.id).join(', ')}`);
+            }
+            return gateway;
+        });
+    }
 }
 exports.default = iDonateClient;

package/dist/shared.d.ts

@@ -1,3 +1,4 @@
-import { CreatePaymentMethodRequest, CreatePaymentMethodResult } from './types';
+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/shared.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPaymentMethod = createPaymentMethod;
+exports.fetchEmbedConfig = fetchEmbedConfig;
 const typeAdapters_1 = require("./typeAdapters");
 const constants_1 = require("./constants");
 const util_1 = require("./util");
@@ -14,3 +15,11 @@ function createPaymentMethod(paymentMethod, config) {
         .then((response) => (0, util_1.parseResponse)(response, { throwErrors: true }))
         .then((response) => (0, typeAdapters_1.buildCreatePaymentMethodResult)(response));
 }
+function fetchEmbedConfig(embedId, config) {
+    return fetch(`${config.embedApiBaseUrl}/config/${embedId}`, {
+        method: 'GET',
+        headers: constants_1.CLIENT_HEADERS,
+    })
+        .then((response) => (0, util_1.parseResponse)(response, { throwErrors: true }))
+        .then((response) => response._raw_response.result);
+}

package/dist/tokenize/CardConnectTokenizer.d.ts

@@ -5,6 +5,7 @@ import ConfigHandler from '../config-handler';
 export declare class CardConnectTokenizer extends Tokenizer {
     private iframeUrl;
     private containerId;
+    private layout;
     private iframe;
     private messageHandler?;
     private expectedOrigin;