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

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

@@ -0,0 +1,77 @@
+import { Tokenizer } from './Tokenizer';
+import { PaymentData, PaymentToken, ValidationResult, PaymentGateway, TokenizerContainer } from './types';
+import ConfigHandler from '../config-handler';
+declare global {
+    interface Window {
+        paypal?: {
+            Buttons: (options: PayPalButtonOptions) => PayPalButtonsInstance;
+        };
+    }
+}
+interface PayPalButtonOptions {
+    fundingSource?: string;
+    createOrder: () => Promise<string>;
+    onApprove: (data: PayPalApproveData) => Promise<void>;
+    onCancel?: (data: any) => void;
+    onError?: (err: any) => void;
+    style?: {
+        layout?: 'vertical' | 'horizontal';
+        color?: 'gold' | 'blue' | 'silver' | 'white' | 'black';
+        shape?: 'rect' | 'pill';
+        label?: 'paypal' | 'checkout' | 'buynow' | 'pay';
+        height?: number;
+    };
+}
+interface PayPalButtonsInstance {
+    render: (selector: string | HTMLElement) => Promise<void>;
+    close: () => void;
+}
+interface PayPalApproveData {
+    orderID: string;
+    payerID?: string;
+    facilitatorAccessToken?: string;
+}
+export declare class PayPalTokenizer extends Tokenizer {
+    private gateway;
+    private containerId;
+    private configContext;
+    private isReady;
+    private containerEl?;
+    private paypalButtonContainer?;
+    private cachedToken?;
+    private currency;
+    private amount?;
+    private enableVenmo;
+    private locale;
+    private clientId;
+    private sandboxMode;
+    private organizationId;
+    private embedId;
+    private clientConfig;
+    private paymentTransactionId?;
+    private paymentMethodId?;
+    private constructor();
+    static create(gateway: PaymentGateway, container: TokenizerContainer, config: {
+        organizationId: string;
+        embedId: string;
+        clientConfig: ConfigHandler;
+    }): Promise<PayPalTokenizer>;
+    private init;
+    private loadPayPalSDK;
+    private waitForPayPalGlobal;
+    private renderButtons;
+    private renderPayPalButtons;
+    private createOrder;
+    private handleApprove;
+    private handleCancel;
+    private handleError;
+    tokenize(paymentData: PaymentData): Promise<PaymentToken>;
+    validate(): Promise<ValidationResult>;
+    clear(): void;
+    focus(field: 'cardNumber' | 'cvv' | 'expiry' | 'routingNumber' | 'accountNumber'): void;
+    destroy(): void;
+    hasToken(): boolean;
+    getToken(): PaymentToken | null;
+    get tokenizationMode(): 'auto' | 'manual';
+}
+export {};

package/dist/esm/tokenize/PayPalTokenizer.js

