@commercelayer/react-components 2.53.1 → 3.0.0-alpha.1

package/lib/reducers/AddressReducer.d.ts

@@ -0,0 +1,60 @@
+import { Dispatch } from 'react';
+import { BaseError, ResourceErrorType } from '../typings/errors';
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+import type { Address, AddressCreate, Order } from '@commercelayer/sdk';
+import { updateOrder } from './OrderReducer';
+import { TCustomerAddress } from './CustomerReducer';
+export declare type AddressActionType = 'setErrors' | 'setAddress' | 'setShipToDifferentAddress' | 'setCloneAddress' | 'cleanup';
+export declare type AddressField = 'city' | 'company' | 'country_code' | 'first_name' | 'last_name' | 'line_1' | 'line_2' | 'phone' | 'state_code' | 'zip_code' | 'billing_info';
+export declare type AddressFieldView = AddressField | 'full_address' | 'full_name';
+export declare const addressFields: AddressField[];
+export declare type AddressResource = Extract<ResourceErrorType, 'billing_address' | 'shipping_address'>;
+export declare type AddressSchema = Address;
+export interface AddressActionPayload {
+    errors: BaseError[];
+    billing_address: TCustomerAddress;
+    shipping_address: AddressCreate;
+    shipToDifferentAddress: boolean;
+    billingAddressId: string;
+    shippingAddressId: string;
+    isBusiness: boolean;
+}
+export declare type AddressState = Partial<AddressActionPayload>;
+export interface AddressAction {
+    type: AddressActionType;
+    payload: Partial<AddressActionPayload>;
+}
+export declare const addressInitialState: AddressState;
+export interface SetAddressErrors {
+    <V extends BaseError[]>(args: {
+        errors: V;
+        resource: Extract<ResourceErrorType, 'billing_address' | 'shipping_address'>;
+        dispatch?: Dispatch<AddressAction>;
+        currentErrors?: V;
+    }): void;
+}
+export declare type SetAddressParams<V extends AddressSchema> = {
+    values: V;
+    resource: AddressResource;
+    dispatch?: Dispatch<AddressAction>;
+};
+export interface SetAddress {
+    <V extends AddressSchema>(params: SetAddressParams<V>): void;
+}
+export interface SaveAddresses {
+    (params: {
+        orderId?: string;
+        order?: Order | null;
+        updateOrder?: typeof updateOrder;
+        config: CommerceLayerConfig;
+        state: AddressState;
+        dispatch: Dispatch<AddressAction>;
+    }): Promise<void>;
+}
+export declare const setAddressErrors: SetAddressErrors;
+export declare const setAddress: SetAddress;
+declare type SetCloneAddress = (id: string, resource: AddressResource, dispatch: Dispatch<AddressAction>) => void;
+export declare const setCloneAddress: SetCloneAddress;
+export declare const saveAddresses: SaveAddresses;
+declare const addressReducer: (state: AddressState, reducer: AddressAction) => AddressState;
+export default addressReducer;

package/lib/reducers/AddressReducer.js

