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

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

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { BaseInputComponentProps, AddressInputName } from '../../typings/index';
+import { AddressValuesKeys } from '../../context/BillingAddressFormContext';
+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

@@ -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";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;

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

@@ -0,0 +1,27 @@
+/// <reference types="react" />
+import { AddressStateSelectName, BaseSelectComponentProps } from '../../typings/index';
+declare type Props = Omit<BaseSelectComponentProps, 'options' | 'name'> & {
+    name: AddressStateSelectName;
+    required?: boolean;
+    disabled?: boolean;
+    inputClassName?: string;
+    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

@@ -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";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;

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

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+declare type Props = {
+    children: ReactNode;
+    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

@@ -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;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;

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

@@ -0,0 +1,15 @@
+import type { ReactNode } from 'react';
+declare type Props = {
+    children: ReactNode;
+    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

@@ -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;export function CommerceLayer(props){const{children,...p}=props;return _jsx(CommerceLayerContext.Provider,{value:{...p},children})}CommerceLayer.propTypes=propTypes;export default CommerceLayer;

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

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+declare type Props = {
+    children: ReactNode;
+    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

@@ -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 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;

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

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+declare type Props = {
+    children: ReactNode;
+    /**
+     * Customer type
+     */
+    isGuest?: boolean;
+};
+export declare function CustomerContainer(props: Props): JSX.Element;
+export default CustomerContainer;

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

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useEffect,useReducer}from"react";import customerReducer,{customerInitialState,getCustomerAddresses,getCustomerOrders,getCustomerPaymentSources,setCustomerEmail,setCustomerErrors,deleteCustomerAddress,createCustomerAddress}from"../../reducers/CustomerReducer";import OrderContext from"../../context/OrderContext";import CommerceLayerContext from"../../context/CommerceLayerContext";import{saveCustomerUser}from"../../reducers/CustomerReducer";import CustomerContext from"../../context/CustomerContext";export function 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&&state.addresses?.length===0&&!isGuest&&getCustomerAddresses({config,dispatch}),order?.available_customer_payment_sources&&!isGuest&&getCustomerPaymentSources({dispatch,order}),config.accessToken&&!order&&!include&&!includeLoaded&&getCustomerOrders({config,dispatch})},[config.accessToken,order,isGuest]);const contextValue={isGuest,...state,saveCustomerUser:async customerEmail=>{await saveCustomerUser({config,customerEmail,dispatch,updateOrder,order})},setCustomerErrors:errors=>setCustomerErrors(errors,dispatch),setCustomerEmail:customerEmail=>setCustomerEmail(customerEmail,dispatch),getCustomerPaymentSources:()=>getCustomerPaymentSources({dispatch,order}),deleteCustomerAddress:({customerAddressId})=>deleteCustomerAddress({customerAddressId,dispatch,config,addresses:state.addresses}),createCustomerAddress:address=>createCustomerAddress({address,config,dispatch,state})};return _jsx(CustomerContext.Provider,{value:contextValue,children})}export default CustomerContainer;

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { ConditionalElement } from '../../typings/index';
+import { TGenericChildrenProps, TResources } from '../utils/GenericFieldComponent';
+declare type StockTransferFieldChildrenProps = TGenericChildrenProps<TResources['Customer']>;
+declare type TCondition = ConditionalElement<Exclude<TResources['Customer'], 'resource'>>;
+declare type Props = {
+    children?: (props: StockTransferFieldChildrenProps) => JSX.Element;
+} & TCondition;
+export declare function CustomerField<P extends Props>(props: P): JSX.Element;
+export default CustomerField;

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

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import GenericFieldComponent from"../utils/GenericFieldComponent";import CustomerContext from"../../context/CustomerContext";export function CustomerField(props){const{attribute,tagElement,children,...p}=props;return _jsx(GenericFieldComponent,{resource:"customers",attribute,tagElement,context:CustomerContext,...p,children})}export default CustomerField;

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

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { BaseInputComponentProps } from '../../typings/index';
+declare type Props = {
+    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'];
+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

@@ -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;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;

package/lib/esm/components/gateways/AdyenGateway.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { GatewayBaseType } from '../PaymentGateway';
+declare type AdyenGateway = GatewayBaseType;
+export declare function AdyenGateway(props: AdyenGateway): JSX.Element | null;
+export default AdyenGateway;

package/lib/esm/components/gateways/AdyenGateway.js

@@ -0,0 +1 @@
+import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import CommerceLayerContext from"../../context/CommerceLayerContext";import CustomerContext from"../../context/CustomerContext";import OrderContext from"../../context/OrderContext";import PaymentMethodChildrenContext from"../../context/PaymentMethodChildrenContext";import PaymentMethodContext from"../../context/PaymentMethodContext";import PaymentSourceContext from"../../context/PaymentSourceContext";import{getPaymentConfig}from"../../reducers/PaymentMethodReducer";import isEmpty from"lodash/isEmpty";import{Fragment,useContext}from"react";import AdyenPayment from"../AdyenPayment";import PaymentCardsTemplate from"../utils/PaymentCardsTemplate";import jwt from"../../utils/jwt";import getCardDetails from"../../utils/getCardDetails";export function AdyenGateway(props){const{readonly,showCard,handleEditClick,children,templateCustomerCards,loading,loaderComponent,templateCustomerSaveToWallet,...p}=props,{order}=useContext(OrderContext),{accessToken}=useContext(CommerceLayerContext),{payment}=useContext(PaymentMethodChildrenContext),{payments,isGuest}=useContext(CustomerContext),{currentPaymentMethodId,config,paymentSource}=useContext(PaymentMethodContext),paymentResource="adyen_payments",locale=order?.language_code,paymentMethods=paymentSource?.payment_methods;if(!readonly&&payment?.id!==currentPaymentMethodId)return null;const clientKey=paymentSource?.public_key,environment=jwt(accessToken).test?"test":"live",adyenConfig=config?getPaymentConfig(paymentResource,config):{},customerPayments=!isEmpty(payments)&&payments?payments.filter(customerPayment=>customerPayment.payment_source?.type==="adyen_payments"):[];if(readonly||showCard){const card=getCardDetails({customerPayment:{payment_source:paymentSource},paymentType:paymentResource}),value={...card,showCard,handleEditClick,readonly};return isEmpty(card)?null:_jsx(PaymentSourceContext.Provider,{value,children})}return!isGuest&&templateCustomerCards?clientKey&&!loading&&paymentMethods?_jsxs(Fragment,{children:[isEmpty(customerPayments)?null:_jsx("div",{className:p.className,children:_jsx(PaymentCardsTemplate,{paymentResource,customerPayments,children:templateCustomerCards})}),_jsx(AdyenPayment,{templateCustomerSaveToWallet,clientKey,locale,environment,config:adyenConfig})]}):loaderComponent:clientKey&&!loading&&paymentMethods?_jsx(AdyenPayment,{clientKey,locale,config:adyenConfig}):loaderComponent}export default AdyenGateway;

package/lib/esm/components/gateways/BraintreeGateway.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { GatewayBaseType } from '../PaymentGateway';
+declare type BraintreeGateway = GatewayBaseType;
+export declare function BraintreeGateway(props: BraintreeGateway): JSX.Element | null;
+export default BraintreeGateway;

package/lib/esm/components/gateways/BraintreeGateway.js

@@ -0,0 +1 @@
+import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import BraintreePayment from"../BraintreePayment";import CustomerContext from"../../context/CustomerContext";import OrderContext from"../../context/OrderContext";import PaymentMethodChildrenContext from"../../context/PaymentMethodChildrenContext";import PaymentMethodContext from"../../context/PaymentMethodContext";import PaymentSourceContext from"../../context/PaymentSourceContext";import{getPaymentConfig}from"../../reducers/PaymentMethodReducer";import getCardDetails from"../../utils/getCardDetails";import isEmpty from"lodash/isEmpty";import{Fragment,useContext}from"react";import PaymentCardsTemplate from"../utils/PaymentCardsTemplate";export function BraintreeGateway(props){const{readonly,showCard,handleEditClick,children,templateCustomerCards,loading,loaderComponent,templateCustomerSaveToWallet,...p}=props,{order}=useContext(OrderContext),{payment}=useContext(PaymentMethodChildrenContext),{payments,isGuest}=useContext(CustomerContext),{currentPaymentMethodId,config,paymentSource}=useContext(PaymentMethodContext),paymentResource="braintree_payments",locale=order?.language_code;if(!readonly&&payment?.id!==currentPaymentMethodId)return null;const authorization=paymentSource?.client_token,braintreeConfig=config?getPaymentConfig(paymentResource,config):{},customerPayments=!isEmpty(payments)&&payments?payments.filter(customerPayment=>customerPayment.payment_source?.type==="braintree_payments"):[];if(readonly||showCard){const card=getCardDetails({customerPayment:{payment_source:paymentSource},paymentType:paymentResource}),value={...card,showCard,handleEditClick,readonly};return isEmpty(card)?null:_jsx(PaymentSourceContext.Provider,{value,children})}return!isGuest&&templateCustomerCards?authorization&&!loading?_jsxs(Fragment,{children:[isEmpty(customerPayments)?null:_jsx("div",{className:p.className,children:_jsx(PaymentCardsTemplate,{paymentResource,customerPayments,children:templateCustomerCards})}),_jsx(BraintreePayment,{templateCustomerSaveToWallet,authorization,locale,config:braintreeConfig})]}):loaderComponent:authorization&&!loading?_jsx(BraintreePayment,{locale,authorization,config:braintreeConfig}):loaderComponent}export default BraintreeGateway;

package/lib/esm/components/gateways/CheckoutComGateway.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { GatewayBaseType } from '../PaymentGateway';
+declare type CheckoutComGateway = GatewayBaseType;
+export declare function CheckoutComGateway(props: CheckoutComGateway): JSX.Element | null;
+export default CheckoutComGateway;

package/lib/esm/components/gateways/CheckoutComGateway.js

@@ -0,0 +1 @@
+import{jsx as _jsx,Fragment as _Fragment,jsxs as _jsxs}from"react/jsx-runtime";import CheckoutComPayment from"../CheckoutComPayment";import CustomerContext from"../../context/CustomerContext";import OrderContext from"../../context/OrderContext";import PaymentMethodChildrenContext from"../../context/PaymentMethodChildrenContext";import PaymentMethodContext from"../../context/PaymentMethodContext";import PaymentSourceContext from"../../context/PaymentSourceContext";import{getPaymentConfig}from"../../reducers/PaymentMethodReducer";import isEmpty from"lodash/isEmpty";import React from"react";import PaymentCardsTemplate from"../utils/PaymentCardsTemplate";import getCardDetails from"../../utils/getCardDetails";export function CheckoutComGateway(props){const{readonly,showCard,handleEditClick,children,templateCustomerCards,show,loading,loaderComponent,templateCustomerSaveToWallet,...p}=props,{order}=React.useContext(OrderContext),{payment}=React.useContext(PaymentMethodChildrenContext),{payments,isGuest}=React.useContext(CustomerContext),{currentPaymentMethodId,config,paymentSource}=React.useContext(PaymentMethodContext),paymentResource="checkout_com_payments",locale=order?.language_code;if(!readonly&&payment?.id!==currentPaymentMethodId)return null;const publicKey=paymentSource?.public_key,paymentConfig=config?getPaymentConfig(paymentResource,config):{},customerPayments=!isEmpty(payments)&&payments?payments.filter(customerPayment=>customerPayment.payment_source?.type===paymentResource):[];if(readonly||showCard){const card=getCardDetails({customerPayment:{payment_source:paymentSource},paymentType:paymentResource}),value={...card,showCard,handleEditClick,readonly};return card.brand?_jsx(PaymentSourceContext.Provider,{value,children}):null}return!isGuest&&templateCustomerCards?publicKey&&!loading?_jsxs(_Fragment,{children:[isEmpty(customerPayments)?null:_jsx("div",{className:p.className,children:_jsx(PaymentCardsTemplate,{paymentResource,customerPayments,children:templateCustomerCards})}),_jsx(CheckoutComPayment,{show,templateCustomerSaveToWallet,publicKey,locale,...paymentConfig})]}):loaderComponent:publicKey&&!loading?_jsx(CheckoutComPayment,{show,publicKey,locale,...paymentConfig}):loaderComponent}export default CheckoutComGateway;

package/lib/esm/components/gateways/KlarnaGateway.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { GatewayBaseType } from '../PaymentGateway';
+declare type KlarnaGateway = GatewayBaseType;
+export declare function KlarnaGateway(props: KlarnaGateway): JSX.Element | null;
+export default KlarnaGateway;

package/lib/esm/components/gateways/KlarnaGateway.js

@@ -0,0 +1 @@
+import{jsx as _jsx,Fragment as _Fragment,jsxs as _jsxs}from"react/jsx-runtime";import React from"react";import KlarnaPayment from"../KlarnaPayment";import CustomerContext from"../../context/CustomerContext";import OrderContext from"../../context/OrderContext";import PaymentMethodChildrenContext from"../../context/PaymentMethodChildrenContext";import PaymentMethodContext from"../../context/PaymentMethodContext";import PaymentSourceContext from"../../context/PaymentSourceContext";import{getPaymentConfig}from"../../reducers/PaymentMethodReducer";import isEmpty from"lodash/isEmpty";import PaymentCardsTemplate from"../utils/PaymentCardsTemplate";export function KlarnaGateway(props){const{readonly,showCard,handleEditClick,children,templateCustomerCards,loading,loaderComponent,...p}=props,{order}=React.useContext(OrderContext),{payment}=React.useContext(PaymentMethodChildrenContext),{payments,isGuest}=React.useContext(CustomerContext),{currentPaymentMethodId,config,paymentSource}=React.useContext(PaymentMethodContext),paymentResource="klarna_payments",locale=order?.language_code;if(!readonly&&payment?.id!==currentPaymentMethodId)return null;const clientToken=paymentSource?.client_token,klarnaConfig=config?getPaymentConfig(paymentResource,config):{},customerPayments=!isEmpty(payments)&&payments?payments.filter(customerPayment=>customerPayment.payment_source?.type===paymentResource):[];if(readonly||showCard){const card=paymentSource?.options?.card,value={...card,showCard,handleEditClick,readonly};return isEmpty(card)?null:_jsx(PaymentSourceContext.Provider,{value,children})}return!isGuest&&templateCustomerCards?_jsxs(_Fragment,{children:[isEmpty(customerPayments)?null:_jsx("div",{className:p.className,children:_jsx(PaymentCardsTemplate,{paymentResource,customerPayments,children:templateCustomerCards})}),_jsx(KlarnaPayment,{clientToken,locale,...klarnaConfig})]}):clientToken&&!loading?_jsx(KlarnaPayment,{clientToken,locale,...klarnaConfig}):loaderComponent}export default KlarnaGateway;

package/lib/esm/components/gateways/PaypalGateway.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { GatewayBaseType } from '../PaymentGateway';
+declare type PaypalGateway = Partial<GatewayBaseType>;
+export declare function PaypalGateway(props: PaypalGateway): JSX.Element | null;
+export default PaypalGateway;

package/lib/esm/components/gateways/PaypalGateway.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import PaypalPayment from"../PaypalPayment";import OrderContext from"../../context/OrderContext";import PaymentMethodChildrenContext from"../../context/PaymentMethodChildrenContext";import PaymentMethodContext from"../../context/PaymentMethodContext";import PaymentSourceContext from"../../context/PaymentSourceContext";import{getPaymentConfig}from"../../reducers/PaymentMethodReducer";import getCardDetails from"../../utils/getCardDetails";import isEmpty from"lodash/isEmpty";import{useContext}from"react";export function PaypalGateway(props){const{readonly,showCard,handleEditClick,children,...p}=props,{order}=useContext(OrderContext),{payment}=useContext(PaymentMethodChildrenContext),{currentPaymentMethodId,config,paymentSource}=useContext(PaymentMethodContext),paymentResource="paypal_payments";if(!readonly&&payment?.id!==currentPaymentMethodId)return null;if(readonly||showCard){const card=getCardDetails({customerPayment:{payment_source:order?.payment_source||paymentSource},paymentType:paymentResource}),value={...card,showCard,handleEditClick,readonly};return isEmpty(card)?null:_jsx(PaymentSourceContext.Provider,{value,children})}const paypalConfig=config&&getPaymentConfig(paymentResource,config);return delete p.show,delete p.templateCustomerCards,delete p.templateCustomerSaveToWallet,delete p.loading,delete p.loaderComponent,delete p.onClickCustomerCards,_jsx(PaypalPayment,{...p,infoMessage:paypalConfig?.infoMessage})}export default PaypalGateway;

package/lib/esm/components/gateways/StripeGateway.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { GatewayBaseType } from '../PaymentGateway';
+declare type StripeGateway = GatewayBaseType;
+export declare function StripeGateway(props: StripeGateway): JSX.Element | null;
+export default StripeGateway;

package/lib/esm/components/gateways/StripeGateway.js

@@ -0,0 +1 @@
+import{jsx as _jsx,Fragment as _Fragment,jsxs as _jsxs}from"react/jsx-runtime";import StripePayment from"../StripePayment";import CustomerContext from"../../context/CustomerContext";import OrderContext from"../../context/OrderContext";import PaymentMethodChildrenContext from"../../context/PaymentMethodChildrenContext";import PaymentMethodContext from"../../context/PaymentMethodContext";import PaymentSourceContext from"../../context/PaymentSourceContext";import{getPaymentConfig}from"../../reducers/PaymentMethodReducer";import getCardDetails from"../../utils/getCardDetails";import isEmpty from"lodash/isEmpty";import React from"react";import PaymentCardsTemplate from"../utils/PaymentCardsTemplate";export function StripeGateway(props){const{readonly,showCard,handleEditClick,children,templateCustomerCards,show,loading,loaderComponent,templateCustomerSaveToWallet,...p}=props,{order}=React.useContext(OrderContext),{payment}=React.useContext(PaymentMethodChildrenContext),{payments,isGuest}=React.useContext(CustomerContext),{currentPaymentMethodId,config,paymentSource}=React.useContext(PaymentMethodContext),paymentResource="stripe_payments",locale=order?.language_code;if(!readonly&&payment?.id!==currentPaymentMethodId)return null;const publishableKey=paymentSource?.publishable_key,paymentSourceId=order?.payment_source?.id||paymentSource?.id,stripeConfig=config?getPaymentConfig(paymentResource,config):{},customerPayments=!isEmpty(payments)&&payments?payments.filter(customerPayment=>customerPayment.payment_source?.type===paymentResource):[];if(readonly||showCard){const card=getCardDetails({customerPayment:{payment_source:paymentSource},paymentType:paymentResource}),value={...card,showCard,handleEditClick,readonly};return isEmpty(card)?null:_jsx(PaymentSourceContext.Provider,{value,children})}return!isGuest&&templateCustomerCards?_jsxs(_Fragment,{children:[isEmpty(customerPayments)?null:_jsx("div",{className:p.className,children:_jsx(PaymentCardsTemplate,{paymentResource,customerPayments,children:templateCustomerCards})}),_jsx(StripePayment,{show,templateCustomerSaveToWallet,publishableKey,locale,...stripeConfig})]}):publishableKey&&!loading&&paymentSourceId?_jsx(StripePayment,{show,publishableKey,locale,...stripeConfig}):loaderComponent}export default StripeGateway;

package/lib/esm/components/gateways/WireTransferGateway.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+import { GatewayBaseType } from '../PaymentGateway';
+declare type WireTransferGateway = GatewayBaseType;
+export declare function WireTransferGateway(props: WireTransferGateway): JSX.Element | null;
+export default WireTransferGateway;

package/lib/esm/components/gateways/WireTransferGateway.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import WireTransferPayment from"../WireTransferPayment";import PaymentMethodChildrenContext from"../../context/PaymentMethodChildrenContext";import PaymentMethodContext from"../../context/PaymentMethodContext";import PaymentSourceContext from"../../context/PaymentSourceContext";import{getPaymentConfig}from"../../reducers/PaymentMethodReducer";import isEmpty from"lodash/isEmpty";import{useContext}from"react";export function WireTransferGateway(props){const{readonly,showCard,handleEditClick,children,...p}=props,{payment}=useContext(PaymentMethodChildrenContext),{currentPaymentMethodId,config,paymentSource}=useContext(PaymentMethodContext),paymentResource="wire_transfers";if(!readonly&&payment?.id!==currentPaymentMethodId)return null;if(readonly||showCard){const card=paymentSource?.options?.card||paymentSource?.metadata?.card,value={...card,showCard,handleEditClick,readonly};return isEmpty(card)?null:_jsx(PaymentSourceContext.Provider,{value,children})}const wireTransferConfig=config&&paymentResource?getPaymentConfig(paymentResource,config):{};return _jsx(WireTransferPayment,{...p,...wireTransferConfig})}export default WireTransferGateway;

package/lib/esm/components/orders/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 declare function AddToCartButton(props: Props): JSX.Element;
+export default AddToCartButton;

package/lib/esm/components/orders/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 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?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})}export default AddToCartButton;

