@idonatedev/idonate-sdk 1.1.0-dev13 → 1.1.0-dev15

package/dist/esm/types.d.ts

@@ -0,0 +1,367 @@
+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';
+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;
+    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';
+export type PaymentGateway = {
+    id: string;
+    backendName: BackendName;
+};
+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/package.json

@@ -1,15 +1,23 @@
 {
 	"name": "@idonatedev/idonate-sdk",
 	"author": "iDonate",
-	"version": "1.1.0-dev13",
+	"version": "1.1.0-dev15",
 	"sideEffects": false,
 	"description": "iDonate Web SDK",
 	"engines": {
 		"node": ">=18.0.0"
 	},
 	"main": "dist/index.js",
+	"module": "dist/esm/index.js",
 	"unpkg": "umd/idonate-sdk.js",
 	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/esm/index.js",
+			"require": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		}
+	},
 	"files": [
 		"/dist",
 		"/umd"
@@ -22,7 +30,10 @@
 		"lint": "npx eslint 'src/**/*.ts'",
 		"lint:fix": "npx eslint --fix 'src/**/*.ts'",
 		"format": "npx prettier --write 'src/**/*.ts'",
-		"build": "npx tsc && webpack",
+		"build": "npm run build:cjs && npm run build:esm && npm run inject:version && webpack",
+		"build:cjs": "npx tsc",
+		"build:esm": "npx tsc -p tsconfig.esm.json",
+		"inject:version": "node scripts/inject-version.js",
 		"watch": "npx tsc -w & webpack --watch",
 		"dev:server": "http-server -p 8000 -c-1 -o /e2e/donation-flow-enhanced.html",
 		"dev": "concurrently \"npm run dev:server\" \"npm run watch\" --names \"server,build\" --prefix-colors \"blue,green\"",