@commercelayer/react-components 3.15.6 → 3.15.7

package/lib/components/AddToCartButton.d.ts

@@ -0,0 +1,34 @@
+import { PropsWithoutRef, ReactNode } from 'react';
+import { FunctionChildren } from '../typings/index';
+import { AddToCartReturn } from '../reducers/OrderReducer';
+import { VariantOption } from './VariantSelector';
+declare type ChildrenProps = {
+    handleClick: () => AddToCartReturn;
+} & Omit<Props, 'children'>;
+declare type AddToCartButtonChildrenProps = FunctionChildren<ChildrenProps>;
+export declare type AddToCartButtonType = ChildrenProps;
+declare type BuyNowMode = {
+    buyNowMode: true;
+    checkoutUrl?: string;
+} | {
+    buyNowMode?: false;
+    checkoutUrl?: never;
+};
+declare type THostedCart = {
+    redirectToHostedCart: true;
+    hostedCartUrl?: string;
+} | {
+    redirectToHostedCart?: false;
+    hostedCartUrl?: never;
+};
+declare type Props = {
+    children?: AddToCartButtonChildrenProps;
+    label?: string | ReactNode;
+    skuCode?: string;
+    bundleCode?: string;
+    disabled?: boolean;
+    skuListId?: string;
+    lineItem?: VariantOption['lineItem'];
+} & BuyNowMode & THostedCart & PropsWithoutRef<JSX.IntrinsicElements['button']>;
+export default function AddToCartButton(props: Props): JSX.Element;
+export {};

package/lib/components/AddToCartButton.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import Parent from"./utils/Parent";import OrderContext from"../context/OrderContext";import isEmpty from"lodash/isEmpty";import has from"lodash/has";import ItemContext from"../context/ItemContext";import getCurrentItemKey from"../utils/getCurrentItemKey";import SkuListsContext from"../context/SkuListsContext";import ExternalFunctionContext from"../context/ExternalFunctionContext";import isFunction from"lodash/isFunction";import SkuChildrenContext from"../context/SkuChildrenContext";import getCartLink from"../utils/getCartLink";import CommerceLayerContext from"../context/CommerceLayerContext";export default function AddToCartButton(props){const{label="Add to cart",children,skuCode,bundleCode,disabled,skuListId,lineItem,buyNowMode=!1,checkoutUrl,redirectToHostedCart,hostedCartUrl,...p}=props,{accessToken,endpoint}=useContext(CommerceLayerContext),{addToCart,orderId,getOrder,setOrderErrors}=useContext(OrderContext),{url,callExternalFunction}=useContext(ExternalFunctionContext),{item,items,quantity,option,prices,lineItems,lineItem:lineItemContext,skuCode:itemSkuCode}=useContext(ItemContext),{skuLists}=useContext(SkuListsContext),{sku}=useContext(SkuChildrenContext),[slug]=endpoint.split(".commercelayer"),sCode=!isEmpty(items)&&skuCode?items[skuCode]?.code:sku?.code||skuCode||getCurrentItemKey(item)||itemSkuCode,availabilityQuantity=item[sCode]?.inventory?.quantity,handleClick=async()=>{const qty=quantity[sCode],opt=option[sCode],customLineItem=isEmpty(lineItem||lineItemContext)?lineItems[sCode]:lineItem||lineItemContext;if(!isEmpty(skuLists)&&skuListId&&url){const slQty=quantity[skuListId]||1;if(has(skuLists,skuListId)){const lineItems2=skuLists&&skuLists[skuListId].map(skuCode2=>({skuCode:skuCode2,quantity:slQty,_update_quantity:1}));return callExternalFunction({url,data:{resourceType:"orders",inputs:[{id:orderId,lineItems:lineItems2}]}}).then(async res=>(getOrder&&orderId&&await getOrder(orderId),res)).catch(({response})=>(setOrderErrors&&setOrderErrors(response.data),response))}}if(!url&&addToCart){const res=await addToCart({bundleCode,skuCode:sCode,skuId:item[sCode]?.id,quantity:qty,option:opt,lineItem:customLineItem,buyNowMode,checkoutUrl});if(redirectToHostedCart){const orderId2=res.orderId;hostedCartUrl?location.href=`https://${hostedCartUrl}/${orderId2}?accessToken=${accessToken}`:orderId2&&slug&&(location.href=getCartLink({orderId:orderId2,slug,accessToken}))}return res}else if(url)return callExternalFunction({url,data:{bundleCode,skuCode:sCode,skuId:item[sCode]?.id,quantity:qty,option:opt,lineItem:customLineItem,buyNowMode,checkoutUrl}}).then(async res=>(getOrder&&orderId&&await getOrder(orderId),res)).catch(({response})=>(setOrderErrors&&setOrderErrors(response.data),response))},autoDisabled=!isEmpty(skuLists)||skuListId?!1:disabled||!prices[sCode]||!sCode||availabilityQuantity===0,parentProps={handleClick,disabled:disabled||autoDisabled,label,...props};return children?_jsx(Parent,{...parentProps,children}):_jsx("button",{...p,disabled:autoDisabled,onClick:handleClick,children:isFunction(label)?label():label})}

package/lib/components/Address.d.ts

@@ -0,0 +1,13 @@
+import { FunctionComponent, ReactNode } from 'react';
+import { Address as AddressType } from '@commercelayer/sdk';
+import { AddressCardsTemplateChildren } from './utils/AddressCardsTemplate';
+declare type Props = {
+    children: ReactNode | AddressCardsTemplateChildren;
+    selectedClassName?: string;
+    disabledClassName?: string;
+    onSelect?: (address: AddressType) => void;
+    addresses?: AddressType[];
+    deselect?: boolean;
+} & JSX.IntrinsicElements['div'];
+declare const Address: FunctionComponent<Props>;
+export default Address;

package/lib/components/Address.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{Fragment,useContext,useState,useEffect}from"react";import AddressChildrenContext from"../context/AddressChildrenContext";import components from"../config/components";import CustomerContext from"../context/CustomerContext";import BillingAddressContext from"../context/BillingAddressContext";import ShippingAddressContext from"../context/ShippingAddressContext";import isEmpty from"lodash/isEmpty";import AddressContext from"../context/AddressContext";import OrderContext from"../context/OrderContext";import AddressCardsTemplate from"./utils/AddressCardsTemplate";const propTypes=components.Address.propTypes,Address=props=>{const{children,className,selectedClassName="",disabledClassName="",onSelect,addresses=[],deselect=!1,...p}=props,{addresses:addressesContext}=useContext(CustomerContext),{setBillingAddress,billingCustomerAddressId}=useContext(BillingAddressContext),{setShippingAddress,shippingCustomerAddressId}=useContext(ShippingAddressContext),{shipToDifferentAddress,billingAddressId,shippingAddressId}=useContext(AddressContext),{order}=useContext(OrderContext),[selected,setSelected]=useState(null),items=isEmpty(addresses)?addressesContext&&addressesContext||[]:addresses;useEffect(()=>{items&&!deselect&&items.map((address,k)=>{billingCustomerAddressId&&address.reference===billingCustomerAddressId&&selected===null&&setSelected(k),!billingAddressId&&k===selected&&setBillingAddress&&setBillingAddress(address.id,{customerAddressId:address.reference}),shippingCustomerAddressId&&address.reference===shippingCustomerAddressId&&selected===null&&setSelected(k),!shippingAddressId&&k===selected&&setShippingAddress&&setShippingAddress(address.id,{customerAddressId:address.reference})}),deselect&&(async()=>{setBillingAddress&&await setBillingAddress(""),setShippingAddress&&await setShippingAddress("")})()},[deselect,billingCustomerAddressId,shippingCustomerAddressId,addressesContext,shipToDifferentAddress]);const handleSelect=async(k,addressId,customerAddressId,disabled,address)=>{!disabled&&setSelected(k),setBillingAddress&&await setBillingAddress(addressId,{customerAddressId}),!disabled&&setShippingAddress&&await setShippingAddress(addressId,{customerAddressId}),onSelect&&onSelect(address)},countryLock=order?.shipping_country_code_lock,components2=typeof children=="function"?[]:items.filter(address=>!(setShippingAddress&&countryLock&&countryLock!==address.country_code)).map((address,k)=>{const addressProps={address},disabled=setShippingAddress&&countryLock&&countryLock!==address.country_code||!1,addressSelectedClass=selected===k?`${className} ${deselect?"":selectedClassName}`:className,customerAddressId=address?.reference||"",finalClassName=disabled?`${className} ${disabledClassName}`:addressSelectedClass;return _jsx(AddressChildrenContext.Provider,{value:addressProps,children:_jsx("div",{className:finalClassName,onClick:()=>handleSelect(k,address.id,customerAddressId,disabled,address),"data-disabled":disabled,...p,children})},k)}),parentProps={customerAddresses:items,selected,handleSelect,countryLock,...props};return typeof children=="function"?_jsx(AddressCardsTemplate,{...parentProps,children}):_jsx(Fragment,{children:components2})};Address.propTypes=propTypes;export default Address;

package/lib/components/AddressCountrySelector.d.ts

