@commercelayer/react-components 3.15.4 → 3.15.6

package/lib/esm/reducers/OrderReducer.d.ts

@@ -0,0 +1,148 @@
+import { Dispatch } from 'react';
+import { SetLocalOrder, DeleteLocalOrder } from '../utils/localStorage';
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+import { BaseMetadataObject } from '../typings/index';
+import { BaseError } from '../typings/errors';
+import { AddressResource } from './AddressReducer';
+import type { Order, OrderUpdate } from '@commercelayer/sdk';
+export declare type GetOrderParams = Partial<{
+    clearWhenPlaced: boolean;
+    config: CommerceLayerConfig;
+    deleteLocalOrder: DeleteLocalOrder;
+    dispatch: Dispatch<OrderActions>;
+    id: string;
+    persistKey: string;
+    state: OrderState;
+}>;
+export declare type GetOrder = (params: GetOrderParams) => Promise<undefined | Order>;
+declare type CreateOrderParams = Pick<AddToCartParams, 'config' | 'dispatch' | 'persistKey' | 'state' | 'orderMetadata' | 'orderAttributes' | 'setLocalOrder'>;
+export declare type CreateOrder = (params?: CreateOrderParams) => Promise<string>;
+export interface AddToCartImportParams extends Omit<AddToCartParams, 'skuCode' | 'skuId' | 'quantity' | 'option' | 'lineItem'> {
+    lineItems: CustomLineItem[];
+}
+export declare type AddToCartReturn = Promise<{
+    success: boolean;
+    orderId: string | undefined;
+}>;
+export declare type AddToCartImport = (params: AddToCartImportParams) => AddToCartReturn;
+export declare type UnsetOrderState = (dispatch: Dispatch<OrderActions>) => void;
+export declare type ResourceIncluded = 'billing_address' | 'shipping_address' | 'line_items.line_item_options.sku_option' | 'line_items.item' | 'available_customer_payment_sources.payment_source' | 'shipments.available_shipping_methods' | 'shipments.stock_transfers' | 'shipments.stock_transfers.line_item' | 'shipments.shipment_line_items.line_item' | 'shipments.shipping_method' | 'shipments.stock_location' | 'shipments.parcels' | 'shipments.parcels.parcel_line_items' | 'payment_source' | 'available_payment_methods' | 'payment_method';
+declare type ResourceIncludedLoaded = Partial<Record<ResourceIncluded, boolean>>;
+export interface OrderPayload {
+    loading?: boolean;
+    orderId?: string;
+    order?: Order;
+    errors?: BaseError[];
+    include?: ResourceIncluded[] | undefined;
+    includeLoaded?: ResourceIncludedLoaded;
+    withoutIncludes?: boolean;
+}
+export declare type AddToCartImportValues = Pick<AddToCartImportParams, 'lineItems'>;
+export declare type getOrderContext = (id: string) => Promise<undefined | Order>;
+export declare type OrderState = Partial<OrderPayload>;
+export interface OrderActions {
+    type: OrderActionType;
+    payload: OrderPayload;
+}
+export declare type OrderActionType = 'setLoading' | 'setOrderId' | 'setOrder' | 'setSingleQuantity' | 'setCurrentSkuCodes' | 'setCurrentSkuPrices' | 'setCurrentItem' | 'setErrors' | 'setSaveAddressToCustomerAddressBook' | 'setGiftCardOrCouponCode' | 'setIncludesResource';
+export declare const createOrder: CreateOrder;
+export declare const getApiOrder: GetOrder;
+export interface UpdateOrderArgs {
+    id: string;
+    attributes: Omit<OrderUpdate, 'id'>;
+    dispatch?: Dispatch<OrderActions>;
+    include?: string[];
+    config?: CommerceLayerConfig;
+    state?: OrderState;
+}
+export declare function updateOrder({ id, attributes, dispatch, config, include, state }: UpdateOrderArgs): Promise<{
+    success: boolean;
+    error?: unknown;
+}>;
+export declare const setOrder: (order: Order, dispatch?: Dispatch<OrderActions>) => void;
+export interface AddResourceToInclude {
+    resourcesIncluded?: ResourceIncluded[];
+    dispatch?: Dispatch<OrderActions>;
+    newResource?: ResourceIncluded | ResourceIncluded[];
+    resourceIncludedLoaded?: ResourceIncludedLoaded;
+    newResourceLoaded?: ResourceIncludedLoaded;
+}
+export declare function addResourceToInclude({ resourcesIncluded, dispatch, newResource, newResourceLoaded, resourceIncludedLoaded }: AddResourceToInclude): void;
+export interface LineItemOption {
+    /**
+     * SKU Option ID. Ex: mNJEgsJwBn
+     */
+    skuOptionId: string;
+    /**
+     * Set of key-value pairs that represent the selected options. Ex: { message: 'This is a option message' }
+     */
+    options: Record<string, string>;
+    quantity?: number;
+}
+export interface CustomLineItem {
+    name?: string;
+    imageUrl?: string | null;
+}
+export declare type AddToCartParams = Partial<{
+    bundleCode: string;
+    skuCode: string;
+    persistKey: string;
+    config: CommerceLayerConfig;
+    dispatch: Dispatch<OrderActions>;
+    state: Partial<OrderState>;
+    quantity: number;
+    lineItemOption: LineItemOption;
+    lineItem: CustomLineItem;
+    orderMetadata: BaseMetadataObject;
+    orderAttributes: Record<string, any>;
+    errors: BaseError[];
+    setLocalOrder: SetLocalOrder;
+    buyNowMode: boolean;
+    checkoutUrl: string;
+}>;
+export declare function addToCart(params: AddToCartParams): Promise<{
+    success: boolean;
+    orderId?: string;
+}>;
+export declare const unsetOrderState: UnsetOrderState;
+interface OrderErrors {
+    dispatch?: Dispatch<OrderActions>;
+    errors: BaseError[];
+}
+export declare function setOrderErrors({ dispatch, errors }: OrderErrors): {
+    success: boolean;
+};
+export declare type SaveAddressToCustomerAddressBook = (params: {
+    dispatch?: Dispatch<OrderActions>;
+    type: AddressResource;
+    value: boolean;
+}) => void;
+export declare const saveAddressToCustomerAddressBook: SaveAddressToCustomerAddressBook;
+export declare type SetGiftCardOrCouponCode = (args: {
+    code: string;
+    codeType: OrderCodeType;
+    dispatch?: Dispatch<OrderActions>;
+    config?: CommerceLayerConfig;
+    order?: Order;
+    include?: string[];
+    state?: OrderState;
+}) => Promise<{
+    success: boolean;
+}>;
+export declare const setGiftCardOrCouponCode: SetGiftCardOrCouponCode;
+export declare type CodeType = 'coupon' | 'gift_card' | 'gift_card_or_coupon';
+export declare type OrderCodeType = `${CodeType}_code`;
+export declare type RemoveGiftCardOrCouponCode = (args: {
+    codeType: OrderCodeType;
+    dispatch?: Dispatch<OrderActions>;
+    config?: CommerceLayerConfig;
+    order?: Order;
+    include?: string[];
+    state?: OrderState;
+}) => Promise<{
+    success: boolean;
+}>;
+export declare const removeGiftCardOrCouponCode: RemoveGiftCardOrCouponCode;
+export declare const orderInitialState: Partial<OrderState>;
+declare const orderReducer: (state: OrderState, reducer: OrderActions) => OrderState;
+export default orderReducer;

