@commercelayer/react-components 3.14.1 → 4.0.0-alpha.1

package/lib/esm/components/LineItemName.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import type { LineItem } from '@commercelayer/sdk';
+export declare type LineItemNameType = Omit<Props, 'children'> & {
+    label: string;
+    lineItem: LineItem;
+};
+declare type Props = {
+    children?: (props: LineItemNameType) => ReactNode;
+} & JSX.IntrinsicElements['p'];
+export declare function LineItemName(props: Props): JSX.Element;
+export declare namespace LineItemName {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+    };
+    var displayName: string;
+}
+export default LineItemName;

package/lib/esm/components/LineItemName.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import LineItemChildrenContext from"../context/LineItemChildrenContext";import Parent from"./utils/Parent";import components from"../config/components";const propTypes=components.LineItemName.propTypes,displayName=components.LineItemName.displayName;export function LineItemName(props){const{lineItem}=useContext(LineItemChildrenContext),label=lineItem?.name,parentProps={label,lineItem,...props};return props.children?_jsx(Parent,{...parentProps,children:props.children}):_jsx("p",{...props,children:label})}LineItemName.propTypes=propTypes,LineItemName.displayName=displayName;export default LineItemName;

package/lib/esm/components/LineItemOption.d.ts

@@ -0,0 +1,30 @@
+import { CSSProperties } from 'react';
+import { LineItemOption as LineItemOptionType } from '@commercelayer/sdk';
+import { FunctionChildren } from '../typings/index';
+declare type LineItemOptionChildrenProps = FunctionChildren<Omit<Props, 'children'> & {
+    lineItemOption: LineItemOptionType;
+}>;
+declare type Props = {
+    id?: string;
+    className?: string;
+    key?: string;
+    style?: CSSProperties;
+    children?: LineItemOptionChildrenProps;
+    name?: string;
+    valueClassName?: string;
+    tagElement?: keyof JSX.IntrinsicElements;
+    tagContainer?: keyof JSX.IntrinsicElements;
+};
+export declare function LineItemOption(props: Props): JSX.Element;
+export declare namespace LineItemOption {
+    var propTypes: {
+        name: import("prop-types").Requireable<string>;
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        valueClassName: import("prop-types").Requireable<string>;
+        className: import("prop-types").Requireable<string>;
+        id: import("prop-types").Requireable<string>;
+        style: import("prop-types").Requireable<object>;
+    };
+    var displayName: string;
+}
+export default LineItemOption;

package/lib/esm/components/LineItemOption.js

@@ -0,0 +1 @@
+import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{useContext}from"react";import LineItemOptionChildrenContext from"../context/LineItemOptionChildrenContext";import get from"lodash/get";import has from"lodash/has";import map from"lodash/map";import Parent from"./utils/Parent";import components from"../config/components";import isJSON from"../utils/isJSON";const propTypes=components.LineItemOption.propTypes,displayName=components.LineItemOption.displayName;export function LineItemOption(props){const{name,children,valueClassName,key,tagElement="li",tagContainer="ul",...p}=props,{lineItemOption,showAll}=useContext(LineItemOptionChildrenContext),parentProps={...props,lineItemOption},TagElement=tagElement,TagContainer=tagContainer,components2=showAll&&isJSON(JSON.stringify(lineItemOption?.options))?map(lineItemOption?.options,(value,key2)=>_jsxs(TagElement,{...p,children:[`${key2}:`,_jsx("span",{className:valueClassName,children:`${value}`})]},key2)):has(lineItemOption,`options.${name}`)?_jsxs(TagElement,{...p,children:[`${name}:`,_jsx("span",{className:valueClassName,...p,children:`${get(lineItemOption,`options.${name}`)}`})]},key):null;return children?_jsx(Parent,{...parentProps,children:props.children}):_jsx(TagContainer,{children:components2})}LineItemOption.propTypes=propTypes,LineItemOption.displayName=displayName;export default LineItemOption;

package/lib/esm/components/LineItemOptions.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+declare type Props = JSX.IntrinsicElements['div'] & {
+    children: ReactNode;
+    title?: string;
+    showName?: boolean;
+    titleTagElement?: keyof JSX.IntrinsicElements;
+    titleClassName?: string;
+} & ({
+    skuOptionId: string;
+    showAll?: never;
+} | {
+    skuOptionId?: never;
+    showAll: true;
+});
+export declare function LineItemOptions(props: Props): JSX.Element;
+export declare namespace LineItemOptions {
+    var displayName: string;
+}
+export default LineItemOptions;

package/lib/esm/components/LineItemOptions.js

@@ -0,0 +1 @@
+import{jsx as _jsx,jsxs as _jsxs,Fragment as _Fragment}from"react/jsx-runtime";import{useContext}from"react";import LineItemChildrenContext from"../context/LineItemChildrenContext";import LineItemOptionChildrenContext from"../context/LineItemOptionChildrenContext";import{isEmpty}from"lodash";import components from"../config/components";const displayName=components.LineItemOptions.displayName;export function LineItemOptions(props){const{skuOptionId,title,children,showName=!0,showAll,className,titleTagElement="h6",titleClassName,...p}=props,{lineItem}=useContext(LineItemChildrenContext),lineItemOptions=isEmpty(lineItem)?[]:lineItem?.line_item_options||[],TitleTagElement=titleTagElement,options=lineItemOptions.filter(o=>showAll?!0:o.skuOption().id===skuOptionId).map((o,k)=>{const showTitle=showName?_jsx(TitleTagElement,{className:titleClassName,children:title||o.name}):null,valueProps={lineItemOption:o,showAll};return _jsxs("div",{className,...p,children:[showTitle,_jsx(LineItemOptionChildrenContext.Provider,{value:valueProps,children})]},k)});return _jsx(_Fragment,{children:options})}LineItemOptions.displayName=displayName;export default LineItemOptions;