@@ -0,0 +1,9 @@
+import { FunctionComponent } from 'react';
+import { AddressCountrySelectName, BaseSelectComponentProps } from '../typings/index';
+declare type AddressCountrySelectorProps = Omit<BaseSelectComponentProps, 'options' | 'name'> & {
+    name: AddressCountrySelectName;
+    required?: boolean;
+    disabled?: boolean;
+} & Pick<JSX.IntrinsicElements['select'], 'className' | 'id' | 'style'>;
+declare const AddressCountrySelector: FunctionComponent<AddressCountrySelectorProps>;
+export default AddressCountrySelector;

package/lib/components/AddressCountrySelector.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useEffect,useState}from"react";import BaseSelect from"./utils/BaseSelect";import components from"../config/components";import BillingAddressFormContext from"../context/BillingAddressFormContext";import ShippingAddressFormContext from"../context/ShippingAddressFormContext";import isEmpty from"lodash/isEmpty";import{getCountries}from"../utils/countryStateCity";const propTypes=components.AddressCountrySelector.propTypes,defaultProps=components.AddressCountrySelector.defaultProps,displayName=components.AddressCountrySelector.displayName,AddressCountrySelector=props=>{const{required=!0,value,name,className,...p}=props,billingAddress=useContext(BillingAddressFormContext),shippingAddress=useContext(ShippingAddressFormContext),[hasError,setHasError]=useState(!1);useEffect(()=>(value&&billingAddress?.setValue&&billingAddress.setValue(name,value),value&&shippingAddress?.setValue&&shippingAddress.setValue(name,value),!isEmpty(billingAddress.errors)&&billingAddress?.errors?.[name]?.error&&setHasError(!0),isEmpty(billingAddress?.errors?.[name])&&hasError&&setHasError(!1),!isEmpty(shippingAddress.errors)&&shippingAddress?.errors?.[name]?.error&&setHasError(!0),isEmpty(shippingAddress?.errors?.[name])&&hasError&&setHasError(!1),()=>{setHasError(!1)}),[value,billingAddress?.errors,shippingAddress?.errors]);const errorClassName=billingAddress?.errorClassName||shippingAddress?.errorClassName,classNameComputed=`${className} ${hasError?errorClassName:""}`;return _jsx(BaseSelect,{className:classNameComputed,ref:billingAddress?.validation||shippingAddress?.validation,required,options:getCountries(),name,value,...p})};AddressCountrySelector.propTypes=propTypes,AddressCountrySelector.defaultProps=defaultProps,AddressCountrySelector.displayName=displayName;export default AddressCountrySelector;

package/lib/components/AddressField.d.ts

@@ -0,0 +1,15 @@
+import { FunctionComponent, ReactNode } from 'react';
+import { AddressFieldView } from '../reducers/AddressReducer';
+import { Address } from '@commercelayer/sdk';
+declare type AddressFieldChildrenProps = Omit<AddressFieldProps, 'children' | 'name'> & {
+    address: Address;
+};
+declare type AddressFieldProps = ({
+    children?: (props: AddressFieldChildrenProps) => ReactNode;
+    name: AddressFieldView;
+} | {
+    children: (props: AddressFieldChildrenProps) => ReactNode;
+    name?: AddressFieldView;
+}) & JSX.IntrinsicElements['p'];
+declare const AddressField: FunctionComponent<AddressFieldProps>;
+export default AddressField;

package/lib/components/AddressField.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import AddressChildrenContext from"../context/AddressChildrenContext";import Parent from"./utils/Parent";import components from"../config/components";import get from"lodash/get";const propTypes=components.AddressField.propTypes,displayName=components.AddressField.displayName,AddressField=props=>{const{name}=props,{address}=useContext(AddressChildrenContext),text=get(address,name),parentProps={address,...props};return props.children?_jsx(Parent,{...parentProps,children:props.children}):_jsx("p",{...props,children:text})};AddressField.propTypes=propTypes,AddressField.displayName=displayName;export default AddressField;

package/lib/components/AddressInput.d.ts

@@ -0,0 +1,7 @@
+import { FunctionComponent } from 'react';
+import { BaseInputComponentProps, AddressInputName } from '../typings/index';
+export declare type AddressInputProps = {
+    name: AddressInputName;
+} & Omit<BaseInputComponentProps, 'name'> & JSX.IntrinsicElements['input'] & JSX.IntrinsicElements['textarea'];
+declare const AddressInput: FunctionComponent<AddressInputProps>;
+export default AddressInput;

package/lib/components/AddressInput.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useEffect,useState}from"react";import BaseInput from"./utils/BaseInput";import components from"../config/components";import BillingAddressFormContext from"../context/BillingAddressFormContext";import ShippingAddressFormContext from"../context/ShippingAddressFormContext";import isEmpty from"lodash/isEmpty";import{businessMandatoryField}from"../utils/validateFormFields";const propTypes=components.AddressInput.propTypes,displayName=components.AddressInput.displayName,AddressInput=props=>{const{placeholder="",required,value,className,...p}=props,billingAddress=useContext(BillingAddressFormContext),shippingAddress=useContext(ShippingAddressFormContext),[hasError,setHasError]=useState(!1);useEffect(()=>(value&&billingAddress?.setValue&&billingAddress.setValue(p.name,value),value&&shippingAddress?.setValue&&shippingAddress.setValue(p.name,value),!isEmpty(billingAddress.errors)&&billingAddress?.errors?.[p.name]?.error&&setHasError(!0),!isEmpty(billingAddress)&&isEmpty(billingAddress?.errors?.[p.name])&&hasError&&setHasError(!1),!isEmpty(shippingAddress.errors)&&shippingAddress?.errors?.[p.name]?.error&&setHasError(!0),!isEmpty(shippingAddress)&&isEmpty(shippingAddress?.errors?.[p.name])&&hasError&&setHasError(!1),()=>{setHasError(!1)}),[value,billingAddress?.errors,shippingAddress?.errors]);const mandatoryField=billingAddress?.isBusiness?businessMandatoryField(p.name,billingAddress.isBusiness):businessMandatoryField(p.name,shippingAddress.isBusiness),reqField=required!==void 0?required:mandatoryField,errorClassName=billingAddress?.errorClassName||shippingAddress?.errorClassName,classNameComputed=`${className} ${hasError?errorClassName:""}`;return p.name==="billing_address_billing_info"&&!billingAddress.requiresBillingInfo?null:_jsx(BaseInput,{ref:billingAddress?.validation||shippingAddress?.validation,className:classNameComputed,required:reqField,placeholder,defaultValue:value,...p})};AddressInput.propTypes=propTypes,AddressInput.displayName=displayName;export default AddressInput;

package/lib/components/AddressStateSelector.d.ts

@@ -0,0 +1,11 @@
+import { FunctionComponent } from 'react';
+import { AddressStateSelectName, BaseSelectComponentProps } from '../typings/index';
+declare type AddressStateSelectorProps = Omit<BaseSelectComponentProps, 'options' | 'name'> & {
+    name: AddressStateSelectName;
+    required?: boolean;
+    disabled?: boolean;
+    inputClassName?: string;
+    selectClassName?: string;
+} & Pick<JSX.IntrinsicElements['select'], 'className' | 'id' | 'style'>;
+declare const AddressStateSelector: FunctionComponent<AddressStateSelectorProps>;
+export default AddressStateSelector;

package/lib/components/AddressStateSelector.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useEffect,useState}from"react";import BaseSelect from"./utils/BaseSelect";import components from"../config/components";import BillingAddressFormContext from"../context/BillingAddressFormContext";import ShippingAddressFormContext from"../context/ShippingAddressFormContext";import isEmpty from"lodash/isEmpty";import{getStateOfCountry,isValidState}from"../utils/countryStateCity";import isEmptyStates from"../utils/isEmptyStates";import AddressesContext from"../context/AddressContext";import BaseInput from"./utils/BaseInput";const propTypes=components.AddressStateSelector.propTypes,defaultProps=components.AddressStateSelector.defaultProps,displayName=components.AddressStateSelector.displayName,AddressStateSelector=props=>{const{required=!0,value,name,className,inputClassName,selectClassName,...p}=props,billingAddress=useContext(BillingAddressFormContext),shippingAddress=useContext(ShippingAddressFormContext),{errors:addressErrors}=useContext(AddressesContext),[hasError,setHasError]=useState(!1),[countryCode,setCountryCode]=useState(""),[val,setVal]=useState(value||"");useEffect(()=>{const billingCountryCode=billingAddress?.values?.billing_address_country_code?.value||billingAddress?.values?.country_code;!isEmpty(billingCountryCode)&&billingCountryCode!==countryCode&&setCountryCode(billingCountryCode);const shippingCountryCode=shippingAddress?.values?.shipping_address_country_code?.value;if(!isEmpty(shippingCountryCode)&&shippingCountryCode!==countryCode&&setCountryCode(shippingCountryCode),[!isEmpty(billingAddress),billingCountryCode,countryCode!==billingCountryCode].every(Boolean)&&!isValidState(val,billingCountryCode)&&!isEmptyStates(billingCountryCode)&&(billingAddress.resetField&&billingAddress.resetField(name),setVal("")),[!isEmpty(shippingAddress),shippingCountryCode,countryCode!==shippingCountryCode].every(Boolean)&&!isValidState(val,shippingCountryCode)&&!isEmptyStates(shippingCountryCode)&&(shippingAddress.resetField&&shippingAddress.resetField(name),setVal("")),!isEmpty(billingAddress)){const fieldError=billingAddress?.errors?.[name]?.error;setHasError(!!fieldError)}if(!isEmpty(shippingAddress)){const fieldError=shippingAddress?.errors?.[name]?.error;setHasError(!!fieldError)}return()=>{setHasError(!1)}},[value,billingAddress,shippingAddress,addressErrors]);const errorClassName=billingAddress?.errorClassName||shippingAddress?.errorClassName,classNameComputed=isEmptyStates(countryCode)?`${className} ${inputClassName} ${hasError?errorClassName:""}`:`${className} ${selectClassName} ${hasError?errorClassName:""}`;return isEmptyStates(countryCode)?_jsx(BaseInput,{...p,name,ref:billingAddress?.validation||shippingAddress?.validation,className:classNameComputed,required,placeholder:p.placeholder?.label||"",defaultValue:val,type:"text"}):_jsx(BaseSelect,{...p,className:classNameComputed,ref:billingAddress?.validation||shippingAddress?.validation,required,options:getStateOfCountry(countryCode),name,value:val})};AddressStateSelector.propTypes=propTypes,AddressStateSelector.defaultProps=defaultProps,AddressStateSelector.displayName=displayName;export default AddressStateSelector;