package/lib/esm/reducers/OrderReducer.js

@@ -0,0 +1 @@
+import{setCustomerOrderParam}from"../utils/localStorage";import baseReducer from"../utils/baseReducer";import isEmpty from"lodash/isEmpty";import getSdk from"../utils/getSdk";import getErrors,{setErrors}from"../utils/getErrors";import getOrganizationSlug from"../utils/organization";const actionType=["setLoading","setOrderId","setOrder","setSingleQuantity","setCurrentSkuCodes","setCurrentSkuPrices","setErrors","setCurrentItem","setSaveAddressToCustomerAddressBook","setIncludesResource"];export const createOrder=async params=>{if(params){const{persistKey,state,dispatch,config,orderMetadata:metadata,orderAttributes={},setLocalOrder}=params;if(state?.orderId)return state.orderId;const sdk=getSdk(config);try{const o=await sdk?.orders.create({metadata,...orderAttributes});return dispatch&&dispatch({type:"setOrderId",payload:{orderId:o?.id}}),persistKey&&setLocalOrder&&setLocalOrder(persistKey,o.id),o.id}catch(error){const errors=getErrors(error,"orders");console.error("Create order",errors),dispatch&&setErrors({currentErrors:state?.errors,newErrors:errors,dispatch})}}return""},getApiOrder=async params=>{const{id,dispatch,config,clearWhenPlaced,persistKey,deleteLocalOrder,state}=params,sdk=getSdk(config);try{const options={};state?.include&&state.include.length>0&&(options.include=state.include);const order=await sdk.orders.retrieve(id,options);return clearWhenPlaced&&order.status==="placed"||clearWhenPlaced&&order.status==="approved"||clearWhenPlaced&&order.status==="cancelled"?(persistKey&&deleteLocalOrder&&deleteLocalOrder(persistKey),dispatch&&dispatch({type:"setOrder",payload:{order:void 0,orderId:""}})):dispatch&&dispatch({type:"setOrder",payload:{order,orderId:order.id}}),order}catch(error){const errors=getErrors(error,"orders");console.error("Retrieve order",errors),dispatch&&setErrors({currentErrors:state?.errors,newErrors:errors,dispatch});return}};export async function updateOrder({id,attributes,dispatch,config,include,state}){const sdk=getSdk(config);try{const resource={...attributes,id};await sdk.orders.update(resource,{include});const order=await getApiOrder({id,config,dispatch,state});return dispatch&&order&&dispatch({type:"setOrder",payload:{order}}),{success:!0}}catch(error){const errors=getErrors(error,"orders");return dispatch&&(setOrderErrors({errors,dispatch}),dispatch({type:"setErrors",payload:{errors}})),{success:!1,error}}}export const setOrder=(order,dispatch)=>{dispatch&&dispatch({type:"setOrder",payload:{order}})};export function addResourceToInclude({resourcesIncluded=[],dispatch,newResource,newResourceLoaded,resourceIncludedLoaded}){const payload={include:void 0,includeLoaded:void 0};if(newResource){const resources=typeof newResource=="string"?[newResource]:newResource;payload.include=[...resourcesIncluded,...resources],resources.forEach(resource=>{const includeLoaded={...payload.includeLoaded,[resource]:!0};payload.includeLoaded=includeLoaded})}else delete payload.include;const payloadIncludeLoaded={...resourceIncludedLoaded,...newResourceLoaded,...payload.includeLoaded&&payload.includeLoaded};payload.includeLoaded=payloadIncludeLoaded,dispatch&&dispatch({type:"setIncludesResource",payload:{...payload,withoutIncludes:!1}})}export async function addToCart(params){const{skuCode,bundleCode,quantity,config,dispatch,lineItem,state,errors=[],buyNowMode,checkoutUrl,lineItemOption}=params;try{if(config){const sdk=getSdk(config),id=await createOrder(params);if(id){const order=sdk.orders.relationship(id),name=lineItem?.name,imageUrl=lineItem?.imageUrl;if(buyNowMode)if(state?.order?.line_items)await Promise.all(state?.order?.line_items.map(async lineItem2=>{await sdk.line_items.delete(lineItem2.id)}));else{const{line_items:lineItems}=await sdk.orders.retrieve(id,{fields:["line_items"],include:["line_items"]});lineItems&&lineItems?.length>0&&await Promise.all(lineItems.map(async lineItem2=>{await sdk.line_items.delete(lineItem2.id)}))}const attrs={order,sku_code:skuCode,name,image_url:imageUrl,quantity:quantity??1,_update_quantity:!0,bundle_code:bundleCode},newLineItem=await sdk.line_items.create(attrs);if(lineItemOption!=null){const{skuOptionId,options,quantity:quantity2}=lineItemOption,skuOption=sdk.sku_options.relationship(skuOptionId),lineItemRel=sdk.line_items.relationship(newLineItem.id),lineItemOptionsAttributes={quantity:quantity2??1,options,sku_option:skuOption,line_item:lineItemRel};await sdk.line_item_options.create(lineItemOptionsAttributes),await getApiOrder({id,...params})}else await getApiOrder({id,...params,state});if(!isEmpty(errors)&&dispatch&&dispatch({type:"setErrors",payload:{errors:[]}}),buyNowMode){const{organization}=getOrganizationSlug(config.endpoint??""),params2=`${id}?accessToken=${config.accessToken??""}`,redirectUrl=checkoutUrl?`${checkoutUrl}/${params2}`:`https://${organization}.checkout.commercelayer.app/${params2}`;location.href=redirectUrl}return{success:!0,orderId:id}}}return{success:!1}}catch(error){const errors2=getErrors(error,"orders");return console.error("Add to cart",errors2),dispatch&&setErrors({currentErrors:state?.errors,newErrors:errors2,dispatch}),{success:!1}}}export const unsetOrderState=dispatch=>{dispatch({type:"setOrderId",payload:{orderId:""}}),dispatch({type:"setOrder",payload:{order:void 0}})};export function setOrderErrors({dispatch,errors=[]}){return dispatch&&dispatch({type:"setErrors",payload:{errors}}),{success:!1}}export const saveAddressToCustomerAddressBook=({type,value,dispatch})=>{const k=`_save_${type}_to_customer_address_book`,v=`${value.toString()}`;setCustomerOrderParam(k,v),dispatch&&dispatch({type:"setSaveAddressToCustomerAddressBook",payload:{[k]:v}})},setGiftCardOrCouponCode=async({code,codeType,dispatch,config,order,include,state})=>{try{if(config&&order&&code&&dispatch){const attributes={[codeType]:code},{success,error}=await updateOrder({id:order.id,attributes,config,include,dispatch,state});if(!success)throw error;return dispatch({type:"setErrors",payload:{errors:[]}}),{success}}return{success:!1}}catch(error){const errors=getErrors(error,"orders",codeType);return dispatch&&setOrderErrors({errors,dispatch}),{success:!1}}},removeGiftCardOrCouponCode=async({codeType,dispatch,config,order,include,state})=>{try{if(config&&order&&dispatch){const attributes={[codeType]:""};return await updateOrder({id:order.id,attributes,config,include,dispatch,state}),dispatch({type:"setErrors",payload:{errors:[]}}),{success:!0}}return{success:!1}}catch(error){const errors=getErrors(error,"orders",codeType);return console.error("Remove gift card o coupon code",errors),dispatch&&setOrderErrors({errors,dispatch}),{success:!1}}},orderInitialState={loading:!0,orderId:"",order:void 0,errors:[],include:void 0,withoutIncludes:!0};const orderReducer=(state,reducer)=>baseReducer(state,reducer,actionType);export default orderReducer;