package/lib/esm/components/orders/AdjustmentAmount.d.ts

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

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

package/lib/esm/components/orders/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 declare function CartLink(props: Props): JSX.Element | null;
+export default CartLink;

package/lib/esm/components/orders/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 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}export default CartLink;

package/lib/esm/components/orders/GiftCardAmount.d.ts

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

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

package/lib/esm/components/orders/OrderContainer.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { BaseMetadataObject } from '../../typings/index';
+import type { OrderCreate, Order } from '@commercelayer/sdk';
+declare type Props = {
+    children: ReactNode;
+    metadata?: BaseMetadataObject;
+    attributes?: OrderCreate;
+    orderId?: string;
+    fetchOrder?: (order: Order) => void;
+};
+export declare function OrderContainer(props: Props): JSX.Element;
+export declare namespace OrderContainer {
+    var propTypes: {
+        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
+        orderId: import("prop-types").Requireable<string>;
+        metadata: import("prop-types").Requireable<{
+            [x: string]: string | null | undefined;
+        }>;
+        attributes: import("prop-types").Requireable<object>;
+    };
+    var defaultProps: {
+        metadata: {};
+    };
+    var displayName: string;
+}
+export default OrderContainer;

package/lib/esm/components/orders/OrderContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useEffect,useReducer,useContext,useMemo,useState}from"react";import orderReducer,{createOrder,getApiOrder,setOrderErrors,setOrder,orderInitialState,updateOrder}from"../../reducers/OrderReducer";import CommerceLayerContext from"../../context/CommerceLayerContext";import OrderContext,{defaultOrderContext}from"../../context/OrderContext";import components from"../../config/components";import OrderStorageContext from"../../context/OrderStorageContext";import compareObjAttribute from"../../utils/compareObjAttribute";const propTypes=components.OrderContainer.propTypes,defaultProps=components.OrderContainer.defaultProps,displayName=components.OrderContainer.displayName;export function OrderContainer(props){const{orderId,children,metadata,attributes,fetchOrder}=props,[state,dispatch]=useReducer(orderReducer,orderInitialState),[lock,setLock]=useState(!1),[lockOrder,setLockOrder]=useState(!0),config=useContext(CommerceLayerContext),{persistKey,clearWhenPlaced,getLocalOrder,setLocalOrder,deleteLocalOrder}=useContext(OrderStorageContext);useEffect(()=>{state.withoutIncludes||dispatch({type:"setLoading",payload:{loading:!0}})},[state.withoutIncludes]),useEffect(()=>{if(attributes&&state?.order&&!lock){const updateAttributes=compareObjAttribute({attributes,object:state.order});Object.keys(updateAttributes).length>0&&(updateOrder({id:state.order.id,attributes:updateAttributes,dispatch,config,include:state.include,state}),setLock(!0))}return()=>{if(attributes&&state?.order){const updateAttributes=compareObjAttribute({attributes,object:state.order});state.order&&Object.keys(updateAttributes).length===0&&setLock(!1)}}},[attributes,state?.order,lock]),useEffect(()=>{const localOrder=persistKey?getLocalOrder(persistKey):orderId,startRequest=Object.keys(state?.includeLoaded||{}).filter(key=>state?.includeLoaded?.[key]===!0),getOrder=async()=>{localOrder&&await getApiOrder({id:localOrder,dispatch,config,persistKey,clearWhenPlaced:!!(persistKey&&clearWhenPlaced),deleteLocalOrder,state})};return config.accessToken&&!state.loading?localOrder&&!state.order&&state.include?.length===startRequest.length&&!state.withoutIncludes&&!lockOrder?getOrder():state?.order?fetchOrder&&fetchOrder(state.order):state.withoutIncludes&&!state.include?.length&&startRequest.length===0&&getOrder():[config.accessToken,!state.order,state.loading,state.withoutIncludes].every(Boolean)?dispatch({type:"setLoading",payload:{loading:!1}}):[config.accessToken,!state.order,state.loading,!state.withoutIncludes].every(Boolean)&&dispatch({type:"setLoading",payload:{loading:!1}}),()=>{!state.order&&state.loading&&!state.withoutIncludes&&(state.include?.length===0&&startRequest.length>0?dispatch({type:"setLoading",payload:{loading:!1}}):state.include&&state.include?.length>0&&(dispatch({type:"setIncludesResource",payload:{include:[]}}),setLockOrder(!1)))}},[config.accessToken,state.includeLoaded,state.include,orderId,state.order,state.loading,state.withoutIncludes,lockOrder]);const orderValue=useMemo(()=>({...state,setOrder:order=>setOrder(order,dispatch),getOrder:id=>getApiOrder({id,dispatch,config,state}),setOrderErrors:errors=>setOrderErrors({dispatch,errors}),createOrder:()=>createOrder({persistKey,dispatch,config,state,orderMetadata:metadata,orderAttributes:attributes,setLocalOrder}),addToCart:values=>defaultOrderContext.addToCart({...values,persistKey,dispatch,state,config,errors:state.errors,orderMetadata:metadata||{},orderAttributes:attributes,setLocalOrder}),saveAddressToCustomerAddressBook:args=>defaultOrderContext.saveAddressToCustomerAddressBook({...args,dispatch}),setGiftCardOrCouponCode:({code,codeType})=>defaultOrderContext.setGiftCardOrCouponCode({code,codeType,dispatch,order:state.order,config,include:state.include,state}),removeGiftCardOrCouponCode:({codeType})=>defaultOrderContext.removeGiftCardOrCouponCode({codeType,dispatch,order:state.order,config,include:state.include,state}),addResourceToInclude:args=>defaultOrderContext.addResourceToInclude({...args,dispatch,resourcesIncluded:state.include,resourceIncludedLoaded:state.includeLoaded}),updateOrder:async args=>await defaultOrderContext.updateOrder({...args,dispatch,config,include:state.include,state})}),[state,config.accessToken]);return _jsx(OrderContext.Provider,{value:orderValue,children})}OrderContainer.propTypes=propTypes,OrderContainer.defaultProps=defaultProps,OrderContainer.displayName=displayName;export default OrderContainer;