package/lib/components/AddressesContainer.d.ts

@@ -0,0 +1,8 @@
+import { FunctionComponent, ReactNode } from 'react';
+export declare type AddressesContainerProps = {
+    children: ReactNode;
+    shipToDifferentAddress?: boolean;
+    isBusiness?: boolean;
+};
+declare const AddressesContainer: FunctionComponent<AddressesContainerProps>;
+export default AddressesContainer;

package/lib/components/AddressesContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import AddressesContext,{defaultAddressContext}from"../context/AddressContext";import{useContext,useEffect,useReducer}from"react";import addressReducer,{addressInitialState,setAddressErrors,setCloneAddress}from"../reducers/AddressReducer";import OrderContext from"../context/OrderContext";import CommerceLayerContext from"../context/CommerceLayerContext";import{saveAddresses}from"../reducers/AddressReducer";import components from"../config/components";const propTypes=components.AddressesContainer.propTypes,displayName=components.AddressesContainer.displayName,AddressesContainer=props=>{const{children,shipToDifferentAddress=!1,isBusiness}=props,[state,dispatch]=useReducer(addressReducer,addressInitialState),{order,orderId,updateOrder}=useContext(OrderContext),config=useContext(CommerceLayerContext);useEffect(()=>(dispatch({type:"setShipToDifferentAddress",payload:{shipToDifferentAddress,isBusiness}}),()=>{dispatch({type:"cleanup",payload:{}})}),[shipToDifferentAddress,isBusiness]);const contextValue={...state,setAddressErrors:(errors,resource)=>setAddressErrors({errors,resource,dispatch,currentErrors:state.errors}),setAddress:params=>defaultAddressContext.setAddress({...params,dispatch}),saveAddresses:async()=>await saveAddresses({config,dispatch,updateOrder,order,orderId,state}),setCloneAddress:(id,resource)=>setCloneAddress(id,resource,dispatch)};return _jsx(AddressesContext.Provider,{value:contextValue,children})};AddressesContainer.propTypes=propTypes,AddressesContainer.displayName=displayName;export default AddressesContainer;

package/lib/components/AdjustmentAmount.d.ts

@@ -0,0 +1,4 @@
+import { FunctionComponent } from 'react';
+import { BaseAmountComponent } from '../typings/index';
+declare const AdjustmentAmount: FunctionComponent<BaseAmountComponent>;
+export default AdjustmentAmount;

package/lib/components/AdjustmentAmount.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.AdjustmentAmount.propTypes,defaultProps=components.AdjustmentAmount.defaultProps,displayName=components.AdjustmentAmount.displayName,AdjustmentAmount=props=>_jsx(BaseOrderPrice,{base:"amount",type:"adjustment",...props});AdjustmentAmount.propTypes=propTypes,AdjustmentAmount.defaultProps=defaultProps,AdjustmentAmount.displayName=displayName;export default AdjustmentAmount;

package/lib/components/AdyenPayment.d.ts

@@ -0,0 +1,55 @@
+import { CSSProperties } from 'react';
+import { PaymentSourceProps } from './PaymentSource';
+declare type Styles = Partial<{
+    base: CSSProperties;
+    error: CSSProperties;
+    placeholder: CSSProperties;
+    validated: CSSProperties;
+}>;
+declare type PaypalStyle = Partial<{
+    /**
+     * @see {@link https://developer.paypal.com/docs/checkout/integration-features/customize-button/#color}
+     */
+    color: 'gold' | 'blue' | 'silver' | 'white' | 'black';
+    /**
+     * @see {@link https://developer.paypal.com/docs/checkout/integration-features/customize-button/#shape}
+     */
+    shape: 'rect' | 'pill';
+    /**
+     * @see {@link https://developer.paypal.com/docs/checkout/integration-features/customize-button/#height}
+     */
+    height: string | number;
+    /**
+     * @see {@link https://developer.paypal.com/docs/checkout/integration-features/customize-button/#label}
+     */
+    label: 'paypal' | 'checkout' | 'buynow' | 'pay';
+    /**
+     * @see {@link https://developer.paypal.com/docs/checkout/integration-features/customize-button/#tagline}
+     */
+    tagline: boolean;
+    /**
+     * @see {@link https://developer.paypal.com/docs/checkout/integration-features/customize-button/#layout}
+     */
+    layout: 'vertical' | 'horizontal';
+}>;
+interface PaymentMethodsStyle {
+    card?: Styles;
+    paypal?: PaypalStyle;
+}
+export declare type AdyenPaymentConfig = {
+    cardContainerClassName?: string;
+    threeDSecureContainerClassName?: string;
+    placeOrderCallback?: (response: {
+        placed: boolean;
+    }) => void;
+    styles?: PaymentMethodsStyle;
+};
+declare type Props = {
+    clientKey?: string;
+    config?: AdyenPaymentConfig;
+    templateCustomerSaveToWallet?: PaymentSourceProps['templateCustomerSaveToWallet'];
+    locale?: string;
+    environment?: string;
+};
+export declare function AdyenPayment({ clientKey, config, templateCustomerSaveToWallet, environment, locale, }: Props): JSX.Element | null;
+export default AdyenPayment;

package/lib/components/AdyenPayment.js

