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

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

@@ -0,0 +1,28 @@
+/// <reference types="react" />
+import { Price as PriceType } from '@commercelayer/sdk';
+import { FunctionChildren, LoaderType } from '../typings/index';
+declare type PriceChildrenProps = FunctionChildren<{
+    loading: boolean;
+    loader: LoaderType;
+    prices: PriceType[];
+} & Omit<PriceProps, 'children'>>;
+export declare type PriceProps = Partial<JSX.IntrinsicElements['span']> & {
+    children?: PriceChildrenProps;
+    compareClassName?: string;
+    showCompare?: boolean;
+    skuCode?: string;
+};
+export declare function Price(props: PriceProps): JSX.Element;
+export declare namespace Price {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        compareClassName: import("prop-types").Requireable<string>;
+        skuCode: import("prop-types").Requireable<string>;
+        showCompare: import("prop-types").Requireable<boolean>;
+    };
+    var defaultProps: {
+        skuCode: string;
+    };
+    var displayName: string;
+}
+export default Price;

package/lib/esm/components/Price.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{Fragment,useState,useEffect,useContext}from"react";import{isEmpty,has,indexOf}from"lodash";import Parent from"./utils/Parent";import PricesContext from"../context/PricesContext";import{getPricesComponent}from"../utils/getPrices";import components from"../config/components";import SkuChildrenContext from"../context/SkuChildrenContext";const propTypes=components.Price.propTypes,defaultProps=components.Price.defaultProps,displayName=components.Price.displayName;export function Price(props){const{children,skuCode=""}=props,{prices,skuCode:pricesSkuCode,loading,skuCodes,setSkuCodes,loader}=useContext(PricesContext),{sku}=useContext(SkuChildrenContext),[skuPrices,setSkuPrices]=useState([]),sCode=pricesSkuCode||skuCode||sku?.code;useEffect(()=>(!isEmpty(prices)&&has(prices,`${sCode}`)?setSkuPrices(prices[sCode]):sCode&&indexOf(skuCodes,sCode)===-1&&(skuCodes.push(sCode),setSkuCodes&&setSkuCodes(skuCodes)),()=>{setSkuPrices([])}),[prices,sCode]);const parentProps={loading,loader,prices:skuPrices,...props},pricesComponent=isEmpty(prices)||isEmpty(skuPrices)?null:getPricesComponent(skuPrices,props);return children?_jsx(Parent,{...parentProps,children}):_jsx(Fragment,{children:loading||isEmpty(pricesComponent)?loader:pricesComponent})}Price.propTypes=propTypes,Price.defaultProps=defaultProps,Price.displayName=displayName;export default Price;

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

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