package/lib/esm/reducers/PaymentMethodReducer.d.ts

@@ -0,0 +1,150 @@
+import { AdyenPaymentConfig } from '../components/payment_source/AdyenPayment';
+import { BraintreeConfig } from '../components/payment_source/BraintreePayment';
+import { PaypalConfig } from '../components/payment_source/PaypalPayment';
+import { StripeConfig } from '../components/payment_source/StripePayment';
+import { WireTransferConfig } from '../components/payment_source/WireTransferPayment';
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+import { getOrderContext, updateOrder } from './OrderReducer';
+import { BaseError } from '../typings/errors';
+import { Order, PaymentMethod, StripePayment, WireTransfer, AdyenPayment, BraintreePayment, CheckoutComPayment, ExternalPayment, PaypalPayment, KlarnaPayment } from '@commercelayer/sdk';
+import { Dispatch, MutableRefObject } from 'react';
+import { CheckoutComConfig } from '../components/payment_source/CheckoutComPayment';
+export declare type PaymentSourceType = AdyenPayment | BraintreePayment | CheckoutComPayment | ExternalPayment | PaypalPayment | StripePayment | WireTransfer;
+interface Card {
+    type: string;
+    brand: string;
+    last4: string;
+    exp_year: number;
+    exp_month: number;
+}
+export interface PaymentSourceObject {
+    adyen_payments: AdyenPayment & {
+        payment_request_data?: {
+            payment_method?: Card;
+        };
+        payment_response?: {
+            resultCode?: 'Authorised';
+        };
+    };
+    braintree_payments: BraintreePayment & {
+        options?: {
+            card: Card;
+        };
+    };
+    external_payments: ExternalPayment & {
+        payment_source_token?: string;
+    };
+    paypal_payments: PaypalPayment;
+    stripe_payments: StripePayment & {
+        options?: {
+            card: Card;
+        };
+    };
+    wire_transfers: WireTransfer;
+    checkout_com_payments: CheckoutComPayment & {
+        payment_response: {
+            source?: Pick<Card, 'last4'> & {
+                scheme: string;
+                expiry_year: number;
+                expiry_month: number;
+            };
+        };
+    };
+    klarna_payments: KlarnaPayment;
+}
+export declare type PaymentMethodActionType = 'setErrors' | 'setPaymentMethods' | 'setPaymentMethodConfig' | 'setPaymentSource' | 'setPaymentRef' | 'setLoading';
+export declare type PaymentRef = MutableRefObject<null | HTMLFormElement>;
+export interface PaymentMethodActionPayload {
+    errors: BaseError[];
+    paymentMethods: PaymentMethod[];
+    currentPaymentMethodType: PaymentResource;
+    currentPaymentMethodId: string;
+    currentPaymentMethodRef: PaymentRef;
+    config: PaymentMethodConfig;
+    paymentSource: PaymentSourceTypes;
+    loading: boolean;
+}
+export declare function setLoading({ loading, dispatch }: {
+    loading: boolean;
+    dispatch?: Dispatch<PaymentMethodAction>;
+}): void;
+export declare type SetPaymentRef = (args: {
+    ref: PaymentRef;
+    dispatch?: Dispatch<PaymentMethodAction>;
+}) => void;
+export declare const setPaymentRef: SetPaymentRef;
+export declare type PaymentMethodState = Partial<PaymentMethodActionPayload>;
+export interface PaymentMethodAction {
+    type: PaymentMethodActionType;
+    payload: Partial<PaymentMethodActionPayload>;
+}
+export declare const paymentMethodInitialState: PaymentMethodState;
+export declare type SetPaymentMethodErrors = <V extends BaseError[]>(errors: V, dispatch?: Dispatch<PaymentMethodAction>) => void;
+export declare const setPaymentMethodErrors: SetPaymentMethodErrors;
+declare type GetPaymentMethods = (args: {
+    order: Order;
+    dispatch: Dispatch<PaymentMethodAction>;
+}) => Promise<void>;
+export declare const getPaymentMethods: GetPaymentMethods;
+export declare type PaymentResource = keyof PaymentSourceObject;
+export declare type PaymentResourceKey = 'braintreePayment' | 'stripePayment' | 'klarnaPayment' | 'wireTransfer' | 'paypalPayment' | 'adyenPayment' | 'checkoutComPayment';
+export declare type SDKPaymentResource = 'AdyenPayment' | 'BraintreePayment' | 'ExternalPayment' | 'PaypalPayment' | 'StripePayment' | 'WireTransfer' | 'CheckoutComPayment';
+export declare type SetPaymentMethod = (args: {
+    config?: CommerceLayerConfig;
+    dispatch?: Dispatch<PaymentMethodAction>;
+    updateOrder?: typeof updateOrder;
+    setOrderErrors?: (collection: any) => {
+        success: boolean;
+    };
+    order?: Order;
+    paymentMethodId: string;
+    paymentResource?: PaymentResource;
+}) => Promise<void>;
+export declare const setPaymentMethod: SetPaymentMethod;
+declare type PaymentSourceTypes = (StripePayment & WireTransfer) | (StripePayment | WireTransfer);
+export declare type SetPaymentSourceResponse = {
+    order: Order;
+    paymentSource: PaymentSourceTypes;
+} | null;
+export declare type SetPaymentSource = (args: {
+    config?: CommerceLayerConfig;
+    dispatch?: Dispatch<PaymentMethodAction>;
+    getOrder?: getOrderContext;
+    attributes?: Record<string, unknown>;
+    order?: Order;
+    paymentResource: PaymentResource;
+    paymentSourceId?: string;
+    customerPaymentSourceId?: string;
+    updateOrder?: typeof updateOrder;
+} & PaymentMethodState) => Promise<PaymentSourceType | undefined>;
+export declare const setPaymentSource: SetPaymentSource;
+export declare type UpdatePaymentSource = (args: {
+    id: string;
+    attributes: Record<string, any>;
+    paymentResource: PaymentResource;
+    config?: CommerceLayerConfig;
+    dispatch?: Dispatch<PaymentMethodAction>;
+}) => Promise<void>;
+export declare const updatePaymentSource: UpdatePaymentSource;
+export declare type DestroyPaymentSource = (args: {
+    paymentSourceId: string;
+    paymentResource: PaymentResource;
+    dispatch?: Dispatch<PaymentMethodAction>;
+    updateOrder?: typeof updateOrder;
+    orderId?: string;
+}) => Promise<void>;
+export declare const destroyPaymentSource: DestroyPaymentSource;
+export interface PaymentMethodConfig {
+    stripePayment?: StripeConfig;
+    braintreePayment?: BraintreeConfig;
+    wireTransfer?: Partial<WireTransferConfig>;
+    paypalPayment?: PaypalConfig;
+    adyenPayment?: AdyenPaymentConfig;
+    checkoutComPayment?: CheckoutComConfig;
+    klarnaPayment?: Pick<AdyenPaymentConfig, 'placeOrderCallback'> & Pick<StripeConfig, 'containerClassName'>;
+}
+declare type SetPaymentMethodConfig = (config: PaymentMethodConfig, dispatch: Dispatch<PaymentMethodAction>) => void;
+export declare const setPaymentMethodConfig: SetPaymentMethodConfig;
+export declare function getPaymentConfig<K extends PaymentResourceKey>(paymentResource: PaymentResource, config: PaymentMethodConfig): PaymentMethodConfig[K];
+declare const paymentMethodReducer: (state: PaymentMethodState, reducer: PaymentMethodAction) => PaymentMethodState;
+export default paymentMethodReducer;