package/lib/esm/components/LineItemQuantity.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import { FunctionChildren } from '../typings/index';
+declare type LineItemQuantityChildrenProps = FunctionChildren<Omit<Props, 'children'> & {
+    quantity: number;
+    handleChange: (event: React.MouseEvent<HTMLSelectElement>) => void;
+}>;
+declare type Props = {
+    children?: LineItemQuantityChildrenProps;
+    max?: number;
+    disabled?: boolean;
+    readonly?: boolean;
+} & (JSX.IntrinsicElements['select'] & JSX.IntrinsicElements['span']);
+export declare function LineItemQuantity(props: Props): JSX.Element;
+export declare namespace LineItemQuantity {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        max: import("prop-types").Requireable<number>;
+        disabled: import("prop-types").Requireable<boolean>;
+        readonly: import("prop-types").Requireable<boolean>;
+    };
+    var defaultProps: {
+        max: number;
+    };
+    var displayName: string;
+}
+export default LineItemQuantity;

package/lib/esm/components/LineItemQuantity.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import LineItemChildrenContext from"../context/LineItemChildrenContext";import LineItemContext from"../context/LineItemContext";import Parent from"./utils/Parent";import components from"../config/components";const propTypes=components.LineItemQuantity.propTypes,defaultProps=components.LineItemQuantity.defaultProps,displayName=components.LineItemQuantity.displayName;export function LineItemQuantity(props){const{max=50,readonly=!1,...p}=props,{lineItem}=useContext(LineItemChildrenContext),{updateLineItem}=useContext(LineItemContext),options=[];for(let i=1;i<=max;i++)options.push(_jsx("option",{value:`${i}`,children:i},i));const handleChange=e=>{const quantity2=Number(e.target.value);updateLineItem&&lineItem&&updateLineItem(lineItem.id,quantity2)},quantity=lineItem?.quantity,parentProps={handleChange,quantity,...props};return props.children?_jsx(Parent,{...parentProps,children:props.children}):readonly?_jsx("span",{...p,children:quantity}):_jsx("select",{title:lineItem?.name,value:quantity,onChange:handleChange,...p,children:options})}LineItemQuantity.propTypes=propTypes,LineItemQuantity.defaultProps=defaultProps,LineItemQuantity.displayName=displayName;export default LineItemQuantity;

package/lib/esm/components/LineItemRemoveLink.d.ts

@@ -0,0 +1,22 @@
+import { PropsWithoutRef } from 'react';
+import { FunctionChildren } from '../typings/index';
+declare type ChildrenProps = FunctionChildren<{
+    handleRemove: (event: React.MouseEvent<HTMLAnchorElement>) => void;
+    label?: string;
+}>;
+declare type Props = {
+    children?: ChildrenProps;
+    label?: string;
+} & PropsWithoutRef<JSX.IntrinsicElements['a']>;
+export declare function LineItemRemoveLink(props: Props): JSX.Element;
+export declare namespace LineItemRemoveLink {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        label: import("prop-types").Requireable<string>;
+    };
+    var defaultProps: {
+        label: string;
+    };
+    var displayName: string;
+}
+export default LineItemRemoveLink;

package/lib/esm/components/LineItemRemoveLink.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import LineItemChildrenContext from"../context/LineItemChildrenContext";import LineItemContext from"../context/LineItemContext";import Parent from"./utils/Parent";import components from"../config/components";const propTypes=components.LineItemRemoveLink.propTypes,defaultProps=components.LineItemRemoveLink.defaultProps,displayName=components.LineItemRemoveLink.displayName;export function LineItemRemoveLink(props){const{label="Remove"}=props,{lineItem}=useContext(LineItemChildrenContext),{deleteLineItem}=useContext(LineItemContext),handleRemove=e=>{e.preventDefault(),deleteLineItem&&lineItem&&deleteLineItem(lineItem.id)},parentProps={handleRemove,...props};return props.children?_jsx(Parent,{...parentProps,children:props.children}):_jsx("a",{...props,href:"#",onClick:handleRemove,children:label})}LineItemRemoveLink.propTypes=propTypes,LineItemRemoveLink.defaultProps=defaultProps,LineItemRemoveLink.displayName=displayName;export default LineItemRemoveLink;

package/lib/esm/components/LineItemsContainer.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+declare type Props = {
+    children: ReactNode;
+    filters?: Record<string, any>;
+    loader?: ReactNode;
+};
+export declare function LineItemsContainer(props: Props): JSX.Element;
+export declare namespace LineItemsContainer {
+    var propTypes: {
+        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
+        filters: import("prop-types").Requireable<object>;
+        loader: import("prop-types").Requireable<string | import("prop-types").ReactElementLike>;
+    };
+    var defaultProps: {
+        filters: {};
+        loader: string;
+    };
+    var displayName: string;
+}
+export default LineItemsContainer;