package/lib/esm/components/PricesContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useEffect,useContext,useReducer}from"react";import getPrices from"../utils/getPrices";import isEmpty from"lodash/isEmpty";import has from"lodash/has";import indexOf from"lodash/indexOf";import CommerceLayerContext from"../context/CommerceLayerContext";import priceReducer,{unsetPriceState}from"../reducers/PriceReducer";import{priceInitialState,getSkusPrice}from"../reducers/PriceReducer";import PricesContext from"../context/PricesContext";import getCurrentItemKey from"../utils/getCurrentItemKey";import ItemContext from"../context/ItemContext";import components from"../config/components";import SkuContext from"../context/SkuContext";const propTypes=components.PricesContainer.propTypes,defaultProps=components.PricesContainer.defaultProps,displayName=components.PricesContainer.displayName;export function PricesContainer(props){const{children,skuCode="",loader="Loading...",perPage=10,filters={}}=props,[state,dispatch]=useReducer(priceReducer,priceInitialState),config=useContext(CommerceLayerContext),{skuCodes}=useContext(SkuContext),{setPrices,prices,items,item:currentItem,skuCode:itemSkuCode}=useContext(ItemContext);indexOf(state.skuCodes,skuCode)===-1&&skuCode&&state.skuCodes.push(skuCode);const sCode=skuCodes&&skuCodes?.length>0?"":skuCode||getCurrentItemKey(currentItem)||itemSkuCode||"",setSkuCodes=skuCodes2=>{dispatch({type:"setSkuCodes",payload:{skuCodes:skuCodes2}})};useEffect(()=>{if(state.skuCodes.length===0&&skuCodes&&skuCodes.length>0&&setSkuCodes(skuCodes),currentItem&&has(prices,sCode)&&dispatch({type:"setPrices",payload:{prices}}),!isEmpty(items)&&isEmpty(currentItem)){const p=getPrices(items);dispatch({type:"setPrices",payload:{prices:p}})}return config.accessToken&&!has(prices,itemSkuCode||sCode)&&(state.skuCodes.length>0||itemSkuCode||sCode)&&getSkusPrice(sCode&&[itemSkuCode||sCode]||state.skuCodes,{config,dispatch,setPrices,prices,perPage,filters}),config.accessToken&&isEmpty(currentItem)&&(state.skuCodes.length>0||skuCode)&&getSkusPrice(sCode&&[sCode]||state.skuCodes,{config,dispatch,setPrices,prices,perPage,filters}),()=>{isEmpty(currentItem)&&unsetPriceState(dispatch)}},[config.accessToken,currentItem,sCode,state.skuCodes.length,itemSkuCode]);const priceValue={...state,skuCode:sCode,loader,setSkuCodes};return _jsx(PricesContext.Provider,{value:priceValue,children})}PricesContainer.propTypes=propTypes,PricesContainer.defaultProps=defaultProps,PricesContainer.displayName=displayName;export default PricesContainer;

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

@@ -0,0 +1,31 @@
+/// <reference types="react" />
+import { FunctionChildren } from '../typings/index';
+declare type ChildrenProps = FunctionChildren<Omit<Props, 'children'> & {
+    handleChange: (event: React.MouseEvent<HTMLInputElement>) => void;
+    handleBlur: (event: React.MouseEvent<HTMLInputElement>) => void;
+}>;
+declare type Props = {
+    children?: ChildrenProps;
+    disabled?: boolean;
+    min?: number;
+    max?: number;
+    value?: string;
+    skuCode?: string;
+    skuListId?: string;
+} & JSX.IntrinsicElements['input'];
+export declare function QuantitySelector(props: Props): JSX.Element;
+export declare namespace QuantitySelector {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        min: import("prop-types").Requireable<number>;
+        max: import("prop-types").Requireable<number>;
+        value: import("prop-types").Requireable<string>;
+        skuCode: import("prop-types").Requireable<string>;
+        disabled: import("prop-types").Requireable<boolean>;
+    };
+    var defaultProps: {
+        min: number;
+    };
+    var displayName: string;
+}
+export default QuantitySelector;

