@commercelayer/react-components 4.20.1 → 4.21.0-beta.2

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

@@ -1,33 +0,0 @@
-import type { CommerceLayerConfig } from '../context/CommerceLayerContext';
-import type { BaseAction } from '../typings/index';
-import type { Dispatch } from 'react';
-import type { BaseError } from '../typings/errors';
-type InStockSubscriptionActionType = 'setErrors';
-type InStockSubscriptionAction = BaseAction<InStockSubscriptionActionType, InStockSubscriptionState>;
-export interface InStockSubscriptionState {
-    errors?: BaseError[];
-}
-export declare const inStockSubscriptionInitialState: InStockSubscriptionState;
-interface TSetInStockSubscriptionParams {
-    /**
-     * Commerce Layer config
-     */
-    config?: CommerceLayerConfig;
-    /**
-     * Customer email
-     */
-    customerEmail?: string;
-    /**
-     * Sku code
-     */
-    skuCode: string;
-    /**
-     * Dispatch function
-     */
-    dispatch?: Dispatch<InStockSubscriptionAction>;
-}
-export declare function setInStockSubscription<T extends TSetInStockSubscriptionParams>({ config, customerEmail, skuCode, dispatch }: T): Promise<{
-    success: boolean;
-}>;
-export default function inStockSubscriptionReducer(state: InStockSubscriptionState, reducer: InStockSubscriptionAction): InStockSubscriptionState;
-export {};

package/lib/esm/reducers/InStockSubscriptionReducer.js

@@ -1,2 +0,0 @@
-"use client";
-import baseReducer from"../utils/baseReducer";import getSdk from"../utils/getSdk";import getErrors from"../utils/getErrors";const actionType=["setErrors"];export const inStockSubscriptionInitialState={errors:[]};export async function setInStockSubscription({config,customerEmail,skuCode,dispatch}){try{if(config==null)throw new Error("Access token and endpoint is required");const sdk=getSdk(config),attributes={sku_code:skuCode};return customerEmail!=null&&(attributes.customer_email=customerEmail),await sdk.in_stock_subscriptions.create(attributes),{success:!0}}catch(error){const errors=getErrors({error,resource:"in_stock_subscriptions"});return dispatch?.({type:"setErrors",payload:{errors}}),{success:!1}}}export default function inStockSubscriptionReducer(state,reducer){return baseReducer(state,reducer,actionType)}

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

@@ -1,47 +0,0 @@
-import type { Dispatch } from 'react';
-import type { CommerceLayerConfig } from '../context/CommerceLayerContext';
-import type { getOrderContext } from './OrderReducer';
-import type { LoaderType } from '../typings/index';
-import type { BaseError } from '../typings/errors';
-import type { Order, LineItem } from '@commercelayer/sdk';
-export interface UpdateLineItemParams {
-    lineItemId: string;
-    quantity?: number;
-    hasExternalPrice?: boolean;
-    dispatch: Dispatch<LineItemAction>;
-    config: CommerceLayerConfig;
-    getOrder: getOrderContext | undefined;
-    orderId: string;
-    errors: BaseError[] | undefined;
-}
-export type UpdateLineItem = (params: UpdateLineItemParams) => Promise<void>;
-export type DeleteLineItemParam = Record<string, any> & UpdateLineItemParams;
-export type DeleteLineItem = (params: DeleteLineItemParam) => Promise<void>;
-export interface GetLineItemsParams {
-    dispatch: Dispatch<LineItemAction>;
-    config: CommerceLayerConfig;
-    order: Order | null;
-    filters: Record<string, any>;
-}
-export type GetLineItems = (params: GetLineItemsParams) => void;
-export interface LineItemPayload {
-    loading?: boolean;
-    loader?: LoaderType;
-    lineItems?: LineItem[] | null;
-    errors?: BaseError[];
-}
-export interface LineItemState extends LineItemPayload {
-    updateLineItem?: (lineItemId: string, quantity?: number, hasExternalPrice?: boolean) => Promise<void>;
-    deleteLineItem?: (lineItemId: string) => Promise<void>;
-}
-export interface LineItemAction {
-    type: LineItemActionType;
-    payload: LineItemPayload;
-}
-export declare const getLineItems: GetLineItems;
-export declare function updateLineItem(params: UpdateLineItemParams): Promise<void>;
-export declare const deleteLineItem: DeleteLineItem;
-export declare const lineItemInitialState: LineItemState;
-export type LineItemActionType = 'setLineItems' | 'setErrors' | 'setLoading';
-declare const lineItemReducer: (state: LineItemState, reducer: LineItemAction) => LineItemState;
-export default lineItemReducer;

package/lib/esm/reducers/LineItemReducer.js