package/lib/esm/components/LineItemsContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useEffect,useReducer,useContext}from"react";import lineItemReducer,{lineItemInitialState,updateLineItem,deleteLineItem}from"../reducers/LineItemReducer";import OrderContext from"../context/OrderContext";import LineItemContext from"../context/LineItemContext";import CommerceLayerContext from"../context/CommerceLayerContext";import components from"../config/components";const propTypes=components.LineItemsContainer.propTypes,defaultProps=components.LineItemsContainer.defaultProps,displayName=components.LineItemsContainer.displayName;export function LineItemsContainer(props){const{children,loader="Loading..."}=props,{order,addResourceToInclude,include,orderId,getOrder,includeLoaded}=useContext(OrderContext),config=useContext(CommerceLayerContext),[state,dispatch]=useReducer(lineItemReducer,lineItemInitialState);useEffect(()=>{include?.includes("line_items.line_item_options.sku_option")?includeLoaded?.["line_items.line_item_options.sku_option"]||addResourceToInclude({newResourceLoaded:{"line_items.line_item_options.sku_option":!0}}):addResourceToInclude({newResource:["line_items.line_item_options.sku_option"]}),include?.includes("line_items.item")?includeLoaded?.["line_items.item"]||addResourceToInclude({newResourceLoaded:{"line_items.item":!0}}):addResourceToInclude({newResource:["line_items.item"]})},[include,includeLoaded]),useEffect(()=>{order?.line_items&&dispatch({type:"setLineItems",payload:{lineItems:order.line_items}})},[order?.line_items]);const lineItemValue={...state,loader,updateLineItem:(lineItemId,quantity=1)=>updateLineItem({lineItemId,quantity,dispatch,config,getOrder,orderId,errors:state.errors}),deleteLineItem:lineItemId=>deleteLineItem({lineItemId,dispatch,config,getOrder,orderId,errors:state.errors})};return _jsx(LineItemContext.Provider,{value:lineItemValue,children:state.loading?loader:children})}LineItemsContainer.propTypes=propTypes,LineItemsContainer.defaultProps=defaultProps,LineItemsContainer.displayName=displayName;export default LineItemsContainer;

package/lib/esm/components/LineItemsCount.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { TypeAccepted } from '../utils/getLineItemsCount';
+import { FunctionChildren } from '../typings/index';
+declare type LineItemsCountChildrenProps = FunctionChildren<Omit<Props, 'children'> & {
+    quantity: number;
+}>;
+declare type Props = {
+    children?: LineItemsCountChildrenProps;
+    typeAccepted?: TypeAccepted[];
+} & JSX.IntrinsicElements['span'];
+export declare function LineItemsCount(props: Props): JSX.Element;
+export declare namespace LineItemsCount {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        id: import("prop-types").Requireable<string>;
+        className: import("prop-types").Requireable<string>;
+        name: import("prop-types").Requireable<string>;
+        style: import("prop-types").Requireable<object>;
+    };
+    var displayName: string;
+}
+export default LineItemsCount;

package/lib/esm/components/LineItemsCount.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useState,useEffect}from"react";import Parent from"./utils/Parent";import getLineItemsCount from"../utils/getLineItemsCount";import LineItemContext from"../context/LineItemContext";import components from"../config/components";const propTypes=components.LineItemsCount.propTypes,displayName=components.LineItemsCount.displayName;export function LineItemsCount(props){const{children,typeAccepted,...p}=props,{lineItems}=useContext(LineItemContext),[quantity,setQuantity]=useState(0);useEffect(()=>{if(lineItems&&lineItems.length>0){const qty=getLineItemsCount({lineItems:lineItems||[],typeAccepted});setQuantity(qty)}return()=>{setQuantity(0)}},[lineItems,typeAccepted]);const parentProps={quantity,typeAccepted,...p};return children?_jsx(Parent,{...parentProps,children}):_jsx("span",{...p,children:quantity})}LineItemsCount.propTypes=propTypes,LineItemsCount.displayName=displayName;export default LineItemsCount;

package/lib/esm/components/LineItemsEmpty.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { FunctionChildren } from '../typings/index';
+export declare type LineItemsCountType = FunctionChildren<Omit<LineItemsCountProps, 'children'> & {
+    quantity: number;
+    text: string;
+}>;
+declare type LineItemsCountProps = {
+    children?: LineItemsCountType;
+    text?: string;
+} & JSX.IntrinsicElements['span'];
+export declare function LineItemsEmpty(props: LineItemsCountProps): JSX.Element | null;
+export declare namespace LineItemsEmpty {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        id: import("prop-types").Requireable<string>;
+        className: import("prop-types").Requireable<string>;
+        name: import("prop-types").Requireable<string>;
+        style: import("prop-types").Requireable<object>;
+        text: import("prop-types").Requireable<string>;
+    };
+    var displayName: string;
+}
+export default LineItemsEmpty;

package/lib/esm/components/LineItemsEmpty.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useState,useEffect}from"react";import Parent from"./utils/Parent";import getLineItemsCount from"../utils/getLineItemsCount";import LineItemContext from"../context/LineItemContext";import components from"../config/components";const propTypes=components.LineItemsEmpty.propTypes,displayName=components.LineItemsEmpty.displayName;export function LineItemsEmpty(props){const{children,text="Your shopping bag is empty",...p}=props,{lineItems}=useContext(LineItemContext),[quantity,setQuantity]=useState(),emptyText=quantity===0?_jsx("span",{...p,children:text}):null;useEffect(()=>{if(lineItems)if(lineItems.length>0){const qty=getLineItemsCount({lineItems:lineItems||[]});setQuantity(qty)}else setQuantity(0);return()=>{setQuantity(void 0)}},[lineItems]);const parentProps={quantity,text,...p};return children?_jsx(Parent,{...parentProps,children}):emptyText}LineItemsEmpty.propTypes=propTypes,LineItemsEmpty.displayName=displayName;export default LineItemsEmpty;

package/lib/esm/components/MetadataInput.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { BaseInputComponentProps } from '../typings/index';
+declare type Props = BaseInputComponentProps & JSX.IntrinsicElements['input'] & JSX.IntrinsicElements['textarea'];
+export declare function MetadataInput(props: Props): JSX.Element;
+export declare namespace MetadataInput {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        name: import("prop-types").Validator<string>;
+        type: import("prop-types").Validator<import("../typings/index").BaseInputType>;
+        onChange: import("prop-types").Requireable<(...args: any[]) => any>;
+        placeholder: import("prop-types").Requireable<string>;
+    };
+    var displayName: string;
+}
+export default MetadataInput;