package/lib/esm/components/QuantitySelector.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useState,useEffect}from"react";import Parent from"./utils/Parent";import has from"lodash/has";import isEmpty from"lodash/isEmpty";import getCurrentItemKey from"../utils/getCurrentItemKey";import ItemContext from"../context/ItemContext";import components from"../config/components";import SkuListsContext from"../context/SkuListsContext";import SkuChildrenContext from"../context/SkuChildrenContext";const propTypes=components.QuantitySelector.propTypes,defaultProps=components.QuantitySelector.defaultProps,displayName=components.QuantitySelector.displayName;export function QuantitySelector(props){const{skuCode,skuListId,children,min=1,max,...p}=props,{item,setQuantity,items,quantity,prices,skuCode:itemSkuCode}=useContext(ItemContext),{sku}=useContext(SkuChildrenContext),{skuLists,listIds}=useContext(SkuListsContext),defaultVal=p?.value||min,[value,setValue]=useState(defaultVal),[disabled,setDisabled]=useState(!!p.disabled),sCode=!isEmpty(items)&&skuCode?items[skuCode]?.code:sku?.code||skuCode||getCurrentItemKey(item)||itemSkuCode,inventory=isEmpty(item)?50:item[sCode]?.inventory?.quantity,maxInv=max||inventory;useEffect(()=>{if(setValue(defaultVal),(!prices[sCode]||!sCode)&&setDisabled(!0),skuListId&&setDisabled(!1),sCode&&!quantity[sCode]){const qty=Number(defaultVal);setQuantity&&setQuantity({...quantity,[`${sCode}`]:qty}),!isEmpty(prices)&&has(prices,sCode)&&setDisabled(!1)}return()=>{setValue(defaultVal)}},[item,listIds,prices,quantity]);const handleChange=e=>{const qty=Number(e.target.value),valid=Number(qty)>=Number(min)&&Number(qty)<=Number(maxInv);setValue(qty),!isEmpty(skuLists)&&skuListId&&valid?setQuantity&&setQuantity({...quantity,[`${skuListId}`]:Number(qty)}):sCode&&valid&&setQuantity&&setQuantity({...quantity,[`${sCode}`]:Number(qty)})},handleBlur=e=>{const qty=e.target.value;if(!(Number(qty)>=Number(min)&&Number(qty)<=Number(maxInv))){const resetVal=Number(qty)<Number(min)?min:maxInv;resetVal&&setValue(resetVal),!isEmpty(skuLists)&&skuListId?setQuantity&&setQuantity({...quantity,[`${skuListId}`]:Number(resetVal)}):setQuantity&&setQuantity({...quantity,[`${sCode}`]:Number(resetVal)})}},parentProps={min,max:maxInv,disabled,handleChange,handleBlur,value,...props};return children?_jsx(Parent,{...parentProps,children}):_jsx("input",{type:"number",max:maxInv,min,value:value||"",disabled,onChange:handleChange,onBlur:handleBlur,...p})}QuantitySelector.propTypes=propTypes,QuantitySelector.defaultProps=defaultProps,QuantitySelector.displayName=displayName;export default QuantitySelector;

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

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

package/lib/esm/components/SaveAddressesButton.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext,useState}from"react";import Parent from"./utils/Parent";import components from"../config/components";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";const propTypes=components.SaveAddressesButton.propTypes,defaultProps=components.SaveAddressesButton.defaultProps,displayName=components.SaveAddressesButton.displayName;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})}SaveAddressesButton.propTypes=propTypes,SaveAddressesButton.defaultProps=defaultProps,SaveAddressesButton.displayName=displayName;export default SaveAddressesButton;

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

@@ -0,0 +1,24 @@
+import { ReactNode } from '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 | ReactNode;
+    onClick?: () => void;
+} & JSX.IntrinsicElements['button'];
+export declare function SaveCustomerButton(props: Props): JSX.Element;
+export declare namespace SaveCustomerButton {
+    var propTypes: {
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        label: import("prop-types").Requireable<string | import("prop-types").ReactElementLike>;
+        onClick: import("prop-types").Requireable<(...args: any[]) => any>;
+    };
+    var defaultProps: {
+        label: string;
+    };
+    var displayName: string;
+}
+export default SaveCustomerButton;

package/lib/esm/components/SaveCustomerButton.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import Parent from"./utils/Parent";import components from"../config/components";import{isEmpty}from"lodash";import CustomerContext from"../context/CustomerContext";const propTypes=components.SaveCustomerButton.propTypes,defaultProps=components.SaveCustomerButton.defaultProps,displayName=components.SaveCustomerButton.displayName;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})}SaveCustomerButton.propTypes=propTypes,SaveCustomerButton.defaultProps=defaultProps,SaveCustomerButton.displayName=displayName;export default SaveCustomerButton;

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

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

package/lib/esm/components/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 components from"../config/components";import OrderContext from"../context/OrderContext";import AddressContext from"../context/AddressContext";const propTypes=components.ShippingAddressContainer.propTypes;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})}ShippingAddressContainer.propTypes=propTypes;export default ShippingAddressContainer;

package/lib/esm/components/ShippingAddressForm.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 ShippingAddressForm(props: Props): JSX.Element;
+export declare namespace ShippingAddressForm {
+    var propTypes: {
+        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
+    };
+}
+export default ShippingAddressForm;