package/lib/esm/components/orders/OrderList.d.ts

@@ -0,0 +1,61 @@
+import { ReactNode, ReactElement } from 'react';
+import { InitialOrderListContext } from '../../context/OrderListChildrenContext';
+import { Column } from 'react-table';
+declare type Props = {
+    children: ReactNode;
+    /**
+     * Columns to show
+     */
+    columns: (Column & {
+        className?: string;
+    })[];
+    /**
+     * Custom loader component
+     */
+    loadingElement?: ReactElement;
+    /**
+     * Function to assign as custom row renderer
+     */
+    actionsComponent?: InitialOrderListContext['actionsComponent'];
+    /**
+     * Class name to assign to the custom row container
+     */
+    actionsContainerClassName?: string;
+    /**
+     * Show actions column
+     */
+    showActions?: boolean;
+    /**
+     * Class name to assign to the table header
+     */
+    theadClassName?: string;
+    /**
+     * Class name to assign to the table row
+     */
+    rowTrClassName?: string;
+} & JSX.IntrinsicElements['table'] & ({
+    /**
+     * Activate infinity scroll
+     */
+    infiniteScroll: true;
+    /**
+     * The window options to use for the infinite scroll
+     */
+    windowOptions?: {
+        height?: number;
+        itemSize?: number;
+        width?: number;
+        column?: number;
+    };
+} | {
+    infiniteScroll?: false;
+    windowOptions?: never;
+});
+export declare function OrderList({ children, columns, loadingElement, showActions, actionsComponent, actionsContainerClassName, infiniteScroll, windowOptions, theadClassName, rowTrClassName, ...p }: Props): JSX.Element;
+export declare namespace OrderList {
+    var propTypes: {
+        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
+    };
+    var displayName: string;
+}
+export default OrderList;