@@ -1,2 +0,0 @@
-"use client";
-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,resource:"line_items"});dispatch({type:"setErrors",payload:{errors}})})};export async function updateLineItem(params){const{config,lineItemId,quantity,hasExternalPrice,getOrder,orderId,dispatch}=params,sdk=getSdk(config);try{await sdk.line_items.update({id:lineItemId,quantity,_external_price:hasExternalPrice}),getOrder&&await getOrder(orderId),dispatch({type:"setErrors",payload:{errors:[]}})}catch(error){const errors=getErrors({error,resource:"line_items",attributes:{id:lineItemId}});dispatch({type:"setErrors",payload:{errors}})}}export const 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,resource:"line_items"});dispatch({type:"setErrors",payload:{errors}})}},lineItemInitialState={loading:!1,errors:[],lineItems:[]};const actionType=["setLineItems","setErrors","setLoading"],lineItemReducer=(state,reducer)=>baseReducer(state,reducer,actionType);export default lineItemReducer;

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

@@ -1,171 +0,0 @@
-import type { Dispatch } from "react";
-import { type SetLocalOrder, type DeleteLocalOrder } from "../utils/localStorage";
-import type { CommerceLayerConfig } from "../context/CommerceLayerContext";
-import type { BaseMetadataObject } from "../typings/index";
-import type { BaseError } from "../typings/errors";
-import type { AddressResource } from "./AddressReducer";
-import type { Order, OrderUpdate, CommerceLayerClient, ResourceUpdate, AdyenPaymentUpdate } from "@commercelayer/sdk";
-import type { LooseAutocomplete } from "../typings/globals";
-export type GetOrderParams = Partial<{
-    clearWhenPlaced: boolean;
-    config: CommerceLayerConfig;
-    deleteLocalOrder: DeleteLocalOrder;
-    dispatch: Dispatch<OrderActions>;
-    id: string;
-    persistKey: string;
-    state: OrderState;
-}>;
-export type GetOrder = (params: GetOrderParams) => Promise<undefined | Order>;
-type CreateOrderParams = Pick<AddToCartParams, "config" | "dispatch" | "persistKey" | "state" | "orderMetadata" | "orderAttributes" | "setLocalOrder">;
-export interface AddToCartImportParams extends Omit<AddToCartParams, "skuCode" | "skuId" | "quantity" | "option" | "lineItem"> {
-    lineItems: CustomLineItem[];
-}
-export type AddToCartReturn = Promise<{
-    success: boolean;
-    orderId: string | undefined;
-}>;
-export type AddToCartImport = (params: AddToCartImportParams) => AddToCartReturn;
-export type UnsetOrderState = (dispatch: Dispatch<OrderActions>) => void;
-export type ResourceIncluded = "billing_address" | "shipping_address" | "line_items.line_item_options.sku_option" | "line_items.item" | "available_customer_payment_sources.payment_source" | "available_customer_payment_sources.payment_method" | "shipments.available_shipping_methods" | "shipments.stock_transfers" | "shipments.stock_transfers.line_item" | "shipments.stock_line_items.line_item" | "shipments.shipping_method" | "shipments.stock_location" | "shipments.parcels" | "shipments.parcels.parcel_line_items" | "payment_source" | "available_payment_methods" | "payment_method";
-type ResourceIncludedLoaded = Partial<Record<ResourceIncluded, boolean>>;
-export interface OrderPayload {
-    loading?: boolean;
-    orderId?: string;
-    order?: Order;
-    errors?: BaseError[];
-    include?: ResourceIncluded[] | undefined;
-    includeLoaded?: ResourceIncludedLoaded;
-    withoutIncludes?: boolean;
-    manageAdyenGiftCard?: boolean;
-}
-export type AddToCartImportValues = Pick<AddToCartImportParams, "lineItems">;
-export type getOrderContext = (id: string) => Promise<undefined | Order>;
-export type OrderState = Partial<OrderPayload>;
-export interface OrderActions {
-    type: OrderActionType;
-    payload: OrderPayload;
-}
-export type OrderActionType = "setLoading" | "setOrderId" | "setOrder" | "setSingleQuantity" | "setCurrentSkuCodes" | "setCurrentSkuPrices" | "setCurrentItem" | "setErrors" | "setSaveAddressToCustomerAddressBook" | "setGiftCardOrCouponCode" | "setIncludesResource";
-export declare function createOrder(params: CreateOrderParams): Promise<string>;
-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;
-    order?: Order;
-}>;
-interface TResourceRequest {
-    resource: Extract<keyof CommerceLayerClient, "adyen_payments">;
-    requestType: "update";
-    attributes: TResourceRequest["resource"] extends "adyen_payments" ? AdyenPaymentUpdate : ResourceUpdate;
-    order: Order;
-    dispatch?: Dispatch<OrderActions>;
-    config?: CommerceLayerConfig;
-    state?: OrderState;
-}
-export declare function paymentSourceRequest({ resource, requestType, dispatch, attributes, config, order, state, }: TResourceRequest): Promise<{
-    success: boolean;
-    order?: Order;
-}>;
-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;
-}
-type TFrequency = "hourly" | "daily" | "weekly" | "monthly" | "two-month" | "three-month" | "four-month" | "six-month" | "yearly";
-export interface CustomLineItem {
-    name?: string;
-    imageUrl?: string | null;
-    metadata?: Record<string, string>;
-    frequency?: LooseAutocomplete<TFrequency>;
-    externalPrice?: boolean;
-    _update_quantity?: boolean;
-}
-export 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;
-    openMiniCart: boolean;
-}>;
-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 type SaveAddressToCustomerAddressBook = (params: {
-    dispatch?: Dispatch<OrderActions>;
-    type: AddressResource;
-    value: boolean;
-}) => void;
-export declare const saveAddressToCustomerAddressBook: SaveAddressToCustomerAddressBook;
-interface TSetGiftCardOrCouponCodeParams {
-    code: string;
-    codeType: OrderCodeType;
-    dispatch?: Dispatch<OrderActions>;
-    config?: CommerceLayerConfig;
-    order?: Order;
-    include?: string[];
-    state?: OrderState;
-}
-export declare function setGiftCardOrCouponCode({ code, codeType, dispatch, config, order, include, state, }: TSetGiftCardOrCouponCodeParams): Promise<{
-    success: boolean;
-    order?: Order;
-}>;
-export type CodeType = "coupon" | "gift_card";
-export type OrderCodeType = `${CodeType}_code`;
-interface TRemoveGiftCardOrCouponCodeParams {
-    codeType: OrderCodeType;
-    dispatch?: Dispatch<OrderActions>;
-    config?: CommerceLayerConfig;
-    order?: Order;
-    include?: string[];
-    state?: OrderState;
-}
-export declare function removeGiftCardOrCouponCode({ codeType, dispatch, config, order, include, state, }: TRemoveGiftCardOrCouponCodeParams): Promise<{
-    success: boolean;
-    order?: Order;
-}>;
-export declare const orderInitialState: Partial<OrderState>;
-declare const orderReducer: (state: OrderState, reducer: OrderActions) => OrderState;
-export default orderReducer;

