@commercelayer/react-components 3.15.4 → 3.15.6

package/lib/reducers/CustomerReducer.js

@@ -1 +0,0 @@
-import baseReducer from"../utils/baseReducer";import getSdk from"../utils/getSdk";import getErrors from"../utils/getErrors";export const saveCustomerUser=async({customerEmail,order,updateOrder})=>{if(order){const attributes={customer_email:customerEmail,id:order.id};await updateOrder({id:order.id,attributes})}},setCustomerErrors=(errors,dispatch)=>{dispatch&&dispatch({type:"setErrors",payload:{errors}})},setCustomerEmail=(customerEmail,dispatch)=>{dispatch&&dispatch({type:"setCustomerEmail",payload:{customerEmail}})},getCustomerAddresses=async({config,dispatch})=>{try{const addresses=[];(await getSdk(config).customer_addresses.list({include:["address"]})).forEach(customerAddress=>{customerAddress.address&&addresses.push(customerAddress.address)}),addresses.sort((a,b)=>a.full_name&&b.full_name?a.full_name.localeCompare(b.full_name):0),dispatch({type:"setAddresses",payload:{addresses}})}catch(error){const errors=getErrors(error,"addresses");dispatch({type:"setErrors",payload:{errors}})}},getCustomerPaymentSources=async({dispatch,order})=>{order?.available_customer_payment_sources&&dispatch({type:"setPayments",payload:{payments:order.available_customer_payment_sources}})},customerInitialState={errors:[],addresses:[],payments:[]};const type=["setErrors","setCustomerEmail","setAddresses","setPayments"],customerReducer=(state,reducer)=>baseReducer(state,reducer,type);export default customerReducer;

package/lib/reducers/ItemReducer.d.ts

@@ -1,69 +0,0 @@
-import { BaseUnsetState } from '../typings/index';
-import { Price } from '@commercelayer/sdk';
-import { Dispatch } from 'react';
-import { SkuInventory } from './AvailabilityReducer';
-export interface Items {
-    [skuCode: string]: SkuInventory;
-}
-export interface ItemPrices {
-    [skuCode: string]: Price;
-}
-export interface ItemQuantity {
-    [skuCode: string]: number;
-}
-export interface ItemOption {
-    [key: string]: {
-        skuOptionId: string;
-        options: {
-            [key: string]: string;
-        };
-    };
-}
-export interface ItemOptions {
-    [skuCode: string]: ItemOption;
-}
-export declare type CustomLineItem = {
-    name?: string;
-    imageUrl?: string | null;
-};
-export interface CustomLineItems {
-    [skuCode: string]: CustomLineItem;
-}
-declare type ItemParams = {
-    type: ItemActionType;
-    key: 'items' | 'item' | 'quantity' | 'option' | 'prices' | 'lineItem' | 'lineItems' | 'skuCode';
-};
-declare type DataType = Items | ItemQuantity | ItemOptions | ItemPrices | CustomLineItems | CustomLineItem | string;
-export interface SetItemState {
-    (data: DataType, params: ItemParams, dispatch: Dispatch<ItemAction>): void;
-}
-export declare const setItemState: SetItemState;
-export declare const unsetItemState: BaseUnsetState<ItemAction>;
-export declare type SetCustomLineItems = (lineItems: CustomLineItems) => void;
-export declare type SetCustomLineItem = (lineItem: CustomLineItem) => void;
-export interface ItemState {
-    skuCode?: string;
-    items?: Items;
-    item?: Items;
-    lineItems?: CustomLineItems;
-    lineItem?: CustomLineItem;
-    quantity?: ItemQuantity;
-    option?: ItemOptions;
-    prices?: ItemPrices;
-    setItems?: (items: Items) => void;
-    setItem?: (item: Items) => void;
-    setQuantity?: (quantity: ItemQuantity) => void;
-    setOption?: (option: ItemOptions) => void;
-    setPrices?: (prices: ItemPrices) => void;
-    setSkuCode?: (skuCode: string) => void;
-    setCustomLineItems: SetCustomLineItems;
-    setCustomLineItem?: SetCustomLineItem;
-}
-declare type ItemActionType = 'setItem' | 'setItems' | 'setQuantity' | 'setOption' | 'setPrices' | 'setCustomLineItems' | 'setCustomLineItem' | 'setSkuCode';
-export interface ItemAction {
-    type: ItemActionType;
-    payload: Partial<ItemState>;
-}
-export declare const itemInitialState: Partial<ItemState>;
-declare const itemReducer: (state: Partial<ItemState>, reducer: ItemAction) => Partial<ItemState>;
-export default itemReducer;