package/lib/esm/components/orders/OrderList.js

@@ -0,0 +1 @@
+import{createElement as _createElement}from"react";import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{useContext,useMemo,useState,useEffect,useCallback}from"react";import components from"../../config/components";import CustomerContext from"../../context/CustomerContext";import OrderListChildrenContext from"../../context/OrderListChildrenContext";import{useTable,useSortBy,useBlockLayout}from"react-table";import{FixedSizeList}from"react-window";import scrollbarWidth from"../../utils/scrollbarWidth";import{sortDescIcon,sortAscIcon}from"../../utils/icons";const propTypes=components.OrderList.propTypes,displayName=components.OrderList.displayName;export function OrderList({children,columns,loadingElement,showActions=!1,actionsComponent,actionsContainerClassName,infiniteScroll,windowOptions,theadClassName,rowTrClassName,...p}){const[loading,setLoading]=useState(!0),{orders}=useContext(CustomerContext),data=useMemo(()=>orders,[orders]),cols=useMemo(()=>columns,[columns]),tablePlugins=[useSortBy];infiniteScroll&&tablePlugins.push(useBlockLayout);const defaultColumn=useMemo(()=>({width:windowOptions?.column||150}),[windowOptions?.column]),table=useTable({data,columns:cols,...infiniteScroll&&{defaultColumn}},...tablePlugins),TableHtmlElement=infiniteScroll?"div":"table",TheadHtmlElement=infiniteScroll?"div":"thead",TbodyHtmlElement=infiniteScroll?"div":"tbody",ThHtmlElement=infiniteScroll?"div":"th",TrHtmlElement=infiniteScroll?"div":"tr";useEffect(()=>(orders&&orders.length>0&&setLoading(!1),()=>{setLoading(!0)}),[orders]);const scrollBarSize=infiniteScroll?useMemo(()=>scrollbarWidth(),[]):0,LoadingComponent=loadingElement||_jsx("div",{children:"Loading..."}),headerComponent=table.headerGroups.map((headerGroup,i)=>{const columns2=headerGroup.headers.map((column,k)=>_createElement(ThHtmlElement,{className:column?.className,...column.getHeaderProps(column?.getSortByToggleProps&&column?.getSortByToggleProps()),key:k},_jsxs("span",{className:column?.titleClassName,children:[column.render("Header"),column.isSorted?column.isSortedDesc?sortDescIcon:sortAscIcon:""]})));return _createElement(TrHtmlElement,{...headerGroup.getHeaderGroupProps(),key:i},columns2)}),components2=infiniteScroll?useCallback(({index,style})=>{const row=table.rows[index];row&&table.prepareRow(row);const childProps={order:orders?.[index],row,showActions,actionsComponent,actionsContainerClassName,infiniteScroll};return _jsx(TrHtmlElement,{...row&&row.getRowProps({style}),className:rowTrClassName,children:_jsx(OrderListChildrenContext.Provider,{value:childProps,children})})},[table.prepareRow,table.rows]):table.rows.map((row,i)=>{table.prepareRow(row);const childProps={order:orders?.[i],row,showActions,actionsComponent,actionsContainerClassName,infiniteScroll};return _createElement(TrHtmlElement,{...row.getRowProps(),className:rowTrClassName,key:i},_jsx(OrderListChildrenContext.Provider,{value:childProps,children}))});return loading?LoadingComponent:_jsxs(TableHtmlElement,{...p,...table.getTableProps(),children:[_jsx(TheadHtmlElement,{className:theadClassName,children:headerComponent}),_jsx(TbodyHtmlElement,{...table.getTableBodyProps(),children:infiniteScroll?_jsx(FixedSizeList,{height:windowOptions?.height||400,itemCount:table.rows.length,itemSize:windowOptions?.itemSize||100,width:windowOptions?.width||table.totalColumnsWidth+scrollBarSize,children:components2}):components2})]})}OrderList.propTypes=propTypes,OrderList.displayName=displayName;export default OrderList;

