@commercelayer/react-components 4.0.0-alpha.2 → 4.0.0-alpha.3

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

@@ -2,14 +2,4 @@
 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

@@ -1 +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;
+import{jsx as _jsx}from"react/jsx-runtime";import BaseInput from"./utils/BaseInput";export function MetadataInput(props){return _jsx(BaseInput,{"data-metadata":!0,...props})}export default MetadataInput;

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

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

package/lib/esm/components/SubmitButton.js

@@ -1 +1 @@
-import{jsx as _jsx}from"react/jsx-runtime";import Parent from"./utils/Parent";import components from"../config/components";import isFunction from"lodash/isFunction";const propTypes=components.SubmitButton.propTypes,defaultProps=components.SubmitButton.defaultProps,displayName=components.SubmitButton.displayName;export function SubmitButton(props){const{children,label="Submit",...p}=props,parentProps={...p,label};return children?_jsx(Parent,{...parentProps,children}):_jsx("button",{type:"submit",...p,children:isFunction(label)?label():label})}SubmitButton.propTypes=propTypes,SubmitButton.defaultProps=defaultProps,SubmitButton.displayName=displayName;export default SubmitButton;
+import{jsx as _jsx}from"react/jsx-runtime";import Parent from"./utils/Parent";import isFunction from"lodash/isFunction";export function SubmitButton(props){const{children,label="Submit",...p}=props,parentProps={...p,label};return children?_jsx(Parent,{...parentProps,children}):_jsx("button",{type:"submit",...p,children:isFunction(label)?label():label})}export default SubmitButton;

package/lib/esm/components/addresses/Address.d.ts