package/lib/reducers/ItemReducer.js

@@ -1 +0,0 @@
-import baseReducer from"../utils/baseReducer";export const setItemState=(data,params,dispatch)=>{dispatch({type:params.type,payload:{[`${params.key}`]:data}})},unsetItemState=dispatch=>{dispatch({type:"setItem",payload:{item:{}}}),dispatch({type:"setItems",payload:{items:{}}}),dispatch({type:"setQuantity",payload:{quantity:{}}}),dispatch({type:"setOption",payload:{option:{}}}),dispatch({type:"setCustomLineItems",payload:{lineItems:{}}}),dispatch({type:"setCustomLineItem",payload:{lineItem:{}}})};const actionType=["setItem","setItems","setQuantity","setOption","setPrices","setCustomLineItems","setCustomLineItem","setSkuCode"];export const itemInitialState={items:{},item:{},quantity:{},option:{},prices:{},lineItems:{},lineItem:{},skuCode:""};const itemReducer=(state,reducer)=>baseReducer(state,reducer,actionType);export default itemReducer;

package/lib/reducers/OrderReducer.d.ts

@@ -1,147 +0,0 @@
-import { Dispatch } from 'react';
-import { SetLocalOrder, DeleteLocalOrder } from '../utils/localStorage';
-import { CommerceLayerConfig } from '../context/CommerceLayerContext';
-import { ItemOption, CustomLineItem } from './ItemReducer';
-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 interface GetOrder {
-    (params: GetOrderParams): Promise<void | Order>;
-}
-declare type CreateOrderParams = Pick<AddToCartParams, 'config' | 'dispatch' | 'persistKey' | 'state' | 'orderMetadata' | 'orderAttributes' | 'setLocalOrder'>;
-export interface CreateOrder {
-    (params?: CreateOrderParams): Promise<string>;
-}
-export declare type AddToCartParams = Partial<{
-    bundleCode: string;
-    skuCode: string;
-    persistKey: string;
-    config: CommerceLayerConfig;
-    dispatch: Dispatch<OrderActions>;
-    state: Partial<OrderState>;
-    skuId: string;
-    quantity: number;
-    option: ItemOption;
-    lineItem: CustomLineItem;
-    orderMetadata: BaseMetadataObject;
-    orderAttributes: Record<string, any>;
-    errors: BaseError[];
-    setLocalOrder: SetLocalOrder;
-    buyNowMode: boolean;
-    checkoutUrl: 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 interface AddToCart {
-    (params: AddToCartParams): AddToCartReturn;
-}
-export interface AddToCartImport {
-    (params: AddToCartImportParams): AddToCartReturn;
-}
-export interface 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' | '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 AddToCartValues = Pick<AddToCartParams, 'bundleCode' | 'lineItem' | 'quantity' | 'skuCode' | 'skuId' | 'option' | 'buyNowMode' | 'checkoutUrl'>;
-export declare type AddToCartImportValues = Pick<AddToCartImportParams, 'lineItems'>;
-export declare type getOrderContext = (id: string) => Promise<void | 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 declare type 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?: undefined;
-} | {
-    success: boolean;
-    error: unknown;
-}>;
-export declare const setOrder: (order: Order, dispatch?: Dispatch<OrderActions>) => void;
-export declare type 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 declare const addToCart: AddToCart;
-export declare const unsetOrderState: UnsetOrderState;
-declare type 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/reducers/OrderReducer.js