package/lib/esm/components/MetadataInput.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import BaseInput from"./utils/BaseInput";import components from"../config/components";const propTypes=components.MetadataInput.propTypes,displayName=components.MetadataInput.displayName;export function MetadataInput(props){return _jsx(BaseInput,{"data-metadata":!0,...props})}MetadataInput.propTypes=propTypes,MetadataInput.displayName=displayName;export default MetadataInput;

package/lib/esm/components/PaymentGateway.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="react" />
+import { LoaderType } from '../typings/index';
+import { PaymentSourceProps } from './PaymentSource';
+export declare type GatewayBaseType = Props & {
+    show: boolean;
+    loading: boolean;
+    loaderComponent: JSX.Element;
+};
+declare type Props = PaymentSourceProps & {
+    showCard: boolean;
+    handleEditClick: (e: MouseEvent) => void;
+    show: boolean;
+    loader?: LoaderType;
+};
+export declare function PaymentGateway({ readonly, showCard, handleEditClick, children, templateCustomerCards, templateCustomerSaveToWallet, onClickCustomerCards, show, loader, ...p }: Props): JSX.Element | null;
+export default PaymentGateway;

package/lib/esm/components/PaymentGateway.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import OrderContext from"../context/OrderContext";import PaymentMethodChildrenContext from"../context/PaymentMethodChildrenContext";import PaymentMethodContext from"../context/PaymentMethodContext";import getPaypalConfig from"../utils/paypalPayment";import{useContext,useEffect,useState}from"react";import getLoaderComponent from"../utils/getLoaderComponent";import CustomerContext from"../context/CustomerContext";export function PaymentGateway({readonly,showCard,handleEditClick,children,templateCustomerCards,templateCustomerSaveToWallet,onClickCustomerCards,show,loader="Loading...",...p}){const loaderComponent=getLoaderComponent(loader),[loading,setLoading]=useState(!0),{payment}=useContext(PaymentMethodChildrenContext),{order}=useContext(OrderContext),{getCustomerPaymentSources}=useContext(CustomerContext),{currentPaymentMethodId,config,currentPaymentMethodType,setPaymentSource,paymentSource}=useContext(PaymentMethodContext),paymentResource=readonly?currentPaymentMethodType:payment?.payment_source_type;useEffect(()=>{if(payment?.id===currentPaymentMethodId&&paymentResource&&order?.payment_method?.payment_source_type===paymentResource){const attributes=config&&paymentResource==="paypal_payments"?getPaypalConfig(paymentResource,config):{},setPaymentSources=async()=>{await setPaymentSource({paymentResource,order,attributes}),getCustomerPaymentSources&&getCustomerPaymentSources()};(!paymentSource&&order?.payment_method.id&&show||!paymentSource||paymentSource.type!==paymentResource)&&setPaymentSources(),paymentSource?.mismatched_amounts&&show&&setPaymentSources(),setLoading(!1)}return()=>{setLoading(!0)}},[order?.payment_method?.id,show,paymentSource]);const gatewayConfig={readonly,showCard,handleEditClick,children,templateCustomerCards,show,loading,onClickCustomerCards,loaderComponent,templateCustomerSaveToWallet,...p};switch(paymentResource){case"stripe_payments":return _jsx(StripeGateway,{...gatewayConfig,children});case"klarna_payments":return _jsx(KlarnaGateway,{...gatewayConfig,children});case"adyen_payments":return _jsx(AdyenGateway,{...gatewayConfig,children});case"braintree_payments":return _jsx(BraintreeGateway,{...gatewayConfig,children});case"wire_transfers":return _jsx(WireTransferGateway,{...gatewayConfig,children});case"paypal_payments":return _jsx(PaypalGateway,{...gatewayConfig,children});case"checkout_com_payments":return _jsx(CheckoutComGateway,{...gatewayConfig,children});default:return null}}export default PaymentGateway;

package/lib/esm/components/PaymentMethod.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+import { LoaderType } from '../typings/index';
+import { PaymentMethod as PaymentMethodType } from '@commercelayer/sdk';
+declare type Props = {
+    children: ReactNode;
+    activeClass?: string;
+    loader?: LoaderType;
+} & Omit<JSX.IntrinsicElements['div'], 'onClick'> & ({
+    clickableContainer: true;
+    onClick?: (payment?: PaymentMethodType | Record<string, any>) => void;
+} | {
+    clickableContainer?: never;
+    onClick?: never;
+});
+export declare function PaymentMethod({ children, className, activeClass, loader, clickableContainer, onClick, ...p }: Props): JSX.Element;
+export declare namespace PaymentMethod {
+    var propTypes: {
+        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
+    };
+    var displayName: string;
+}
+export default PaymentMethod;

package/lib/esm/components/PaymentMethod.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{Fragment,useContext,useState,useEffect}from"react";import PaymentMethodContext from"../context/PaymentMethodContext";import PaymentMethodChildrenContext from"../context/PaymentMethodChildrenContext";import components from"../config/components";import getLoaderComponent from"../utils/getLoaderComponent";const propTypes=components.PaymentMethod.propTypes,displayName=components.PaymentMethod.displayName;export function PaymentMethod({children,className,activeClass,loader="Loading...",clickableContainer,onClick,...p}){const[loading,setLoading]=useState(!0),[paymentSelected,setPaymentSelected]=useState(""),{paymentMethods,currentPaymentMethodId,setPaymentMethod,setLoading:setLoadingPlaceOrder}=useContext(PaymentMethodContext);useEffect(()=>(paymentMethods&&setLoading(!1),currentPaymentMethodId&&setPaymentSelected(currentPaymentMethodId),()=>{setLoading(!0)}),[paymentMethods,currentPaymentMethodId]);const components2=paymentMethods&&paymentMethods.map((payment,k)=>{const isActive=currentPaymentMethodId===payment?.id,paymentMethodProps={payment,clickableContainer,paymentSelected,setPaymentSelected},paymentResource=payment?.payment_source_type,onClickable=clickableContainer?async e=>{e.stopPropagation(),setLoadingPlaceOrder({loading:!0}),setPaymentSelected(payment.id);const paymentMethodId=payment?.id;await setPaymentMethod({paymentResource,paymentMethodId}),onClick&&onClick(payment),setLoadingPlaceOrder({loading:!1})}:void 0;return _jsx("div",{"data-test-id":paymentResource,className:`${className} ${isActive?activeClass:""}`,onClick:onClickable,...p,children:_jsx(PaymentMethodChildrenContext.Provider,{value:paymentMethodProps,children})},k)});return loading?getLoaderComponent(loader):_jsx(Fragment,{children:components2})}PaymentMethod.propTypes=propTypes,PaymentMethod.displayName=displayName;export default PaymentMethod;