@@ -0,0 +1 @@
+import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{useContext,useEffect,useRef,useState}from"react";import PaymentMethodContext from"../context/PaymentMethodContext";import{setCustomerOrderParam}from"../utils/localStorage";import Parent from"./utils/Parent";import getBrowserInfo,{cleanUrlBy}from"../utils/browserInfo";import PlaceOrderContext from"../context/PlaceOrderContext";import OrderContext from"../context/OrderContext";const threeDSConfiguration={challengeWindowSize:"05"},defaultConfig={};export function AdyenPayment({clientKey,config,templateCustomerSaveToWallet,environment="test",locale="en_US"}){const{cardContainerClassName,threeDSecureContainerClassName,styles}={...defaultConfig,...config},[loadAdyen,setLoadAdyen]=useState(!1),[checkout,setCheckout]=useState(null),{setPaymentSource,paymentSource,setPaymentMethodErrors,currentPaymentMethodType,setPaymentRef}=useContext(PaymentMethodContext),{order}=useContext(OrderContext),{placeOrderButtonRef}=useContext(PlaceOrderContext),ref=useRef(null),handleSubmit=async(e,component)=>{const savePaymentSourceToCustomerWallet=e?.elements?.save_payment_source_to_customer_wallet?.checked;return savePaymentSourceToCustomerWallet&&setCustomerOrderParam("_save_payment_source_to_customer_wallet",savePaymentSourceToCustomerWallet),component&&component.submit&&component.submit(),!1},handleChange=async(state,checkout2)=>{if(state.isValid){ref.current&&(ref.current.onsubmit=()=>handleSubmit(ref.current,checkout2),setPaymentRef({ref}));const browserInfo=getBrowserInfo(),attributes={payment_request_data:{payment_method:state.data.paymentMethod,shopperInteraction:"Ecommerce",recurringProcessingModel:"CardOnFile",origin:window.location.origin,return_url:window.location.href,redirect_from_issuer_method:"GET",browser_info:{acceptHeader:"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",...browserInfo}}};paymentSource&&await setPaymentSource({paymentSourceId:paymentSource.id,paymentResource:"adyen_payments",attributes})}},handleOnAdditionalDetails=async(state,component)=>{const attributes={payment_request_details:state.data,_details:1};try{const pSource=paymentSource&&await setPaymentSource({paymentSourceId:paymentSource.id,paymentResource:"adyen_payments",attributes}),adyenAction=pSource?.payment_response?.action,resultCode=pSource?.payment_response?.resultCode;if(adyenAction&&component)return component.handleAction(adyenAction),!1;if(["Authorised","Pending","Received"].includes(resultCode))return placeOrderButtonRef?.current!=null&&(placeOrderButtonRef.current.disabled&&(placeOrderButtonRef.current.disabled=!1),placeOrderButtonRef.current?.click()),!0;if(["Cancelled","Refused"].includes(resultCode)){const message=pSource?.payment_response?.refusalReason;setPaymentMethodErrors([{code:"PAYMENT_INTENT_AUTHENTICATION_FAILURE",resource:"payment_methods",field:currentPaymentMethodType,message}]),component&&component.mount("#adyen-dropin")}return!1}catch(error){return console.error("Adyen additional details error:",error),!1}},onSubmit=async(state,component)=>{const browserInfo=getBrowserInfo(),url=cleanUrlBy();let control=await setPaymentSource({paymentSourceId:paymentSource?.id,paymentResource:"adyen_payments"});if(control?.payment_response?.resultCode==="Authorised")return!0;const paymentDataAvailable=Object.keys(control?.payment_request_data).length>0,paymentMethodSelected=control?.payment_request_data?.payment_method?.type;(!paymentDataAvailable||paymentMethodSelected!==state.data.paymentMethod.type)&&(control=await setPaymentSource({paymentSourceId:paymentSource?.id,paymentResource:"adyen_payments",attributes:{payment_request_data:{...state.data,payment_method:state.data.paymentMethod,return_url:url,origin:window.location.origin,redirect_from_issuer_method:"GET",browser_info:{acceptHeader:"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",...browserInfo}}}}));const attributes={payment_request_data:{...state.data,payment_method:state.data.paymentMethod,return_url:url,origin:window.location.origin,redirect_from_issuer_method:"GET",browser_info:{acceptHeader:"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",...browserInfo}},_authorize:1};delete attributes.payment_request_data.paymentMethod;try{const res=await setPaymentSource({paymentSourceId:paymentSource?.id,paymentResource:"adyen_payments",attributes}),action=res?.payment_response?.action;if(component&&action)return component.handleAction(action),!1;const resultCode=res?.payment_response?.resultCode;if(["Authorised","Pending","Received"].includes(resultCode))return placeOrderButtonRef?.current!=null&&(placeOrderButtonRef.current.disabled&&(placeOrderButtonRef.current.disabled=!1),placeOrderButtonRef.current?.click()),!0;if(["Cancelled"].includes(resultCode)){const message=res?.payment_response?.refusalReason;setPaymentMethodErrors([{code:"PAYMENT_INTENT_AUTHENTICATION_FAILURE",resource:"payment_methods",field:currentPaymentMethodType,message}])}if(res?.payment_response?.errorType)if(res?.payment_response?.errorCode==="14_006")onSubmit(state,component);else{const message=res?.payment_response?.message;setPaymentMethodErrors([{code:"PAYMENT_INTENT_AUTHENTICATION_FAILURE",resource:"payment_methods",field:currentPaymentMethodType,message}])}return!1}catch(error){return setPaymentMethodErrors([{code:"PAYMENT_INTENT_AUTHENTICATION_FAILURE",resource:"payment_methods",field:currentPaymentMethodType,message:error.message}]),!1}};return useEffect(()=>{const paymentMethodsResponse=paymentSource?.payment_methods?.paymentMethods?paymentSource?.payment_methods.paymentMethods:[],[firstPaymentMethod]=paymentMethodsResponse,isOnlyCard=paymentMethodsResponse?.length===1&&firstPaymentMethod.type==="scheme";paymentMethodsResponse.length===0&&console.error("Payment methods are not available. Please, check your Adyen configuration.");const options={locale,environment,clientKey,amount:{currency:order?.currency_code||"",value:order?.total_amount_with_taxes_cents||0},countryCode:order?.country_code||"",paymentMethodsResponse:{paymentMethods:paymentMethodsResponse},showPayButton:!1,paymentMethodsConfiguration:{threeDS2:threeDSConfiguration,paypal:{showPayButton:!0,style:styles?.paypal},card:{styles:styles?.card,holderNameRequired:!1}},onAdditionalDetails:handleOnAdditionalDetails,onChange:handleChange,onSubmit};return!ref&&clientKey&&setCustomerOrderParam("_save_payment_source_to_customer_wallet","false"),clientKey&&!loadAdyen&&window&&!checkout&&import("@adyen/adyen-web").then(({default:AdyenCheckout})=>{const type=isOnlyCard?"card":"dropin";AdyenCheckout(options).then(adyenCheckout=>{const component=adyenCheckout.create(type,{onSelect:component2=>{const id=component2._id;id.search("scheme")===-1&&ref.current&&(id.search("paypal")===-1?ref.current.onsubmit=()=>handleSubmit(ref.current,component2):ref.current.onsubmit=null,setPaymentRef({ref}))}}).mount("#adyen-dropin");component&&(setCheckout(component),setLoadAdyen(!0))})}),()=>{setPaymentRef({ref:{current:null}}),setLoadAdyen(!1)}},[clientKey,ref]),!clientKey&&!loadAdyen&&!checkout?null:_jsxs("form",{ref,onSubmit:e=>handleSubmit(e,checkout),children:[_jsx("div",{className:cardContainerClassName,id:"adyen-dropin"}),templateCustomerSaveToWallet&&_jsx(Parent,{name:"save_payment_source_to_customer_wallet",children:templateCustomerSaveToWallet}),_jsx("div",{className:threeDSecureContainerClassName,id:"adyen-action"})]})}export default AdyenPayment;

package/lib/components/AvailabilityContainer.d.ts

@@ -0,0 +1,7 @@
+import { FunctionComponent, ReactNode } from 'react';
+declare type AvailabilityContainerProps = {
+    children: ReactNode;
+    skuCode?: string;
+};
+declare const AvailabilityContainer: FunctionComponent<AvailabilityContainerProps>;
+export default AvailabilityContainer;

package/lib/components/AvailabilityContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useReducer,useEffect}from"react";import availabilityReducer,{availabilityInitialState,getAvailability,getAvailabilityByIds}from"../reducers/AvailabilityReducer";import AvailabilityContext from"../context/AvailabilityContext";import ItemContext from"../context/ItemContext";import getCurrentItemKey from"../utils/getCurrentItemKey";import components from"../config/components";import CommerceLayerContext from"../context/CommerceLayerContext";import LineItemChildrenContext from"../context/LineItemChildrenContext";import SkuChildrenContext from"../context/SkuChildrenContext";import SkuContext from"../context/SkuContext";import isEqual from"lodash/isEqual";const propTypes=components.AvailabilityContainer.propTypes,displayName=components.AvailabilityContainer.displayName,AvailabilityContainer=props=>{const{children,skuCode}=props,{item,skuCode:itemSkuCode,setItem}=useContext(ItemContext),{lineItem}=useContext(LineItemChildrenContext),{sku}=useContext(SkuChildrenContext),{skus}=useContext(SkuContext),config=useContext(CommerceLayerContext),[state,dispatch]=useReducer(availabilityReducer,availabilityInitialState),sCode=skuCode||getCurrentItemKey(item)||itemSkuCode||lineItem?.sku_code||sku?.code;return useEffect(()=>{if(sCode&&!skus){const available=item[sCode]?.inventory?.available,quantity=item[sCode]?.inventory?.quantity,[level]=item[sCode]?.inventory?.levels||[{quantity:null,delivery_lead_times:[]}];if(level!==void 0&&level?.delivery_lead_times?.length>0){const[delivery]=level.delivery_lead_times;dispatch({type:"setAvailability",payload:{...delivery,quantity:level?.quantity}})}else config.accessToken&&!item?.[sCode]?getAvailability({skuCode:sCode,config,dispatch,setItem,item}):available||dispatch({type:"setAvailability",payload:{quantity}})}else if(skus&&config.accessToken){const itemKeys=Object.keys(item).sort(),skuCodes=skus.map(s=>s?.code).sort();if(!isEqual(skuCodes,itemKeys)){const skusIds=skus.map(s=>s.id);getAvailabilityByIds({skusIds,config,dispatch,setItem})}}return()=>{dispatch({type:"setAvailability",payload:{}})}},[config.accessToken,item,sCode,skus]),_jsx(AvailabilityContext.Provider,{value:{...state},children})};AvailabilityContainer.propTypes=propTypes,AvailabilityContainer.displayName=displayName;export default AvailabilityContainer;

package/lib/components/AvailabilityTemplate.d.ts

@@ -0,0 +1,15 @@
+import { FunctionComponent } from 'react';
+import { TimeFormat, FunctionChildren } from '../typings/index';
+import { DeliveryLeadTime } from '../reducers/AvailabilityReducer';
+declare type AvailabilityTemplateChildrenProps = FunctionChildren<Omit<AvailabilityTemplateProps, 'children'> & DeliveryLeadTime & {
+    text: string;
+    quantity: number;
+}>;
+declare type AvailabilityTemplateProps = {
+    children?: AvailabilityTemplateChildrenProps;
+    timeFormat?: TimeFormat;
+    showShippingMethodName?: boolean;
+    showShippingMethodPrice?: boolean;
+} & JSX.IntrinsicElements['p'];
+declare const AvailabilityTemplate: FunctionComponent<AvailabilityTemplateProps>;
+export default AvailabilityTemplate;