@@ -1 +0,0 @@
-import{setCustomerOrderParam}from"../utils/localStorage";import baseReducer from"../utils/baseReducer";import isEmpty from"lodash/isEmpty";import size from"lodash/size";import map from"lodash/map";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"||order.status==="approved"||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=>{payload.includeLoaded={...payload.includeLoaded,[resource]:!0}})}else delete payload.include;payload.includeLoaded={...resourceIncludedLoaded,...newResourceLoaded,...payload.includeLoaded&&payload.includeLoaded},dispatch&&dispatch({type:"setIncludesResource",payload:{...payload,withoutIncludes:!1}})}export const addToCart=async params=>{const{skuCode,bundleCode,skuId,quantity,option,config,dispatch,lineItem,state,errors=[],buyNowMode,checkoutUrl}=params;try{if(!config)throw{errors:[{code:"INVALID_RESOURCE",resource:"orders",title:"Markup error",message:"You are trying to place an order outside the OrderContainer component"}]};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}=await sdk.orders.retrieve(id,{fields:["line_items"],include:["line_items"]});line_items&&line_items?.length>0&&await Promise.all(line_items.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};skuId&&(attrs.item=sdk.skus.relationship(skuId));const newLineItem=await sdk.line_items.create(attrs);if(isEmpty(option))await getApiOrder({id,...params,state});else{let c=0;map(option,async opt=>{const{options,skuOptionId}=opt,skuOption=sdk.sku_options.relationship(skuOptionId),lineItemRel=sdk.line_items.relationship(newLineItem.id),lineItemOptionsAttributes={quantity:1,options,sku_option:skuOption,line_item:lineItemRel};await sdk.line_item_options.create(lineItemOptionsAttributes),c+=1,c===size(option)&&await getApiOrder({id,...params})})}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,orderId:void 0}}catch(error){const errors2=getErrors(error,"orders");return console.error("Add to cart",errors2),dispatch&&setErrors({currentErrors:state?.errors,newErrors:errors2,dispatch}),{success:!1,orderId:void 0}}},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}`;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/reducers/PaymentMethodReducer.d.ts

@@ -1,152 +0,0 @@
-import { AdyenPaymentConfig } from '../components/AdyenPayment';
-import { BraintreeConfig } from '../components/BraintreePayment';
-import { PaypalConfig } from '../components/PaypalPayment';
-import { StripeConfig } from '../components/StripePayment';
-import { WireTransferConfig } from '../components/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/CheckoutComPayment';
-export declare type PaymentSourceType = AdyenPayment | BraintreePayment | CheckoutComPayment | ExternalPayment | PaypalPayment | StripePayment | WireTransfer;
-declare type Card = {
-    type: string;
-    brand: string;
-    last4: string;
-    exp_year: number;
-    exp_month: number;
-};
-export declare type 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 interface 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 | void>;
-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 declare type 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/reducers/PaymentMethodReducer.js

@@ -1 +0,0 @@
-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:[]},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/reducers/PriceReducer.d.ts

@@ -1,44 +0,0 @@
-import { BaseAction, LoaderType } from '../typings/index';
-import { Price } from '@commercelayer/sdk';
-import { CommerceLayerConfig } from '../context/CommerceLayerContext';
-import { Dispatch } from 'react';
-import { ItemPrices } from './ItemReducer';
-import { BaseError } from '../typings/errors';
-export interface Prices {
-    [key: string]: Price | Price[];
-}
-declare type SkuCodesPrice = string[];
-export interface SetSkuCodesPrice {
-    (skuCodes: SkuCodesPrice): void;
-}
-export interface PriceState {
-    loading: boolean;
-    prices: Prices;
-    skuCodes: SkuCodesPrice;
-    errors?: BaseError[];
-    skuCode?: string;
-    setSkuCodes?: SetSkuCodesPrice;
-    loader?: LoaderType;
-}
-export interface PriceAction extends BaseAction {
-    type: PriceActionType;
-}
-export declare const priceInitialState: PriceState;
-export interface GetSkusPrice {
-    (skuCodes: SkuCodesPrice, options: {
-        config: CommerceLayerConfig;
-        dispatch: Dispatch<PriceAction>;
-        setPrices: ((item: ItemPrices) => void) | undefined;
-        prices: ItemPrices;
-        perPage: number;
-        filters: Record<string, any>;
-    }): void;
-}
-export declare const getSkusPrice: GetSkusPrice;
-export interface 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/reducers/PriceReducer.js