package/lib/esm/components/PaymentMethodAmount.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { BaseAmountComponent } from '../typings/index';
+export declare function PaymentMethodAmount(props: BaseAmountComponent): JSX.Element;
+export declare namespace PaymentMethodAmount {
+    var propTypes: {
+        id: import("prop-types").Requireable<string>;
+        className: import("prop-types").Requireable<string>;
+        style: import("prop-types").Requireable<object>;
+        name: import("prop-types").Requireable<string>;
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        format: import("prop-types").Requireable<import("../typings/index").BaseFormatPrice>;
+    };
+    var defaultProps: {
+        format: import("../typings/index").BaseFormatPrice;
+    };
+    var displayName: string;
+}
+export default PaymentMethodAmount;

package/lib/esm/components/PaymentMethodAmount.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import BaseOrderPrice from"./utils/BaseOrderPrice";import components from"../config/components";const propTypes=components.PaymentMethodAmount.propTypes,defaultProps=components.PaymentMethodAmount.defaultProps,displayName=components.PaymentMethodAmount.displayName;export function PaymentMethodAmount(props){return _jsx(BaseOrderPrice,{base:"amount",type:"payment_method",...props})}PaymentMethodAmount.propTypes=propTypes,PaymentMethodAmount.defaultProps=defaultProps,PaymentMethodAmount.displayName=displayName;export default PaymentMethodAmount;

package/lib/esm/components/PaymentMethodName.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+declare type PaymentMethodNameChildrenProps = Omit<Props, 'children'> & {
+    labelName: string;
+};
+declare type Props = {
+    children?: (props: PaymentMethodNameChildrenProps) => ReactNode;
+} & JSX.IntrinsicElements['label'];
+export declare function PaymentMethodName(props: Props): JSX.Element;
+export declare namespace PaymentMethodName {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+    };
+    var displayName: string;
+}
+export default PaymentMethodName;

package/lib/esm/components/PaymentMethodName.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import PaymentMethodChildrenContext from"../context/PaymentMethodChildrenContext";import Parent from"./utils/Parent";import components from"../config/components";const propTypes=components.PaymentMethodName.propTypes,displayName=components.PaymentMethodName.displayName;export function PaymentMethodName(props){const{payment}=useContext(PaymentMethodChildrenContext),labelName=payment?.name,htmlFor=payment?.payment_source_type,parentProps={htmlFor,labelName,...props};return props.children?_jsx(Parent,{...parentProps,children:props.children}):_jsx("label",{htmlFor,...props,children:labelName})}PaymentMethodName.propTypes=propTypes,PaymentMethodName.displayName=displayName;export default PaymentMethodName;

package/lib/esm/components/PaymentMethodPrice.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="react" />
+import { BaseAmountComponent } from '../typings/index';
+declare type Props = {
+    type?: 'amount';
+    labelFree?: string;
+} & BaseAmountComponent;
+export declare function PaymentMethodPrice(props: Props): JSX.Element;
+export declare namespace PaymentMethodPrice {
+    var propTypes: {
+        type: import("prop-types").Requireable<"amount">;
+        id: import("prop-types").Requireable<string>;
+        className: import("prop-types").Requireable<string>;
+        style: import("prop-types").Requireable<object>;
+        name: import("prop-types").Requireable<string>;
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        format: import("prop-types").Requireable<import("../typings/index").BaseFormatPrice>;
+    };
+    var displayName: string;
+}
+export default PaymentMethodPrice;

package/lib/esm/components/PaymentMethodPrice.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useState,useEffect,useContext}from"react";import getAmount from"../utils/getAmount";import PaymentMethodChildrenContext from"../context/PaymentMethodChildrenContext";import Parent from"./utils/Parent";import components from"../config/components";const propTypes=components.PaymentMethodPrice.propTypes,displayName=components.PaymentMethodPrice.displayName;export function PaymentMethodPrice(props){const{format="formatted",type="amount",labelFree="Free",...p}=props,{payment}=useContext(PaymentMethodChildrenContext),[price,setPrice]=useState(""),[priceCents,setPriceCents]=useState(0);useEffect(()=>{if(payment){const p2=getAmount({base:"price",type,format,obj:payment});setPrice(p2);const c=getAmount({base:"price",type,format:"cents",obj:payment});setPriceCents(c)}return()=>{setPrice(""),setPriceCents(0)}},[payment]);const parentProps={labelFree,price,priceCents,...p};return props.children?_jsx(Parent,{...parentProps,children:props.children}):_jsx("span",{...p,children:priceCents===0?labelFree:price})}PaymentMethodPrice.propTypes=propTypes,PaymentMethodPrice.displayName=displayName;export default PaymentMethodPrice;