@@ -1,8 +1,8 @@
-import { ReactNode } from 'react';
+/// <reference types="react" />
 import type { Address as AddressType } from '@commercelayer/sdk';
 import { AddressCardsTemplateChildren } from '../utils/AddressCardsTemplate';
 declare type Props = {
-    children: ReactNode | AddressCardsTemplateChildren;
+    children: AddressCardsTemplateChildren;
     selectedClassName?: string;
     disabledClassName?: string;
     onSelect?: (address: AddressType) => void;
@@ -10,9 +10,4 @@ declare type Props = {
     deselect?: boolean;
 } & JSX.IntrinsicElements['div'];
 export declare function Address(props: Props): JSX.Element;
-export declare namespace Address {
-    var propTypes: {
-        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
-    };
-}
 export default Address;

package/lib/esm/components/addresses/Address.js

@@ -1 +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;export function 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:()=>void 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;
+import{jsx as _jsx}from"react/jsx-runtime";import{Fragment,useContext,useState,useEffect}from"react";import AddressChildrenContext from"../../context/AddressChildrenContext";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";export function 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,components=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:()=>void 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:components})}export default Address;

package/lib/esm/components/addresses/AddressCountrySelector.d.ts

@@ -7,20 +7,4 @@ declare type Props = Omit<BaseSelectComponentProps, 'options' | 'name'> & {
     disabled?: boolean;
 } & Pick<JSX.IntrinsicElements['select'], 'className' | 'id' | 'style'>;
 export declare function AddressCountrySelector(props: Props): JSX.Element;
-export declare namespace AddressCountrySelector {
-    var propTypes: {
-        children: import("prop-types").Requireable<(...args: any[]) => any>;
-        placeholder: import("prop-types").Requireable<import("prop-types").InferProps<{
-            label: import("prop-types").Validator<string>;
-            value: import("prop-types").Validator<string | number>;
-        }>>;
-        value: import("prop-types").Requireable<string>;
-        name: import("prop-types").Validator<AddressCountrySelectName>;
-        required: import("prop-types").Requireable<boolean>;
-    };
-    var defaultProps: {
-        required: boolean;
-    };
-    var displayName: string;
-}
 export default AddressCountrySelector;

package/lib/esm/components/addresses/AddressCountrySelector.js

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

package/lib/esm/components/addresses/AddressField.d.ts

@@ -8,36 +8,30 @@ declare type Props = {
     type?: 'field';
     label?: never;
     onClick?: never;
-    children?: (props: AddressFieldChildrenProps) => ReactNode;
+    children?: (props: AddressFieldChildrenProps) => JSX.Element;
     name: AddressFieldView;
     className?: string;
 } | {
     type?: 'edit';
     label: string | ReactNode;
     onClick: (address: Address) => void;
-    children?: (props: AddressFieldChildrenProps) => ReactNode;
+    children?: (props: AddressFieldChildrenProps) => JSX.Element;
     name?: AddressFieldView;
     className?: string;
 } | {
     type?: 'delete';
     label: string;
     onClick: () => void;
-    children?: (props: AddressFieldChildrenProps) => ReactNode;
+    children?: (props: AddressFieldChildrenProps) => JSX.Element;
     name?: AddressFieldView;
     className?: string;
 } | {
     type?: 'edit' | 'field' | 'delete';
     label?: never;
     onClick?: never;
-    children: (props: AddressFieldChildrenProps) => ReactNode;
+    children: (props: AddressFieldChildrenProps) => JSX.Element;
     name?: never;
     className?: string;
 };
 export declare function AddressField(props: Props): JSX.Element;
-export declare namespace AddressField {
-    var propTypes: {
-        children: import("prop-types").Requireable<(...args: any[]) => any>;
-    };
-    var displayName: string;
-}
 export default AddressField;

package/lib/esm/components/addresses/AddressField.js

@@ -1 +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 CustomerContext from"../../context/CustomerContext";const propTypes=components.AddressField.propTypes,displayName=components.AddressField.displayName;export function AddressField(props){const{name,type="field",label,onClick,...p}=props,{address}=useContext(AddressChildrenContext),text=name&&address?address?.[name]:"",{deleteCustomerAddress}=useContext(CustomerContext),handleClick=e=>{e.stopPropagation(),e.preventDefault(),type==="delete"&&deleteCustomerAddress&&address?.reference&&deleteCustomerAddress({customerAddressId:address?.reference}),address&&onClick&&onClick(address)},parentProps={address,...props};return props.children?_jsx(Parent,{...parentProps,children:props.children}):type==="field"?_jsx("p",{...p,name,children:text}):_jsx("a",{...p,onClick:handleClick,children:typeof label=="function"?label():label})}AddressField.propTypes=propTypes,AddressField.displayName=displayName;export default AddressField;
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import AddressChildrenContext from"../../context/AddressChildrenContext";import Parent from"../utils/Parent";import CustomerContext from"../../context/CustomerContext";export function AddressField(props){const{name,type="field",label,onClick,...p}=props,{address}=useContext(AddressChildrenContext),text=name&&address?address?.[name]:"",{deleteCustomerAddress}=useContext(CustomerContext),handleClick=e=>{e.stopPropagation(),e.preventDefault(),type==="delete"&&deleteCustomerAddress&&address?.reference&&deleteCustomerAddress({customerAddressId:address?.reference}),address&&onClick&&onClick(address)},parentProps={address,...props};return props.children?_jsx(Parent,{...parentProps,children:props.children}):type==="field"?_jsx("p",{...p,name,children:text}):_jsx("a",{...p,onClick:handleClick,children:label})}export default AddressField;

package/lib/esm/components/addresses/AddressInput.d.ts

@@ -5,15 +5,4 @@ declare type Props = {
     name: Extract<AddressValuesKeys, AddressInputName>;
 } & Omit<BaseInputComponentProps, 'name'> & JSX.IntrinsicElements['input'] & JSX.IntrinsicElements['textarea'];
 export declare function AddressInput(props: Props): JSX.Element | null;
-export declare namespace AddressInput {
-    var propTypes: {
-        children: import("prop-types").Requireable<(...args: any[]) => any>;
-        name: import("prop-types").Validator<AddressInputName>;
-        type: import("prop-types").Validator<import("../../typings/index").BaseInputType>;
-        placeholder: import("prop-types").Requireable<string>;
-        disabled: import("prop-types").Requireable<boolean>;
-        required: import("prop-types").Requireable<boolean>;
-    };
-    var displayName: string;
-}
 export default AddressInput;

package/lib/esm/components/addresses/AddressInput.js

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

package/lib/esm/components/addresses/AddressStateSelector.d.ts

@@ -8,20 +8,4 @@ declare type Props = Omit<BaseSelectComponentProps, 'options' | 'name'> & {
     selectClassName?: string;
 } & Pick<JSX.IntrinsicElements['select'], 'className' | 'id' | 'style'>;
 export declare function AddressStateSelector(props: Props): JSX.Element;
-export declare namespace AddressStateSelector {
-    var propTypes: {
-        children: import("prop-types").Requireable<(...args: any[]) => any>;
-        placeholder: import("prop-types").Requireable<import("prop-types").InferProps<{
-            label: import("prop-types").Validator<string>;
-            value: import("prop-types").Validator<string | number>;
-        }>>;
-        value: import("prop-types").Requireable<string>;
-        name: import("prop-types").Validator<AddressStateSelectName>;
-        required: import("prop-types").Requireable<boolean>;
-    };
-    var defaultProps: {
-        required: boolean;
-    };
-    var displayName: string;
-}
 export default AddressStateSelector;

package/lib/esm/components/addresses/AddressStateSelector.js

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

package/lib/esm/components/addresses/AddressesContainer.d.ts

@@ -1,15 +1,8 @@
-import { ReactNode } from 'react';
+/// <reference types="react" />
 declare type Props = {
-    children: ReactNode;
+    children: JSX.Element[] | JSX.Element;
     shipToDifferentAddress?: boolean;
     isBusiness?: boolean;
 };
 export declare function AddressesContainer(props: Props): JSX.Element;
-export declare namespace AddressesContainer {
-    var propTypes: {
-        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
-        shipToDifferentAddress: import("prop-types").Requireable<boolean>;
-    };
-    var displayName: string;
-}
 export default AddressesContainer;

package/lib/esm/components/addresses/AddressesContainer.js

@@ -1 +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;export function 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;
+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";export function 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})}export default AddressesContainer;

package/lib/esm/components/addresses/BillingAddressContainer.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare type Props = {
+    children: JSX.Element[] | JSX.Element;
+};
+export declare function BillingAddressContainer(props: Props): JSX.Element;
+export default BillingAddressContainer;

package/lib/esm/components/addresses/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 OrderContext from"../../context/OrderContext";import AddressContext from"../../context/AddressContext";export function 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})}export default BillingAddressContainer;