@@ -1 +0,0 @@
-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:[]},getSkusPrice=(skuCodes,{config,dispatch,setPrices,prices,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,...prices,...pricesObj},setPrices&&setPrices(allPrices),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},setPrices&&setPrices(allPrices),dispatch({type:"setPrices",payload:{prices:allPrices}})}}).catch(error=>{const errors=getErrors(error,"prices");dispatch({type:"setErrors",payload:{errors}})})},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/reducers/ShipmentReducer.d.ts

@@ -1,40 +0,0 @@
-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 interface 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/reducers/SkuOptionsReducer.d.ts

@@ -1,26 +0,0 @@
-import { Dispatch } from 'react';
-import { SkuOption } from '@commercelayer/sdk';
-import { BaseUnsetState } from '../typings/index';
-import { BaseError } from '../typings/errors';
-export interface SkuOptionsState {
-    skuCode?: string;
-    skuOptions?: SkuOption[];
-    errors?: BaseError[];
-}
-interface GetSkuOptionsParams {
-    dispatch: Dispatch<SkuOptionsAction>;
-    skuOptions?: SkuOption[];
-}
-export interface GetSkuOptions {
-    (params: GetSkuOptionsParams): void;
-}
-export declare const getSkuOptions: GetSkuOptions;
-export declare const unsetSkuOptionsState: BaseUnsetState<SkuOptionsAction>;
-export declare type SkuOptionsActionType = 'setSkuOptions' | 'setErrors';
-export interface SkuOptionsAction {
-    type: SkuOptionsActionType;
-    payload: SkuOptionsState;
-}
-export declare const skuOptionsInitialState: SkuOptionsState;
-declare const skuOptionsReducer: (state: SkuOptionsState, reducer: SkuOptionsAction) => SkuOptionsState;
-export default skuOptionsReducer;

package/lib/reducers/SkuOptionsReducer.js

@@ -1 +0,0 @@
-import baseReducer from"../utils/baseReducer";export const getSkuOptions=async params=>{const{skuOptions,dispatch}=params;dispatch({type:"setSkuOptions",payload:{skuOptions}})},unsetSkuOptionsState=dispatch=>{dispatch({type:"setSkuOptions",payload:{skuOptions:[]}}),dispatch({type:"setErrors",payload:{errors:[]}})};const actionType=["setSkuOptions","setErrors"];export const skuOptionsInitialState={skuCode:"",skuOptions:[]};const skuOptionsReducer=(state,reducer)=>baseReducer(state,reducer,actionType);export default skuOptionsReducer;

package/lib/reducers/SkuReducer.d.ts

@@ -1,21 +0,0 @@
-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;
-declare type 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/reducers/VariantReducer.d.ts