@@ -0,0 +1 @@
+import baseReducer from"../utils/baseReducer";import isEmpty from"lodash/isEmpty";import getSdk from"../utils/getSdk";import camelCase from"lodash/camelCase";export const addressFields=["city","company","country_code","first_name","last_name","line_1","line_2","phone","state_code","zip_code"],addressInitialState={errors:[]},setAddressErrors=({errors,dispatch,currentErrors=[],resource})=>{const billingErrors=resource==="billing_address"?errors.filter(e=>e.resource===resource):currentErrors.filter(e=>e.resource==="billing_address"),shippingErrors=resource==="shipping_address"?errors.filter(e=>e.resource===resource):currentErrors.filter(e=>e.resource==="shipping_address"),finalErrors=[...billingErrors,...shippingErrors];dispatch&&dispatch({type:"setErrors",payload:{errors:finalErrors}})},setAddress=({values,resource,dispatch})=>{dispatch&&dispatch({type:"setAddress",payload:{[`${resource}`]:values}})},setCloneAddress=(id,resource,dispatch)=>{dispatch({type:"setCloneAddress",payload:{[`${camelCase(resource)}Id`]:id}})},saveAddresses=async({config,updateOrder,order,state})=>{var _a,_b,_c;const{shipToDifferentAddress,billing_address,shipping_address,billingAddressId,shippingAddressId}=state;try{const sdk=getSdk(config);if(order){const currentBillingAddressRef=(_a=order?.billing_address)===null||_a===void 0?void 0:_a.reference,orderAttributes={id:order?.id,_billing_address_clone_id:billingAddressId,_shipping_address_clone_id:billingAddressId};if(currentBillingAddressRef===billingAddressId&&(orderAttributes._billing_address_clone_id=(_b=order?.billing_address)===null||_b===void 0?void 0:_b.id,orderAttributes._shipping_address_clone_id=(_c=order?.shipping_address)===null||_c===void 0?void 0:_c.id),!isEmpty(billing_address)&&billing_address){delete orderAttributes._billing_address_clone_id,delete orderAttributes._shipping_address_clone_id,orderAttributes._shipping_address_same_as_billing=!0;const address=await sdk.addresses.create(billing_address);orderAttributes.billing_address=sdk.addresses.relationship(address.id)}if(shipToDifferentAddress&&(delete orderAttributes._shipping_address_same_as_billing,shippingAddressId&&(orderAttributes._shipping_address_clone_id=shippingAddressId),!isEmpty(shipping_address)&&shipping_address)){delete orderAttributes._shipping_address_clone_id;const address=await sdk.addresses.create(shipping_address);orderAttributes.shipping_address=sdk.addresses.relationship(address.id)}!isEmpty(orderAttributes)&&updateOrder&&await updateOrder({id:order.id,attributes:orderAttributes})}}catch(error){console.error(error)}};const type=["setErrors","setAddress","setShipToDifferentAddress","setCloneAddress","cleanup"],addressReducer=(state,reducer)=>baseReducer(state,reducer,type);export default addressReducer;

package/lib/reducers/AvailabilityReducer.d.ts

@@ -0,0 +1,61 @@
+import { BaseError } from '../typings/errors';
+import { Sku } from '@commercelayer/sdk';
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+import { Dispatch } from 'react';
+import { Items } from './ItemReducer';
+export declare type DeliveryLeadTime = {
+    shipping_method: {
+        name: string;
+        reference: string;
+        price_amount_cents: number;
+        free_over_amount_cents: number;
+        formatted_price_amount: string;
+        formatted_free_over_amount: string;
+    };
+    min: LeadTimes;
+    max: LeadTimes;
+};
+declare type Level = {
+    delivery_lead_times: Partial<DeliveryLeadTime>[];
+    quantity: number;
+};
+declare type Inventory = {
+    inventory: {
+        available: boolean;
+        quantity: number;
+        levels: Level[];
+    };
+};
+export declare type SkuInventory = Sku & Inventory;
+export declare type LeadTimes = {
+    hours: number;
+    days: number;
+};
+export declare type AvailabilityPayload = {
+    quantity?: number | null;
+    errors?: BaseError[];
+} & Partial<DeliveryLeadTime>;
+export declare type AvailabilityState = AvailabilityPayload;
+export interface AvailabilityAction {
+    type: AvailabilityActionType;
+    payload: AvailabilityPayload;
+}
+export declare const availabilityInitialState: AvailabilityState;
+declare type GetAvailability = (args: {
+    skuCode: string;
+    dispatch: Dispatch<AvailabilityAction>;
+    config: CommerceLayerConfig;
+    setItem?: (item: Items) => void;
+    item?: Items;
+}) => void;
+export declare const getAvailability: GetAvailability;
+declare type GetAvailabilityArgs = {
+    skusIds: string[];
+    dispatch: Dispatch<AvailabilityAction>;
+    config: CommerceLayerConfig;
+    setItem?: (item: Items) => void;
+};
+export declare function getAvailabilityByIds({ skusIds, config, setItem, }: GetAvailabilityArgs): Promise<void>;
+export declare type AvailabilityActionType = 'setAvailability' | 'setErrors';
+declare const availabilityReducer: (state: AvailabilityState, reducer: AvailabilityAction) => AvailabilityState;
+export default availabilityReducer;