package/lib/esm/reducers/PaymentMethodReducer.js

@@ -0,0 +1 @@
+import baseReducer from"../utils/baseReducer";import getErrors,{setErrors}from"../utils/getErrors";import getSdk from"../utils/getSdk";import camelCase from"lodash/camelCase";import has from"lodash/has";import isEmpty from"lodash/isEmpty";export function setLoading({loading,dispatch}){dispatch&&dispatch({type:"setLoading",payload:{loading}})}export const setPaymentRef=({ref,dispatch})=>{ref&&dispatch&&dispatch({type:"setPaymentRef",payload:{currentPaymentMethodRef:ref}})},paymentMethodInitialState={errors:[],paymentMethods:void 0},setPaymentMethodErrors=(errors,dispatch)=>{dispatch&&dispatch({type:"setErrors",payload:{errors}})},getPaymentMethods=async({order,dispatch})=>{const paymentMethods=order.available_payment_methods,paymentMethod=order.payment_method,paymentSource=order.payment_source;dispatch({type:"setPaymentMethods",payload:{paymentMethods,currentPaymentMethodId:paymentMethod?.id,currentPaymentMethodType:paymentMethod?.payment_source_type,paymentSource}})},setPaymentMethod=async({config,dispatch,order,paymentMethodId,updateOrder,setOrderErrors,paymentResource})=>{try{if(config&&order&&dispatch&&paymentResource){localStorage.removeItem("_save_payment_source_to_customer_wallet");const attributes={payment_method:getSdk(config).payment_methods.relationship(paymentMethodId)};updateOrder&&await updateOrder({id:order.id,attributes}),dispatch({type:"setPaymentMethods",payload:{currentPaymentMethodId:paymentMethodId,currentPaymentMethodType:paymentResource,errors:[]}}),setOrderErrors&&setOrderErrors([])}}catch(error){const errors=getErrors(error,"orders",paymentResource);console.error("Set payment method",errors)}},setPaymentSource=async({config,dispatch,getOrder,attributes,order,paymentResource,customerPaymentSourceId,paymentSourceId,updateOrder,errors:currentErrors})=>{try{if(config&&order){let paymentSource;const sdk=getSdk(config);if(customerPaymentSourceId)updateOrder&&await updateOrder({id:order.id,attributes:{_customer_payment_source_id:customerPaymentSourceId}});else{if(paymentSourceId){const attrs={id:paymentSourceId,...attributes};paymentSource=attributes!=null?await sdk[paymentResource].update(attrs):sdk[paymentResource].retrieve(paymentSourceId)}else{const attrs={...attributes,order:sdk.orders.relationship(order.id)};paymentSource=await sdk[paymentResource].create(attrs)}return getOrder&&await getOrder(order.id),dispatch&&dispatch({type:"setPaymentSource",payload:{paymentSource,errors:[]}}),paymentSource}}}catch(error){const errors=getErrors(error,"payment_methods",paymentResource);console.error("Set payment source:",errors),dispatch&&setErrors({currentErrors,newErrors:errors,dispatch})}},updatePaymentSource=async({id,attributes,config,dispatch,paymentResource})=>{if(config)try{const paymentSource=await getSdk(config)[paymentResource].update({id,...attributes});dispatch&&dispatch({type:"setPaymentSource",payload:{paymentSource}})}catch(err){console.error("Update payment source:",err)}},destroyPaymentSource=async({paymentSourceId,paymentResource,dispatch})=>{paymentSourceId&&paymentResource&&dispatch&&dispatch({type:"setPaymentSource",payload:{paymentSource:void 0}})},setPaymentMethodConfig=(config,dispatch)=>{dispatch({type:"setPaymentMethodConfig",payload:{config}})};export function getPaymentConfig(paymentResource,config){const resource=camelCase(paymentResource).replace("Payments","Payment").replace("Transfers","Transfer");return!isEmpty(config)&&has(config,resource)?config[resource]:void 0}const type=["setErrors","setPaymentMethodConfig","setPaymentMethods","setPaymentSource","setPaymentRef","setLoading"],paymentMethodReducer=(state,reducer)=>baseReducer(state,reducer,type);export default paymentMethodReducer;