package/lib/esm/reducers/OrderReducer.js

@@ -1,2 +0,0 @@
-"use client";
-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{getOrganizationConfig}from"../utils/organization";import{publish}from"../utils/events";import{getDomain}from"../utils/getDomain";import{getApplicationLink}from"../utils/getApplicationLink";const actionType=["setLoading","setOrderId","setOrder","setSingleQuantity","setCurrentSkuCodes","setCurrentSkuPrices","setErrors","setCurrentItem","setSaveAddressToCustomerAddressBook","setIncludesResource"];export async function createOrder(params){if(params){const{persistKey,state,dispatch,config,orderMetadata:metadata,orderAttributes={},setLocalOrder}=params;if(state?.orderId)return state.orderId;const sdk=config!=null?getSdk(config):void 0;try{if(sdk==null)return"";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,resource:"orders"});console.error("Create order",errors),dispatch&&setErrors({currentErrors:state?.errors,newErrors:errors,dispatch})}}return""}export const getApiOrder=async params=>{const{id,dispatch,config,clearWhenPlaced,persistKey,deleteLocalOrder,state}=params,sdk=config!=null?getSdk(config):void 0;try{if(sdk==null)return;const options={};state?.include&&state.include.length>0&&(options.include=state.include);const order=await sdk.orders.retrieve(id??"",options);return clearWhenPlaced&&order.editable===!1?(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,resource:"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=config!=null?getSdk(config):void 0;try{if(sdk==null)return{success:!1};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,order}}catch(error){const errors=getErrors({error,resource:"orders"});return dispatch&&(setOrderErrors({errors,dispatch}),dispatch({type:"setErrors",payload:{errors}})),{success:!1,error}}}export async function paymentSourceRequest({resource,requestType,dispatch,attributes,config,order,state}){const sdk=config!=null?getSdk(config):void 0;try{return sdk==null?{success:!1}:(await sdk[resource][requestType](attributes),{success:!0,order:(await updateOrder({id:order.id,attributes:{},config,include:state?.include,dispatch,state}))?.order})}catch(error){console.error("Resource request",error);const errors=getErrors({error,resource:"orders"});return console.error("Remove gift card o coupon code",errors),dispatch&&setOrderErrors({errors,dispatch}),{success:!1}}}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=[...new Set([...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,openMiniCart=!0}=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,metadata=lineItem?.metadata,frequency=lineItem?.frequency,externalPrice=lineItem?.externalPrice;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:lineItem?._update_quantity??!0,bundle_code:bundleCode,metadata,frequency};externalPrice===!0&&(attrs._external_price=externalPrice);const 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&&id&&config?.accessToken!=null&&config?.endpoint!=null){const params2=`${id}?accessToken=${config.accessToken??""}`,{domain,slug}=getDomain(config.endpoint),href=getApplicationLink({slug,orderId:id,accessToken:config.accessToken,applicationType:"checkout",domain}),organizationConfig=await getOrganizationConfig({accessToken:config.accessToken,endpoint:config.endpoint,params:{accessToken:config.accessToken,orderId:order?.id,slug}}),redirectUrl=checkoutUrl?`${checkoutUrl}/${params2}`:organizationConfig?.links?.checkout??href;location.href=redirectUrl}else openMiniCart&&publish("open-cart");return{success:!0,orderId:id}}}return{success:!1}}catch(error){const errors2=getErrors({error,resource:"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}})};export async function setGiftCardOrCouponCode({code,codeType,dispatch,config,order,include,state}){try{if(config&&order&&code&&dispatch){const attributes={[codeType]:code},{success,order:currentOrder,error}=await updateOrder({id:order.id,attributes,config,include,dispatch,state});if(!success)throw error;return dispatch({type:"setErrors",payload:{errors:[]}}),{success,order:currentOrder}}return{success:!1}}catch(error){const errors=getErrors({error,resource:"orders",field:codeType});return dispatch&&setOrderErrors({errors,dispatch}),{success:!1}}}export async function removeGiftCardOrCouponCode({codeType,dispatch,config,order,include,state}){try{if(config&&order&&dispatch){const attributes={[codeType]:""},orderUpdated=await updateOrder({id:order.id,attributes,config,include,dispatch,state});return dispatch({type:"setErrors",payload:{errors:[]}}),{success:!0,order:orderUpdated?.order}}return{success:!1}}catch(error){const errors=getErrors({error,resource:"orders",field:codeType});return console.error("Remove gift card o coupon code",errors),dispatch&&setOrderErrors({errors,dispatch}),{success:!1}}}export const 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