package/lib/reducers/AvailabilityReducer.js

@@ -0,0 +1 @@
+import baseReducer from"../utils/baseReducer";import getSdk from"../utils/getSdk";export const availabilityInitialState={quantity:null,min:{days:0,hours:0},max:{days:0,hours:0},errors:[]},getAvailability=async({skuCode,dispatch,config,setItem,item})=>{var _a;const sdk=getSdk(config);try{const[sku]=await sdk.skus.list({fields:{skus:["id"]},filters:{code_in:skuCode}});if(sku){const skuInventory=await sdk.skus.retrieve(sku.id,{fields:{skus:["inventory"]}}),[level]=((_a=skuInventory.inventory)===null||_a===void 0?void 0:_a.levels)||[],[delivery]=level?.delivery_lead_times||[];dispatch({type:"setAvailability",payload:Object.assign(Object.assign({},delivery),{quantity:skuInventory.inventory.quantity})}),setItem&&setItem(Object.assign(Object.assign({},item),{[skuCode]:skuInventory}))}}catch(error){console.error("Get SKU availability",error)}};export async function getAvailabilityByIds({skusIds,config,setItem}){const sdk=getSdk(config);try{const inventories=await Promise.all(skusIds.map(async id=>await sdk.skus.retrieve(id,{fields:{skus:["inventory","code"]}}))),item={};inventories.forEach(v=>{v?.code&&(item[v.code]=v)}),setItem&&setItem(item)}catch(error){console.error("Get SKU availability",error)}}const typeAction=["setAvailability","setErrors"],availabilityReducer=(state,reducer)=>baseReducer(state,reducer,typeAction);export default availabilityReducer;

package/lib/reducers/BillingAddressReducer.js

@@ -0,0 +1 @@
+import baseReducer from"../utils/baseReducer";import getSdk from"../utils/getSdk";export const billingAddressInitialState={_billing_address_clone_id:""},setBillingAddress=async(id,options)=>{try{if(options?.order){if(options.customerAddressId){const sdk=getSdk(options.config),attributes={id,reference:options.customerAddressId};await sdk.addresses.update(attributes)}options.dispatch({type:"setBillingAddress",payload:{_billing_address_clone_id:id}})}}catch(error){console.error("Set billing address",error)}},setBillingCustomerAddressId=async({dispatch,order,setCloneAddress})=>{var _a;const customerAddressId=(_a=order?.billing_address)===null||_a===void 0?void 0:_a.reference;try{customerAddressId&&(dispatch({type:"setBillingCustomerAddressId",payload:{billingCustomerAddressId:customerAddressId}}),setCloneAddress(customerAddressId,"billing_address"))}catch(error){console.error("error",error)}};const type=["setBillingAddress","setBillingCustomerAddressId","cleanup"],billingAddressReducer=(state,reducer)=>baseReducer(state,reducer,type);export default billingAddressReducer;

package/lib/reducers/CustomerReducer.d.ts