package/lib/esm/reducers/PlaceOrderReducer.d.ts

@@ -0,0 +1,62 @@
+import { Dispatch, RefObject } from 'react';
+import { BaseError } from '../typings/errors';
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+import { Order } from '@commercelayer/sdk';
+import { PaymentResource } from './PaymentMethodReducer';
+import { PaymentSourceType } from './PaymentMethodReducer';
+export declare type PlaceOrderActionType = 'setErrors' | 'setPlaceOrderPermitted' | 'setButtonRef';
+export declare type PlaceOrderOptions = {
+    paypalPayerId?: string;
+    adyen?: {
+        MD?: string;
+        PaRes?: string;
+        redirectResult?: string;
+    };
+    checkoutCom?: {
+        session_id: string;
+    };
+};
+export interface PlaceOrderActionPayload {
+    errors: BaseError[];
+    isPermitted: boolean;
+    paymentType: PaymentResource;
+    paymentSecret: string;
+    paymentId: string;
+    paymentSource: PaymentSourceType;
+    options?: PlaceOrderOptions;
+    placeOrderButtonRef?: RefObject<HTMLButtonElement>;
+}
+export declare function setButtonRef(ref: RefObject<HTMLButtonElement>, dispatch: Dispatch<PlaceOrderAction>): void;
+export declare type PlaceOrderState = Partial<PlaceOrderActionPayload>;
+export interface PlaceOrderAction {
+    type: PlaceOrderActionType;
+    payload: Partial<PlaceOrderActionPayload>;
+}
+export declare const placeOrderInitialState: PlaceOrderState;
+export interface SetPlaceOrderErrors {
+    <V extends BaseError[]>(errors: V, dispatch?: Dispatch<PlaceOrderAction>): void;
+}
+export declare const setPlaceOrderErrors: SetPlaceOrderErrors;
+declare type PlaceOrderPermitted = (args: {
+    config?: CommerceLayerConfig;
+    dispatch: Dispatch<PlaceOrderAction>;
+    order?: Order;
+    options?: PlaceOrderOptions;
+}) => void;
+export declare const placeOrderPermitted: PlaceOrderPermitted;
+export declare type SetPlaceOrder = (args: {
+    config?: CommerceLayerConfig;
+    order?: Order;
+    state?: PlaceOrderState;
+    setOrderErrors?: (errors: BaseError[]) => void;
+    paymentSource?: PaymentSourceType & {
+        approval_url?: string;
+    };
+    include?: string[];
+    setOrder?: (order: Order) => void;
+}) => Promise<{
+    placed: boolean;
+}>;
+export declare const setPlaceOrder: SetPlaceOrder;
+declare const placeOrderReducer: (state: PlaceOrderState, reducer: PlaceOrderAction) => PlaceOrderState;
+export default placeOrderReducer;