package/lib/esm/components/addresses/BillingAddressForm.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+declare type Props = {
+    children: JSX.Element[] | JSX.Element;
+    reset?: boolean;
+    errorClassName?: string;
+} & Omit<JSX.IntrinsicElements['form'], 'onSubmit'>;
+export declare function BillingAddressForm(props: Props): JSX.Element;
+export default BillingAddressForm;

package/lib/esm/components/addresses/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 OrderContext from"../../context/OrderContext";import{getSaveBillingAddressToAddressBook}from"../../utils/localStorage";import{businessMandatoryField}from"../../utils/validateFormFields";export function 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(values&&Object.keys(values).length>0){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)?values?.state_code?formErrors.push({code,message:message||"",resource:"billing_address",field:fieldName}):delete errors[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})})}export default BillingAddressForm;

package/lib/esm/components/addresses/SaveAddressesButton.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { FunctionChildren } from '../../typings/index';
+declare type ChildrenProps = FunctionChildren<Omit<Props, 'children'>>;
+declare type Props = {
+    children?: ChildrenProps;
+    label?: string | JSX.Element;
+    onClick?: () => void;
+    addressId?: string;
+} & JSX.IntrinsicElements['button'];
+export declare function SaveAddressesButton(props: Props): JSX.Element;
+export default SaveAddressesButton;

package/lib/esm/components/addresses/SaveAddressesButton.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useState}from"react";import Parent from"../utils/Parent";import AddressContext from"../../context/AddressContext";import{shippingAddressController,countryLockController,billingAddressController}from"../../utils/addressesManager";import OrderContext from"../../context/OrderContext";import CustomerContext from"../../context/CustomerContext";import isFunction from"lodash/isFunction";export function SaveAddressesButton(props){const{children,label="Continue to delivery",resource,disabled=!1,addressId,onClick,...p}=props,{errors,billing_address,shipToDifferentAddress,shipping_address,saveAddresses,billingAddressId,shippingAddressId}=useContext(AddressContext),{order}=useContext(OrderContext),{addresses,isGuest,createCustomerAddress}=useContext(CustomerContext),[forceDisable,setForceDisable]=useState(disabled),customerEmail=(isGuest===!0||typeof isGuest>"u")&&!order?.customer_email,billingDisable=billingAddressController({billing_address,errors,billingAddressId,requiresBillingInfo:order?.requires_billing_info}),shippingDisable=shippingAddressController({billingDisable,errors,shipToDifferentAddress,shipping_address,shippingAddressId}),countryLockDisable=countryLockController({countryCodeLock:order?.shipping_country_code_lock,addresses,shipToDifferentAddress,billingAddressId,billing_address,shipping_address,shippingAddressId}),disable=disabled||customerEmail||billingDisable||shippingDisable||countryLockDisable,handleClick=()=>{if(errors&&Object.keys(errors).length===0&&!disable){if(setForceDisable(!0),order)saveAddresses();else if(createCustomerAddress&&billing_address){const address={...billing_address};addressId&&(address.id=addressId),createCustomerAddress(address)}setForceDisable(!1),onClick&&onClick()}},parentProps={...p,label,resource,handleClick,disabled:disable};return children?_jsx(Parent,{...parentProps,children}):_jsx("button",{type:"button",disabled:disable||forceDisable,onClick:handleClick,...p,children:isFunction(label)?label():label})}export default SaveAddressesButton;