@@ -0,0 +1,131 @@
+import { Dispatch } from 'react';
+import { BaseError } from '../typings/errors';
+import type { Address, AddressCreate, AddressUpdate, Customer, CustomerPaymentSource, Order } from '@commercelayer/sdk';
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+import { updateOrder } from './OrderReducer';
+export declare type CustomerActionType = 'setErrors' | 'setCustomerEmail' | 'setAddresses' | 'setPayments' | 'setOrders';
+export declare type CustomerActionPayload = {
+    addresses: Address[];
+    payments: CustomerPaymentSource[];
+    customerEmail: string;
+    errors: BaseError[];
+    orders: Order[];
+    isGuest: boolean;
+    customers: Customer;
+};
+export declare type CustomerState = Partial<CustomerActionPayload>;
+export interface CustomerAction {
+    type: CustomerActionType;
+    payload: Partial<CustomerActionPayload>;
+}
+export declare type SetSaveOnBlur = (args: {
+    saveOnBlur: boolean;
+    dispatch: Dispatch<CustomerAction>;
+}) => void;
+export declare type SaveCustomerUser = {
+    /**
+     * The Commerce Layer Config
+     */
+    config: CommerceLayerConfig;
+    /**
+     * The customer email
+     */
+    customerEmail: string;
+    /**
+     * The Customer dispatch function
+     */
+    dispatch: Dispatch<CustomerAction>;
+    /**
+     * The Commerce Layer Order resource
+     */
+    order?: Order;
+    /**
+     * The function to update the order resource
+     */
+    updateOrder: typeof updateOrder;
+};
+export declare function saveCustomerUser({ customerEmail, order, updateOrder, }: SaveCustomerUser): Promise<void>;
+export interface SetCustomerErrors {
+    <V extends BaseError[]>(errors: V, dispatch?: Dispatch<CustomerAction>): void;
+}
+export declare function setCustomerErrors(
+/**
+ * @param errors - An array of errors
+ */
+errors: BaseError[], 
+/**
+ * @param dispatch - The dispatch function
+ */
+dispatch?: Dispatch<CustomerAction>): void;
+export declare function setCustomerEmail(
+/**
+ * @param customerEmail The email address of the customer
+ */
+customerEmail: string, 
+/**
+ * @param dispatch The dispatch function
+ */
+dispatch?: Dispatch<CustomerAction>): void;
+export declare type GetCustomerAddresses = {
+    /**
+     * The Commerce Layer config
+     */
+    config: CommerceLayerConfig;
+    /**
+     * The Customer dispatch function
+     */
+    dispatch: Dispatch<CustomerAction>;
+};
+export declare function getCustomerAddresses({ config, dispatch, }: GetCustomerAddresses): Promise<void>;
+export declare type DeleteCustomerAddress = {
+    config?: CommerceLayerConfig;
+    dispatch?: Dispatch<CustomerAction>;
+    customerAddressId: string;
+    addresses?: Address[];
+};
+export declare function deleteCustomerAddress({ config, dispatch, customerAddressId, addresses, }: DeleteCustomerAddress): Promise<void>;
+export declare type GetCustomerPaymentSources = {
+    /**
+     * The Customer dispatch function
+     */
+    dispatch?: Dispatch<CustomerAction>;
+    /**
+     * The Commerce Layer Order resource
+     */
+    order?: Order;
+};
+export declare function getCustomerPaymentSources(params?: GetCustomerPaymentSources): void;
+export declare type GetCustomerOrders = (params: {
+    /**
+     * The Commerce Layer config
+     */
+    config: CommerceLayerConfig;
+    /**
+     * The Customer dispatch function
+     */
+    dispatch: Dispatch<CustomerAction>;
+}) => Promise<void>;
+export declare const getCustomerOrders: GetCustomerOrders;
+export declare type TCustomerAddress = AddressCreate & AddressUpdate;
+declare type TCreateCustomerAddress = {
+    /**
+     * Customer address dispatch function
+     */
+    dispatch?: Dispatch<CustomerAction>;
+    /**
+     * The Commerce Layer Config
+     */
+    config?: CommerceLayerConfig;
+    /**
+     * The address to create or update if there is an id
+     */
+    address: TCustomerAddress;
+    /**
+     * Current state of the customer
+     */
+    state?: CustomerState;
+};
+export declare function createCustomerAddress({ address, config, dispatch, state, }: TCreateCustomerAddress): Promise<void>;
+export declare const customerInitialState: CustomerState;
+declare const customerReducer: (state: CustomerState, reducer: CustomerAction) => CustomerState;
+export default customerReducer;

package/lib/reducers/CustomerReducer.js