package/lib/esm/components/orders/OrderListRow.d.ts

@@ -0,0 +1,30 @@
+import { ReactNode } from 'react';
+import { Cell, Row } from 'react-table';
+import type { Order } from '@commercelayer/sdk';
+declare type ChildrenProps = Omit<Props, 'children'> & {
+    /**
+     * The order resource
+     */
+    order: Order;
+    /**
+     * The current row
+     */
+    row: Row;
+    /**
+     * The current cell
+     */
+    cell: Cell[];
+    /**
+     * Infinite scroll enabled
+     */
+    infiniteScroll: boolean;
+};
+declare type Props = {
+    children?: (props: ChildrenProps) => ReactNode;
+    /**
+     * The order field to show
+     */
+    field: keyof Order;
+} & JSX.IntrinsicElements['td'];
+export declare function OrderListRow({ field, children, ...p }: Props): JSX.Element;
+export default OrderListRow;

package/lib/esm/components/orders/OrderListRow.js

@@ -0,0 +1 @@
+import{createElement as _createElement}from"react";import{jsx as _jsx,Fragment as _Fragment,jsxs as _jsxs}from"react/jsx-runtime";import{useContext}from"react";import Parent from"../utils/Parent";import OrderListChildrenContext from"../../context/OrderListChildrenContext";import isDate from"../../utils/isDate";import last from"lodash/last";export function OrderListRow({field,children,...p}){const{order,row,showActions,actionsComponent,actionsContainerClassName,infiniteScroll}=useContext(OrderListChildrenContext),cell=row?.cells.filter(cell2=>cell2.column.id===field),isLastRow=last(row?.cells)?.column.id===field,As=infiniteScroll?"div":"td",ActionRow=()=>showActions&&isLastRow&&actionsComponent&&_jsx(As,{...p,className:actionsContainerClassName,children:_jsx(Parent,{...parentProps,children:actionsComponent})})||null,parentProps={...p,field,order,row,cell,infiniteScroll};return children?_jsxs(_Fragment,{children:[_jsx(Parent,{...parentProps,children}),_jsx(ActionRow,{})]}):_jsxs(_Fragment,{children:[cell?.map((cell2,k)=>{const cellValue=cell2.value,value=isDate(cellValue)?new Date(Date.parse(cellValue)).toLocaleString():cell2.render("Cell");return _createElement(As,{...p,...cell2.getCellProps(),key:k},value)}),_jsx(ActionRow,{})]})}export default OrderListRow;