package/lib/esm/components/addresses/ShippingAddressContainer.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+declare type Props = {
+    children: JSX.Element[] | JSX.Element;
+};
+export declare function ShippingAddressContainer(props: Props): JSX.Element;
+export default ShippingAddressContainer;

package/lib/esm/components/addresses/ShippingAddressContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import ShippingAddressContext from"../../context/ShippingAddressContext";import{useContext,useEffect,useReducer}from"react";import shippingAddressReducer,{setShippingAddress,shippingAddressInitialState,setShippingCustomerAddressId}from"../../reducers/ShippingAddressReducer";import CommerceLayerContext from"../../context/CommerceLayerContext";import OrderContext from"../../context/OrderContext";import AddressContext from"../../context/AddressContext";export function ShippingAddressContainer(props){const{children}=props,[state,dispatch]=useReducer(shippingAddressReducer,shippingAddressInitialState),config=useContext(CommerceLayerContext),{order}=useContext(OrderContext),{setCloneAddress}=useContext(AddressContext);useEffect(()=>(order&&config&&setShippingCustomerAddressId({dispatch,order,setCloneAddress}),()=>{dispatch({type:"cleanup",payload:{}})}),[config,order]);const contextValue={...state,setShippingAddress:async(id,options)=>{await setShippingAddress(id,{config,dispatch,order,customerAddressId:options?.customerAddressId}),setCloneAddress(id,"shipping_address")}};return _jsx(ShippingAddressContext.Provider,{value:contextValue,children})}export default ShippingAddressContainer;

package/lib/esm/components/addresses/ShippingAddressForm.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+declare type Props = {
+    children: JSX.Element[] | JSX.Element;
+    reset?: boolean;
+    errorClassName?: string;
+} & Omit<JSX.IntrinsicElements['form'], 'onSubmit'>;
+export declare function ShippingAddressForm(props: Props): JSX.Element;
+export default ShippingAddressForm;