@@ -0,0 +1,268 @@
+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());
+    });
+};
+import { Tokenizer } from './Tokenizer';
+import { TokenizationError, } from './types';
+const PAYPAL_SDK_URL = 'https://www.paypal.com/sdk/js';
+const PAYPAL_SCRIPT_ID = 'paypal-sdk-script';
+const INIT_TIMEOUT = 10000;
+export class PayPalTokenizer extends Tokenizer {
+    constructor(gateway, containerId, config, configContext) {
+        var _a, _b;
+        super();
+        this.gateway = gateway;
+        this.containerId = containerId;
+        this.configContext = configContext;
+        this.isReady = false;
+        this.mode = 'credit_card';
+        const gatewayConfig = gateway.config;
+        if (!(gatewayConfig === null || gatewayConfig === void 0 ? void 0 : gatewayConfig.client_id)) {
+            throw new Error('PayPal gateway configuration missing client_id');
+        }
+        this.clientId = gatewayConfig.client_id;
+        this.sandboxMode = (_a = gatewayConfig.sandbox_mode) !== null && _a !== void 0 ? _a : false;
+        this.currency = config.currency || 'USD';
+        this.amount = config.amount;
+        this.enableVenmo = (_b = config.enableVenmo) !== null && _b !== void 0 ? _b : true;
+        this.locale = config.locale || 'en_US';
+        this.organizationId = configContext.organizationId;
+        this.embedId = configContext.embedId;
+        this.clientConfig = configContext.clientConfig;
+    }
+    static create(gateway, container, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenizer = new PayPalTokenizer(gateway, container.containerId, container, config);
+            yield tokenizer.init();
+            return tokenizer;
+        });
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.containerEl = document.getElementById(this.containerId);
+            if (!this.containerEl) {
+                throw new Error(`Container element not found: ${this.containerId}`);
+            }
+            this.containerEl.innerHTML = '';
+            Object.assign(this.containerEl.style, {
+                display: 'flex',
+                flexDirection: 'column',
+                gap: '0.5rem',
+                alignItems: 'stretch',
+            });
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error('PayPal SDK initialization timeout'));
+                }, INIT_TIMEOUT);
+                this.loadPayPalSDK()
+                    .then(() => {
+                    clearTimeout(timeout);
+                    return this.renderButtons();
+                })
+                    .then(() => {
+                    this.isReady = true;
+                    this.emit('ready');
+                    resolve();
+                })
+                    .catch((error) => {
+                    clearTimeout(timeout);
+                    this.emit('error', {
+                        message: 'Failed to initialize PayPal',
+                        code: 'INIT_FAILED',
+                        details: error,
+                    });
+                    reject(error);
+                });
+            });
+        });
+    }
+    loadPayPalSDK() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (window.paypal) {
+                return Promise.resolve();
+            }
+            if (document.getElementById(PAYPAL_SCRIPT_ID)) {
+                return this.waitForPayPalGlobal();
+            }
+            const params = new URLSearchParams({
+                'client-id': this.clientId,
+                currency: this.currency,
+                intent: 'capture',
+            });
+            const disabledFunding = ['card', 'paylater'];
+            if (this.enableVenmo) {
+                params.set('enable-funding', 'venmo');
+            }
+            else {
+                disabledFunding.push('venmo');
+            }
+            params.set('disable-funding', disabledFunding.join(','));
+            const script = document.createElement('script');
+            script.id = PAYPAL_SCRIPT_ID;
+            script.src = `${PAYPAL_SDK_URL}?${params.toString()}`;
+            script.async = true;
+            return new Promise((resolve, reject) => {
+                script.onload = () => {
+                    this.waitForPayPalGlobal().then(resolve).catch(reject);
+                };
+                script.onerror = () => {
+                    reject(new Error('Failed to load PayPal SDK'));
+                };
+                document.head.appendChild(script);
+            });
+        });
+    }
+    waitForPayPalGlobal() {
+        return __awaiter(this, arguments, void 0, function* (timeout = 5000) {
+            const startTime = Date.now();
+            while (Date.now() - startTime < timeout) {
+                if (window.paypal) {
+                    return Promise.resolve();
+                }
+                yield new Promise((resolve) => setTimeout(resolve, 100));
+            }
+            throw new Error('Timeout waiting for PayPal SDK to load');
+        });
+    }
+    renderButtons() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!window.paypal) {
+                throw new Error('PayPal SDK not loaded');
+            }
+            if (!this.containerEl) {
+                throw new Error('Container element not found');
+            }
+            this.paypalButtonContainer = document.createElement('div');
+            this.paypalButtonContainer.id = `${this.containerId}-buttons`;
+            this.paypalButtonContainer.style.minHeight = '40px';
+            this.containerEl.appendChild(this.paypalButtonContainer);
+            yield this.renderPayPalButtons();
+        });
+    }
+    renderPayPalButtons() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!window.paypal || !this.paypalButtonContainer) {
+                return;
+            }
+            const button = window.paypal.Buttons({
+                createOrder: () => this.createOrder(),
+                onApprove: (data) => this.handleApprove(data),
+                onCancel: (data) => this.handleCancel(data),
+                onError: (err) => this.handleError(err, 'PayPal error'),
+                style: {
+                    layout: 'vertical',
+                    shape: 'rect',
+                    height: 40,
+                },
+            });
+            yield button.render(this.paypalButtonContainer);
+        });
+    }
+    createOrder() {
+        const endpoint = `${this.clientConfig.embedApiBaseUrl}/payment/paypal/create-order`;
+        const requestBody = {
+            payment_gateway_id: this.gateway.id,
+            currency: this.currency,
+        };
+        if (this.amount !== undefined) {
+            requestBody.amount = this.amount;
+        }
+        return fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+        })
+            .then((response) => {
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            return response.json();
+        })
+            .then((data) => {
+            if (!data.orderId) {
+                throw new Error('Order creation failed: missing orderId');
+            }
+            this.paymentTransactionId = data.payment_transaction_id;
+            this.paymentMethodId = data.payment_method_id;
+            return data.orderId;
+        })
+            .catch((error) => {
+            this.handleError(error, 'Order creation failed');
+            throw error;
+        });
+    }
+    handleApprove(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = {
+                token: data.orderID,
+                lastFour: data.orderID.slice(-4),
+                provider: 'paypal_checkout',
+                paymentMethodId: this.paymentMethodId,
+                paymentTransactionId: this.paymentTransactionId,
+            };
+            this.cachedToken = token;
+            this.emit('tokenReady', token);
+        });
+    }
+    handleCancel(data) {
+        this.emit('error', {
+            message: 'Payment cancelled by user',
+            code: 'USER_CANCELLED',
+        });
+    }
+    handleError(error, context) {
+        const errorMessage = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.toString()) || 'Unknown error';
+        this.emit('error', {
+            message: `${context}: ${errorMessage}`,
+            code: (error === null || error === void 0 ? void 0 : error.code) || 'PAYPAL_ERROR',
+            details: error,
+        });
+    }
+    tokenize(paymentData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isReady) {
+                throw new Error('Tokenizer not initialized');
+            }
+            if (this.cachedToken) {
+                return this.cachedToken;
+            }
+            throw new TokenizationError('No PayPal order approved. User must click PayPal or Venmo button to complete payment.', 'NO_TOKEN');
+        });
+    }
+    validate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                isValid: true,
+                errors: [],
+            };
+        });
+    }
+    clear() {
+        this.cachedToken = undefined;
+    }
+    focus(field) {
+    }
+    destroy() {
+        if (this.containerEl) {
+            this.containerEl.innerHTML = '';
+        }
+        this.eventHandlers.clear();
+        this.cachedToken = undefined;
+    }
+    hasToken() {
+        return !!this.cachedToken;
+    }
+    getToken() {
+        return this.cachedToken || null;
+    }
+    get tokenizationMode() {
+        return 'auto';
+    }
+}

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