package/lib/esm/components/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 components from"../config/components";import OrderContext from"../context/OrderContext";import{getSaveShippingAddressToAddressBook}from"../utils/localStorage";import{businessMandatoryField}from"../utils/validateFormFields";const propTypes=components.ShippingAddressForm.propTypes;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})})}ShippingAddressForm.propTypes=propTypes;export default ShippingAddressForm;

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

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import { BaseAmountComponent } from '../typings/index';
+export declare function ShippingAmount(props: BaseAmountComponent): JSX.Element;
+export declare namespace ShippingAmount {
+    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 ShippingAmount;

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

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

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

package/lib/esm/components/SkuField.js

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

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

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+declare type Props = {
+    children: ReactNode;
+};
+declare function Skus<P extends Props>({ children }: P): JSX.Element;
+declare namespace Skus {
+    var propTypes: {
+        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
+    };
+}
+export default Skus;

package/lib/esm/components/Skus.js

@@ -0,0 +1 @@
+import{jsx as _jsx,Fragment as _Fragment}from"react/jsx-runtime";import components from"../config/components";import SkuChildrenContext from"../context/SkuChildrenContext";import SkuContext from"../context/SkuContext";import{useContext}from"react";export default function Skus({children}){const{skus}=useContext(SkuContext),components2=skus&&skus.map((sku,key)=>{const value={sku};return _jsx(SkuChildrenContext.Provider,{value,children},key)});return _jsx(_Fragment,{children:components2})}Skus.propTypes=components.Skus.propTypes;

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

@@ -0,0 +1,14 @@
+import { QueryParamsList } from '@commercelayer/sdk';
+import { ReactNode } from 'react';
+declare type Props = {
+    skus: string[];
+    children: ReactNode;
+    queryParams?: QueryParamsList;
+};
+declare function SkusContainer<P extends Props>(props: P): JSX.Element;
+declare namespace SkusContainer {
+    var propTypes: {
+        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
+    };
+}
+export default SkusContainer;

package/lib/esm/components/SkusContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import components from"../config/components";import CommerceLayerContext from"../context/CommerceLayerContext";import SkuContext from"../context/SkuContext";import skuReducer,{getSku,skuInitialState}from"../reducers/SkuReducer";import{useContext,useEffect,useMemo,useReducer}from"react";export default function SkusContainer(props){const{skus,children,queryParams}=props,[state,dispatch]=useReducer(skuReducer,skuInitialState),config=useContext(CommerceLayerContext),loadSkus=async()=>await getSku({config,dispatch,skus,queryParams});useEffect(()=>(config.accessToken&&state?.skus&&state?.skus.length===0&&loadSkus(),()=>{dispatch({type:"setLoading",payload:{loading:!0}})}),[config,skus]);const contextValue=useMemo(()=>state,[state]);return _jsx(SkuContext.Provider,{value:contextValue,children})}SkusContainer.propTypes=components.SkusContainer.propTypes;

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

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+declare type Props = {
+    children: ReactNode;
+} & JSX.IntrinsicElements['p'];
+export declare function StockTransfer(props: Props): JSX.Element;
+export declare namespace StockTransfer {
+    var propTypes: {
+        children: import("prop-types").Validator<boolean | import("react").ReactChild | import("react").ReactFragment | import("react").ReactPortal | (() => ReactNode)>;
+    };
+    var displayName: string;
+}
+export default StockTransfer;

package/lib/esm/components/StockTransfer.js

@@ -0,0 +1 @@
+import{jsx as _jsx,Fragment as _Fragment}from"react/jsx-runtime";import{useContext}from"react";import components from"../config/components";import ShipmentChildrenContext from"../context/ShipmentChildrenContext";import StockTransferChildrenContext from"../context/StockTransferChildrenContext";const propTypes=components.StockTransfer.propTypes,displayName=components.StockTransfer.displayName;export function StockTransfer(props){const{children}=props,{stockTransfers,lineItems}=useContext(ShipmentChildrenContext),components2=stockTransfers?.filter(st=>!!lineItems?.find(l=>l.sku_code!==st.sku_code)).map((stockTransfer,k)=>{const stockTransferProps={stockTransfer:stockTransfer.type==="line_items"?stockTransfer:stockTransfer?.line_item};return _jsx(StockTransferChildrenContext.Provider,{value:stockTransferProps,children},k)});return _jsx(_Fragment,{children:components2})}StockTransfer.propTypes=propTypes,StockTransfer.displayName=displayName;export default StockTransfer;

package/lib/esm/components/StockTransferField.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['StockTransfer']>;
+declare type TCondition = ConditionalElement<Exclude<TResources['StockTransfer'], 'resource'>>;
+declare type Props = {
+    children?: (props: StockTransferFieldChildrenProps) => JSX.Element;
+} & TCondition;
+export declare function StockTransferField<P extends Props>(props: P): JSX.Element;
+export default StockTransferField;

package/lib/esm/components/StockTransferField.js

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

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

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import { StripeCardElementOptions, StripeElementLocale } from '@stripe/stripe-js';
+import { PaymentMethodConfig } from '../reducers/PaymentMethodReducer';
+import { PaymentSourceProps } from './PaymentSource';
+export declare type StripeConfig = {
+    containerClassName?: string;
+    hintLabel?: string;
+    name?: string;
+    options?: StripeCardElementOptions;
+    [key: string]: any;
+};
+declare type Props = PaymentMethodConfig['stripePayment'] & JSX.IntrinsicElements['div'] & Partial<PaymentSourceProps['templateCustomerSaveToWallet']> & {
+    show?: boolean;
+    publishableKey: string;
+    locale?: StripeElementLocale;
+};
+export declare function StripePayment({ publishableKey, show, options, locale, ...p }: Props): JSX.Element | null;
+export default StripePayment;

package/lib/esm/components/StripePayment.js

@@ -0,0 +1 @@
+import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";import{useContext,useEffect,useRef,useState}from"react";import PaymentMethodContext from"../context/PaymentMethodContext";import{CardElement,Elements,useElements,useStripe}from"@stripe/react-stripe-js";import Parent from"./utils/Parent";import OrderContext from"../context/OrderContext";import{setCustomerOrderParam}from"../utils/localStorage";const defaultOptions={style:{base:{fontSize:"16px",color:"#424770","::placeholder":{color:"#aab7c4"}},invalid:{color:"#9e2146"}},hidePostalCode:!0};function StripePaymentForm({options=defaultOptions,templateCustomerSaveToWallet}){const ref=useRef(null),{setPaymentSource,currentPaymentMethodType,setPaymentMethodErrors,setPaymentRef,paymentSource}=useContext(PaymentMethodContext),{order}=useContext(OrderContext),stripe=useStripe(),elements=useElements();useEffect(()=>(ref.current&&stripe&&elements&&paymentSource&&(ref.current.onsubmit=paymentSource2=>onSubmit({event:ref.current,stripe,elements,paymentSource:paymentSource2}),setPaymentRef({ref})),()=>{setPaymentRef({ref:{current:null}})}),[ref,stripe,elements,paymentSource]);const onSubmit=async({event,stripe:stripe2,elements:elements2,paymentSource:ps})=>{if(!stripe2)return!1;const savePaymentSourceToCustomerWallet=event?.elements?.save_payment_source_to_customer_wallet?.checked;savePaymentSourceToCustomerWallet&&setCustomerOrderParam("_save_payment_source_to_customer_wallet",savePaymentSourceToCustomerWallet);const cardElement=elements2&&elements2.getElement(CardElement);if(cardElement){const billingInfo=order?.billing_address,email=order?.customer_email,billing_details={name:billingInfo?.full_name,email,phone:billingInfo?.phone,address:{city:billingInfo?.city,country:billingInfo?.country_code,line1:billingInfo?.line_1,postal_code:billingInfo?.zip_code,state:billingInfo?.state_code}},{paymentMethod}=await stripe2.createPaymentMethod({type:"card",card:cardElement,billing_details}),clientSecret=ps?.client_secret,paymentSourceId=ps?.id;if(clientSecret){const{error,paymentIntent}=await stripe2.confirmCardPayment(clientSecret,{payment_method:{card:cardElement,billing_details}});if(error)return console.error(error),setPaymentMethodErrors([{code:"PAYMENT_INTENT_AUTHENTICATION_FAILURE",resource:"payment_methods",field:currentPaymentMethodType,message:error.message}]),!1;if(paymentIntent&&paymentMethod&&paymentSourceId&&currentPaymentMethodType)try{return await setPaymentSource({paymentSourceId,paymentResource:currentPaymentMethodType,attributes:{options:{...paymentMethod,setup_future_usage:"off_session"}}}),!0}catch{return!1}}}return!1};return _jsxs("form",{ref,children:[_jsx(CardElement,{options:{...defaultOptions,...options}}),templateCustomerSaveToWallet&&_jsx(Parent,{name:"save_payment_source_to_customer_wallet",children:templateCustomerSaveToWallet})]})}export function StripePayment({publishableKey,show,options,locale="auto",...p}){const[isLoaded,setIsLoaded]=useState(!1),[stripe,setStripe]=useState(null),{containerClassName,templateCustomerSaveToWallet,fonts=[],...divProps}=p;return useEffect(()=>{if(show&&publishableKey){const{loadStripe}=require("@stripe/stripe-js");(async()=>{const res=await loadStripe(publishableKey,{locale});setStripe(res),setIsLoaded(!0)})()}return()=>{setIsLoaded(!1)}},[show,publishableKey]),isLoaded&&stripe?_jsx("div",{className:containerClassName,...divProps,children:_jsx(Elements,{stripe,options:{fonts},children:_jsx(StripePaymentForm,{options,templateCustomerSaveToWallet})})}):null}export default StripePayment;

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

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { FunctionChildren } from '../typings/index';
+declare type ChildrenProps = FunctionChildren<Omit<Props, 'children'>>;
+declare type Props = {
+    children?: ChildrenProps;
+    label?: string | ReactNode;
+} & 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

@@ -0,0 +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;

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

@@ -0,0 +1,52 @@
+import { ReactNode } from 'react';
+import { VariantHandleCallback } from './utils/VariantTemplate';
+import { BaseSelectorType } from '../typings/index';
+import { FunctionChildren } from '../typings/index';
+import { VariantsObject, SetSkuCode } from '../reducers/VariantReducer';
+export interface VariantOption {
+    label: string;
+    code: string;
+    lineItem?: {
+        name: string;
+        imageUrl?: string | null;
+    } | null;
+}
+declare type ChildrenProps = FunctionChildren<Omit<Props, 'children'> & {
+    variants: VariantsObject;
+    handleSelect: SetSkuCode;
+    loading: boolean;
+}>;
+declare type Props = {
+    children?: ChildrenProps;
+    options: VariantOption[];
+    type?: BaseSelectorType;
+    loader?: ReactNode;
+    placeholder?: string;
+    skuCode?: string;
+    handleCallback?: VariantHandleCallback;
+} & JSX.IntrinsicElements['input'] & JSX.IntrinsicElements['select'];
+export declare function VariantSelector(props: Props): JSX.Element;
+export declare namespace VariantSelector {
+    var propTypes: {
+        options: import("prop-types").Validator<import("prop-types").InferProps<{
+            label: import("prop-types").Validator<string>;
+            code: import("prop-types").Validator<string>;
+            lineItem: import("prop-types").Requireable<import("prop-types").InferProps<{
+                name: import("prop-types").Validator<string>;
+                imageUrl: import("prop-types").Requireable<string>;
+            }>>;
+        }>[]>;
+        name: import("prop-types").Requireable<string>;
+        children: import("prop-types").Requireable<(...args: any[]) => any>;
+        type: import("prop-types").Requireable<BaseSelectorType>;
+        loader: import("prop-types").Requireable<import("prop-types").ReactElementLike>;
+        placeholder: import("prop-types").Requireable<string>;
+        skuCode: import("prop-types").Requireable<string>;
+    };
+    var defaultProps: {
+        placeholder: string;
+        type: BaseSelectorType;
+    };
+    var displayName: string;
+}
+export default VariantSelector;

package/lib/esm/components/VariantSelector.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{Fragment,useContext,useEffect}from"react";import VariantTemplate from"./utils/VariantTemplate";import Parent from"./utils/Parent";import VariantsContext from"../context/VariantsContext";import components from"../config/components";const propTypes=components.VariantSelector.propTypes,defaultProps=components.VariantSelector.defaultProps,displayName=components.VariantSelector.displayName;export function VariantSelector(props){const{children,type,placeholder,skuCode,name,options,...prs}=props,{setSkuCode,skuCode:variantSkuCode,loading,variants,setSkuCodes}=useContext(VariantsContext);useEffect(()=>(setSkuCodes&&setSkuCodes(options),()=>{setSkuCodes&&setSkuCodes([])}),[options]);const sCode=variantSkuCode||skuCode||"",DefaultTemplate=()=>loading?_jsx(Fragment,{children:props.loader||"Loading..."}):_jsx(VariantTemplate,{variants,type,placeholder,skuCode:sCode,options,handleChange:setSkuCode,name,...prs}),parentProps={variants,loading:!!loading,handleSelect:setSkuCode,skuCode:sCode,...props};return children?_jsx(Parent,{...parentProps,children}):_jsx(Fragment,{children:_jsx(DefaultTemplate,{})})}VariantSelector.propTypes=propTypes,VariantSelector.defaultProps=defaultProps,VariantSelector.displayName=displayName;export default VariantSelector;

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

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

package/lib/esm/components/VariantsContainer.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useEffect,useReducer,useContext}from"react";import variantReducer,{variantInitialState,unsetVariantState,setSkuCode,getVariants}from"../reducers/VariantReducer";import CommerceLayerContext from"../context/CommerceLayerContext";import VariantsContext from"../context/VariantsContext";import{setVariantSkuCodes}from"../reducers/VariantReducer";import isEmpty from"lodash/isEmpty";import isEqual from"lodash/isEqual";import getCurrentItemKey from"../utils/getCurrentItemKey";import ItemContext from"../context/ItemContext";import components from"../config/components";const propTypes=components.VariantsContainer.propTypes,defaultProps=components.VariantsContainer.defaultProps,displayName=components.VariantsContainer.displayName;export function VariantsContainer(props){const{children,skuCode="",filters={}}=props,config=useContext(CommerceLayerContext),{setItem,setItems,items,item:currentItem,setCustomLineItems,skuCode:itemSkuCode,setSkuCode:setItemSkuCode}=useContext(ItemContext),[state,dispatch]=useReducer(variantReducer,variantInitialState),sCode=getCurrentItemKey(currentItem)||skuCode||state.skuCode||itemSkuCode||"";useEffect(()=>{if(!isEmpty(items)&&!isEmpty(state.variants)&&!isEqual(items,state.variants)){const mergeItems={...items,...state.variants};setItems&&setItems(mergeItems)}return state.skuCodes.length>=1&&config.accessToken&&(dispatch({type:"setLoading",payload:{loading:!0}}),getVariants({config,state,dispatch,setItem,skuCode:sCode,filters})),()=>unsetVariantState(dispatch)},[config.accessToken]);const variantValue={...state,skuCode:sCode,setSkuCode:(code,id,lineItem={})=>{isEmpty(lineItem)||setCustomLineItems&&setCustomLineItems({[code]:lineItem}),setSkuCode({code,id,config,setItem,dispatch,setItemSkuCode})},setSkuCodes:skuCodes=>setVariantSkuCodes({skuCodes,dispatch,setCustomLineItems})};return _jsx(VariantsContext.Provider,{value:variantValue,children})}VariantsContainer.propTypes=propTypes,VariantsContainer.defaultProps=defaultProps,VariantsContainer.displayName=displayName;export default VariantsContainer;

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

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+export declare type WireTransferConfig = {
+    infoMessage?: {
+        text?: string | ReactNode;
+        className?: string;
+    };
+};
+declare type Props = WireTransferConfig & JSX.IntrinsicElements['div'];
+export declare function WireTransferPayment({ infoMessage, ...p }: Props): JSX.Element;
+export default WireTransferPayment;