package/lib/components/AvailabilityTemplate.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import AvailabilityContext from"../context/AvailabilityContext";import Parent from"./utils/Parent";import{isEmpty}from"lodash";import components from"../config/components";import ItemContext from"../context/ItemContext";import SkuChildrenContext from"../context/SkuChildrenContext";const propTypes=components.AvailabilityTemplate.propTypes,defaultProps=components.AvailabilityTemplate.defaultProps,displayName=components.AvailabilityTemplate.displayName,AvailabilityTemplate=props=>{const{timeFormat,showShippingMethodName,showShippingMethodPrice,children,...p}=props;let{min,max,shipping_method,quantity}=useContext(AvailabilityContext);const{item}=useContext(ItemContext),{sku}=useContext(SkuChildrenContext),text=[];if(item&&sku){const code=sku.code,currentItem=item[code];if(currentItem){const[level]=currentItem.inventory?.levels||[],[delivery]=level?.delivery_lead_times||[];delivery&&(min=delivery?.min,max=delivery?.max,shipping_method=delivery?.shipping_method),quantity=currentItem.inventory.quantity}}const mn=!isEmpty(min)&&timeFormat?min?.[timeFormat]:"",mx=!isEmpty(max)&&timeFormat?max?.[timeFormat]:"",shippingMethodPrice=showShippingMethodPrice&&shipping_method?.formatted_price_amount?`(${shipping_method?.formatted_price_amount})`:"",name=showShippingMethodName&&shipping_method?`with ${shipping_method.name}`:"";quantity&&quantity>0?(text.push("Available"),mn&&mx&&text.push(`in ${mn} - ${mx} ${timeFormat} ${name} ${shippingMethodPrice}`)):quantity===0&&text.push("Out of stock");const parentProps={min,max,shipping_method,quantity,text:text.join(" "),...props};return children?_jsx(Parent,{...parentProps,children}):_jsx("p",{...p,children:text.join(" ")})};AvailabilityTemplate.propTypes=propTypes,AvailabilityTemplate.defaultProps=defaultProps,AvailabilityTemplate.displayName=displayName;export default AvailabilityTemplate;

package/lib/components/BillingAddressContainer.d.ts

@@ -0,0 +1,6 @@
+import { FunctionComponent, ReactNode } from 'react';
+declare type Props = {
+    children: ReactNode;
+};
+declare const BillingAddressContainer: FunctionComponent<Props>;
+export default BillingAddressContainer;

package/lib/components/BillingAddressContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import BillingAddressContext from"../context/BillingAddressContext";import{useContext,useEffect,useReducer}from"react";import billingAddressReducer,{billingAddressInitialState,setBillingAddress,setBillingCustomerAddressId}from"../reducers/BillingAddressReducer";import CommerceLayerContext from"../context/CommerceLayerContext";import components from"../config/components";import OrderContext from"../context/OrderContext";import AddressContext from"../context/AddressContext";const propTypes=components.BillingAddressContainer.propTypes,BillingAddressContainer=props=>{const{children}=props,[state,dispatch]=useReducer(billingAddressReducer,billingAddressInitialState),config=useContext(CommerceLayerContext),{order,include,addResourceToInclude}=useContext(OrderContext),{shipToDifferentAddress,setCloneAddress}=useContext(AddressContext);useEffect(()=>(include?.includes("billing_address")||addResourceToInclude({newResource:"billing_address",resourcesIncluded:include}),order&&config&&setBillingCustomerAddressId({dispatch,order,setCloneAddress}),()=>{dispatch({type:"cleanup",payload:{}})}),[order,include]);const contextValue={...state,setBillingAddress:async(id,options)=>{await setBillingAddress(id,{config,dispatch,order,shipToDifferentAddress,customerAddressId:options?.customerAddressId}),setCloneAddress(id,"billing_address")}};return _jsx(BillingAddressContext.Provider,{value:contextValue,children})};BillingAddressContainer.propTypes=propTypes;export default BillingAddressContainer;

package/lib/components/BillingAddressForm.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+declare type BillingAddressFormProps = {
+    children: ReactNode;
+    reset?: boolean;
+    errorClassName?: string;
+} & Omit<JSX.IntrinsicElements['form'], 'onSubmit'>;
+declare const BillingAddressForm: React.FunctionComponent<BillingAddressFormProps>;
+export default BillingAddressForm;

package/lib/components/BillingAddressForm.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import AddressesContext from"../context/AddressContext";import{useRapidForm}from"rapid-form";import{useContext,useEffect,useRef}from"react";import BillingAddressFormContext from"../context/BillingAddressFormContext";import{isEmpty}from"lodash";import components from"../config/components";import OrderContext from"../context/OrderContext";import{getSaveBillingAddressToAddressBook}from"../utils/localStorage";import{businessMandatoryField}from"../utils/validateFormFields";const propTypes=components.BillingAddressForm.propTypes,BillingAddressForm=props=>{const{children,errorClassName,autoComplete="on",reset=!1,...p}=props,{validation,values,errors,reset:resetForm}=useRapidForm(),{setAddressErrors,setAddress,isBusiness}=useContext(AddressesContext),{saveAddressToCustomerAddressBook,order,include,addResourceToInclude,includeLoaded}=useContext(OrderContext),ref=useRef(null);useEffect(()=>{if(include?.includes("billing_address")?includeLoaded?.billing_address||addResourceToInclude({newResourceLoaded:{billing_address:!0}}):addResourceToInclude({newResource:"billing_address"}),isEmpty(errors)){if(!isEmpty(values)){setAddressErrors([],"billing_address");for(const name in values){const field=values[name];businessMandatoryField(name,isBusiness)||delete values[name],(field?.value||field?.required===!1&&field?.type!=="checkbox")&&(values[name.replace("billing_address_","")]=field.value,delete values[name]),field?.type==="checkbox"&&(delete values[name],saveAddressToCustomerAddressBook({type:"billing_address",value:field.checked}))}setAddress({values:{...values,...isBusiness&&{business:isBusiness}},resource:"billing_address"})}}else{const formErrors=[];for(const fieldName in errors){const code=errors[fieldName]?.code,message=errors[fieldName]?.message;["billing_address_state_code"].includes(fieldName)?isEmpty(values.state_code)?delete errors[fieldName]:formErrors.push({code,message:message||"",resource:"billing_address",field:fieldName}):formErrors.push({code,message:message||"",resource:"billing_address",field:fieldName})}setAddressErrors(formErrors,"billing_address")}const checkboxChecked=ref.current?.querySelector('[name="billing_address_save_to_customer_book"]')?.checked||getSaveBillingAddressToAddressBook();reset&&(!isEmpty(values)||!isEmpty(errors)||checkboxChecked)&&(saveAddressToCustomerAddressBook&&saveAddressToCustomerAddressBook({type:"billing_address",value:!1}),ref&&(ref.current?.reset(),resetForm({target:ref.current}),setAddressErrors([],"billing_address"),setAddress({values:{},resource:"billing_address"})))},[errors,values,reset,include,includeLoaded,isBusiness]);const providerValues={isBusiness,values,validation,setValue:(name,value)=>{const field={[name.replace("billing_address_","")]:value};setAddress({values:{...values,...field,...isBusiness&&{business:isBusiness}},resource:"billing_address"})},errorClassName,requiresBillingInfo:order?.requires_billing_info||!1,errors,resetField:name=>resetForm({currentTarget:ref.current},name)};return _jsx(BillingAddressFormContext.Provider,{value:providerValues,children:_jsx("form",{ref,autoComplete,...p,children})})};BillingAddressForm.propTypes=propTypes;export default BillingAddressForm;

package/lib/components/BraintreePayment.d.ts

@@ -0,0 +1,30 @@
+import { FunctionComponent } from 'react';
+import { HostedFieldFieldOptions } from 'braintree-web/modules/hosted-fields';
+import { PaymentSourceProps } from './PaymentSource';
+declare type BraintreeHostedFields<Type> = {
+    [Property in keyof Type]: {
+        label?: string;
+    } & Type[Property];
+};
+export declare type BraintreeConfig = {
+    containerClassName?: string;
+    cardContainerClassName?: string;
+    expDateContainerClassName?: string;
+    fieldsContainerClassName?: string;
+    cvvContainerClassName?: string;
+    cardDetailsContainerClassName?: string;
+    fieldLabelClassName?: string;
+    inputWrapperClassName?: string;
+    fields?: BraintreeHostedFields<HostedFieldFieldOptions>;
+    styles?: {
+        [key: string]: Record<string, string>;
+    };
+};
+declare type BraintreePaymentProps = {
+    authorization: string;
+    config?: BraintreeConfig;
+    templateCustomerSaveToWallet?: PaymentSourceProps['templateCustomerSaveToWallet'];
+    locale?: string;
+};
+declare const BraintreePayment: FunctionComponent<BraintreePaymentProps>;
+export default BraintreePayment;

package/lib/components/BraintreePayment.js

