@tagadapay/plugin-sdk 2.6.2 → 2.6.6

package/dist/v2/core/resources/vipOffers.js

@@ -0,0 +1,27 @@
+/**
+ * VIP Offers Resource Client
+ * Axios-based API client for VIP offer endpoints
+ */
+export class VipOffersResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Get VIP preview showing potential savings
+     */
+    async getVipPreview(sessionId, vipOfferIds) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${sessionId}/vip-preview`, {
+            orderBumpOfferIds: vipOfferIds,
+            orderBumpType: 'vip',
+        });
+    }
+    /**
+     * Toggle an order bump (used for VIP offers)
+     */
+    async toggleOrderBump(sessionId, orderBumpOfferId, selected) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${sessionId}/toggle-order-bump`, {
+            orderBumpOfferId,
+            selected,
+        });
+    }
+}

package/dist/v2/core/utils/order.d.ts

@@ -77,6 +77,7 @@ export interface Order {
         firstName: string;
         lastName: string;
         address1: string;
+        address2: string;
         city: string;
         country: string;
         state: string;

package/dist/v2/core/utils/pluginConfig.d.ts

@@ -2,11 +2,11 @@
  * Plugin Configuration Utility Functions
  * Pure functions for plugin configuration management
  */
-export interface PluginConfig<TConfig = Record<string, any>> {
+export type PluginConfig<TConfig = Record<string, any>> = {
     storeId?: string;
     accountId?: string;
     basePath?: string;
-    config?: TConfig;
+    config?: any;
     productId?: string;
     variants?: Record<string, string>;
     prices?: Record<string, any>;
@@ -15,13 +15,13 @@ export interface PluginConfig<TConfig = Record<string, any>> {
     upsellId?: string;
     googleApiKey?: string;
     branding?: any;
-}
-export interface RawPluginConfig<TConfig = Record<string, any>> {
+} & TConfig;
+export type RawPluginConfig<TConfig = Record<string, any>> = {
     storeId?: string;
     accountId?: string;
     basePath?: string;
-    config?: TConfig;
-}
+    config?: any;
+} & TConfig;
 /**
  * Core plugin config loading function
  * Handles local dev, production, and raw config

package/dist/v2/index.d.ts

@@ -5,15 +5,18 @@
  * - core: Pure functions without React dependencies
  * - react: React hooks and components using core functions
  */
-export * from './core/utils/pluginConfig';
-export * from './core/utils/products';
 export * from './core/googleAutocomplete';
 export * from './core/isoData';
 export * from './core/utils/currency';
-export type { CheckoutData, CheckoutSession, CheckoutLineItem, CheckoutInitParams, Promotion, } from './core/resources/checkout';
-export type { Order, OrderLineItem, } from './core/utils/order';
-export type { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferSummary, } from './core/resources/postPurchases';
-export type { Offer, OfferItem, OfferSummary, } from './core/resources/offers';
-export type { OrderBumpOffer, OrderBumpPreview, } from './core/utils/orderBump';
-export type { Payment, PaymentResponse, PaymentOptions, CardPaymentMethod, ApplePayToken, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse, PaymentInstrumentCustomer } from './core/resources/payments';
-export { TagadaProvider, useTagadaContext, useCheckoutToken, usePluginConfig, useGoogleAutocomplete, useGeoLocation, useISOData, getAvailableLanguages, useLanguageImport, useCountryOptions, useRegionOptions, useCheckout, useOrderBump, usePromotions, useProducts, useOrder, usePostPurchases, useOffers, usePayment, useThreeds, useThreedsModal, useCurrency, useApiQuery, useApiMutation, useInvalidateQuery, usePreloadQuery, queryKeys, formatMoney } from './react';
+export * from './core/utils/pluginConfig';
+export * from './core/utils/products';
+export type { CheckoutData, CheckoutInitParams, CheckoutLineItem, CheckoutSession, Promotion } from './core/resources/checkout';
+export type { Order, OrderLineItem } from './core/utils/order';
+export type { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferSummary } from './core/resources/postPurchases';
+export type { Offer, OfferItem, OfferSummary } from './core/resources/offers';
+export type { OrderBumpOffer, OrderBumpPreview } from './core/utils/orderBump';
+export type { ApplePayToken, CardPaymentMethod, Payment, PaymentInstrumentCustomer, PaymentInstrumentCustomerResponse, PaymentInstrumentResponse, PaymentOptions, PaymentResponse } from './core/resources/payments';
+export type { ShippingRate, ShippingRatesResponse } from './core/resources/shippingRates';
+export type { ApplyDiscountResponse, Discount, DiscountCodeValidation, RemoveDiscountResponse } from './core/resources/discounts';
+export type { ToggleOrderBumpResponse, VipOffer, VipPreviewResponse } from './core/resources/vipOffers';
+export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscounts, useExpressPaymentMethods, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useTagadaContext, useThreeds, useThreedsModal, useVipOffers } from './react';

package/dist/v2/index.js

@@ -6,10 +6,10 @@
  * - react: React hooks and components using core functions
  */
 // Core exports (selective to avoid conflicts)
-export * from './core/utils/pluginConfig';
-export * from './core/utils/products';
 export * from './core/googleAutocomplete';
 export * from './core/isoData';
 export * from './core/utils/currency';
+export * from './core/utils/pluginConfig';
+export * from './core/utils/products';
 // React exports (hooks and components only, types are exported above)
-export { TagadaProvider, useTagadaContext, useCheckoutToken, usePluginConfig, useGoogleAutocomplete, useGeoLocation, useISOData, getAvailableLanguages, useLanguageImport, useCountryOptions, useRegionOptions, useCheckout, useOrderBump, usePromotions, useProducts, useOrder, usePostPurchases, useOffers, usePayment, useThreeds, useThreedsModal, useCurrency, useApiQuery, useApiMutation, useInvalidateQuery, usePreloadQuery, queryKeys, formatMoney } from './react';
+export { ApplePayButton, ExpressPaymentMethodsProvider, formatMoney, getAvailableLanguages, GooglePayButton, queryKeys, TagadaProvider, useApiMutation, useApiQuery, useCheckout, useCheckoutToken, useCountryOptions, useCurrency, useDiscounts, useExpressPaymentMethods, useGeoLocation, useGoogleAutocomplete, useInvalidateQuery, useISOData, useLanguageImport, useOffers, useOrder, useOrderBump, usePayment, usePluginConfig, usePostPurchases, usePreloadQuery, useProducts, usePromotions, useRegionOptions, useShippingRates, useTagadaContext, useThreeds, useThreedsModal, useVipOffers } from './react';

package/dist/v2/react/components/ApplePayButton.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Apple Pay Button Component for v2 Architecture
+ * Uses v2 useExpressPaymentMethods hook and follows clean architecture principles
+ */
+import React from 'react';
+import { CheckoutData } from '../../core/resources/checkout';
+declare class ApplePaySession {
+    static canMakePayments(): boolean;
+    static canMakePaymentsWithActiveCard(merchantId: string): Promise<boolean>;
+    static STATUS_SUCCESS: number;
+    static STATUS_FAILURE: number;
+    static STATUS_INVALID_BILLING_POSTAL_ADDRESS: number;
+    static STATUS_INVALID_SHIPPING_POSTAL_ADDRESS: number;
+    static STATUS_INVALID_SHIPPING_CONTACT: number;
+    static STATUS_PIN_REQUIRED: number;
+    static STATUS_PIN_INCORRECT: number;
+    static STATUS_PIN_LOCKOUT: number;
+    constructor(version: number, paymentRequest: ApplePayPaymentRequest);
+    begin(): void;
+    abort(): void;
+    completeMerchantValidation(merchantSession: any): void;
+    completePayment(result: ApplePayPaymentAuthorizationResult): void;
+    completeShippingContactSelection(update: ApplePayShippingContactUpdate): void;
+    completeShippingMethodSelection(update: ApplePayShippingMethodUpdate): void;
+    completePaymentMethodSelection(update: ApplePayPaymentMethodUpdate): void;
+    onvalidatemerchant: ((event: ApplePayValidateMerchantEvent) => void) | null;
+    onpaymentauthorized: ((event: ApplePayPaymentAuthorizedEvent) => void) | null;
+    onshippingcontactselected: ((event: ApplePayShippingContactSelectionEvent) => void) | null;
+    onshippingmethodselected: ((event: ApplePayShippingMethodSelectionEvent) => void) | null;
+    onpaymentmethodselected: ((event: ApplePayPaymentMethodSelectionEvent) => void) | null;
+    oncancel: ((event: Event) => void) | null;
+}
+interface ApplePayPaymentRequest {
+    countryCode: string;
+    currencyCode: string;
+    supportedNetworks: string[];
+    merchantCapabilities: string[];
+    total: ApplePayLineItem;
+    lineItems?: ApplePayLineItem[];
+    shippingType?: 'shipping' | 'delivery' | 'storePickup' | 'servicePickup';
+    shippingMethods?: ApplePayShippingMethod[];
+    requiredBillingContactFields?: string[];
+    requiredShippingContactFields?: string[];
+    applicationData?: string;
+}
+interface ApplePayLineItem {
+    label: string;
+    amount: string;
+    type?: 'final' | 'pending';
+}
+interface ApplePayShippingMethod {
+    label: string;
+    amount: string;
+    detail?: string;
+    identifier: string;
+}
+interface ApplePayPaymentToken {
+    paymentData: any;
+    paymentMethod: {
+        displayName: string;
+        network: string;
+        type: string;
+        paymentPass: any;
+        billingContact?: ApplePayPaymentContact;
+    };
+    transactionIdentifier: string;
+}
+interface ApplePayPaymentContact {
+    phoneNumber?: string;
+    emailAddress?: string;
+    givenName?: string;
+    familyName?: string;
+    phoneticGivenName?: string;
+    phoneticFamilyName?: string;
+    addressLines?: string[];
+    locality?: string;
+    administrativeArea?: string;
+    postalCode?: string;
+    countryCode?: string;
+}
+interface ApplePayValidateMerchantEvent {
+    validationURL: string;
+}
+interface ApplePayPaymentAuthorizedEvent {
+    payment: {
+        token: ApplePayPaymentToken;
+        billingContact?: ApplePayPaymentContact;
+        shippingContact?: ApplePayPaymentContact;
+    };
+}
+interface ApplePayShippingContactSelectionEvent {
+    shippingContact: ApplePayPaymentContact;
+}
+interface ApplePayShippingMethodSelectionEvent {
+    shippingMethod: ApplePayShippingMethod;
+}
+interface ApplePayPaymentMethodSelectionEvent {
+    paymentMethod: any;
+}
+interface ApplePayPaymentAuthorizationResult {
+    status: number;
+    errors?: ApplePayError[];
+}
+interface ApplePayShippingContactUpdate {
+    errors?: ApplePayError[];
+    newShippingMethods?: ApplePayShippingMethod[];
+    newTotal?: ApplePayLineItem;
+    newLineItems?: ApplePayLineItem[];
+}
+interface ApplePayShippingMethodUpdate {
+    newTotal?: ApplePayLineItem;
+    newLineItems?: ApplePayLineItem[];
+}
+interface ApplePayPaymentMethodUpdate {
+    newTotal?: ApplePayLineItem;
+    newLineItems?: ApplePayLineItem[];
+}
+interface ApplePayError {
+    code: string;
+    message: string;
+    contactField?: string;
+}
+declare global {
+    interface Window {
+        ApplePaySession: typeof ApplePaySession;
+    }
+}
+export interface ApplePayButtonProps {
+    className?: string;
+    disabled?: boolean;
+    onSuccess?: (payment: any) => void;
+    onError?: (error: string) => void;
+    onCancel?: () => void;
+    storeName?: string;
+    currencyCode?: string;
+    variant?: 'default' | 'outline' | 'ghost';
+    size?: 'sm' | 'md' | 'lg';
+    checkout: CheckoutData;
+}
+export declare const ApplePayButton: React.FC<ApplePayButtonProps>;
+export default ApplePayButton;

package/dist/v2/react/components/ApplePayButton.js

@@ -0,0 +1,320 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Apple Pay Button Component for v2 Architecture
+ * Uses v2 useExpressPaymentMethods hook and follows clean architecture principles
+ */
+import { useCallback, useEffect, useState } from 'react';
+import { useExpressPaymentMethods } from '../hooks/useExpressPaymentMethods';
+export const ApplePayButton = ({ className = '', disabled = false, onSuccess, onError, onCancel, storeName, currencyCode = 'USD', variant = 'outline', size = 'lg', checkout, }) => {
+    const { applePayPaymentMethod, shippingMethods, lineItems, handleAddExpressId, updateCheckoutSessionValues, updateCustomerEmail, reComputeOrderSummary, setError: setContextError, } = useExpressPaymentMethods();
+    const [processingPayment, setProcessingPayment] = useState(false);
+    const [isApplePayAvailable, setIsApplePayAvailable] = useState(false);
+    const [applePayError, setApplePayError] = useState(null);
+    // Don't render if no Apple Pay payment method is enabled
+    if (!applePayPaymentMethod) {
+        return null;
+    }
+    // Check Apple Pay availability
+    useEffect(() => {
+        const checkApplePayAvailability = async () => {
+            if (typeof window === 'undefined' || !window.ApplePaySession) {
+                setIsApplePayAvailable(false);
+                return;
+            }
+            try {
+                const canMakePayments = window.ApplePaySession.canMakePayments();
+                if (canMakePayments) {
+                    const merchantId = applePayPaymentMethod?.metadata?.merchantId || '';
+                    const canMakePaymentsWithActiveCard = await window.ApplePaySession.canMakePaymentsWithActiveCard(merchantId);
+                    setIsApplePayAvailable(canMakePaymentsWithActiveCard);
+                    if (canMakePaymentsWithActiveCard) {
+                        handleAddExpressId('apple_pay');
+                    }
+                }
+                else {
+                    setIsApplePayAvailable(false);
+                }
+            }
+            catch (error) {
+                console.error('Error checking Apple Pay availability:', error);
+                setIsApplePayAvailable(false);
+            }
+        };
+        checkApplePayAvailability();
+    }, [applePayPaymentMethod, handleAddExpressId]);
+    // Convert Apple Pay contact to internal Address format
+    const applePayContactToAddress = useCallback((contact) => {
+        return {
+            address1: contact.addressLines?.[0] || '',
+            address2: contact.addressLines?.[1] || '',
+            lastName: contact.familyName || '',
+            firstName: contact.givenName || '',
+            city: contact.locality || '',
+            state: contact.administrativeArea || '',
+            country: contact.countryCode || '',
+            postal: contact.postalCode || '',
+            phone: contact.phoneNumber || '',
+            email: contact.emailAddress || '',
+        };
+    }, []);
+    // Validate merchant with backend
+    const validateMerchant = useCallback(async (validationURL) => {
+        const response = await fetch('/api/v1/apple-pay/validate-merchant', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                validationURL,
+                checkoutSessionId: checkout.checkoutSession.id,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error('Failed to validate Apple Pay merchant');
+        }
+        return response.json();
+    }, [checkout.checkoutSession.id]);
+    // Process Apple Pay payment
+    const processApplePayPayment = useCallback(async (token, billingContact, shippingContact) => {
+        try {
+            setProcessingPayment(true);
+            // Update addresses before processing payment
+            if (shippingContact) {
+                const shippingAddress = applePayContactToAddress(shippingContact);
+                const billingAddress = billingContact ? applePayContactToAddress(billingContact) : null;
+                await updateCheckoutSessionValues({
+                    data: {
+                        shippingAddress,
+                        billingAddress,
+                    },
+                });
+            }
+            // Update customer email
+            if (shippingContact?.emailAddress) {
+                await updateCustomerEmail({
+                    data: {
+                        email: shippingContact.emailAddress,
+                    },
+                });
+            }
+            // Process payment with backend API
+            const response = await fetch('/api/v1/apple-pay/process-payment', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    checkoutSessionId: checkout.checkoutSession.id,
+                    paymentToken: token,
+                    billingContact,
+                    shippingContact,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error('Failed to process Apple Pay payment');
+            }
+            const paymentResult = await response.json();
+            if (onSuccess) {
+                onSuccess(paymentResult);
+            }
+            return paymentResult;
+        }
+        catch (error) {
+            console.error('Error processing Apple Pay payment:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Apple Pay payment failed';
+            setApplePayError(errorMessage);
+            setContextError(errorMessage);
+            if (onError) {
+                onError(errorMessage);
+            }
+            throw error;
+        }
+        finally {
+            setProcessingPayment(false);
+        }
+    }, [
+        checkout.checkoutSession.id,
+        applePayContactToAddress,
+        updateCheckoutSessionValues,
+        updateCustomerEmail,
+        onSuccess,
+        onError,
+        setContextError,
+    ]);
+    // Handle Apple Pay button click
+    const handleApplePayClick = useCallback(() => {
+        if (!isApplePayAvailable || processingPayment || !checkout.summary) {
+            return;
+        }
+        const paymentRequest = {
+            countryCode: 'US', // TODO: Get from checkout session
+            currencyCode: currencyCode,
+            supportedNetworks: ['visa', 'masterCard', 'amex', 'discover'],
+            merchantCapabilities: ['supports3DS'],
+            total: {
+                label: storeName || checkout.checkoutSession.store?.name || 'Total',
+                amount: (checkout.summary.totalAdjustedAmount / 100).toFixed(2),
+                type: 'final',
+            },
+            lineItems: lineItems.map((item) => ({
+                label: item.label,
+                amount: item.amount,
+                type: 'final',
+            })),
+            shippingType: 'shipping',
+            shippingMethods: shippingMethods.map((method) => ({
+                label: method.label,
+                amount: method.amount,
+                detail: method.detail,
+                identifier: method.identifier,
+            })),
+            requiredBillingContactFields: ['postalAddress', 'name', 'phone', 'email'],
+            requiredShippingContactFields: ['postalAddress', 'name', 'phone', 'email'],
+        };
+        const session = new window.ApplePaySession(3, paymentRequest);
+        session.onvalidatemerchant = async (event) => {
+            try {
+                const merchantSession = await validateMerchant(event.validationURL);
+                session.completeMerchantValidation(merchantSession);
+            }
+            catch (error) {
+                console.error('Merchant validation failed:', error);
+                session.abort();
+                const errorMessage = 'Apple Pay setup failed';
+                setApplePayError(errorMessage);
+                setContextError(errorMessage);
+                if (onError) {
+                    onError(errorMessage);
+                }
+            }
+        };
+        session.onshippingcontactselected = async (event) => {
+            try {
+                const shippingAddress = applePayContactToAddress(event.shippingContact);
+                await updateCheckoutSessionValues({
+                    data: { shippingAddress },
+                });
+                const newOrderSummary = await reComputeOrderSummary();
+                const update = {
+                    newShippingMethods: newOrderSummary?.shippingMethods.map((method) => ({
+                        label: method.label,
+                        amount: method.amount,
+                        detail: method.detail,
+                        identifier: method.identifier,
+                    })) || [],
+                    newTotal: {
+                        label: storeName || checkout.checkoutSession.store?.name || 'Total',
+                        amount: newOrderSummary?.total.amount || '0.00',
+                        type: 'final',
+                    },
+                    newLineItems: newOrderSummary?.lineItems.map((item) => ({
+                        label: item.label,
+                        amount: item.amount,
+                        type: 'final',
+                    })) || [],
+                };
+                session.completeShippingContactSelection(update);
+            }
+            catch (error) {
+                console.error('Shipping contact selection failed:', error);
+                session.completeShippingContactSelection({
+                    errors: [
+                        {
+                            code: 'shippingContactInvalid',
+                            message: 'Unable to ship to this address',
+                        },
+                    ],
+                });
+            }
+        };
+        session.onshippingmethodselected = async (event) => {
+            try {
+                // Update shipping method via API
+                const response = await fetch('/api/v1/shipping-rates/select', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        checkoutSessionId: checkout.checkoutSession.id,
+                        shippingRateId: event.shippingMethod.identifier,
+                    }),
+                });
+                if (!response.ok) {
+                    throw new Error('Failed to update shipping method');
+                }
+                const newOrderSummary = await reComputeOrderSummary();
+                const update = {
+                    newTotal: {
+                        label: storeName || checkout.checkoutSession.store?.name || 'Total',
+                        amount: newOrderSummary?.total.amount || '0.00',
+                        type: 'final',
+                    },
+                    newLineItems: newOrderSummary?.lineItems.map((item) => ({
+                        label: item.label,
+                        amount: item.amount,
+                        type: 'final',
+                    })) || [],
+                };
+                session.completeShippingMethodSelection(update);
+            }
+            catch (error) {
+                console.error('Shipping method selection failed:', error);
+                session.completeShippingMethodSelection({});
+            }
+        };
+        session.onpaymentauthorized = async (event) => {
+            try {
+                await processApplePayPayment(event.payment.token, event.payment.billingContact, event.payment.shippingContact);
+                session.completePayment({
+                    status: window.ApplePaySession.STATUS_SUCCESS,
+                });
+            }
+            catch (error) {
+                console.error('Payment authorization failed:', error);
+                session.completePayment({
+                    status: window.ApplePaySession.STATUS_FAILURE,
+                });
+            }
+        };
+        session.oncancel = () => {
+            if (onCancel) {
+                onCancel();
+            }
+        };
+        session.begin();
+    }, [
+        isApplePayAvailable,
+        processingPayment,
+        checkout,
+        currencyCode,
+        storeName,
+        lineItems,
+        shippingMethods,
+        validateMerchant,
+        applePayContactToAddress,
+        updateCheckoutSessionValues,
+        reComputeOrderSummary,
+        processApplePayPayment,
+        onCancel,
+        onError,
+        setContextError,
+    ]);
+    // Button size classes
+    const sizeClasses = {
+        sm: 'h-8 px-3 text-sm',
+        md: 'h-10 px-4 text-base',
+        lg: 'h-12 px-6 text-lg',
+    };
+    // Button variant classes
+    const variantClasses = {
+        default: 'bg-black text-white hover:bg-black/90',
+        outline: 'border border-black bg-white text-black hover:bg-black hover:text-white',
+        ghost: 'text-black hover:bg-black/10',
+    };
+    if (!isApplePayAvailable) {
+        return null;
+    }
+    return (_jsxs("div", { className: "w-full", children: [_jsx("button", { type: "button", onClick: handleApplePayClick, disabled: disabled || processingPayment, className: `relative w-full rounded-md font-medium transition-colors focus:outline-none focus:ring-2 focus:ring-black focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 ${sizeClasses[size]} ${variantClasses[variant]} ${className} `, children: processingPayment ? (_jsxs("div", { className: "flex items-center justify-center gap-2", children: [_jsx("div", { className: "h-4 w-4 animate-spin rounded-full border-2 border-current border-t-transparent" }), _jsx("span", { children: "Processing..." })] })) : (_jsxs("span", { className: "flex items-center justify-center gap-2", children: [_jsx("svg", { className: "h-6 w-6", viewBox: "0 0 24 24", fill: "currentColor", children: _jsx("path", { d: "M18.71 19.5c-.83 1.24-1.71 2.45-3.05 2.47-1.34.03-1.77-.79-3.29-.79-1.53 0-2 .77-3.27.82-1.31.05-2.3-1.32-3.14-2.53C4.25 17 2.94 12.45 4.7 9.39c.87-1.52 2.43-2.48 4.12-2.51 1.28-.02 2.5.87 3.29.87.78 0 2.26-1.07 3.81-.91.65.03 2.47.26 3.64 1.98-.09.06-2.17 1.28-2.15 3.81.03 3.02 2.65 4.03 2.68 4.04-.03.07-.42 1.44-1.38 2.83M13 3.5c.73-.83 1.94-1.46 2.94-1.5.13 1.17-.34 2.35-1.04 3.19-.69.85-1.83 1.51-2.95 1.42-.15-1.15.41-2.35 1.05-3.11z" }) }), "Pay with Apple Pay"] })) }), applePayError && (_jsx("div", { className: "mt-2 rounded border border-red-200 bg-red-50 p-2 text-sm text-red-600", children: applePayError }))] }));
+};
+export default ApplePayButton;

package/dist/v2/react/components/GooglePayButton.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Google Pay Button Component for v2 Architecture
+ * Uses v2 useExpressPaymentMethods hook and follows clean architecture principles
+ */
+import React from 'react';
+import { CheckoutData } from '../../core/resources/checkout';
+export interface GooglePayButtonProps {
+    className?: string;
+    disabled?: boolean;
+    onSuccess?: (payment: any) => void;
+    onError?: (error: string) => void;
+    onCancel?: () => void;
+    checkout: CheckoutData;
+    size?: 'sm' | 'md' | 'lg';
+    buttonColor?: 'default' | 'black' | 'white';
+    buttonType?: 'buy' | 'plain' | 'donate' | 'pay';
+}
+export declare const GooglePayButton: React.FC<GooglePayButtonProps>;
+export default GooglePayButton;