package/lib/esm/reducers/PriceReducer.d.ts

@@ -0,0 +1,37 @@
+import { BaseAction, LoaderType } from '../typings/index';
+import { Price } from '@commercelayer/sdk';
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+import { Dispatch } from 'react';
+import { BaseError } from '../typings/errors';
+export interface Prices {
+    [key: string]: Price | Price[];
+}
+declare type SkuCodesPrice = string[];
+export interface PriceState {
+    loading: boolean;
+    prices: Prices;
+    skuCodes: SkuCodesPrice;
+    errors?: BaseError[];
+    skuCode?: string;
+    setSkuCodes?: typeof setSkuCodes;
+    loader?: LoaderType;
+}
+export interface PriceAction extends BaseAction {
+    type: PriceActionType;
+}
+export declare const priceInitialState: PriceState;
+export declare function setSkuCodes({ skuCodes, dispatch }: {
+    skuCodes: SkuCodesPrice;
+    dispatch?: Dispatch<PriceAction>;
+}): void;
+export declare function getSkusPrice(skuCodes: SkuCodesPrice, { config, dispatch, perPage, filters }: {
+    config: CommerceLayerConfig;
+    dispatch: Dispatch<PriceAction>;
+    perPage: number;
+    filters: Record<string, any>;
+}): void;
+export declare type UnsetPriceState = (dispatch: Dispatch<PriceAction>) => void;
+export declare const unsetPriceState: UnsetPriceState;
+export declare type PriceActionType = 'setLoading' | 'setPrices' | 'setSkuCodes' | 'setErrors';
+declare const priceReducer: (state: PriceState, reducer: PriceAction) => PriceState;
+export default priceReducer;

package/lib/esm/reducers/PriceReducer.js

@@ -0,0 +1 @@
+import getPrices from"../utils/getPrices";import baseReducer from"../utils/baseReducer";import getSdk from"../utils/getSdk";import getErrors from"../utils/getErrors";export const priceInitialState={loading:!0,prices:{},skuCodes:[],errors:[]};export function setSkuCodes({skuCodes,dispatch}){dispatch&&dispatch({type:"setSkuCodes",payload:{skuCodes}})}export function getSkusPrice(skuCodes,{config,dispatch,perPage,filters}){let allPrices={};const sdk=getSdk(config);sdk.prices.list({filters:{sku_code_in:skuCodes.join(","),...filters},pageSize:perPage}).then(async response=>{const pricesObj=getPrices(response);allPrices={...allPrices,...pricesObj},dispatch({type:"setPrices",payload:{prices:allPrices}}),dispatch({type:"setLoading",payload:{loading:!1}});const meta=response.meta;if(meta.pageCount>1)for(let pageNumber=meta.currentPage+1;pageNumber<=meta.pageCount;pageNumber++){const pageResponse=await sdk.prices.list({filters:{sku_code_in:skuCodes.join(","),...filters},pageSize:perPage,pageNumber}),pricesObj2=getPrices(pageResponse);allPrices={...allPrices,...pricesObj2},dispatch({type:"setPrices",payload:{prices:allPrices}})}}).catch(error=>{const errors=getErrors(error,"prices");dispatch({type:"setErrors",payload:{errors}})})}export const unsetPriceState=dispatch=>{dispatch({type:"setPrices",payload:{prices:{}}}),dispatch({type:"setLoading",payload:{loading:!1}})};const typeAction=["setLoading","setPrices","setSkuCodes","setErrors"],priceReducer=(state,reducer)=>baseReducer(state,reducer,typeAction);export default priceReducer;