@@ -0,0 +1 @@
+import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{useContext,useEffect,useRef,useState}from"react";import PaymentMethodContext from"../context/PaymentMethodContext";import isEmpty from"lodash/isEmpty";import OrderContext from"../context/OrderContext";import Parent from"./utils/Parent";import{setCustomerOrderParam}from"../utils/localStorage";import promisify from"../utils/promisify";const defaultConfig={styles:{input:{"font-size":"16px",color:"#3A3A3A"},".number":{"font-family":"monospace"},":focus":{color:"blue"},".valid":{color:"green"},".invalid":{color:"red"},"@media screen and (max-width: 700px)":{input:{"font-size":"14px"}}},fields:{number:{label:"Card Number",selector:"#card-number",placeholder:"4111 1111 1111 1111"},cvv:{label:"CVV",selector:"#cvv",placeholder:"123"},expirationDate:{label:"Expiration Date",selector:"#expiration-date",placeholder:"10/2022"}},submitLabel:"Set payment method"},BraintreePayment=({authorization,config,templateCustomerSaveToWallet})=>{const{fields,styles,containerClassName,cardContainerClassName,fieldsContainerClassName,expDateContainerClassName,fieldLabelClassName,cvvContainerClassName,inputWrapperClassName,cardDetailsContainerClassName}={...defaultConfig,...config},[loadBraintree,setLoadBraintree]=useState(!1),{setPaymentSource,paymentSource,setPaymentMethodErrors,currentPaymentMethodType,setPaymentRef}=useContext(PaymentMethodContext),{order}=useContext(OrderContext),ref=useRef(null),handleSubmitForm=async({event,hostedFieldsInstance,threeDSInstance})=>{const savePaymentSourceToCustomerWallet=event?.elements?.save_payment_source_to_customer_wallet?.checked;if(savePaymentSourceToCustomerWallet&&setCustomerOrderParam("_save_payment_source_to_customer_wallet",savePaymentSourceToCustomerWallet),hostedFieldsInstance)try{const payload=await promisify(hostedFieldsInstance).then(payload2=>payload2),billingAddress=order?.billing_address,verifyCardOptions={nonce:payload.nonce,bin:payload.details.bin,amount:order?.total_amount_with_taxes_float,email:order?.customer_email,billingAddress:{givenName:billingAddress?.first_name,surname:billingAddress?.last_name,phoneNumber:billingAddress?.phone,streetAddress:billingAddress?.line_1,countryCodeAlpha2:billingAddress?.country_code,postalCode:billingAddress?.zip_code,region:billingAddress?.state_code,locality:billingAddress?.city},onLookupComplete:(_data,next)=>{next()}},response=await threeDSInstance.verifyCard(verifyCardOptions);return response.rawCardinalSDKVerificationData.Validated&&paymentSource?(paymentSource&&await setPaymentSource({paymentSourceId:paymentSource.id,paymentResource:"braintree_payments",attributes:{payment_method_nonce:response.nonce,options:{id:response.nonce,card:{last4:response.details.lastFour,exp_year:response.details.expirationYear,exp_month:response.details.expirationMonth,brand:response.details.cardType.toLowerCase()}}}}),!0):!1}catch(error){return console.error(error),setPaymentMethodErrors([{code:"PAYMENT_INTENT_AUTHENTICATION_FAILURE",resource:"payment_methods",field:currentPaymentMethodType,message:error.message}]),!1}return!1};return useEffect(()=>{if(!ref&&authorization&&setCustomerOrderParam("_save_payment_source_to_customer_wallet","false"),authorization&&!loadBraintree&&!isEmpty(window)){const braintreeClient=require("braintree-web/client"),hostedFields=require("braintree-web/hosted-fields"),threeDSecure=require("braintree-web/three-d-secure");braintreeClient.create({authorization},(clientErr,clientInstance)=>{if(clientErr){console.error(clientErr);return}hostedFields.create({client:clientInstance,fields,styles},(hostedFieldsErr,hostedFieldsInstance)=>{if(hostedFieldsErr){console.error(hostedFieldsErr);return}setLoadBraintree(!0),threeDSecure.create({authorization,version:2},(threeDSecureErr,threeDSInstance)=>{threeDSecureErr&&(console.error("3DSecure error",threeDSecureErr),setPaymentMethodErrors([{code:"PAYMENT_INTENT_AUTHENTICATION_FAILURE",resource:"payment_methods",field:currentPaymentMethodType,message:threeDSecureErr.message}])),ref.current&&(ref.current.onsubmit=paymentSource2=>handleSubmitForm({event:ref.current,hostedFieldsInstance,threeDSInstance,paymentSource:paymentSource2}),setPaymentRef({ref}))})})})}return()=>{setPaymentRef({ref:{current:null}}),setLoadBraintree(!1)}},[authorization,ref]),!authorization&&!loadBraintree?null:_jsx("div",{className:containerClassName,children:_jsxs("form",{ref,id:"braintree-form",onSubmit:handleSubmitForm,className:containerClassName,children:[_jsxs("div",{className:fieldsContainerClassName,children:[_jsxs("div",{className:cardContainerClassName,children:[_jsx("label",{className:fieldLabelClassName,htmlFor:"card-number",children:fields?.number?.label}),_jsx("div",{className:inputWrapperClassName,id:"card-number"})]}),_jsxs("div",{className:cardDetailsContainerClassName,children:[_jsxs("div",{className:expDateContainerClassName,children:[_jsx("label",{className:fieldLabelClassName,htmlFor:"expiration-date",children:fields?.expirationDate?.label}),_jsx("div",{className:inputWrapperClassName,id:"expiration-date"})]}),_jsxs("div",{className:cvvContainerClassName,children:[_jsx("label",{className:fieldLabelClassName,htmlFor:"cvv",children:fields?.cvv?.label}),_jsx("div",{className:inputWrapperClassName,id:"cvv"})]})]})]}),_jsx("div",{className:fieldsContainerClassName,children:templateCustomerSaveToWallet&&_jsx(Parent,{name:"save_payment_source_to_customer_wallet",children:templateCustomerSaveToWallet})})]})})};export default BraintreePayment;

package/lib/components/CartLink.d.ts

@@ -0,0 +1,12 @@
+import { MouseEvent, ReactNode } from 'react';
+import { FunctionChildren } from '../typings/index';
+declare type TChildren = FunctionChildren<Omit<Props, 'children'> & {
+    href: string;
+    handleClick?: (e: MouseEvent<HTMLAnchorElement>) => Promise<void>;
+}>;
+declare type Props = {
+    children?: TChildren;
+    label?: string | ReactNode;
+} & JSX.IntrinsicElements['a'];
+export default function CartLink(props: Props): JSX.Element | null;
+export {};

package/lib/components/CartLink.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import OrderContext from"../context/OrderContext";import Parent from"./utils/Parent";import CommerceLayerContext from"../context/CommerceLayerContext";import getCartLink from"../utils/getCartLink";export default function CartLink(props){const{label,children,...p}=props,{order,createOrder}=useContext(OrderContext),{accessToken,endpoint}=useContext(CommerceLayerContext),[slug]=endpoint.split(".commercelayer"),href=slug&&order?.id?getCartLink({slug,orderId:order?.id,accessToken}):"",handleClick=async event=>{if(event.preventDefault(),order?.id)location.href=href;else{const orderId=await createOrder();slug&&(location.href=getCartLink({slug,orderId,accessToken}))}},parentProps={handleClick,label,href,...p};return accessToken?children?_jsx(Parent,{...parentProps,children}):_jsx("a",{href,...p,onClick:handleClick,children:typeof label=="function"?label():label}):null}

package/lib/components/CheckoutComPayment.d.ts

@@ -0,0 +1,23 @@
+import { FunctionComponent } from 'react';
+import { PaymentMethodConfig } from '../reducers/PaymentMethodReducer';
+import { PaymentSourceProps } from './PaymentSource';
+import { FramesStyle } from 'frames-react';
+export declare type CheckoutComConfig = {
+    containerClassName?: string;
+    hintLabel?: string;
+    name?: string;
+    success_url?: string;
+    failure_url?: string;
+    options?: {
+        style: FramesStyle;
+    };
+    [key: string]: unknown;
+};
+declare type CheckoutComPaymentProps = PaymentMethodConfig['checkoutComPayment'] & JSX.IntrinsicElements['div'] & {
+    show?: boolean;
+    publicKey: string;
+    locale?: string;
+    templateCustomerSaveToWallet?: PaymentSourceProps['templateCustomerSaveToWallet'];
+};
+declare const CheckoutComPayment: FunctionComponent<CheckoutComPaymentProps>;
+export default CheckoutComPayment;

package/lib/components/CheckoutComPayment.js

@@ -0,0 +1 @@
+import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{useContext,useRef}from"react";import useExternalScript from"../utils/hooks/useExternalScript";import PaymentMethodContext from"../context/PaymentMethodContext";import{Frames,CardNumber,ExpiryDate,Cvv}from"frames-react";import OrderContext from"../context/OrderContext";import Parent from"./utils/Parent";import{setCustomerOrderParam}from"../utils/localStorage";const scriptUrl="https://cdn.checkout.com/js/framesv2.min.js",systemLanguages=["DE-DE","EN-GB","ES-ES","FR-FR","IT-IT","KR-KR","NL-NL"],defaultOptions={style:{base:{color:"black",fontSize:"18px"},autofill:{backgroundColor:"yellow"},hover:{color:"blue"},focus:{color:"blue"},valid:{color:"green"},invalid:{color:"red"},placeholder:{base:{color:"gray"},focus:{border:"solid 1px blue"}}}},CheckoutComPayment=({publicKey,options=defaultOptions,locale="EN-GB",...p})=>{const ref=useRef(null),loaded=useExternalScript(scriptUrl),{setPaymentRef,currentPaymentMethodType,paymentSource,setPaymentSource,setPaymentMethodErrors}=useContext(PaymentMethodContext),{order}=useContext(OrderContext),{containerClassName,templateCustomerSaveToWallet,success_url=window.location.href,failure_url=window.location.href,show,...divProps}=p,handleSubmit=async()=>{const savePaymentSourceToCustomerWallet=ref?.current?.elements?.save_payment_source_to_customer_wallet?.checked;if(savePaymentSourceToCustomerWallet&&setCustomerOrderParam("_save_payment_source_to_customer_wallet",savePaymentSourceToCustomerWallet),window.Frames){window.Frames.cardholder={name:order?.billing_address?.full_name,billingAddress:{addressLine1:order?.billing_address?.line_1,addressLine2:order?.billing_address?.line_2,zip:order?.billing_address?.zip_code,city:order?.billing_address?.city,state:order?.billing_address?.state_code,country:order?.billing_address?.country_code},phone:order?.billing_address?.phone};try{const data=await window.Frames.submitCard();if(data.token&&paymentSource&&currentPaymentMethodType){const ps=await setPaymentSource({paymentSourceId:paymentSource.id,paymentResource:currentPaymentMethodType,attributes:{token:data.token,payment_type:"token",success_url,failure_url,_authorize:!0}});ps&&ps.redirect_uri&&(window.location.href=ps.redirect_uri)}}catch(error){console.error(error),setPaymentMethodErrors([{code:"PAYMENT_INTENT_AUTHENTICATION_FAILURE",resource:"payment_methods",field:currentPaymentMethodType,message:error?.message}])}}return!1},lang=`${locale.toUpperCase()}-${locale.toUpperCase()}`,localization=systemLanguages.includes(lang)?lang:"EN-GB";return loaded&&show?_jsxs("form",{ref,children:[_jsx("div",{className:containerClassName,...divProps,children:_jsxs(Frames,{config:{debug:!0,publicKey,localization,...options},cardValidationChanged:e=>{e.isValid&&ref.current&&(ref.current.onsubmit=()=>handleSubmit(),setPaymentRef({ref}))},cardTokenized:data=>data,children:[_jsx(CardNumber,{}),_jsx(ExpiryDate,{}),_jsx(Cvv,{})]})}),templateCustomerSaveToWallet&&_jsx(Parent,{name:"save_payment_source_to_customer_wallet",children:templateCustomerSaveToWallet})]}):null};export default CheckoutComPayment;