package/lib/esm/components/WireTransferPayment.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import PaymentMethodContext from"../context/PaymentMethodContext";import isFunction from"lodash/isFunction";import{useContext,useEffect,useRef}from"react";const defaultMessage="after placing the order, you will need to manually complete the payment with your bank";export function WireTransferPayment({infoMessage,...p}){const ref=useRef(null),{setPaymentSource,paymentSource,currentPaymentMethodType,setPaymentRef}=useContext(PaymentMethodContext);useEffect(()=>(ref.current&&paymentSource&&currentPaymentMethodType&&(ref.current.onsubmit=()=>handleClick(),setPaymentRef({ref})),()=>{setPaymentRef({ref:{current:null}})}),[ref,paymentSource,currentPaymentMethodType]);const handleClick=async()=>{if(paymentSource&&currentPaymentMethodType)try{return await setPaymentSource({paymentSourceId:paymentSource.id,paymentResource:currentPaymentMethodType,attributes:{metadata:{card:{id:paymentSource.id,brand:"wire-transfer",last4:""}}}}),!0}catch{return!1}return!1};return _jsx("form",{ref,children:_jsx("div",{...p,children:_jsx("span",{className:infoMessage?.className,children:isFunction(infoMessage?.text)?infoMessage?.text():infoMessage?.text||defaultMessage})})})}export default WireTransferPayment;

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

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

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{Fragment,useContext,useState,useEffect}from"react";import AddressChildrenContext from"../../context/AddressChildrenContext";import components from"../../config/components";import CustomerContext from"../../context/CustomerContext";import BillingAddressContext from"../../context/BillingAddressContext";import ShippingAddressContext from"../../context/ShippingAddressContext";import isEmpty from"lodash/isEmpty";import AddressContext from"../../context/AddressContext";import OrderContext from"../../context/OrderContext";import AddressCardsTemplate from"../utils/AddressCardsTemplate";const propTypes=components.Address.propTypes;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;

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