package/lib/esm/reducers/ShipmentReducer.d.ts

@@ -0,0 +1,38 @@
+import { Dispatch } from 'react';
+import { BaseError } from '../typings/errors';
+import { DeliveryLeadTime, LineItem, Order, Shipment } from '@commercelayer/sdk';
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+import { getOrderContext } from './OrderReducer';
+export declare type ShipmentActionType = 'setErrors' | 'setShipments' | 'setShippingMethod';
+export declare type ShipmentLineItem = LineItem & {
+    line_item: LineItem;
+};
+export interface ShipmentActionPayload {
+    errors: BaseError[];
+    shipments: Shipment[];
+    deliveryLeadTimes: DeliveryLeadTime[];
+}
+export declare type ShipmentState = Partial<ShipmentActionPayload>;
+export interface ShipmentAction {
+    type: ShipmentActionType;
+    payload: Partial<ShipmentActionPayload>;
+}
+export declare const shipmentInitialState: ShipmentState;
+export declare type SetShipmentErrors = <V extends BaseError[]>(errors: V, dispatch?: Dispatch<ShipmentAction>) => void;
+export declare const setShipmentErrors: SetShipmentErrors;
+declare type GetShipments = (args: {
+    order: Order;
+    dispatch: Dispatch<ShipmentAction>;
+    config: CommerceLayerConfig;
+}) => Promise<void>;
+export declare const getShipments: GetShipments;
+declare type SetShippingMethod = (args: {
+    config: CommerceLayerConfig;
+    shipmentId: string;
+    shippingMethodId: string;
+    order?: Order;
+    getOrder?: getOrderContext;
+}) => Promise<void>;
+export declare const setShippingMethod: SetShippingMethod;
+declare const shipmentReducer: (state: ShipmentState, reducer: ShipmentAction) => ShipmentState;
+export default shipmentReducer;

package/lib/esm/reducers/ShippingAddressReducer.d.ts

@@ -0,0 +1,32 @@
+import { Dispatch } from 'react';
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+import { Order } from '@commercelayer/sdk';
+import { getOrderContext } from './OrderReducer';
+import { AddressResource } from './AddressReducer';
+export declare type ShippingAddressActionType = 'setShippingAddress' | 'setShippingCustomerAddressId' | 'cleanup';
+export interface ShippingAddressActionPayload {
+    _shipping_address_clone_id: string;
+    shippingCustomerAddressId: string;
+}
+export declare type ShippingAddressState = Partial<ShippingAddressActionPayload>;
+export interface ShippingAddressAction {
+    type: ShippingAddressActionType;
+    payload: Partial<ShippingAddressActionPayload>;
+}
+export declare const shippingAddressInitialState: ShippingAddressState;
+export declare type SetShippingAddress = (id: string, options?: {
+    config: CommerceLayerConfig;
+    dispatch: Dispatch<ShippingAddressAction>;
+    order?: Order | null;
+    getOrder?: getOrderContext;
+    customerAddressId?: string;
+}) => Promise<void>;
+export declare const setShippingAddress: SetShippingAddress;
+declare type SetShippingCustomerAddressId = (args: {
+    dispatch: Dispatch<ShippingAddressAction>;
+    order: Order;
+    setCloneAddress: (id: string, resource: AddressResource) => void;
+}) => void;
+export declare const setShippingCustomerAddressId: SetShippingCustomerAddressId;
+declare const shippingAddressReducer: (state: ShippingAddressState, reducer: ShippingAddressAction) => ShippingAddressState;
+export default shippingAddressReducer;

package/lib/esm/reducers/SkuListsReducer.d.ts

@@ -0,0 +1,21 @@
+import { Dispatch } from 'react';
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+declare type SkuListsActionType = 'getSkuList' | 'setSkuList';
+export declare type SkuListsState = Partial<{
+    listIds: string[];
+    skuLists: Record<string, any>;
+}>;
+export declare const skuListsInitialState: SkuListsState;
+export interface SkuListsAction {
+    payload: Partial<SkuListsState>;
+    type: SkuListsActionType;
+}
+export declare type GetSkuList = (params: {
+    config: CommerceLayerConfig;
+    dispatch: Dispatch<SkuListsAction>;
+    listIds: string[];
+    state: SkuListsState;
+}) => Promise<void>;
+export declare const getSkuList: GetSkuList;
+declare const skuListsReducer: (state: SkuListsState, reducer: SkuListsAction) => SkuListsState;
+export default skuListsReducer;

package/lib/esm/reducers/SkuReducer.d.ts

@@ -0,0 +1,21 @@
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+import { BaseAction } from '../typings/index';
+import { QueryParamsList, Sku } from '@commercelayer/sdk';
+import { Dispatch } from 'react';
+declare type SkuActionType = 'getSkus' | 'setLoading';
+declare type SkuAction = BaseAction<SkuActionType, SkuState>;
+export declare type SkuState = Partial<{
+    skus: Sku[];
+    loading: boolean;
+    skuCodes: string[];
+}>;
+export declare const skuInitialState: SkuState;
+interface GetSku {
+    config: CommerceLayerConfig;
+    skus: string[];
+    dispatch: Dispatch<SkuAction>;
+    queryParams?: QueryParamsList;
+}
+export declare function getSku<T extends GetSku>({ config, skus, dispatch, queryParams }: T): Promise<void>;
+export default function skuReducer(state: SkuState, reducer: SkuAction): SkuState;
+export {};