package/lib/components/CheckoutLink.d.ts

@@ -0,0 +1,13 @@
+import { FunctionComponent } from 'react';
+import { FunctionChildren } from '../typings/index';
+declare type CheckoutLinkChildrenProps = FunctionChildren<Omit<CheckoutLinkProps, 'children'> & {
+    checkoutUrl: string;
+    href: string;
+}>;
+declare type CheckoutLinkProps = {
+    children?: CheckoutLinkChildrenProps;
+    label?: string;
+    hostedCheckout?: boolean;
+} & JSX.IntrinsicElements['a'];
+declare const CheckoutLink: FunctionComponent<CheckoutLinkProps>;
+export default CheckoutLink;

package/lib/components/CheckoutLink.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import OrderContext from"../context/OrderContext";import components from"../config/components";import Parent from"./utils/Parent";import CommerceLayerContext from"../context/CommerceLayerContext";const propTypes=components.CheckoutLink.propTypes,defaultProps=components.CheckoutLink.defaultProps,displayName=components.CheckoutLink.displayName,CheckoutLink=props=>{const{label,hostedCheckout=!0,children,...p}=props,{order}=useContext(OrderContext),{accessToken,endpoint}=useContext(CommerceLayerContext),[slug]=endpoint.split(".commercelayer"),href=hostedCheckout?`${slug}.checkout.commercelayer.app/${order?.id}?accessToken=${accessToken}`:order?.checkout_url,parentProps={checkoutUrl:order?.checkout_url,hostedCheckout,label,href,...p};return children?_jsx(Parent,{...parentProps,children}):_jsx("a",{href,...p,children:label})};CheckoutLink.propTypes=propTypes,CheckoutLink.defaultProps=defaultProps,CheckoutLink.displayName=displayName;export default CheckoutLink;

package/lib/components/CommerceLayer.d.ts

@@ -0,0 +1,8 @@
+import { FunctionComponent, ReactNode } from 'react';
+declare type CommerceLayerProps = {
+    children: ReactNode;
+    accessToken: string;
+    endpoint: string;
+};
+declare const CommerceLayer: FunctionComponent<CommerceLayerProps>;
+export default CommerceLayer;

package/lib/components/CommerceLayer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import CommerceLayerContext from"../context/CommerceLayerContext";import components from"../config/components";const propTypes=components.CommerceLayer.propTypes,CommerceLayer=props=>{const{children,...p}=props;return _jsx(CommerceLayerContext.Provider,{value:{...p},children})};CommerceLayer.propTypes=propTypes;export default CommerceLayer;

package/lib/components/CustomerContainer.d.ts

@@ -0,0 +1,7 @@
+import { FunctionComponent, ReactNode } from 'react';
+export declare type CustomerContainer = {
+    children: ReactNode;
+    isGuest?: boolean;
+};
+declare const CustomerContainer: FunctionComponent<CustomerContainer>;
+export default CustomerContainer;

package/lib/components/CustomerContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useEffect,useReducer}from"react";import customerReducer,{customerInitialState,getCustomerAddresses,getCustomerPaymentSources}from"../reducers/CustomerReducer";import OrderContext from"../context/OrderContext";import CommerceLayerContext from"../context/CommerceLayerContext";import components from"../config/components";import{saveCustomerUser}from"../reducers/CustomerReducer";import CustomerContext from"../context/CustomerContext";import{defaultCustomerContext}from"../context/CustomerContext";const propTypes=components.CustomerContainer.propTypes,displayName=components.CustomerContainer.displayName,CustomerContainer=props=>{const{children,isGuest=!1}=props,[state,dispatch]=useReducer(customerReducer,customerInitialState),{order,addResourceToInclude,include,updateOrder,includeLoaded}=useContext(OrderContext),config=useContext(CommerceLayerContext);useEffect(()=>{!include?.includes("available_customer_payment_sources.payment_source")&&!isGuest?addResourceToInclude({newResource:"available_customer_payment_sources.payment_source"}):!includeLoaded?.["available_customer_payment_sources.payment_source"]&&!isGuest&&addResourceToInclude({newResourceLoaded:{"available_customer_payment_sources.payment_source":!0}})},[include,includeLoaded]),useEffect(()=>{config.accessToken&&order&&state.addresses?.length===0&&!isGuest&&getCustomerAddresses({config,dispatch}),order?.available_customer_payment_sources&&!isGuest&&getCustomerPaymentSources({dispatch,order})},[config.accessToken,order,isGuest]);const contextValue={isGuest,...state,saveCustomerUser:async customerEmail=>{await saveCustomerUser({config,customerEmail,dispatch,updateOrder,order})},setCustomerErrors:errors=>defaultCustomerContext.setCustomerErrors(errors,dispatch),setCustomerEmail:customerEmail=>defaultCustomerContext.setCustomerEmail(customerEmail,dispatch),getCustomerPaymentSources:()=>getCustomerPaymentSources({dispatch,order})};return _jsx(CustomerContext.Provider,{value:contextValue,children})};CustomerContainer.propTypes=propTypes,CustomerContainer.displayName=displayName;export default CustomerContainer;

package/lib/components/CustomerInput.d.ts

@@ -0,0 +1,11 @@
+import { FunctionComponent } from 'react';
+import { BaseInputComponentProps } from '../typings/index';
+declare type CustomerInputProps = {
+    name?: 'customer_email' | string;
+    type?: 'email' | string;
+    saveOnBlur?: boolean;
+    onBlur?: (email: string) => void;
+    errorClassName?: string;
+} & Omit<BaseInputComponentProps, 'name' | 'type' | 'onBlur'> & JSX.IntrinsicElements['input'] & JSX.IntrinsicElements['textarea'];
+declare const CustomerInput: FunctionComponent<CustomerInputProps>;
+export default CustomerInput;

package/lib/components/CustomerInput.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useEffect,useState}from"react";import BaseInput from"./utils/BaseInput";import components from"../config/components";import{useRapidForm}from"rapid-form";import CustomerContext from"../context/CustomerContext";import isEmpty from"lodash/isEmpty";const propTypes=components.CustomerInput.propTypes,displayName=components.CustomerInput.displayName,CustomerInput=props=>{const{name="customer_email",placeholder="",required=!0,saveOnBlur=!1,type="email",value,onBlur,className,errorClassName,...p}=props,{validation,values,errors}=useRapidForm({fieldEvent:"blur"}),{saveCustomerUser,setCustomerErrors,setCustomerEmail}=useContext(CustomerContext),[hasError,setHasError]=useState(!1),handleOnBlur=async()=>{saveOnBlur&&isEmpty(errors)&&!isEmpty(values)&&(await saveCustomerUser(values[name].value),onBlur&&onBlur(values[name].value))};useEffect(()=>{if(isEmpty(errors))isEmpty(values)||(setCustomerErrors([]),setCustomerEmail(values[name].value),setHasError(!1));else{const formErrors=[];for(const fieldName in errors){const code=errors[fieldName]?.code,message=errors[fieldName]?.message;formErrors.push({code,message:message||"",resource:"orders",field:fieldName})}isEmpty(formErrors)||(setHasError(!0),setCustomerErrors(formErrors))}return()=>{setHasError(!1)}},[errors]);const classNameComputed=`${className} ${hasError?errorClassName:""}`;return _jsx(BaseInput,{name,type,ref:validation,required,placeholder,defaultValue:value,onBlur:handleOnBlur,className:classNameComputed,...p})};CustomerInput.propTypes=propTypes,CustomerInput.displayName=displayName;export default CustomerInput;

package/lib/components/DeliveryLeadTime.d.ts