@@ -0,0 +1 @@
+import baseReducer from"../utils/baseReducer";import getSdk from"../utils/getSdk";import getErrors from"../utils/getErrors";import jwtDecode from"../utils/jwt";export async function saveCustomerUser({customerEmail,order,updateOrder}){if(order){const attributes={customer_email:customerEmail,id:order.id};await updateOrder({id:order.id,attributes})}}export function setCustomerErrors(errors,dispatch){dispatch&&dispatch({type:"setErrors",payload:{errors}})}export function setCustomerEmail(customerEmail,dispatch){dispatch&&dispatch({type:"setCustomerEmail",payload:{customerEmail}})}export async function getCustomerAddresses({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}})}}export async function deleteCustomerAddress({config,dispatch,customerAddressId,addresses}){if(config&&addresses&&dispatch&&config)try{await getSdk(config).customer_addresses.delete(customerAddressId);const newAddresses=addresses.filter(({reference})=>reference!==customerAddressId);dispatch({type:"setAddresses",payload:{addresses:newAddresses}})}catch{throw new Error("Couldn't delete address")}}export function getCustomerPaymentSources(params){if(params){const{order,dispatch}=params;order?.available_customer_payment_sources&&dispatch&&dispatch({type:"setPayments",payload:{payments:order.available_customer_payment_sources}})}}export const getCustomerOrders=async({config,dispatch})=>{var _a;if(config.accessToken){const{owner}=jwtDecode(config.accessToken);if(owner?.id){const customers=await getSdk(config).customers.retrieve(owner.id,{include:["orders"]}),orders=(_a=customers.orders)===null||_a===void 0?void 0:_a.filter(order=>order.status!=="pending"&&order.status!=="draft");dispatch({type:"setOrders",payload:{orders,customers}})}}};export async function createCustomerAddress({address,config,dispatch,state}){var _a,_b,_c;if(config&&address){const sdk=getSdk(config),{id}=address;try{if(id){const upAddress=await sdk.addresses.update(address),updatedAddresses=(_a=state?.addresses)===null||_a===void 0?void 0:_a.map(a=>a.id===upAddress.id?upAddress:a);dispatch&&dispatch({type:"setAddresses",payload:{addresses:updatedAddresses}})}else{const newAddress=await sdk.addresses.create(address);if(((_b=state?.customers)===null||_b===void 0?void 0:_b.id)&&newAddress?.id){const newCustomerAddress=await sdk.customer_addresses.create({customer:sdk.customers.relationship((_c=state?.customers)===null||_c===void 0?void 0:_c.id),address:sdk.addresses.relationship(newAddress.id)});await sdk.addresses.update({id:newAddress.id,reference:newCustomerAddress.id}),dispatch&&state?.addresses&&(newAddress.reference=newCustomerAddress.id,dispatch({type:"setAddresses",payload:{addresses:[...state.addresses,newAddress]}}))}}}catch{throw new Error("Couldn't create customer address")}}}export const customerInitialState={errors:[],addresses:[],payments:[],orders:[]};const type=["setErrors","setCustomerEmail","setAddresses","setPayments","setOrders"],customerReducer=(state,reducer)=>baseReducer(state,reducer,type);export default customerReducer;

package/lib/reducers/GiftCardReducer.js

@@ -0,0 +1 @@
+import{__rest}from"tslib";import baseReducer from"../utils/baseReducer";import{isEmpty}from"lodash";import getErrors from"../utils/getErrors";import getSdk from"../utils/getSdk";export const giftCardInitialState={currencyCode:"",balanceCent:0,singleUse:!1,rechargeable:!0,loading:!1,expiresAt:null,errors:[]},addGiftCardRecipient=async(values,config,dispatch)=>{try{const recipient=await getSdk(config).gift_card_recipients.create(values);dispatch({type:"setGiftCardRecipient",payload:{giftCardRecipient:recipient}})}catch(error){console.error(error)}},addGiftCardLoading=(loading,dispatch)=>{dispatch({type:"setGiftCardLoading",payload:{loading}})},addGiftCard=async(values,{config,dispatch,getOrder,createOrder,order})=>{var _a;try{const sdk=getSdk(config);addGiftCardLoading(!0,dispatch);const{firstName,lastName,email}=values,val=__rest(values,["firstName","lastName","email"]),giftCardValue=Object.assign({recipient_email:email},val),giftCard=await sdk.gift_cards.create(giftCardValue,{include:["gift_card_recipient"]}),recipientValues={id:(_a=giftCard.gift_card_recipient)===null||_a===void 0?void 0:_a.id};if(firstName&&(recipientValues.first_name=firstName),lastName&&(recipientValues.last_name=lastName),isEmpty(recipientValues)||await sdk.gift_card_recipients.update(recipientValues),createOrder&&getOrder){const id=order?order.id:await createOrder();if(id){const order2=sdk.orders.relationship(id),item=sdk.gift_cards.relationship(giftCard.id);await sdk.line_items.create({quantity:1,order:order2,item}),getOrder&&await getOrder(id)}}dispatch({type:"setGiftCardRecipient",payload:Object.assign({},giftCardValue)}),addGiftCardLoading(!1,dispatch)}catch(error){const errors=getErrors(error,"gift_cards");dispatch({type:"setGiftCardErrors",payload:{errors}}),addGiftCardLoading(!1,dispatch)}},addGiftCardError=(errors,dispatch)=>{dispatch({type:"setGiftCardErrors",payload:{errors}})};const type=["setAvailability","setGiftCardRecipient","setGiftCardErrors","setGiftCardLoading"],giftCardReducer=(state,reducer)=>baseReducer(state,reducer,type);export default giftCardReducer;