@@ -1,161 +0,0 @@
-import type { AdyenPaymentConfig } from "../components/payment_source/AdyenPayment";
-import type { BraintreeConfig } from "../components/payment_source/BraintreePayment";
-import type { PaypalConfig } from "../components/payment_source/PaypalPayment";
-import type { StripeConfig } from "../components/payment_source/StripePayment";
-import type { WireTransferConfig } from "../components/payment_source/WireTransferPayment";
-import type { CommerceLayerConfig } from "../context/CommerceLayerContext";
-import type { getOrderContext, updateOrder } from "./OrderReducer";
-import type { BaseError } from "../typings/errors";
-import type { Order, PaymentMethod, StripePayment, WireTransfer, AdyenPayment, BraintreePayment, CheckoutComPayment, ExternalPayment, PaypalPayment, KlarnaPayment } from "@commercelayer/sdk";
-import type { Dispatch, MutableRefObject } from "react";
-import type { CheckoutComConfig } from "../components/payment_source/CheckoutComPayment";
-import type { ExternalPaymentConfig } from "../components/payment_source/ExternalPayment";
-import type { ResourceKeys } from "../utils/getPaymentAttributes";
-export type PaymentSourceType = Order["payment_source"];
-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;
-        };
-        payment_method?: {
-            card: Card;
-            type: string | "klarna" | "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 type PaymentMethodActionType = "setErrors" | "setPaymentMethods" | "setPaymentMethodConfig" | "setPaymentSource" | "setPaymentRef" | "setLoading";
-export type PaymentRef = MutableRefObject<null | HTMLFormElement>;
-export interface PaymentMethodActionPayload {
-    errors: BaseError[];
-    paymentMethods: PaymentMethod[] | null;
-    currentPaymentMethodType: PaymentResource;
-    currentPaymentMethodId: string;
-    currentPaymentMethodRef: PaymentRef;
-    currentCustomerPaymentSourceId: string | null;
-    config: PaymentMethodConfig;
-    paymentSource: Order["payment_source"] | null;
-    loading: boolean;
-}
-export declare function setLoading({ loading, dispatch, }: {
-    loading: boolean;
-    dispatch?: Dispatch<PaymentMethodAction>;
-}): void;
-export type SetPaymentRef = (args: {
-    ref: PaymentRef;
-    dispatch?: Dispatch<PaymentMethodAction>;
-}) => void;
-export declare const setPaymentRef: SetPaymentRef;
-export type PaymentMethodState = Partial<PaymentMethodActionPayload>;
-export interface PaymentMethodAction {
-    type: PaymentMethodActionType;
-    payload: Partial<PaymentMethodActionPayload>;
-}
-export declare const paymentMethodInitialState: PaymentMethodState;
-export type SetPaymentMethodErrors = <V extends BaseError[]>(errors: V, dispatch?: Dispatch<PaymentMethodAction>) => void;
-export declare const setPaymentMethodErrors: SetPaymentMethodErrors;
-type GetPaymentMethods = (args: {
-    order: Order;
-    dispatch: Dispatch<PaymentMethodAction>;
-}) => Promise<void>;
-export declare const getPaymentMethods: GetPaymentMethods;
-export type PaymentResource = keyof PaymentSourceObject;
-export type PaymentResourceKey = "braintreePayment" | "stripePayment" | "klarnaPayment" | "wireTransfer" | "paypalPayment" | "adyenPayment" | "checkoutComPayment";
-export type SDKPaymentResource = "AdyenPayment" | "BraintreePayment" | "ExternalPayment" | "PaypalPayment" | "StripePayment" | "WireTransfer" | "CheckoutComPayment";
-interface TSetPaymentMethodParams {
-    config?: CommerceLayerConfig;
-    dispatch?: Dispatch<PaymentMethodAction>;
-    updateOrder?: typeof updateOrder;
-    setOrderErrors?: (collection: any) => {
-        success: boolean;
-    };
-    order?: Order;
-    paymentMethodId: string;
-    paymentResource?: PaymentResource;
-}
-export declare function setPaymentMethod({ config, dispatch, order, paymentMethodId, updateOrder, setOrderErrors, paymentResource, }: TSetPaymentMethodParams): Promise<{
-    success: boolean;
-    order?: Order;
-}>;
-type PaymentSourceTypes = (StripePayment & WireTransfer) | (StripePayment | WireTransfer);
-export type SetPaymentSourceResponse = {
-    order: Order;
-    paymentSource: PaymentSourceTypes;
-} | null;
-export interface SetPaymentSourceParams extends Omit<PaymentMethodState, "config"> {
-    config?: CommerceLayerConfig;
-    dispatch?: Dispatch<PaymentMethodAction>;
-    getOrder?: getOrderContext;
-    attributes?: Record<string, unknown>;
-    order?: Order;
-    paymentResource: PaymentResource;
-    paymentSourceId?: string;
-    customerPaymentSourceId?: string;
-    updateOrder?: typeof updateOrder;
-}
-export declare function setPaymentSource({ config, dispatch, getOrder, attributes, order, paymentResource, customerPaymentSourceId, paymentSourceId, updateOrder, errors: currentErrors, }: SetPaymentSourceParams): Promise<PaymentSourceType | undefined | null>;
-export type UpdatePaymentSource = (args: {
-    id: string;
-    attributes: Record<string, any>;
-    paymentResource: PaymentResource;
-    config?: CommerceLayerConfig;
-    dispatch?: Dispatch<PaymentMethodAction>;
-}) => Promise<void>;
-export declare const updatePaymentSource: UpdatePaymentSource;
-export 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 {
-    adyenPayment?: AdyenPaymentConfig;
-    braintreePayment?: BraintreeConfig;
-    checkoutComPayment?: CheckoutComConfig;
-    externalPayment?: ExternalPaymentConfig;
-    klarnaPayment?: Pick<AdyenPaymentConfig, "placeOrderCallback"> & Pick<StripeConfig, "containerClassName">;
-    paypalPayment?: PaypalConfig;
-    stripePayment?: StripeConfig;
-    wireTransfer?: Partial<WireTransferConfig>;
-}
-type SetPaymentMethodConfig = (config: PaymentMethodConfig, dispatch: Dispatch<PaymentMethodAction>) => void;
-export declare const setPaymentMethodConfig: SetPaymentMethodConfig;
-export declare function getPaymentConfig<R extends PaymentResource = PaymentResource, K extends PaymentMethodConfig = PaymentMethodConfig>(paymentResource: R, config: K): Pick<K, ResourceKeys<R>>;
-declare const paymentMethodReducer: (state: PaymentMethodState, reducer: PaymentMethodAction) => PaymentMethodState;
-export default paymentMethodReducer;

package/lib/esm/reducers/PaymentMethodReducer.js

@@ -1,2 +0,0 @@
-"use client";
-import baseReducer from"../utils/baseReducer";import getErrors,{setErrors}from"../utils/getErrors";import getSdk from"../utils/getSdk";import{snakeToCamelCase}from"../utils/snakeToCamelCase";import{replace}from"../utils/replace";import{pick}from"../utils/pick";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}})};export async function setPaymentMethod({config,dispatch,order,paymentMethodId,updateOrder,setOrderErrors,paymentResource}){let response={success:!1};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!=null&&(response=await updateOrder({id:order.id,attributes})),dispatch({type:"setPaymentMethods",payload:{currentPaymentMethodId:paymentMethodId,currentPaymentMethodType:paymentResource,errors:[]}}),setOrderErrors&&setOrderErrors([])}return response}catch(error){const errors=getErrors({error,resource:"orders",field:paymentResource});return console.error("Set payment method",errors),response}}export async function setPaymentSource({config,dispatch,getOrder,attributes,order,paymentResource,customerPaymentSourceId,paymentSourceId,updateOrder,errors:currentErrors}){try{const isAlreadyPlaced=order?.status==="placed";if(config&&order&&!isAlreadyPlaced){let paymentSource;const sdk=getSdk(config);if(customerPaymentSourceId){if(updateOrder!=null){const{order:orderUpdated}=await updateOrder({id:order.id,attributes:{_customer_payment_source_id:customerPaymentSourceId}});dispatch!=null&&orderUpdated!=null&&dispatch({type:"setPaymentSource",payload:{paymentSource:orderUpdated.payment_source,currentCustomerPaymentSourceId:orderUpdated.payment_source?.id}})}}else{if(paymentSourceId){const attrs={id:paymentSourceId,...attributes};paymentSource=attributes!=null?await sdk[paymentResource].update(attrs):await 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:[],currentCustomerPaymentSourceId:null}}),paymentSource}}}catch(error){const errors=getErrors({error,resource:"payment_methods",field:paymentResource});if(errors!=null&&errors?.length>0){const[error2]=errors;if(error2?.status==="401"&&getOrder!=null&&order!=null){const currentOrder=await getOrder(order?.id);currentOrder?.status!=null&&!["placed","approved"].includes(currentOrder.status)&&(console.error("Set payment source:",errors),setErrors({currentErrors,newErrors:errors,dispatch}))}}else setErrors({currentErrors,newErrors:errors,dispatch})}}export const 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 resourceKeys=replace(replace(paymentResource,"payments","payment"),"transfers","transfer"),resource=snakeToCamelCase(resourceKeys);return pick(config,[resource])}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