@@ -1,72 +0,0 @@
-import { Sku } from '@commercelayer/sdk';
-import { VariantOption } from '../components/VariantSelector';
-import { Dispatch } from 'react';
-import { CommerceLayerConfig } from '../context/CommerceLayerContext';
-import { Items, CustomLineItem, SetCustomLineItems } from './ItemReducer';
-import { BaseError } from '../typings/errors';
-declare type SetSkuCodeVariantParams = {
-    code: string;
-    id: string;
-    config: CommerceLayerConfig;
-    dispatch: Dispatch<VariantAction>;
-    setItem: ((item: Items) => void) | undefined;
-    setItemSkuCode?: ((skuCode: string) => void) | undefined;
-};
-export interface SetSkuCodeVariant {
-    (params: SetSkuCodeVariantParams): void;
-}
-declare type SetVariantSkuCodesParams = {
-    skuCodes: VariantOption[];
-    dispatch: Dispatch<VariantAction>;
-    setCustomLineItems?: SetCustomLineItems;
-};
-export interface SetVariantSkuCodes {
-    (params: SetVariantSkuCodesParams): void;
-}
-export interface VariantsObject {
-    [key: string]: Sku;
-}
-export declare type SetSkuCode = (code: string, id: string, lineItem?: CustomLineItem) => void;
-export interface VariantPayload {
-    loading?: boolean;
-    variants?: VariantsObject | Record<string, any>;
-    skuCodes?: string[];
-    skuCode?: string;
-    errors?: BaseError[];
-    currentSkuId?: string;
-    currentSkuInventory?: any;
-    currentQuantity?: number;
-    currentPrices?: Sku[];
-    setSkuCode?: SetSkuCode;
-    setSkuCodes?: (skuCodes: VariantOption[]) => void;
-}
-export interface VariantState extends VariantPayload {
-    skuCodes: string[];
-    variants: VariantsObject | Record<string, any>;
-}
-export interface VariantAction {
-    type: VariantActionType;
-    payload: VariantPayload;
-}
-export declare const setVariantSkuCodes: SetVariantSkuCodes;
-export interface UnsetVariantState {
-    (dispatch: Dispatch<VariantAction>): void;
-}
-export declare const setSkuCode: SetSkuCodeVariant;
-declare type GetVariantsParams = {
-    config: CommerceLayerConfig;
-    state: VariantState;
-    skuCode: string;
-    dispatch: Dispatch<VariantAction>;
-    filters: Record<string, any>;
-    setItem: ((item: Items) => void) | undefined;
-};
-export interface GetVariants {
-    (params: GetVariantsParams): void;
-}
-export declare const getVariants: GetVariants;
-export declare const unsetVariantState: UnsetVariantState;
-export declare const variantInitialState: VariantState;
-export declare type VariantActionType = 'setLoading' | 'setVariants' | 'setSkuCodes' | 'setSkuCode' | 'setCurrentSkuId' | 'setCurrentSkuInventory' | 'setCurrentPrices' | 'setErrors';
-declare const variantReducer: (state: VariantState, reducer: VariantAction) => VariantState;
-export default variantReducer;

package/lib/reducers/VariantReducer.js

@@ -1 +0,0 @@
-import baseReducer from"../utils/baseReducer";import getSkus from"../utils/getSkus";import{isEmpty,has}from"lodash";import getSdk from"../utils/getSdk";export const setVariantSkuCodes=({skuCodes,dispatch,setCustomLineItems})=>{const lineItems={},sCodes=skuCodes.map(s=>(has(s,"lineItem")&&(lineItems[s.code]=s.lineItem),s.code));isEmpty(lineItems)||setCustomLineItems&&setCustomLineItems(lineItems),dispatch({type:"setSkuCodes",payload:{skuCodes:sCodes}})},setSkuCode=params=>{const{id,code,config,setItem,dispatch,setItemSkuCode}=params;id&&getSdk(config).skus.retrieve(id,{include:["sku_options"]}).then(sku=>{setItem&&setItem({[`${code}`]:sku}),setItemSkuCode&&setItemSkuCode(code)}).catch(errors=>{dispatch({type:"setErrors",payload:{errors}})})},getVariants=params=>{const{config,state,skuCode,dispatch,setItem,filters}=params;getSdk(config).skus.list({filters:{code_in:state.skuCodes.join(","),...filters}}).then(skus=>{const skusObj=getSkus(skus,state.skuCodes);skuCode&&setSkuCode({code:skusObj[skuCode].code,id:skusObj[skuCode].id,config,dispatch,setItem}),dispatch({type:"setVariants",payload:{variants:skusObj}}),dispatch({type:"setLoading",payload:{loading:!1}})}).catch(errors=>{dispatch({type:"setErrors",payload:{errors}})})},unsetVariantState=dispatch=>{dispatch({type:"setSkuCode",payload:{skuCode:""}}),dispatch({type:"setVariants",payload:{variants:{}}}),dispatch({type:"setLoading",payload:{loading:!1}})},variantInitialState={loading:!1,variants:{},skuCodes:[],skuCode:"",errors:[],currentSkuId:"",currentSkuInventory:{available:!1,quantity:0,levels:[]},currentQuantity:1,currentPrices:[]};const actionType=["setLoading","setVariants","setSkuCodes","setSkuCode","setCurrentSkuId","setCurrentSkuInventory","setCurrentPrices","setErrors"],variantReducer=(state,reducer)=>baseReducer(state,reducer,actionType);export default variantReducer;