@@ -0,0 +1,92 @@
+import { Tokenizer } from './Tokenizer';
+import { PaymentData, PaymentToken, ValidationResult, PaymentGateway, TokenizerContainer } from './types';
+import { ACHAccount, Address, Contact, CreditCard, SpreedlyInstance } from '../types';
+import ConfigHandler from '../config-handler';
+export declare class SpreedlyTokenizer extends Tokenizer {
+    private environmentKey;
+    private containerId;
+    private layout;
+    private spreedly;
+    private isReady;
+    private currentValidationState;
+    private mergedStyles;
+    private expiryEl?;
+    private numberEl;
+    private cvvEl;
+    private expiryId;
+    private containerEl?;
+    private organizationId;
+    private embedId;
+    private clientConfig;
+    private bankCountry;
+    private routingNumberEl?;
+    private accountNumberEl?;
+    private accountTypeEl?;
+    private institutionNumberEl?;
+    private transitNumberEl?;
+    private enableTestMode;
+    private constructor();
+    static create(gateway: PaymentGateway, container: TokenizerContainer, config: {
+        organizationId: string;
+        embedId: string;
+        clientConfig: ConfigHandler;
+    }): Promise<SpreedlyTokenizer>;
+    private init;
+    tokenize(paymentData: PaymentData): Promise<PaymentToken>;
+    private tokenizeCardInternal;
+    private createCanadianBankAccountFields;
+    private tokenizeBankAccountInternal;
+    validate(): Promise<ValidationResult>;
+    private validateCardInternal;
+    private validateBankAccountInternal;
+    private applyUnifiedStyles;
+    private stylesToCssString;
+    clear(): void;
+    focus(field: 'cardNumber' | 'cvv' | 'expiry' | 'routingNumber' | 'accountNumber'): void;
+    destroy(): void;
+    hasToken(): boolean;
+    getToken(): PaymentToken | null;
+    get tokenizationMode(): 'auto' | 'manual';
+    private updateOverallValidation;
+    private handleFieldEvent;
+    private createInternalElements;
+    private createCreditCardFields;
+    private createBankAccountFields;
+    private createUSBankAccountFields;
+    private updateBankAccountValidation;
+    private validateExpiry;
+    private applyErrorStyles;
+    private static ensureSpreedlyLoaded;
+    private static loadScript;
+    private static waitForGlobal;
+    static tokenizeBankAccount(data: {
+        contact: Partial<Contact> & ({
+            firstName: string;
+            lastName: string;
+        } | {
+            fullName: string;
+        });
+        address: Partial<Address>;
+        account: Partial<ACHAccount> & Pick<ACHAccount, 'accountNumber' | 'routingNumber'>;
+    }, config: ConfigHandler): Promise<string>;
+    static tokenizeCreditCard(data: {
+        contact: Partial<Contact> & ({
+            firstName: string;
+            lastName: string;
+        } | {
+            fullName: string;
+        });
+        address: Partial<Address>;
+        card: CreditCard;
+    }, config: ConfigHandler): Promise<string>;
+    static tokenizePayPal(data: {
+        contact: Contact;
+        address: Address;
+    }, config: ConfigHandler): Promise<string>;
+}
+declare global {
+    interface Window {
+        Spreedly: SpreedlyInstance;
+        SpreedlyPaymentFrame: new () => SpreedlyInstance;
+    }
+}