@@ -1,72 +0,0 @@
-import type { Dispatch, RefObject } from "react";
-import type { CommerceLayerConfig } from "../context/CommerceLayerContext";
-import type { BaseError } from "../typings/errors";
-import type { Order } from "@commercelayer/sdk";
-import type { PaymentResource, PaymentSourceType } from "./PaymentMethodReducer";
-export type PlaceOrderActionType = "setErrors" | "setPlaceOrderPermitted" | "setButtonRef" | "setStatus";
-export interface PlaceOrderOptions {
-    paypalPayerId?: string;
-    adyen?: {
-        MD?: string;
-        PaRes?: string;
-        redirectResult?: string;
-    };
-    checkoutCom?: {
-        session_id: string;
-    };
-    stripe?: {
-        /**
-         * @deprecated
-         * Use `paymentIntentClientSecret` instead
-         */
-        redirectStatus?: string;
-        paymentIntentClientSecret: string;
-    };
-}
-export interface PlaceOrderActionPayload {
-    errors: BaseError[];
-    isPermitted: boolean;
-    paymentType: PaymentResource;
-    paymentSecret: string;
-    paymentId: string;
-    paymentSource: PaymentSourceType;
-    options?: PlaceOrderOptions;
-    placeOrderButtonRef?: RefObject<HTMLButtonElement | null>;
-    status: "placing" | "standby";
-}
-export declare function setButtonRef(ref: RefObject<HTMLButtonElement | null>, dispatch: Dispatch<PlaceOrderAction>): void;
-export type PlaceOrderState = Partial<PlaceOrderActionPayload>;
-export interface PlaceOrderAction {
-    type: PlaceOrderActionType;
-    payload: Partial<PlaceOrderActionPayload>;
-}
-export declare const placeOrderInitialState: PlaceOrderState;
-export declare function setPlaceOrderErrors<V extends BaseError[]>(errors: V, dispatch: Dispatch<PlaceOrderAction>): void;
-interface TPlaceOrderPermittedParams {
-    config?: CommerceLayerConfig;
-    dispatch: Dispatch<PlaceOrderAction>;
-    order?: Order;
-    options?: PlaceOrderOptions;
-}
-export declare function placeOrderPermitted({ config, order, dispatch, options, }: TPlaceOrderPermittedParams): void;
-interface TSetPlaceOrderParams {
-    config?: CommerceLayerConfig;
-    order?: Order;
-    state?: PlaceOrderState;
-    setOrderErrors?: (errors: BaseError[]) => void;
-    paymentSource?: PaymentSourceType;
-    include?: string[];
-    setOrder?: (order: Order) => void;
-    currentCustomerPaymentSourceId?: string | null;
-}
-export declare function setPlaceOrder({ state, order, config, setOrderErrors, paymentSource, setOrder, include, currentCustomerPaymentSourceId, }: TSetPlaceOrderParams): Promise<{
-    placed: boolean;
-    errors?: BaseError[];
-    order?: Order;
-}>;
-export declare function setPlaceOrderStatus({ status, dispatch, }: {
-    status: "placing" | "standby";
-    dispatch?: Dispatch<PlaceOrderAction>;
-}): void;
-declare const placeOrderReducer: (state: PlaceOrderState, reducer: PlaceOrderAction) => PlaceOrderState;
-export default placeOrderReducer;