package/lib/esm/components/addresses/ShippingAddressForm.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 ShippingAddressFormContext from"../../context/ShippingAddressFormContext";import{isEmpty}from"lodash";import OrderContext from"../../context/OrderContext";import{getSaveShippingAddressToAddressBook}from"../../utils/localStorage";import{businessMandatoryField}from"../../utils/validateFormFields";export function ShippingAddressForm(props){const{children,errorClassName,autoComplete="on",reset=!1,...p}=props,{validation,values,errors,reset:resetForm}=useRapidForm(),{setAddressErrors,setAddress,shipToDifferentAddress,isBusiness}=useContext(AddressesContext),{saveAddressToCustomerAddressBook,include,addResourceToInclude,includeLoaded}=useContext(OrderContext),ref=useRef(null);useEffect(()=>{if(include?.includes("shipping_address")?includeLoaded?.shipping_address||addResourceToInclude({newResourceLoaded:{shipping_address:!0}}):addResourceToInclude({newResource:"shipping_address"}),isEmpty(errors)){if(!isEmpty(values)&&shipToDifferentAddress){setAddressErrors([],"shipping_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("shipping_address_","")]=field.value,delete values[name]),field?.type==="checkbox"&&(delete values[name],saveAddressToCustomerAddressBook({type:"shipping_address",value:field.checked}))}setAddress({values:{...values,...isBusiness&&{business:isBusiness}},resource:"shipping_address"})}}else{const formErrors=[];for(const fieldName in errors){const code=errors[fieldName]?.code,message=errors[fieldName]?.message;["shipping_address_state_code"].includes(fieldName)?isEmpty(values.state_code)?delete errors[fieldName]:formErrors.push({code,message:message||"",resource:"shipping_address",field:fieldName}):formErrors.push({code,message:message||"",resource:"shipping_address",field:fieldName})}shipToDifferentAddress&&setAddressErrors(formErrors,"shipping_address")}const checkboxChecked=ref.current?.querySelector('[name="shipping_address_save_to_customer_book"]')?.checked||getSaveShippingAddressToAddressBook();reset&&(!isEmpty(values)||!isEmpty(errors)||checkboxChecked)&&(saveAddressToCustomerAddressBook&&saveAddressToCustomerAddressBook({type:"shipping_address",value:!1}),ref&&(ref.current?.reset(),resetForm({target:ref.current}),setAddressErrors([],"shipping_address"),setAddress({values:{},resource:"shipping_address"})))},[values,errors,shipToDifferentAddress,reset,include,includeLoaded,isBusiness]);const providerValues={values,validation,setValue:(name,value)=>{const field={[name.replace("shipping_address_","")]:value};setAddress({values:{...values,...field,...isBusiness&&{business:isBusiness}},resource:"shipping_address"})},errorClassName,errors,resetField:name=>resetForm({currentTarget:ref.current},name)};return _jsx(ShippingAddressFormContext.Provider,{value:providerValues,children:_jsx("form",{ref,autoComplete,...p,children})})}export default ShippingAddressForm;

package/lib/esm/components/auth/CommerceLayer.d.ts

@@ -1,15 +1,8 @@
-import type { ReactNode } from 'react';
+/// <reference types="react" />
 declare type Props = {
-    children: ReactNode;
+    children: JSX.Element[] | JSX.Element;
     accessToken: string;
     endpoint: string;
 };
 export declare function CommerceLayer(props: Props): JSX.Element;
-export declare namespace CommerceLayer {
-    var propTypes: {
-        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
-        accessToken: import("prop-types").Validator<string>;
-        endpoint: import("prop-types").Validator<string>;
-    };
-}
 export default CommerceLayer;

package/lib/esm/components/auth/CommerceLayer.js

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

package/lib/esm/components/customers/CustomerAddressForm.d.ts

@@ -1,13 +1,8 @@
-import { ReactNode } from 'react';
+/// <reference types="react" />
 declare type Props = {
-    children: ReactNode;
+    children: JSX.Element[] | JSX.Element;
     reset?: boolean;
     errorClassName?: string;
 } & Omit<JSX.IntrinsicElements['form'], 'onSubmit'>;
 export declare function CustomerAddressForm(props: Props): JSX.Element;
-export declare namespace CustomerAddressForm {
-    var propTypes: {
-        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
-    };
-}
 export default CustomerAddressForm;

package/lib/esm/components/customers/CustomerAddressForm.js

@@ -1 +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 CustomerAddressFormContext from"../../context/CustomerAddressFormContext";import components from"../../config/components";import OrderContext from"../../context/OrderContext";import isEmptyStates from"../../utils/isEmptyStates";const propTypes=components.CustomerAddressForm.propTypes;export function CustomerAddressForm(props){const{children,errorClassName,autoComplete="on",reset=!1,...p}=props,{validation,values,errors,reset:resetForm}=useRapidForm(),{setAddressErrors,setAddress}=useContext(AddressesContext),{order}=useContext(OrderContext),ref=useRef(null);useEffect(()=>{if(Object.keys(errors).length>0){const formErrors=[];for(const fieldName in errors){const code=errors[fieldName]?.code,message=errors[fieldName]?.message||"";fieldName==="billing_address_state_code"?values.state_code?delete errors[fieldName]:formErrors.push({code,message,resource:"billing_address",field:fieldName}):formErrors.push({code,message,resource:"billing_address",field:fieldName})}setAddressErrors(formErrors,"billing_address")}else if(Object.keys(values).length>0){setAddressErrors([],"billing_address");for(const name in values){const field=values[name];if(field?.value&&(values[name.replace("billing_address_","")]=field.value,delete values[name]),["billing_address_state_code"].includes(name)){const countryCode=values.billing_address_country_code?.value||values.country_code;!isEmptyStates(countryCode)&&!field.value&&delete values.billing_address_state_code}}setAddress({values,resource:"billing_address"})}reset&&(Object.keys(values).length>0||Object.keys(errors).length>0)&&ref&&(ref.current?.reset(),resetForm({target:ref.current}),setAddressErrors([],"billing_address"),setAddress({values:{},resource:"billing_address"}))},[errors,values,reset]);const providerValues={values,validation,setValue:(name,value)=>{const field={[name.replace("billing_address_","")]:value};setAddress({values:{...values,...field},resource:"billing_address"})},errorClassName,requiresBillingInfo:order?.requiresBillingInfo||!1,errors,resetField:name=>resetForm({currentTarget:ref.current},name)};return _jsx(CustomerAddressFormContext.Provider,{value:providerValues,children:_jsx("form",{ref,autoComplete,...p,children})})}CustomerAddressForm.propTypes=propTypes;export default CustomerAddressForm;
+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 CustomerAddressFormContext from"../../context/CustomerAddressFormContext";import OrderContext from"../../context/OrderContext";import isEmptyStates from"../../utils/isEmptyStates";export function CustomerAddressForm(props){const{children,errorClassName,autoComplete="on",reset=!1,...p}=props;console.log(useRapidForm);debugger;const{validation,values,errors,reset:resetForm}=useRapidForm(),{setAddressErrors,setAddress}=useContext(AddressesContext),{order}=useContext(OrderContext),ref=useRef(null);useEffect(()=>{if(Object.keys(errors).length>0){const formErrors=[];for(const fieldName in errors){const code=errors[fieldName]?.code,message=errors[fieldName]?.message||"";fieldName==="billing_address_state_code"?values.state_code?delete errors[fieldName]:formErrors.push({code,message,resource:"billing_address",field:fieldName}):formErrors.push({code,message,resource:"billing_address",field:fieldName})}setAddressErrors(formErrors,"billing_address")}else if(Object.keys(values).length>0){setAddressErrors([],"billing_address");for(const name in values){const field=values[name];if(field?.value&&(values[name.replace("billing_address_","")]=field.value,delete values[name]),["billing_address_state_code"].includes(name)){const countryCode=values.billing_address_country_code?.value||values.country_code;!isEmptyStates(countryCode)&&!field.value&&delete values.billing_address_state_code}}setAddress({values,resource:"billing_address"})}reset&&(Object.keys(values).length>0||Object.keys(errors).length>0)&&ref&&(ref.current?.reset(),resetForm({target:ref.current}),setAddressErrors([],"billing_address"),setAddress({values:{},resource:"billing_address"}))},[errors,values,reset]);const providerValues={values,validation,setValue:(name,value)=>{const field={[name.replace("billing_address_","")]:value};setAddress({values:{...values,...field},resource:"billing_address"})},errorClassName,requiresBillingInfo:order?.requiresBillingInfo||!1,errors,resetField:name=>resetForm({currentTarget:ref.current},name)};return _jsx(CustomerAddressFormContext.Provider,{value:providerValues,children:_jsx("form",{ref,autoComplete,...p,children})})}export default CustomerAddressForm;

package/lib/esm/components/customers/CustomerContainer.d.ts

@@ -1,6 +1,6 @@
-import { ReactNode } from 'react';
+/// <reference types="react" />
 declare type Props = {
-    children: ReactNode;
+    children: JSX.Element[] | JSX.Element;
     /**
      * Customer type
      */

package/lib/esm/components/customers/CustomerInput.d.ts

@@ -8,16 +8,4 @@ declare type Props = {
     errorClassName?: string;
 } & Omit<BaseInputComponentProps, 'name' | 'type' | 'onBlur'> & JSX.IntrinsicElements['input'] & JSX.IntrinsicElements['textarea'];
 export declare function CustomerInput(props: Props): JSX.Element;
-export declare namespace CustomerInput {
-    var propTypes: {
-        children: import("prop-types").Requireable<(...args: any[]) => any>;
-        name: import("prop-types").Requireable<string>;
-        type: import("prop-types").Requireable<string>;
-        placeholder: import("prop-types").Requireable<string>;
-        disabled: import("prop-types").Requireable<boolean>;
-        required: import("prop-types").Requireable<boolean>;
-        saveOnBlur: import("prop-types").Requireable<boolean>;
-    };
-    var displayName: string;
-}
 export default CustomerInput;

package/lib/esm/components/customers/CustomerInput.js

@@ -1 +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;export function 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)&&(saveCustomerUser&&await saveCustomerUser(values[name].value),onBlur&&onBlur(values[name].value))};useEffect(()=>{if(isEmpty(errors))isEmpty(values)||(setCustomerErrors&&setCustomerErrors([]),setCustomerEmail&&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&&setCustomerErrors(formErrors))}return()=>{setHasError(!1)}},[errors]);const classNameComputed=`${className||""} ${hasError&&errorClassName?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;
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useEffect,useState}from"react";import BaseInput from"../utils/BaseInput";import{useRapidForm}from"rapid-form";import CustomerContext from"../../context/CustomerContext";import isEmpty from"lodash/isEmpty";export function 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)&&(saveCustomerUser&&await saveCustomerUser(values[name].value),onBlur&&onBlur(values[name].value))};useEffect(()=>{if(isEmpty(errors))isEmpty(values)||(setCustomerErrors&&setCustomerErrors([]),setCustomerEmail&&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&&setCustomerErrors(formErrors))}return()=>{setHasError(!1)}},[errors]);const classNameComputed=`${className||""} ${hasError&&errorClassName?errorClassName:""}`;return _jsx(BaseInput,{name,type,ref:validation,required,placeholder,defaultValue:value,onBlur:handleOnBlur,className:classNameComputed,...p})}export default CustomerInput;

package/lib/esm/components/customers/SaveCustomerButton.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+import { FunctionChildren } from '../../typings/index';
+declare type ParentProps = {
+    handleClick: () => any;
+};
+declare type ChildrenProps = FunctionChildren<Omit<Props & ParentProps, 'children'>>;
+declare type Props = {
+    children?: ChildrenProps;
+    label?: string | JSX.Element;
+    onClick?: () => void;
+} & JSX.IntrinsicElements['button'];
+export declare function SaveCustomerButton(props: Props): JSX.Element;
+export default SaveCustomerButton;

package/lib/esm/components/customers/SaveCustomerButton.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import Parent from"../utils/Parent";import{isEmpty}from"lodash";import CustomerContext from"../../context/CustomerContext";export function SaveCustomerButton(props){const{children,label="Save",resource,disabled,onClick,...p}=props,{errors,saveCustomerUser,customerEmail}=useContext(CustomerContext),disable=disabled||!isEmpty(errors)||isEmpty(customerEmail),handleClick=async()=>{isEmpty(errors)&&!disable&&(saveCustomerUser&&await saveCustomerUser(customerEmail),onClick&&onClick())},parentProps={...p,label,resource,handleClick,disabled:disable};return children?_jsx(Parent,{...parentProps,children}):_jsx("button",{type:"button",disabled:disable,onClick:void 0,...p,children:label})}export default SaveCustomerButton;

package/lib/esm/components/gift_cards/GiftCard.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { BaseState } from '../../typings/index';
+declare type Props = {
+    children: JSX.Element[] | JSX.Element;
+    onSubmit?: (values: BaseState) => void;
+} & JSX.IntrinsicElements['form'];
+export declare function GiftCard(props: Props): JSX.Element;
+export default GiftCard;

package/lib/esm/components/gift_cards/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";export function 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)})}export default GiftCard;

package/lib/esm/components/gift_cards/GiftCardContainer.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+export declare type Props = {
+    children: JSX.Element[] | JSX.Element;
+};
+export declare function GiftCardContainer(props: Props): JSX.Element;
+export default GiftCardContainer;

package/lib/esm/components/gift_cards/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";export function 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})}export default GiftCardContainer;

package/lib/esm/components/gift_cards/GiftCardCurrencySelector.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { BaseSelectComponentProps } from '../../typings/index';
+declare type Props = Omit<BaseSelectComponentProps, 'options' | 'name'> & {
+    required?: boolean;
+} & Pick<JSX.IntrinsicElements['select'], 'className' | 'id' | 'style'>;
+export declare function GiftCardCurrencySelector(props: Props): JSX.Element;
+export default GiftCardCurrencySelector;

package/lib/esm/components/gift_cards/GiftCardCurrencySelector.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import BaseSelect from"../utils/BaseSelect";import currencyOptions from"../../config/currency";export function GiftCardCurrencySelector(props){return _jsx(BaseSelect,{options:currencyOptions,name:"currencyCode",...props})}export default GiftCardCurrencySelector;

package/lib/esm/components/gift_cards/GiftCardInput.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { BaseInputComponentProps, GiftCardInputName } from '../../typings/index';
+declare type Props = {
+    name: GiftCardInputName;
+} & Omit<BaseInputComponentProps, 'name'> & JSX.IntrinsicElements['input'] & JSX.IntrinsicElements['textarea'];
+export declare function GiftCardInput(props: Props): JSX.Element;
+export default GiftCardInput;

package/lib/esm/components/gift_cards/GiftCardInput.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import BaseInput from"../utils/BaseInput";export function GiftCardInput(props){const{placeholder="",...p}=props;return _jsx(BaseInput,{placeholder,...p})}export default GiftCardInput;

package/lib/{cjs/components → esm/components/gift_cards}/GiftCardOrCouponCode.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="react" />
-import { FunctionChildren } from '../typings/index';
-import type { CodeType } from '../reducers/OrderReducer';
+import { FunctionChildren } from '../../typings/index';
+import type { CodeType } from '../../reducers/OrderReducer';
 declare type ChildrenProps = Omit<Props, 'children'> & {
     code?: string;
     hide?: boolean;
@@ -14,11 +14,4 @@ declare type Props = {
     children?: GiftCardOrCouponCodeChildrenProps;
 } & JSX.IntrinsicElements['span'];
 export declare function GiftCardOrCouponCode({ children, type, ...props }: Props): JSX.Element | null;
-export declare namespace GiftCardOrCouponCode {
-    var propTypes: {
-        children: import("prop-types").Requireable<(...args: any[]) => any>;
-        type: import("prop-types").Requireable<CodeType>;
-    };
-    var displayName: string;
-}
 export default GiftCardOrCouponCode;

package/lib/esm/components/gift_cards/GiftCardOrCouponCode.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 has from"lodash/has";import isEmpty from"lodash/isEmpty";export function GiftCardOrCouponCode({children,type,...props}){const{order}=useContext(OrderContext);let codeType=type&&`${type}_code`;!type&&order&&has(order,"coupon_code")&&!isEmpty(order.coupon_code)?codeType="coupon_code":type||(codeType="gift_card_code");const code=order&&codeType?order[codeType]:"",hide=!(order&&code),parentProps={...props,code,hide,discountAmountCents:order?.discount_amount_cents,discountAmountFloat:order?.discount_amount_float,formattedDiscountAmount:order?.formatted_discount_amount};return children?_jsx(Parent,{...parentProps,children}):hide?null:_jsx("span",{...props,children:code})}export default GiftCardOrCouponCode;

package/lib/esm/components/gift_cards/GiftCardOrCouponForm.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+declare type Props = {
+    children: JSX.Element[] | JSX.Element;
+    onSubmit?: (response: {
+        success: boolean;
+        value: string;
+    }) => void;
+} & Omit<JSX.IntrinsicElements['form'], 'onSubmit'>;
+export declare function GiftCardOrCouponForm(props: Props): JSX.Element | null;
+export default GiftCardOrCouponForm;

package/lib/esm/components/gift_cards/GiftCardOrCouponForm.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useRapidForm}from"rapid-form";import{useContext,useEffect,useRef,useState}from"react";import CouponAndGiftCardFormContext from"../../context/CouponAndGiftCardFormContext";import OrderContext from"../../context/OrderContext";import isEmpty from"lodash/isEmpty";import camelCase from"lodash/camelCase";import dropWhile from"lodash/dropWhile";import has from"lodash/has";import{findIndex}from"lodash";export function GiftCardOrCouponForm(props){const{children,autoComplete="on",onSubmit,...p}=props,{validation,values,reset}=useRapidForm(),[codeType,setCodeType]=useState("gift_card_or_coupon_code"),{setGiftCardOrCouponCode,order,errors,setOrderErrors}=useContext(OrderContext),ref=useRef(null),inputName="gift_card_or_coupon_code";useEffect(()=>{if(values[inputName]?.value===""&&findIndex(errors,{field:camelCase(inputName)})!==-1){const err=dropWhile(errors,i=>i.field===camelCase(inputName));setOrderErrors(err),onSubmit&&onSubmit({value:values[inputName]?.value,success:!1})}values[inputName]?.value===""&&(setOrderErrors([]),onSubmit&&onSubmit({value:values[inputName]?.value,success:!1}))},[values]),useEffect(()=>{order?.gift_card_code&&!order?.coupon_code&&setCodeType("coupon_code"),!order?.gift_card_code&&order?.coupon_code&&setCodeType("gift_card_code"),!order?.gift_card_code&&!order?.coupon_code&&setCodeType("gift_card_or_coupon_code")},[order]);const handleSubmit=async e=>{e.preventDefault();const code=has(values,inputName)?values[inputName].value:void 0;if(code){const{success}=await setGiftCardOrCouponCode({code,codeType}),value=values[inputName]?.value;onSubmit&&onSubmit({success,value}),success&&reset(e)}};return order?.gift_card_code&&order?.coupon_code||isEmpty(order)?null:_jsx(CouponAndGiftCardFormContext.Provider,{value:{validation,codeType},children:_jsx("form",{ref,autoComplete,onSubmit:handleSubmit,...p,children})})}export default GiftCardOrCouponForm;