package/lib/esm/typings/errors.d.ts

@@ -0,0 +1,51 @@
+import PropTypes from 'prop-types';
+import { ChildrenFunction } from './index';
+export declare type CodeErrorType = 'EMPTY_ERROR' | 'FILTER_NOT_ALLOWED' | 'FORBIDDEN' | 'INTERNAL_SERVER_ERROR' | 'INVALID_DATA_FORMAT' | 'INVALID_FIELD' | 'INVALID_FIELD_FORMAT' | 'INVALID_FIELD_VALUE' | 'INVALID_FILTERS_SYNTAX' | 'INVALID_FILTER_VALUE' | 'INVALID_INCLUDE' | 'INVALID_LINKS_OBJECT' | 'INVALID_PAGE_OBJECT' | 'INVALID_PAGE_VALUE' | 'INVALID_RESOURCE' | 'INVALID_RESOURCE_ID' | 'INVALID_SORT_CRITERIA' | 'INVALID_TOKEN' | 'KEY_NOT_INCLUDED_IN_URL' | 'KEY_ORDER_MISMATCH' | 'LOCKED' | 'NOT_ACCEPTABLE' | 'OUT_OF_STOCK' | 'PARAM_MISSING' | 'PARAM_NOT_ALLOWED' | 'PAYMENT_NOT_APPROVED_FOR_EXECUTION' | 'PAYMENT_INTENT_AUTHENTICATION_FAILURE' | 'RECORD_NOT_FOUND' | 'RECORD_NOT_FOUND' | 'RELATION_EXISTS' | 'NO_SHIPPING_METHODS' | 'SAVE_FAILED' | 'TYPE_MISMATCH' | 'UNAUTHORIZED' | 'UNSUPPORTED_MEDIA_TYPE' | 'VALIDATION_ERROR';
+export declare type ResourceErrorType = 'addresses' | 'billing_address' | 'gift_cards' | 'gift_card_or_coupon_code' | 'line_items' | 'orders' | 'payment_methods' | 'prices' | 'shipments' | 'shipping_address' | 'customer_address' | 'sku_options' | 'variant';
+export interface BaseError {
+    code: CodeErrorType;
+    message: string;
+    resource?: ResourceErrorType | null;
+    field?: string;
+    id?: string;
+    title?: string;
+    detail?: string;
+}
+export declare const REType: ResourceErrorType[];
+export declare const BaseErrorObject: PropTypes.Requireable<PropTypes.InferProps<{
+    code: PropTypes.Validator<NonNullable<CodeErrorType>>;
+    message: PropTypes.Validator<string>;
+    resource: PropTypes.Requireable<ResourceErrorType>;
+    field: PropTypes.Requireable<string>;
+    id: PropTypes.Requireable<string>;
+}>>;
+export declare const ErrorPropTypes: {
+    resource: PropTypes.Validator<NonNullable<ResourceErrorType>>;
+    children: PropTypes.Requireable<(...args: any[]) => any>;
+    field: PropTypes.Requireable<string>;
+};
+declare type ErrorChildrenComponentProps = ChildrenFunction<Omit<ErrorComponentProps, 'children'> & {
+    errors: string[];
+}>;
+export interface ErrorComponentProps {
+    /**
+     * Resource which caused the error
+     */
+    resource: ResourceErrorType;
+    children?: ErrorChildrenComponentProps;
+    /**
+     * Field which caused the error
+     */
+    field?: string;
+    /**
+     * Error message which you can translate
+     */
+    messages?: Array<{
+        code: CodeErrorType;
+        message: string;
+        resource?: ResourceErrorType;
+        field?: string;
+        id?: string;
+    }>;
+}
+export {};

package/lib/esm/typings/errors.js

@@ -0,0 +1 @@
+import PropTypes from"prop-types";const CEType=["EMPTY_ERROR","FILTER_NOT_ALLOWED","FORBIDDEN","INTERNAL_SERVER_ERROR","INVALID_DATA_FORMAT","INVALID_FIELD","INVALID_FIELD_FORMAT","INVALID_FIELD_VALUE","INVALID_FILTERS_SYNTAX","INVALID_FILTER_VALUE","INVALID_INCLUDE","INVALID_LINKS_OBJECT","INVALID_PAGE_OBJECT","INVALID_PAGE_VALUE","INVALID_RESOURCE","INVALID_RESOURCE_ID","INVALID_SORT_CRITERIA","INVALID_TOKEN","KEY_NOT_INCLUDED_IN_URL","KEY_ORDER_MISMATCH","LOCKED","NOT_ACCEPTABLE","PARAM_MISSING","PARAM_NOT_ALLOWED","RECORD_NOT_FOUND","RECORD_NOT_FOUND","RELATION_EXISTS","SAVE_FAILED","TYPE_MISMATCH","UNAUTHORIZED","UNSUPPORTED_MEDIA_TYPE","VALIDATION_ERROR"];export const REType=["gift_cards","line_items","orders","prices","sku_options","variant"],BaseErrorObject=PropTypes.shape({code:PropTypes.oneOf(CEType).isRequired,message:PropTypes.string.isRequired,resource:PropTypes.oneOf(REType),field:PropTypes.string,id:PropTypes.string}),ErrorPropTypes={resource:PropTypes.oneOf(["billing_address","gift_cards","line_items","orders","payment_methods","prices","shipping_address","customer_address","sku_options","variant","shipments"]).isRequired,children:PropTypes.func,field:PropTypes.string};