package/lib/reducers/LineItemReducer.js

@@ -0,0 +1 @@
+import baseReducer from"../utils/baseReducer";import getSdk from"../utils/getSdk";import getErrors from"../utils/getErrors";export const getLineItems=params=>{const{order,dispatch,config}=params,sdk=getSdk(config);let allLineItems=[];order&&sdk.orders.retrieve(order?.id,{include:["line_items","line_items.line_item_options.sku_option"],fields:{orders:["line_items"]}}).then(response=>{dispatch({type:"setLoading",payload:{loading:!1}});const items=response.line_items||[];allLineItems=[...allLineItems,...items],dispatch({type:"setLineItems",payload:{lineItems:allLineItems}})}).catch(error=>{const errors=getErrors(error,"line_items");dispatch({type:"setErrors",payload:{errors}})})},updateLineItem=async params=>{const{config,lineItemId,quantity,getOrder,orderId,dispatch}=params,sdk=getSdk(config);try{await sdk.line_items.update({id:lineItemId,quantity}),getOrder&&await getOrder(orderId),dispatch({type:"setErrors",payload:{errors:[]}})}catch(error){const errors=getErrors(error,"line_items");dispatch({type:"setErrors",payload:{errors}})}},deleteLineItem=async params=>{const{config,lineItemId,getOrder,orderId,dispatch}=params,sdk=getSdk(config);try{await sdk.line_items.delete(lineItemId),getOrder&&await getOrder(orderId),dispatch({type:"setErrors",payload:{errors:[]}})}catch(error){const errors=getErrors(error,"line_items");dispatch({type:"setErrors",payload:{errors}})}},lineItemInitialState={loading:!1,lineItems:[],errors:[]};const actionType=["setLineItems","setErrors","setLoading"],lineItemReducer=(state,reducer)=>baseReducer(state,reducer,actionType);export default lineItemReducer;

package/lib/reducers/OrderReducer.d.ts

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

@@ -0,0 +1 @@
+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(Object.assign({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=Object.assign(Object.assign({},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=Object.assign(Object.assign({},payload.includeLoaded),{[resource]:!0})})}else delete payload.include;payload.includeLoaded=Object.assign(Object.assign(Object.assign({},resourceIncludedLoaded),newResourceLoaded),payload.includeLoaded&&payload.includeLoaded),dispatch&&dispatch({type:"setIncludesResource",payload:Object.assign(Object.assign({},payload),{withoutIncludes:!1})})}export const addToCart=async params=>{var _a,_b;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(!((_a=state?.order)===null||_a===void 0)&&_a.line_items)await Promise.all((_b=state?.order)===null||_b===void 0?void 0:_b.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(Object.assign(Object.assign({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(Object.assign({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

@@ -0,0 +1,151 @@
+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 = {
+    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

@@ -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:[]},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=Object.assign({id:paymentSourceId},attributes);paymentSource=await sdk[paymentResource].update(attrs)}else{const attrs=Object.assign(Object.assign({},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(Object.assign({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;