package/lib/esm/components/PaymentMethodRadioButton.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode, ChangeEvent } from 'react';
+import { PaymentMethod } from '@commercelayer/sdk';
+declare type ShippingMethodRadioButtonChildrenProps = Omit<Props, 'children'> & {
+    checked: boolean;
+    handleOnChange: (event: ChangeEvent<HTMLInputElement>) => Promise<void>;
+};
+declare type Props = {
+    children?: (props: ShippingMethodRadioButtonChildrenProps) => ReactNode;
+    onChange?: (payment?: PaymentMethod | Record<string, any>) => void;
+} & JSX.IntrinsicElements['input'];
+export declare function PaymentMethodRadioButton(props: Props): JSX.Element;
+export declare namespace PaymentMethodRadioButton {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+    };
+    var displayName: string;
+}
+export default PaymentMethodRadioButton;

package/lib/esm/components/PaymentMethodRadioButton.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import PaymentMethodChildrenContext from"../context/PaymentMethodChildrenContext";import Parent from"./utils/Parent";import components from"../config/components";import PaymentMethodContext from"../context/PaymentMethodContext";import OrderContext from"../context/OrderContext";const propTypes=components.PaymentMethodRadioButton.propTypes,displayName=components.PaymentMethodRadioButton.displayName;export function PaymentMethodRadioButton(props){const{onChange,...p}=props,{payment,paymentSelected,setPaymentSelected,clickableContainer}=useContext(PaymentMethodChildrenContext),{order}=useContext(OrderContext),{setPaymentMethod,setLoading}=useContext(PaymentMethodContext),orderId=order?.id||"",paymentResource=payment?.payment_source_type,paymentMethodId=payment?.id,name=`payment-${orderId}`,checked=paymentSelected===payment?.id,handleOnChange=async e=>{e.stopPropagation(),setPaymentSelected&&setPaymentSelected(paymentMethodId),setLoading({loading:!0}),!clickableContainer&&await setPaymentMethod({paymentResource,paymentMethodId}),onChange&&onChange(payment),setLoading({loading:!1})},id=payment?.payment_source_type,parentProps={handleOnChange,checked,id,name,...props};return props.children?_jsx(Parent,{...parentProps,children:props.children}):_jsx("input",{title:name,type:"radio",id,onChange:handleOnChange,checked,...p})}PaymentMethodRadioButton.propTypes=propTypes,PaymentMethodRadioButton.displayName=displayName;export default PaymentMethodRadioButton;

package/lib/esm/components/PaymentMethodsContainer.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { PaymentMethodConfig } from '../reducers/PaymentMethodReducer';
+declare type Props = {
+    children: ReactNode;
+    config?: PaymentMethodConfig;
+};
+export declare function PaymentMethodsContainer(props: Props): JSX.Element;
+export declare namespace PaymentMethodsContainer {
+    var propTypes: {
+        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
+    };
+    var displayName: string;
+}
+export default PaymentMethodsContainer;

package/lib/esm/components/PaymentMethodsContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import PaymentMethodContext,{defaultPaymentMethodContext}from"../context/PaymentMethodContext";import{useContext,useEffect,useReducer,useMemo}from"react";import paymentMethodReducer,{paymentMethodInitialState,getPaymentMethods,setPaymentMethodConfig}from"../reducers/PaymentMethodReducer";import OrderContext from"../context/OrderContext";import CommerceLayerContext from"../context/CommerceLayerContext";import components from"../config/components";import{isEmpty}from"lodash";import{setPaymentRef}from"../reducers/PaymentMethodReducer";const propTypes=components.PaymentMethodsContainer.propTypes,displayName=components.PaymentMethodsContainer.displayName;export function PaymentMethodsContainer(props){const{children,config}=props,[state,dispatch]=useReducer(paymentMethodReducer,paymentMethodInitialState),{order,getOrder,setOrderErrors,include,addResourceToInclude,updateOrder,includeLoaded}=useContext(OrderContext),credentials=useContext(CommerceLayerContext);async function getPayMethods(){order&&await getPaymentMethods({order,dispatch})}useEffect(()=>{include?.includes("available_payment_methods")?includeLoaded?.available_payment_methods||addResourceToInclude({newResourceLoaded:{available_payment_methods:!0,payment_source:!0,payment_method:!0,"line_items.line_item_options.sku_option":!0,"line_items.item":!0}}):addResourceToInclude({newResource:["available_payment_methods","payment_source","payment_method","line_items.line_item_options.sku_option","line_items.item"]}),config&&isEmpty(state.config)&&setPaymentMethodConfig(config,dispatch),credentials&&order&&(state.paymentMethods||getPayMethods()),order?.payment_source&&dispatch({type:"setPaymentSource",payload:{paymentSource:order?.payment_source}}),order?.payment_source===null&&dispatch({type:"setPaymentSource",payload:{paymentSource:void 0}})},[order,credentials,include,includeLoaded]);const contextValue=useMemo(()=>({...state,setLoading:({loading})=>defaultPaymentMethodContext.setLoading({loading,dispatch}),setPaymentRef:({ref})=>setPaymentRef({ref,dispatch}),setPaymentMethodErrors:errors=>defaultPaymentMethodContext.setPaymentMethodErrors(errors,dispatch),setPaymentMethod:async args=>await defaultPaymentMethodContext.setPaymentMethod({...args,config:credentials,updateOrder,order,dispatch,setOrderErrors}),setPaymentSource:async args=>await defaultPaymentMethodContext.setPaymentSource({...state,...args,config:credentials,dispatch,getOrder,updateOrder,order}),updatePaymentSource:async args=>await defaultPaymentMethodContext.updatePaymentSource({...args,config:credentials,dispatch}),destroyPaymentSource:async args=>await defaultPaymentMethodContext.destroyPaymentSource({...args,dispatch,config:credentials,updateOrder,orderId:order?.id})}),[state]);return _jsx(PaymentMethodContext.Provider,{value:contextValue,children})}PaymentMethodsContainer.propTypes=propTypes,PaymentMethodsContainer.displayName=displayName;export default PaymentMethodsContainer;