@@ -0,0 +1,26 @@
+/// <reference types="react" />
+import { AddressCountrySelectName, BaseSelectComponentProps } from '../../typings/index';
+import { AddressValuesKeys } from '../../context/BillingAddressFormContext';
+declare type Props = Omit<BaseSelectComponentProps, 'options' | 'name'> & {
+    name: Extract<AddressValuesKeys, AddressCountrySelectName>;
+    required?: boolean;
+    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

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

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

@@ -0,0 +1,43 @@
+import { ReactNode } from 'react';
+import { AddressFieldView } from '../../reducers/AddressReducer';
+import type { Address } from '@commercelayer/sdk';
+declare type AddressFieldChildrenProps = Omit<Props, 'children' | 'name'> & {
+    address: Address;
+};
+declare type Props = {
+    type?: 'field';
+    label?: never;
+    onClick?: never;
+    children?: (props: AddressFieldChildrenProps) => ReactNode;
+    name: AddressFieldView;
+    className?: string;
+} | {
+    type?: 'edit';
+    label: string | ReactNode;
+    onClick: (address: Address) => void;
+    children?: (props: AddressFieldChildrenProps) => ReactNode;
+    name?: AddressFieldView;
+    className?: string;
+} | {
+    type?: 'delete';
+    label: string;
+    onClick: () => void;
+    children?: (props: AddressFieldChildrenProps) => ReactNode;
+    name?: AddressFieldView;
+    className?: string;
+} | {
+    type?: 'edit' | 'field' | 'delete';
+    label?: never;
+    onClick?: never;
+    children: (props: AddressFieldChildrenProps) => ReactNode;
+    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

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";import{useContext}from"react";import AddressChildrenContext from"../../context/AddressChildrenContext";import Parent from"../utils/Parent";import components from"../../config/components";import 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;