@@ -0,0 +1,10 @@
+import { FunctionComponent, ReactNode } from 'react';
+export declare type DeliveryLeadTimeField = 'min_hours' | 'max_hours' | 'min_days' | 'max_days';
+export declare type DeliveryLeadTimeComponentChildren = Omit<ShippingMethodPriceProps, 'children'>;
+export interface ShippingMethodPriceProps extends Partial<JSX.IntrinsicElements['span']> {
+    children?: (props: DeliveryLeadTimeComponentChildren) => ReactNode;
+    type: DeliveryLeadTimeField;
+    text?: string;
+}
+declare const DeliveryLeadTime: FunctionComponent<ShippingMethodPriceProps>;
+export default DeliveryLeadTime;

package/lib/components/DeliveryLeadTime.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useState,useEffect}from"react";import ShippingMethodChildrenContext from"../context/ShippingMethodChildrenContext";import Parent from"./utils/Parent";import components from"../config/components";const propTypes=components.DeliveryLeadTime.propTypes,displayName=components.DeliveryLeadTime.displayName,DeliveryLeadTime=props=>{const{type,...p}=props,[text,setText]=useState(),{deliveryLeadTimeForShipment}=useContext(ShippingMethodChildrenContext);useEffect(()=>(deliveryLeadTimeForShipment&&deliveryLeadTimeForShipment[type]&&setText(deliveryLeadTimeForShipment[type]),()=>{setText("")}),[deliveryLeadTimeForShipment]);const parentProps={text,...p};return props.children?_jsx(Parent,{...parentProps,children:props.children}):_jsx("span",{...p,children:text})};DeliveryLeadTime.propTypes=propTypes,DeliveryLeadTime.displayName=displayName;export default DeliveryLeadTime;

package/lib/components/DiscountAmount.d.ts

@@ -0,0 +1,4 @@
+import { FunctionComponent } from 'react';
+import { BaseAmountComponent } from '../typings/index';
+declare const DiscountAmount: FunctionComponent<BaseAmountComponent>;
+export default DiscountAmount;

package/lib/components/DiscountAmount.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.DiscountAmount.propTypes,defaultProps=components.DiscountAmount.defaultProps,displayName=components.DiscountAmount.displayName,DiscountAmount=props=>_jsx(BaseOrderPrice,{base:"amount",type:"discount",...props});DiscountAmount.propTypes=propTypes,DiscountAmount.defaultProps=defaultProps,DiscountAmount.displayName=displayName;export default DiscountAmount;

package/lib/components/Errors.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { ErrorComponentProps } from '../typings/errors';
+export declare type ErrorsProps = ErrorComponentProps & JSX.IntrinsicElements['span'];
+declare const Errors: React.FunctionComponent<ErrorsProps>;
+export default Errors;

package/lib/components/Errors.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,Fragment,useMemo}from"react";import Parent from"./utils/Parent";import GiftCardContext from"../context/GiftCardContext";import OrderContext from"../context/OrderContext";import AddressContext from"../context/AddressContext";import getAllErrors from"./utils/getAllErrors";import LineItemContext from"../context/LineItemContext";import LineItemChildrenContext from"../context/LineItemChildrenContext";import components from"../config/components";import CustomerContext from"../context/CustomerContext";import PaymentMethodContext from"../context/PaymentMethodContext";import PaymentMethodChildrenContext from"../context/PaymentMethodChildrenContext";import ShipmentContext from"../context/ShipmentContext";const propTypes=components.Errors.propTypes,displayName=components.Errors.displayName,Errors=props=>{const{children,messages=[],resource,field,...p}=props,{payment}=useContext(PaymentMethodChildrenContext),{errors:orderErrors}=useContext(OrderContext),{errors:giftCardErrors}=useContext(GiftCardContext),{errors:lineItemErrors}=useContext(LineItemContext),{errors:addressErrors}=useContext(AddressContext),{errors:customerErrors}=useContext(CustomerContext),{errors:shipmentErrors}=useContext(ShipmentContext),{errors:paymentMethodErrors,currentPaymentMethodType,currentPaymentMethodId}=useContext(PaymentMethodContext),{lineItem}=useContext(LineItemChildrenContext),allErrors=useMemo(()=>[...giftCardErrors||[],...orderErrors||[],...lineItemErrors||[],...addressErrors||[],...customerErrors||[],...shipmentErrors||[],...paymentMethodErrors?.filter(v=>v.field===currentPaymentMethodType&&payment?.id===currentPaymentMethodId)||[]],[giftCardErrors,orderErrors,lineItemErrors,addressErrors,customerErrors,shipmentErrors,paymentMethodErrors]).filter((v,k,a)=>v?.code!==a[k-1]?.code),msgErrors=getAllErrors({allErrors,field,messages,props:p,lineItem,resource,returnHtml:!children}),parentProps={messages,resource,field,errors:msgErrors,...p};return children?_jsx(Parent,{...parentProps,children}):_jsx(Fragment,{children:msgErrors})};Errors.propTypes=propTypes,Errors.displayName=displayName;export default Errors;

package/lib/components/ExternalFunction.d.ts

@@ -0,0 +1,7 @@
+import { FunctionComponent, ReactNode } from 'react';
+declare type Props = {
+    children: ReactNode;
+    url: string;
+};
+declare const ExternalFunction: FunctionComponent<Props>;
+export default ExternalFunction;

package/lib/components/ExternalFunction.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import ExternalFunctionContext,{callExternalFunction}from"../context/ExternalFunctionContext";import components from"../config/components";const propTypes=components.ExternalFunction.propTypes,displayName=components.ExternalFunction.displayName,ExternalFunction=({children,url})=>_jsx(ExternalFunctionContext.Provider,{value:{url,callExternalFunction},children});ExternalFunction.propTypes=propTypes,ExternalFunction.displayName=displayName;export default ExternalFunction;

package/lib/components/GiftCard.d.ts

@@ -0,0 +1,8 @@
+import { FunctionComponent, ReactNode } from 'react';
+import { BaseState } from '../typings/index';
+declare type GiftCardProps = {
+    children: ReactNode;
+    onSubmit?: (values: BaseState) => void;
+} & JSX.IntrinsicElements['form'];
+declare const GiftCard: FunctionComponent<GiftCardProps>;
+export default GiftCard;

package/lib/components/GiftCard.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{Fragment,useRef,useContext}from"react";import validateFormFields from"../utils/validateFormFields";import{isEmpty}from"lodash";import GiftCardContext from"../context/GiftCardContext";import components from"../config/components";const propTypes=components.GiftCard.propTypes,defaultProps=components.GiftCard.defaultProps,displayName=components.GiftCard.displayName,GiftCard=props=>{const{children,onSubmit}=props,name="giftCardForm",ref=useRef(null),{addGiftCard,addGiftCardError}=useContext(GiftCardContext);return _jsx(Fragment,{children:_jsx("form",{name,ref,onSubmit:e=>{e.preventDefault();const currentForm=ref.current,elements=currentForm?.elements,{errors,values}=validateFormFields(elements,["currencyCode","balanceCents"],"gift_cards");isEmpty(errors)?(addGiftCard(values),currentForm?.reset(),onSubmit&&onSubmit(values)):addGiftCardError(errors)},children},name)})};GiftCard.propTypes=propTypes,GiftCard.defaultProps=defaultProps,GiftCard.displayName=displayName;export default GiftCard;

package/lib/components/GiftCardAmount.d.ts

@@ -0,0 +1,4 @@
+import { FunctionComponent } from 'react';
+import { BaseAmountComponent } from '../typings/index';
+declare const GiftCardAmount: FunctionComponent<BaseAmountComponent>;
+export default GiftCardAmount;

package/lib/components/GiftCardAmount.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.GiftCardAmount.propTypes,displayName=components.GiftCardAmount.displayName,GiftCardAmount=props=>_jsx(BaseOrderPrice,{base:"amount",type:"gift_card",...props});GiftCardAmount.propTypes=propTypes,GiftCardAmount.displayName=displayName;export default GiftCardAmount;

package/lib/components/GiftCardContainer.d.ts

@@ -0,0 +1,6 @@
+import { FunctionComponent, ReactNode } from 'react';
+export declare type GiftCardContainer = {
+    children: ReactNode;
+};
+declare const GiftCardContainer: FunctionComponent<GiftCardContainer>;
+export default GiftCardContainer;

package/lib/components/GiftCardContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useReducer,useContext}from"react";import GiftCardContext from"../context/GiftCardContext";import CommerceLayerContext from"../context/CommerceLayerContext";import giftCardReducer,{giftCardInitialState,addGiftCardRecipient,addGiftCard,addGiftCardError,addGiftCardLoading}from"../reducers/GiftCardReducer";import OrderContext from"../context/OrderContext";import components from"../config/components";const propTypes=components.GiftCardContainer.propTypes,displayName=components.GiftCardContainer.displayName,GiftCardContainer=props=>{const{children}=props,[state,dispatch]=useReducer(giftCardReducer,giftCardInitialState),config=useContext(CommerceLayerContext),{getOrder,createOrder,order}=useContext(OrderContext),giftCardValue={...state,addGiftCardRecipient:values=>addGiftCardRecipient(values,config,dispatch),addGiftCard:values=>addGiftCard({...values},{config,dispatch,getOrder,createOrder,order}),addGiftCardError:errors=>addGiftCardError(errors,dispatch),addGiftCardLoading:loading=>addGiftCardLoading(loading,dispatch)};return _jsx(GiftCardContext.Provider,{value:giftCardValue,children})};GiftCardContainer.propTypes=propTypes,GiftCardContainer.displayName=displayName;export default GiftCardContainer;