package/lib/esm/components/PaymentSource.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { LoaderType } from '../typings/index';
+import { CustomerCardsTemplateChildren } from './utils/PaymentCardsTemplate';
+export declare type CustomerCardsProps = {
+    handleClick: () => void;
+};
+export declare type CustomerSaveToWalletProps = {
+    name: 'save_payment_source_to_customer_wallet';
+};
+export declare type PaymentSourceProps = {
+    children?: ReactNode;
+    readonly?: boolean;
+    templateCustomerCards?: CustomerCardsTemplateChildren;
+    onClickCustomerCards?: () => void;
+    templateCustomerSaveToWallet?: (props: CustomerSaveToWalletProps) => ReactNode;
+    loader?: LoaderType;
+} & JSX.IntrinsicElements['div'];
+export declare function PaymentSource(props: PaymentSourceProps): JSX.Element;
+export declare namespace PaymentSource {
+    var propTypes: {
+        children: import("prop-types").Requireable<ReactNode | (() => ReactNode)>;
+        readonly: import("prop-types").Requireable<boolean>;
+    };
+    var displayName: string;
+}
+export default PaymentSource;

package/lib/esm/components/PaymentSource.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useState,useEffect}from"react";import PaymentMethodChildrenContext from"../context/PaymentMethodChildrenContext";import components from"../config/components";import PaymentMethodContext from"../context/PaymentMethodContext";import CustomerContext from"../context/CustomerContext";import PaymentGateway from"./PaymentGateway";import getCardDetails from"../utils/getCardDetails";import OrderContext from"../context/OrderContext";const propTypes=components.PaymentSource.propTypes,displayName=components.PaymentSource.displayName;export function PaymentSource(props){const{readonly}=props,{payment}=useContext(PaymentMethodChildrenContext),{order}=useContext(OrderContext),{payments}=useContext(CustomerContext),{currentPaymentMethodId,paymentSource,destroyPaymentSource}=useContext(PaymentMethodContext),[show,setShow]=useState(!1),[showCard,setShowCard]=useState(!1);useEffect(()=>(readonly?(setShow(!0),setShowCard(!0)):payment?.id===currentPaymentMethodId?(setShow(!0),getCardDetails({paymentType:payment?.payment_source_type,customerPayment:{payment_source:paymentSource}}).brand&&setShowCard(!0)):setShow(!1),()=>{setShow(!1),setShowCard(!1)}),[currentPaymentMethodId,paymentSource,payments,payment,readonly,order]);const gatewayProps={...props,show,showCard,handleEditClick:async e=>{if(e.stopPropagation(),paymentSource){const paymentSourceId=paymentSource?.id;await destroyPaymentSource({paymentSourceId,paymentResource:payment?.payment_source_type})}setShowCard(!showCard),setShow(!0)},readonly};return _jsx(PaymentGateway,{...gatewayProps})}PaymentSource.propTypes=propTypes,PaymentSource.displayName=displayName;export default PaymentSource;

package/lib/esm/components/PaymentSourceBrandIcon.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+import { IconBrand } from '../context/PaymentSourceContext';
+import { FunctionChildren } from '../typings/index';
+declare type CustomComponent = FunctionChildren<Omit<Props & {
+    brand: IconBrand;
+    defaultSrc: string;
+    url: string;
+}, 'children'>>;
+declare type Props = {
+    children?: CustomComponent;
+    width?: number;
+    height?: number;
+} & JSX.IntrinsicElements['img'];
+export declare function PaymentSourceBrandIcon({ src, width, children, ...p }: Props): JSX.Element;
+export declare namespace PaymentSourceBrandIcon {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        width: import("prop-types").Requireable<number>;
+        height: import("prop-types").Requireable<number>;
+        src: import("prop-types").Requireable<string>;
+        className: import("prop-types").Requireable<string>;
+    };
+    var displayName: string;
+}
+export default PaymentSourceBrandIcon;

package/lib/esm/components/PaymentSourceBrandIcon.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import PaymentSourceContext from"../context/PaymentSourceContext";import{useContext,useRef}from"react";import Parent from"./utils/Parent";import components from"../config/components";const propTypes=components.PaymentSourceBrandIcon.propTypes,displayName=components.PaymentSourceBrandIcon.displayName;export function PaymentSourceBrandIcon({src,width=32,children,...p}){const{brand}=useContext(PaymentSourceContext),ref=useRef(null),defaultSrc="//data.commercelayer.app/assets/images/icons/credit-cards/color/credit-card.svg",url=src||`//data.commercelayer.app/assets/images/icons/credit-cards/color/${brand}.svg`,handleError=()=>{ref.current&&(ref.current.src=defaultSrc)},parentProps={brand,defaultSrc,url,width,...p};return children?_jsx(Parent,{...parentProps,children}):_jsx("img",{ref,src:url,onError:handleError,width,...p})}PaymentSourceBrandIcon.propTypes=propTypes,PaymentSourceBrandIcon.displayName=displayName;export default PaymentSourceBrandIcon;

package/lib/esm/components/PaymentSourceBrandName.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { IconBrand } from '../context/PaymentSourceContext';
+import { FunctionChildren } from '../typings/index';
+declare type CustomComponent = FunctionChildren<Omit<Props & {
+    brand: IconBrand;
+}, 'children'>>;
+declare type Props = {
+    children?: CustomComponent;
+    label?: string;
+} & JSX.IntrinsicElements['span'];
+export declare function PaymentSourceBrandName({ children, label, ...props }: Props): JSX.Element;
+export declare namespace PaymentSourceBrandName {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        label: import("prop-types").Requireable<string>;
+    };
+    var displayName: string;
+}
+export default PaymentSourceBrandName;