package/lib/esm/reducers/PlaceOrderReducer.js

@@ -1,2 +0,0 @@
-"use client";
-import baseReducer from"../utils/baseReducer";import isEmpty from"lodash/isEmpty";import{isDoNotShip,shipmentsFilled}from"../utils/shipments";import{saveBillingAddress,saveShippingAddress,saveToWallet}from"../utils/customerOrderOptions";import getSdk from"../utils/getSdk";import getErrors from"../utils/getErrors";import{isGuestToken}from"../utils/isGuestToken";import{setCustomerOrderParam}from"../utils/localStorage";import{hasSubscriptions}from"../utils/hasSubscriptions";import{updateOrderSubscriptionCustomerPaymentSource}from"../utils/updateOrderSubscriptionCustomerPaymentSource";export function setButtonRef(ref,dispatch){ref?.current!=null&&dispatch({type:"setButtonRef",payload:{placeOrderButtonRef:ref}})}export const placeOrderInitialState={errors:[],isPermitted:!1,status:"standby"};export function setPlaceOrderErrors(errors,dispatch){dispatch&&dispatch({type:"setErrors",payload:{errors}})}export function placeOrderPermitted({config,order,dispatch,options}){if(order&&config){let isPermitted=!0;order.privacy_url&&order.terms_url&&(isPermitted=localStorage.getItem("privacy-terms")==="true");const billingAddress=order.billing_address,shippingAddress=order.shipping_address,doNotShip=isDoNotShip(order.line_items),shipments=order.shipments,shipment=shipments&&shipmentsFilled(shipments),paymentMethod=order.payment_method,paymentSource=order.payment_source;order.total_amount_with_taxes_cents!==0&&isEmpty(paymentMethod?.id)&&(isPermitted=!1),isEmpty(billingAddress)&&(isPermitted=!1),isEmpty(shippingAddress)&&!doNotShip&&(isPermitted=!1),!isEmpty(shipments)&&!shipment&&(isPermitted=!1),paymentSource?.mismatched_amounts&&(isPermitted=!1),dispatch({type:"setPlaceOrderPermitted",payload:{isPermitted,paymentType:paymentMethod?.payment_source_type,paymentSecret:paymentSource?.client_secret,paymentId:paymentSource?.options?.id,paymentSource,options}})}}export async function setPlaceOrder({state,order,config,setOrderErrors,paymentSource,setOrder,include,currentCustomerPaymentSourceId}){const response={placed:!1};if(state&&config&&order){if(order?.status==="placed")return{placed:!0,order};const sdk=getSdk(config),{options,paymentType}=state;try{const lastOrderStatus=await sdk.orders.retrieve(order.id);if(lastOrderStatus.status==="placed")return{placed:!0,order:lastOrderStatus};if(paymentType==="paypal_payments"&&paymentSource?.type==="paypal_payments"){if(!options?.paypalPayerId&&paymentSource?.approval_url)return window.location.href=paymentSource?.approval_url,response;await sdk[paymentType].update({id:paymentSource.id,paypal_payer_id:options?.paypalPayerId})}if(paymentType==="checkout_com_payments"&&paymentSource&&options?.checkoutCom?.session_id){const payment=await sdk[paymentType].update({id:paymentSource.id,_details:!0,session_id:options?.checkoutCom?.session_id});if(payment?.payment_response?.status!=="Authorized"){const[action]=payment?.payment_response?.actions||[""];throw{errors:[{code:"PAYMENT_NOT_APPROVED_FOR_EXECUTION",message:action?.response_summary,resource:"orders",field:"checkout_com_payments"}]}}}const updateAttributes={id:order.id,_place:!0};if(saveBillingAddress()&&await sdk.orders.update({id:order.id,_save_billing_address_to_customer_address_book:!0}),saveShippingAddress()&&await sdk.orders.update({id:order.id,_save_shipping_address_to_customer_address_book:!0}),paymentType==="stripe_payments"&&paymentSource!=null){const ps=paymentSource,currentUrl=window.location.href,returnUrl=ps?.options?.return_url;currentUrl!==returnUrl&&await sdk[paymentType].update({id:paymentSource.id,options:{return_url:currentUrl}})}switch(hasSubscriptions(order)&&config?.accessToken!=null&&!isGuestToken(config.accessToken)&&currentCustomerPaymentSourceId==null&&setCustomerOrderParam("_save_payment_source_to_customer_wallet","true"),paymentType){case"braintree_payments":{const total=order?.total_amount_cents??0;await Promise.all([saveToWallet()&&total>0&&sdk.orders.update({id:order.id,_save_payment_source_to_customer_wallet:!0})]);const orderUpdated=await sdk.orders.update(updateAttributes,{include});return setOrder&&setOrder(orderUpdated),setOrderErrors&&setOrderErrors([]),updateOrderSubscriptionCustomerPaymentSource(orderUpdated,paymentType,sdk),{placed:!0,order:orderUpdated}}default:{const orderUpdated=await sdk.orders.update(updateAttributes,{include}),total=orderUpdated?.total_amount_cents??0;return setOrder&&setOrder(orderUpdated),await Promise.all([saveToWallet()&&total>0&&sdk.orders.update({id:order.id,_save_payment_source_to_customer_wallet:!0}).catch(error=>{const errors=getErrors({error,resource:"orders",field:paymentType});setOrderErrors&&setOrderErrors(errors)})]).then(()=>{updateOrderSubscriptionCustomerPaymentSource(orderUpdated,paymentType,sdk)}),{placed:!0,order:orderUpdated}}}}catch(error){const errors=getErrors({error,resource:"orders",field:paymentType});return setOrderErrors&&setOrderErrors(errors),{...response,errors}}}return response}export function setPlaceOrderStatus({status,dispatch}){dispatch?.({type:"setStatus",payload:{status}})}const type=["setErrors","setPlaceOrderPermitted","setButtonRef","setStatus"],placeOrderReducer=(state,reducer)=>baseReducer(state,reducer,type);export default placeOrderReducer;

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