package/lib/esm/components/orders/OrderNumber.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { BaseFieldProps } from '../utils/BaseField';
+declare type Props = Omit<BaseFieldProps, 'attribute'>;
+export declare function OrderNumber(props: Props): JSX.Element;
+export declare namespace OrderNumber {
+    var propTypes: {
+        className: import("prop-types").Requireable<string>;
+    };
+    var displayName: string;
+}
+export default OrderNumber;

package/lib/esm/components/orders/OrderNumber.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import components from"../../config/components";import BaseField from"../utils/BaseField";const propTypes=components.OrderNumber.propTypes,displayName=components.OrderNumber.displayName;export function OrderNumber(props){return _jsx(BaseField,{attribute:"number",...props})}OrderNumber.propTypes=propTypes,OrderNumber.displayName=displayName;export default OrderNumber;

package/lib/esm/components/orders/OrderStorage.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+declare type Props = {
+    children: ReactNode;
+    persistKey: string;
+    clearWhenPlaced?: boolean;
+};
+export declare function OrderStorage(props: Props): JSX.Element;
+export declare namespace OrderStorage {
+    var propTypes: {
+        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
+        clearWhenPlaced: import("prop-types").Requireable<boolean>;
+        persistKey: import("prop-types").Validator<string>;
+    };
+    var displayName: string;
+}
+export default OrderStorage;

package/lib/esm/components/orders/OrderStorage.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import OrderStorageContext from"../../context/OrderStorageContext";import components from"../../config/components";import{getLocalOrder,setLocalOrder,deleteLocalOrder}from"../../utils/localStorage";const propTypes=components.OrderStorage.propTypes,displayName=components.OrderStorage.displayName;export function OrderStorage(props){const{children,clearWhenPlaced=!0,...p}=props;return _jsx(OrderStorageContext.Provider,{value:{...p,setLocalOrder,getLocalOrder,deleteLocalOrder,clearWhenPlaced},children})}OrderStorage.propTypes=propTypes,OrderStorage.displayName=displayName;export default OrderStorage;