package/lib/esm/components/PaymentSourceBrandName.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import PaymentSourceContext from"../context/PaymentSourceContext";import{capitalize}from"lodash";import{useContext}from"react";import Parent from"./utils/Parent";import components from"../config/components";const propTypes=components.PaymentSourceBrandName.propTypes,displayName=components.PaymentSourceBrandName.displayName;export function PaymentSourceBrandName({children,label,...props}){const{brand}=useContext(PaymentSourceContext),brandName=brand&&capitalize(brand.replace("-"," ")),parentProps={brand:brandName,label,...props};return children?_jsx(Parent,{...parentProps,children}):_jsx("span",{...props,children:label||capitalize(brandName)})}PaymentSourceBrandName.propTypes=propTypes,PaymentSourceBrandName.displayName=displayName;export default PaymentSourceBrandName;

package/lib/esm/components/PaymentSourceDetail.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { FunctionChildren } from '../typings/index';
+export declare type PaymentSourceDetailType = 'last4' | 'exp_year' | 'exp_month';
+declare type CustomComponent = FunctionChildren<Omit<Props & {
+    text: string;
+}, 'children'>>;
+declare type Props = {
+    children?: CustomComponent;
+    type: PaymentSourceDetailType;
+} & JSX.IntrinsicElements['span'];
+export declare function PaymentSourceDetail({ type, children, ...p }: Props): JSX.Element;
+export declare namespace PaymentSourceDetail {
+    var propTypes: {
+        type: import("prop-types").Validator<PaymentSourceDetailType>;
+    };
+    var displayName: string;
+}
+export default PaymentSourceDetail;

package/lib/esm/components/PaymentSourceDetail.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import components from"../config/components";import PaymentSourceContext from"../context/PaymentSourceContext";import{has}from"lodash";import{useContext}from"react";import Parent from"./utils/Parent";const propTypes=components.PaymentSourceDetail.propTypes,displayName=components.PaymentSourceDetail.displayName;export function PaymentSourceDetail({type,children,...p}){const card=useContext(PaymentSourceContext),text=has(card,type)?card[type]:type==="last4"?"****":"**",parentProps={type,text,...p};return children?_jsx(Parent,{...parentProps,children}):_jsx("span",{...p,children:text})}PaymentSourceDetail.propTypes=propTypes,PaymentSourceDetail.displayName=displayName;export default PaymentSourceDetail;

package/lib/esm/components/PaymentSourceEditButton.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { FunctionChildren } from '../typings/index';
+declare type CustomComponent = FunctionChildren<Omit<Props, 'children'>>;
+declare type Props = {
+    children?: CustomComponent;
+    label?: string | ReactNode;
+} & Omit<JSX.IntrinsicElements['button'], 'onClick'>;
+export declare function PaymentSourceEditButton({ children, label, ...props }: Props): JSX.Element | null;
+export declare namespace PaymentSourceEditButton {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        label: import("prop-types").Requireable<string | import("prop-types").ReactElementLike>;
+    };
+    var displayName: string;
+}
+export default PaymentSourceEditButton;

package/lib/esm/components/PaymentSourceEditButton.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import PaymentSourceContext from"../context/PaymentSourceContext";import{useContext}from"react";import Parent from"./utils/Parent";import components from"../config/components";const displayName=components.PaymentSourceEditButton.displayName,propTypes=components.PaymentSourceEditButton.propTypes;export function PaymentSourceEditButton({children,label="Edit",...props}){const{showCard,handleEditClick,readonly}=useContext(PaymentSourceContext),parentProps={showCard,label,handleEditClick,...props};return children?_jsx(Parent,{...parentProps,children}):readonly?null:_jsx("button",{...props,onClick:handleEditClick,children:label})}PaymentSourceEditButton.propTypes=propTypes,PaymentSourceEditButton.displayName=displayName;export default PaymentSourceEditButton;

package/lib/esm/components/PaypalPayment.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+export declare type PaypalConfig = {
+    return_url: string;
+    cancel_url: string;
+    infoMessage?: {
+        text?: string | ReactNode;
+        className?: string;
+    };
+};
+declare type Props = Omit<PaypalConfig, 'return_url' | 'cancel_url'> & JSX.IntrinsicElements['div'];
+export declare function PaypalPayment({ infoMessage, ...p }: Props): JSX.Element;
+export default PaypalPayment;

package/lib/esm/components/PaypalPayment.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import PaymentMethodContext from"../context/PaymentMethodContext";import isFunction from"lodash/isFunction";import{useContext,useEffect,useRef}from"react";const defaultMessage="by placing the order, you will be redirected to the PayPal website to sign in and authorize the payment";export function PaypalPayment({infoMessage,...p}){const ref=useRef(null),{setPaymentSource,paymentSource,currentPaymentMethodType,setPaymentRef}=useContext(PaymentMethodContext);useEffect(()=>(ref.current&&paymentSource&&currentPaymentMethodType&&paymentSource?.approval_url&&(ref.current.onsubmit=()=>handleClick(),setPaymentRef({ref})),()=>{setPaymentRef({ref:{current:null}})}),[ref,paymentSource,currentPaymentMethodType]);const handleClick=async()=>{if(paymentSource&&currentPaymentMethodType)try{return await setPaymentSource({paymentSourceId:paymentSource.id,paymentResource:currentPaymentMethodType,attributes:{metadata:{card:{id:paymentSource.id,brand:"paypal",last4:""}}}}),!0}catch{return!1}return!1};return _jsx("form",{ref,children:_jsx("div",{...p,children:_jsx("span",{className:infoMessage?.className,children:isFunction(infoMessage?.text)?infoMessage?.text():infoMessage?.text||defaultMessage})})})}export default PaypalPayment;