@@ -1,35 +0,0 @@
-import type { BaseAction, LoaderType } from '../typings/index';
-import type { QueryPageSize, Price } from '@commercelayer/sdk';
-import type { CommerceLayerConfig } from '../context/CommerceLayerContext';
-import type { Dispatch } from 'react';
-import type { BaseError } from '../typings/errors';
-export type Prices = Record<string, Price | Price[]>;
-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: QueryPageSize;
-    filters: Record<string, any>;
-}): void;
-export type UnsetPriceState = (dispatch: Dispatch<PriceAction>) => void;
-export declare const unsetPriceState: UnsetPriceState;
-export type PriceActionType = 'setLoading' | 'setPrices' | 'setSkuCodes' | 'setErrors';
-declare const priceReducer: (state: PriceState, reducer: PriceAction) => PriceState;
-export default priceReducer;

package/lib/esm/reducers/PriceReducer.js

@@ -1,2 +0,0 @@
-"use client";
-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,resource:"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

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

package/lib/esm/reducers/ShipmentReducer.js

@@ -1,2 +0,0 @@
-"use client";
-import baseReducer from"../utils/baseReducer";import getSdk from"../utils/getSdk";import{canPlaceOrder}from"../utils/canPlaceOrder";export const shipmentInitialState={errors:[]},setShipmentErrors=(errors,dispatch)=>{dispatch&&dispatch({type:"setErrors",payload:{errors}})},getShipments=async({order,dispatch,config})=>{try{const sdk=getSdk(config),shipments=order.shipments;let allDeliveryLeadTimes=[],currentPage=1,totalPages=1;do{const response=await sdk.delivery_lead_times.list({include:["shipping_method","stock_location"],pageNumber:currentPage});allDeliveryLeadTimes=allDeliveryLeadTimes.concat(response),totalPages=response.meta.pageCount,currentPage++}while(currentPage<=totalPages);dispatch({type:"setShipments",payload:{shipments,deliveryLeadTimes:allDeliveryLeadTimes}})}catch(error){console.error(error)}};export async function setShippingMethod({config,shipmentId,shippingMethodId,getOrder,order}){try{if(order!=null&&!canPlaceOrder(order))return{success:!1,order};if(shippingMethodId){const sdk=getSdk(config);if(await sdk.shipments.update({id:shipmentId,shipping_method:sdk.shipping_methods.relationship(shippingMethodId)}),getOrder!=null&&order!=null)return{success:!0,order:await getOrder(order.id)}}return{success:!1}}catch(error){return console.error(error),{success:!1}}}const type=["setErrors","setShipments","setShippingMethod"],shipmentReducer=(state,reducer)=>baseReducer(state,reducer,type);export default shipmentReducer;