@commercelayer/react-components 3.15.2 → 4.0.0-alpha.10

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

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

package/lib/cjs/reducers/PaymentMethodReducer.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getPaymentConfig=exports.setPaymentMethodConfig=exports.destroyPaymentSource=exports.updatePaymentSource=exports.setPaymentSource=exports.setPaymentMethod=exports.getPaymentMethods=exports.setPaymentMethodErrors=exports.paymentMethodInitialState=exports.setPaymentRef=exports.setLoading=void 0;const tslib_1=require("tslib"),baseReducer_1=tslib_1.__importDefault(require("../utils/baseReducer")),getErrors_1=tslib_1.__importStar(require("../utils/getErrors")),getSdk_1=tslib_1.__importDefault(require("../utils/getSdk")),camelCase_1=tslib_1.__importDefault(require("lodash/camelCase")),has_1=tslib_1.__importDefault(require("lodash/has")),isEmpty_1=tslib_1.__importDefault(require("lodash/isEmpty"));function setLoading({loading,dispatch}){dispatch&&dispatch({type:"setLoading",payload:{loading}})}exports.setLoading=setLoading;const setPaymentRef=({ref,dispatch})=>{ref&&dispatch&&dispatch({type:"setPaymentRef",payload:{currentPaymentMethodRef:ref}})};exports.setPaymentRef=setPaymentRef,exports.paymentMethodInitialState={errors:[]};const setPaymentMethodErrors=(errors,dispatch)=>{dispatch&&dispatch({type:"setErrors",payload:{errors}})};exports.setPaymentMethodErrors=setPaymentMethodErrors;const 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}})};exports.getPaymentMethods=getPaymentMethods;const 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:(0,getSdk_1.default)(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=(0,getErrors_1.default)(error,"orders",paymentResource);console.error("Set payment method",errors)}};exports.setPaymentMethod=setPaymentMethod;const setPaymentSource=async({config,dispatch,getOrder,attributes={},order,paymentResource,customerPaymentSourceId,paymentSourceId,updateOrder,errors:currentErrors})=>{try{if(config&&order){let paymentSource;const sdk=(0,getSdk_1.default)(config);if(customerPaymentSourceId)updateOrder&&await updateOrder({id:order.id,attributes:{_customer_payment_source_id:customerPaymentSourceId}});else{if(paymentSourceId){const attrs={id:paymentSourceId,...attributes};paymentSource=await sdk[paymentResource].update(attrs)}else{const attrs={...attributes,order:sdk.orders.relationship(order.id)};paymentSource=await sdk[paymentResource].create(attrs)}return getOrder&&await getOrder(order.id),dispatch&&dispatch({type:"setPaymentSource",payload:{paymentSource,errors:[]}}),paymentSource}}}catch(error){const errors=(0,getErrors_1.default)(error,"payment_methods",paymentResource);console.error("Set payment source:",errors),dispatch&&(0,getErrors_1.setErrors)({currentErrors,newErrors:errors,dispatch})}};exports.setPaymentSource=setPaymentSource;const updatePaymentSource=async({id,attributes,config,dispatch,paymentResource})=>{if(config)try{const paymentSource=await(0,getSdk_1.default)(config)[paymentResource].update({id,...attributes});dispatch&&dispatch({type:"setPaymentSource",payload:{paymentSource}})}catch(err){console.error("Update payment source:",err)}};exports.updatePaymentSource=updatePaymentSource;const destroyPaymentSource=async({paymentSourceId,paymentResource,dispatch})=>{paymentSourceId&&paymentResource&&dispatch&&dispatch({type:"setPaymentSource",payload:{paymentSource:void 0}})};exports.destroyPaymentSource=destroyPaymentSource;const setPaymentMethodConfig=(config,dispatch)=>{dispatch({type:"setPaymentMethodConfig",payload:{config}})};exports.setPaymentMethodConfig=setPaymentMethodConfig;function getPaymentConfig(paymentResource,config){const resource=(0,camelCase_1.default)(paymentResource).replace("Payments","Payment").replace("Transfers","Transfer");return!(0,isEmpty_1.default)(config)&&(0,has_1.default)(config,resource)?config[resource]:void 0}exports.getPaymentConfig=getPaymentConfig;const type=["setErrors","setPaymentMethodConfig","setPaymentMethods","setPaymentSource","setPaymentRef","setLoading"],paymentMethodReducer=(state,reducer)=>(0,baseReducer_1.default)(state,reducer,type);exports.default=paymentMethodReducer;

package/lib/cjs/reducers/PlaceOrderReducer.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.setPlaceOrder=exports.placeOrderPermitted=exports.setPlaceOrderErrors=exports.placeOrderInitialState=exports.setButtonRef=void 0;const tslib_1=require("tslib"),baseReducer_1=tslib_1.__importDefault(require("../utils/baseReducer")),isEmpty_1=tslib_1.__importDefault(require("lodash/isEmpty")),shipments_1=require("../utils/shipments"),customerOrderOptions_1=require("../utils/customerOrderOptions"),getSdk_1=tslib_1.__importDefault(require("../utils/getSdk")),getErrors_1=tslib_1.__importDefault(require("../utils/getErrors"));function setButtonRef(ref,dispatch){ref!=null&&ref.current!=null&&dispatch({type:"setButtonRef",payload:{placeOrderButtonRef:ref}})}exports.setButtonRef=setButtonRef,exports.placeOrderInitialState={errors:[],isPermitted:!1};const setPlaceOrderErrors=(errors,dispatch)=>{dispatch&&dispatch({type:"setErrors",payload:{errors}})};exports.setPlaceOrderErrors=setPlaceOrderErrors;const placeOrderPermitted=async({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=(0,shipments_1.isDoNotShip)(order.line_items),shipments=order.shipments,shipment=shipments&&(0,shipments_1.shipmentsFilled)(shipments),paymentMethod=order.payment_method,paymentSource=order.payment_source;order.total_amount_with_taxes_cents!==0&&(0,isEmpty_1.default)(paymentMethod?.id)&&(isPermitted=!1),(0,isEmpty_1.default)(billingAddress)&&(isPermitted=!1),(0,isEmpty_1.default)(shippingAddress)&&!doNotShip&&(isPermitted=!1),!(0,isEmpty_1.default)(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}})}};exports.placeOrderPermitted=placeOrderPermitted;const setPlaceOrder=async({state,order,config,setOrderErrors,paymentSource,setOrder,include})=>{const response={placed:!1};if(state&&config&&order){const sdk=(0,getSdk_1.default)(config),{options,paymentType}=state;try{if(paymentType==="paypal_payments"&&paymentSource){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};switch((0,customerOrderOptions_1.saveBillingAddress)()&&await sdk.orders.update({id:order.id,_save_billing_address_to_customer_address_book:!0}),(0,customerOrderOptions_1.saveShippingAddress)()&&await sdk.orders.update({id:order.id,_save_shipping_address_to_customer_address_book:!0}),paymentType){case"braintree_payments":{(0,customerOrderOptions_1.saveToWallet)()&&await 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([]),{placed:!0}}default:{const orderUpdated=await sdk.orders.update(updateAttributes,{include});return setOrder&&setOrder(orderUpdated),(0,customerOrderOptions_1.saveToWallet)()&&await sdk.orders.update({id:order.id,_save_payment_source_to_customer_wallet:!0}),setOrderErrors&&setOrderErrors([]),{placed:!0}}}}catch(error){const errors=(0,getErrors_1.default)(error,"orders",paymentType);return setOrderErrors&&setOrderErrors(errors),{...response,errors}}}return response};exports.setPlaceOrder=setPlaceOrder;const type=["setErrors","setPlaceOrderPermitted","setButtonRef"],placeOrderReducer=(state,reducer)=>(0,baseReducer_1.default)(state,reducer,type);exports.default=placeOrderReducer;

package/lib/cjs/reducers/PriceReducer.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.unsetPriceState=exports.getSkusPrice=exports.priceInitialState=void 0;const tslib_1=require("tslib"),getPrices_1=tslib_1.__importDefault(require("../utils/getPrices")),baseReducer_1=tslib_1.__importDefault(require("../utils/baseReducer")),getSdk_1=tslib_1.__importDefault(require("../utils/getSdk")),getErrors_1=tslib_1.__importDefault(require("../utils/getErrors"));exports.priceInitialState={loading:!0,prices:{},skuCodes:[],errors:[]};const getSkusPrice=(skuCodes,{config,dispatch,setPrices,prices,perPage,filters})=>{let allPrices={};const sdk=(0,getSdk_1.default)(config);sdk.prices.list({filters:{sku_code_in:skuCodes.join(","),...filters},pageSize:perPage}).then(async response=>{const pricesObj=(0,getPrices_1.default)(response);allPrices={...allPrices,...prices,...pricesObj},setPrices&&setPrices(allPrices),dispatch({type:"setPrices",payload:{prices:allPrices}}),dispatch({type:"setLoading",payload:{loading:!1}});const meta=response.meta;if(meta.pageCount>1)for(let pageNumber=meta.currentPage+1;pageNumber<=meta.pageCount;pageNumber++){const pageResponse=await sdk.prices.list({filters:{sku_code_in:skuCodes.join(","),...filters},pageSize:perPage,pageNumber}),pricesObj2=(0,getPrices_1.default)(pageResponse);allPrices={...allPrices,...pricesObj2},setPrices&&setPrices(allPrices),dispatch({type:"setPrices",payload:{prices:allPrices}})}}).catch(error=>{const errors=(0,getErrors_1.default)(error,"prices");dispatch({type:"setErrors",payload:{errors}})})};exports.getSkusPrice=getSkusPrice;const unsetPriceState=dispatch=>{dispatch({type:"setPrices",payload:{prices:{}}}),dispatch({type:"setLoading",payload:{loading:!1}})};exports.unsetPriceState=unsetPriceState;const typeAction=["setLoading","setPrices","setSkuCodes","setErrors"],priceReducer=(state,reducer)=>(0,baseReducer_1.default)(state,reducer,typeAction);exports.default=priceReducer;

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

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

package/lib/cjs/reducers/ShipmentReducer.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.setShippingMethod=exports.getShipments=exports.setShipmentErrors=exports.shipmentInitialState=void 0;const tslib_1=require("tslib"),baseReducer_1=tslib_1.__importDefault(require("../utils/baseReducer")),getSdk_1=tslib_1.__importDefault(require("../utils/getSdk"));exports.shipmentInitialState={errors:[]};const setShipmentErrors=(errors,dispatch)=>{dispatch&&dispatch({type:"setErrors",payload:{errors}})};exports.setShipmentErrors=setShipmentErrors;const getShipments=async({order,dispatch,config})=>{try{const sdk=(0,getSdk_1.default)(config),shipments=order.shipments,deliveryLeadTimes=await sdk.delivery_lead_times.list({include:["shipping_method","stock_location"]});dispatch({type:"setShipments",payload:{shipments,deliveryLeadTimes}})}catch(error){console.error(error)}};exports.getShipments=getShipments;const setShippingMethod=async({config,shipmentId,shippingMethodId,getOrder,order})=>{try{if(shippingMethodId){const sdk=(0,getSdk_1.default)(config);await sdk.shipments.update({id:shipmentId,shipping_method:sdk.shipping_methods.relationship(shippingMethodId)}),getOrder&&order&&await getOrder(order.id)}}catch(error){console.error(error)}};exports.setShippingMethod=setShippingMethod;const type=["setErrors","setShipments","setShippingMethod"],shipmentReducer=(state,reducer)=>(0,baseReducer_1.default)(state,reducer,type);exports.default=shipmentReducer;

package/lib/cjs/reducers/ShippingAddressReducer.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.setShippingCustomerAddressId=exports.setShippingAddress=exports.shippingAddressInitialState=void 0;const tslib_1=require("tslib"),baseReducer_1=tslib_1.__importDefault(require("../utils/baseReducer")),getSdk_1=tslib_1.__importDefault(require("../utils/getSdk"));exports.shippingAddressInitialState={_shipping_address_clone_id:""};const setShippingAddress=async(id,options)=>{try{if(options?.order){if(options.customerAddressId){const sdk=(0,getSdk_1.default)(options.config),attributes={id,reference:options.customerAddressId};await sdk.addresses.update(attributes)}options.dispatch({type:"setShippingAddress",payload:{_shipping_address_clone_id:id}})}}catch(error){console.error(error)}};exports.setShippingAddress=setShippingAddress;const setShippingCustomerAddressId=async({dispatch,order,setCloneAddress})=>{const customerAddressId=order?.shipping_address?.reference;try{customerAddressId&&(dispatch({type:"setShippingCustomerAddressId",payload:{shippingCustomerAddressId:customerAddressId}}),setCloneAddress(customerAddressId,"shipping_address"))}catch(error){console.error("error",error)}};exports.setShippingCustomerAddressId=setShippingCustomerAddressId;const type=["setShippingAddress","setShippingCustomerAddressId","cleanup"],shippingAddressReducer=(state,reducer)=>(0,baseReducer_1.default)(state,reducer,type);exports.default=shippingAddressReducer;

package/lib/cjs/reducers/SkuListsReducer.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getSkuList=exports.skuListsInitialState=void 0;const tslib_1=require("tslib"),baseReducer_1=tslib_1.__importDefault(require("../utils/baseReducer")),getSdk_1=tslib_1.__importDefault(require("../utils/getSdk")),actionType=["getSkuList","setSkuList"];exports.skuListsInitialState={listIds:[]};const getSkuList=async({listIds,config,dispatch})=>{const skuLists={};try{const sdk=(0,getSdk_1.default)(config);listIds.forEach(async id=>{const skuCodes=(await sdk.sku_lists.retrieve(id,{include:["skus"],fields:{skus:["code"]}})).skus;skuLists[id]=skuCodes}),dispatch({payload:{skuLists},type:"getSkuList"})}catch(error){console.error(error)}};exports.getSkuList=getSkuList;const skuListsReducer=(state,reducer)=>(0,baseReducer_1.default)(state,reducer,actionType);exports.default=skuListsReducer;

package/lib/cjs/reducers/SkuOptionsReducer.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.skuOptionsInitialState=exports.unsetSkuOptionsState=exports.getSkuOptions=void 0;const tslib_1=require("tslib"),baseReducer_1=tslib_1.__importDefault(require("../utils/baseReducer")),getSkuOptions=async params=>{const{skuOptions,dispatch}=params;dispatch({type:"setSkuOptions",payload:{skuOptions}})};exports.getSkuOptions=getSkuOptions;const unsetSkuOptionsState=dispatch=>{dispatch({type:"setSkuOptions",payload:{skuOptions:[]}}),dispatch({type:"setErrors",payload:{errors:[]}})};exports.unsetSkuOptionsState=unsetSkuOptionsState;const actionType=["setSkuOptions","setErrors"];exports.skuOptionsInitialState={skuCode:"",skuOptions:[]};const skuOptionsReducer=(state,reducer)=>(0,baseReducer_1.default)(state,reducer,actionType);exports.default=skuOptionsReducer;

package/lib/cjs/reducers/SkuReducer.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getSku=exports.skuInitialState=void 0;const tslib_1=require("tslib"),baseReducer_1=tslib_1.__importDefault(require("../utils/baseReducer")),getSdk_1=tslib_1.__importDefault(require("../utils/getSdk")),actionType=["getSkus"];exports.skuInitialState={skus:[],loading:!0,skuCodes:[]};async function getSku({config,skus,dispatch,queryParams}){if(!config.accessToken||skus.length===0)return;const sdk=(0,getSdk_1.default)(config);let allSkus=[];const get=await sdk.skus.list({...queryParams,filters:{...queryParams?.filters,code_in:skus.join(",")}});allSkus=[...get];const meta=get.meta;if(meta.pageCount>1)for(let pageNumber=meta.currentPage+1;pageNumber<=meta.pageCount;pageNumber++){const getPage=await sdk.skus.list({...queryParams,filters:{...queryParams?.filters,code_in:skus.join(",")},pageNumber});allSkus=[...allSkus,...getPage]}dispatch({type:"getSkus",payload:{skus:allSkus,loading:!1,skuCodes:skus}})}exports.getSku=getSku;function skuReducer(state,reducer){return(0,baseReducer_1.default)(state,reducer,actionType)}exports.default=skuReducer;

package/lib/cjs/reducers/VariantReducer.d.ts

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

package/lib/cjs/reducers/VariantReducer.js

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

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

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

package/lib/cjs/typings/errors.js

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

package/lib/cjs/typings/index.d.ts

@@ -0,0 +1,129 @@
+import { Dispatch, ForwardedRef, ReactNode, Ref } from 'react';
+import PropTypes, { InferProps } from 'prop-types';
+import { BaseError } from './errors';
+export declare const BC: {
+    id: PropTypes.Requireable<string>;
+    className: PropTypes.Requireable<string>;
+    style: PropTypes.Requireable<object>;
+    name: PropTypes.Requireable<string>;
+};
+export declare const PTLoader: PropTypes.Requireable<NonNullable<string | PropTypes.ReactElementLike | null | undefined>>;
+export declare const BaseSelectComponentPropTypes: {
+    children: PropTypes.Requireable<(...args: any[]) => any>;
+    options: PropTypes.Validator<NonNullable<PropTypes.InferProps<{
+        label: PropTypes.Validator<string>;
+        value: PropTypes.Validator<NonNullable<NonNullable<string | number | null | undefined>>>;
+        selected: PropTypes.Requireable<boolean>;
+    }>>[]>;
+    placeholder: PropTypes.Requireable<PropTypes.InferProps<{
+        label: PropTypes.Validator<string>;
+        value: PropTypes.Validator<NonNullable<NonNullable<string | number | null | undefined>>>;
+    }>>;
+    value: PropTypes.Requireable<string>;
+    name: PropTypes.Validator<string>;
+};
+export declare type SelectPlaceholder = Option;
+declare type BaseSelectChildrenComponentProps = Omit<BaseSelectComponentProps, 'children'>;
+interface Option {
+    label: string;
+    value: string | number;
+    disabled?: boolean;
+}
+export interface BaseSelectComponentProps {
+    children?: (props: BaseSelectChildrenComponentProps) => JSX.Element;
+    options: Option[];
+    placeholder?: Option;
+    value?: string;
+    className?: string;
+    required?: boolean;
+    name: string;
+    onChange?: (event: React.ChangeEvent<HTMLSelectElement>) => void;
+}
+export declare const BaseInputComponentPropTypes: {
+    children: PropTypes.Requireable<(...args: any[]) => any>;
+    name: PropTypes.Validator<string>;
+    type: PropTypes.Validator<NonNullable<BaseInputType>>;
+    onChange: PropTypes.Requireable<(...args: any[]) => any>;
+    placeholder: PropTypes.Requireable<string>;
+};
+declare type BaseInputChildrenComponentProps = Omit<BaseInputComponentProps, 'children'> & {
+    handleChange: (event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    parentRef: ForwardedRef<any>;
+};
+export interface BaseInputComponentProps {
+    ref?: Ref<any>;
+    children?: (props: BaseInputChildrenComponentProps) => JSX.Element;
+    name: string;
+    onChange?: (event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void;
+    placeholder?: string;
+}
+export declare type LineItemType = 'gift_cards' | 'payment_methods' | 'promotions' | 'shipments' | 'skus' | 'bundles' | 'adjustments';
+export declare type GiftCardInputName = 'balanceCents' | 'balanceMaxCents' | 'singleUse' | 'rechargeable' | 'imageUrl' | 'expiresAt' | 'referenceOrigin' | 'email' | 'firstName' | 'lastName' | 'reference';
+export declare type AddressInputName = 'billing_address_city' | 'billing_address_company' | 'billing_address_first_name' | 'billing_address_email' | 'billing_address_last_name' | 'billing_address_line_1' | 'billing_address_line_2' | 'billing_address_phone' | 'billing_address_state_code' | 'billing_address_zip_code' | 'billing_address_billing_info' | 'billing_address_save_to_customer_book' | 'customer_address_city' | 'customer_address_company' | 'customer_address_first_name' | 'customer_address_email' | 'customer_address_last_name' | 'customer_address_line_1' | 'customer_address_line_2' | 'customer_address_phone' | 'customer_address_state_code' | 'customer_address_zip_code' | 'customer_address_billing_info' | 'shipping_address_city' | 'shipping_address_company' | 'shipping_address_email' | 'shipping_address_first_name' | 'shipping_address_last_name' | 'shipping_address_line_1' | 'shipping_address_line_2' | 'shipping_address_phone' | 'shipping_address_state_code' | 'shipping_address_zip_code' | 'shipping_address_save_to_customer_book';
+export declare type AddressCountrySelectName = 'billing_address_country_code' | 'shipping_address_country_code' | 'customer_address_country_code';
+export declare type AddressStateSelectName = 'billing_address_state_code' | 'shipping_address_state_code' | 'customer_address_state_code';
+export declare type BaseInputType = 'checkbox' | 'date' | 'email' | 'number' | 'tel' | 'text' | 'textarea';
+export declare type LoaderType = string | ReactNode;
+export declare const BMObject: PropTypes.Requireable<{
+    [x: string]: string | null | undefined;
+}>;
+export interface BaseMetadataObject {
+    [key: string]: string | undefined | null;
+}
+export declare type TimeFormat = 'days' | 'hours';
+export declare type BaseComponent = InferProps<typeof BC>;
+export interface BaseAction<A = string, P = Record<string, any>> {
+    type: A;
+    payload: P;
+}
+export interface BaseState {
+    [key: string]: any;
+    errors?: BaseError[];
+}
+export declare type BaseActionType<T = string> = T[];
+export declare type BFSetStateContainer<T> = <P extends T>(param: P) => void;
+export declare type BaseReducer = <S extends BaseState, A extends BaseAction, T extends BaseActionType>(state: S, action: A, type: T) => S;
+export declare type BaseUnsetState<A> = (dispatch: Dispatch<A>) => void;
+export interface BaseMetadata {
+    [key: string]: string | undefined | null;
+}
+export declare type BaseFormatPrice = 'formatted' | 'cents' | 'float';
+export declare const baseOrderPricePropTypes: {
+    id: PropTypes.Requireable<string>;
+    className: PropTypes.Requireable<string>;
+    style: PropTypes.Requireable<object>;
+    name: PropTypes.Requireable<string>;
+    base: PropTypes.Validator<string>;
+    type: PropTypes.Validator<string>;
+    children: PropTypes.Requireable<(...args: any[]) => any>;
+    format: PropTypes.Requireable<BaseFormatPrice>;
+};
+export declare const baseOrderComponentPricePropTypes: {
+    id: PropTypes.Requireable<string>;
+    className: PropTypes.Requireable<string>;
+    style: PropTypes.Requireable<object>;
+    name: PropTypes.Requireable<string>;
+    children: PropTypes.Requireable<(...args: any[]) => any>;
+    format: PropTypes.Requireable<BaseFormatPrice>;
+};
+export declare type BasePriceType = 'total' | 'option' | 'unit';
+export declare type BaseSelectorType = 'select' | 'radio';
+export declare type BaseAmountComponentChildren = Omit<BaseAmountComponent, 'children'>;
+export declare type BaseAmountComponent = {
+    children?: (props: BaseAmountComponentChildren) => JSX.Element;
+    format?: BaseFormatPrice;
+    price?: string;
+    priceCents?: number;
+    labelFree?: string;
+} & JSX.IntrinsicElements['span'];
+export declare type ChildrenFunction<P = Record<string, any>> = (props: P) => JSX.Element;
+export declare type ExcludeTag<T extends keyof JSX.IntrinsicElements> = Exclude<keyof JSX.IntrinsicElements, T>;
+export declare type ExtractTag<T extends keyof JSX.IntrinsicElements> = Extract<keyof JSX.IntrinsicElements, T>;
+export declare type ConditionalElement<E> = ({
+    attribute: Extract<keyof E, 'image_url'>;
+    tagElement: ExtractTag<'img'>;
+} & JSX.IntrinsicElements['img']) | ({
+    attribute: Exclude<keyof E, 'image_url'>;
+    tagElement: ExcludeTag<'img'>;
+} & JSX.IntrinsicElements[ExcludeTag<'img'>]);
+export {};

package/lib/cjs/typings/index.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.baseOrderComponentPricePropTypes=exports.baseOrderPricePropTypes=exports.BMObject=exports.BaseInputComponentPropTypes=exports.BaseSelectComponentPropTypes=exports.PTLoader=exports.BC=void 0;const tslib_1=require("tslib"),prop_types_1=tslib_1.__importDefault(require("prop-types"));exports.BC={id:prop_types_1.default.string,className:prop_types_1.default.string,style:prop_types_1.default.object,name:prop_types_1.default.string},exports.PTLoader=prop_types_1.default.oneOfType([prop_types_1.default.element,prop_types_1.default.string]),exports.BaseSelectComponentPropTypes={children:prop_types_1.default.func,options:prop_types_1.default.arrayOf(prop_types_1.default.shape({label:prop_types_1.default.string.isRequired,value:prop_types_1.default.oneOfType([prop_types_1.default.string,prop_types_1.default.number]).isRequired,selected:prop_types_1.default.bool}).isRequired).isRequired,placeholder:prop_types_1.default.shape({label:prop_types_1.default.string.isRequired,value:prop_types_1.default.oneOfType([prop_types_1.default.string,prop_types_1.default.number]).isRequired}),value:prop_types_1.default.string,name:prop_types_1.default.string.isRequired},exports.BaseInputComponentPropTypes={children:prop_types_1.default.func,name:prop_types_1.default.string.isRequired,type:prop_types_1.default.oneOf(["text","email","number","date","checkbox","textarea"]).isRequired,onChange:prop_types_1.default.func,placeholder:prop_types_1.default.string},exports.BMObject=prop_types_1.default.objectOf(prop_types_1.default.string),exports.baseOrderPricePropTypes={base:prop_types_1.default.string.isRequired,type:prop_types_1.default.string.isRequired,children:prop_types_1.default.func,format:prop_types_1.default.oneOf(["formatted","cents","float"]),...exports.BC},exports.baseOrderComponentPricePropTypes={children:exports.baseOrderPricePropTypes.children,format:exports.baseOrderPricePropTypes.format,...exports.BC};

package/lib/cjs/utils/PropsType.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});

package/lib/cjs/utils/addressesManager.d.ts

@@ -0,0 +1,29 @@
+import { BaseError } from '../typings/errors';
+import { Address, AddressCreate } from '@commercelayer/sdk';
+import { TCustomerAddress } from '../reducers/CustomerReducer';
+declare type BillingAddressController = (params: {
+    billing_address?: AddressCreate;
+    billingAddressId?: string;
+    errors?: BaseError[];
+    requiresBillingInfo?: boolean;
+}) => boolean;
+export declare const billingAddressController: BillingAddressController;
+declare type ShippingAddressController = (params: {
+    billingDisable?: boolean;
+    errors?: BaseError[];
+    shipToDifferentAddress?: boolean;
+    shipping_address?: AddressCreate;
+    shippingAddressId?: string;
+}) => boolean;
+export declare const shippingAddressController: ShippingAddressController;
+declare type CountryLockController = (params: {
+    addresses?: Address[] | null;
+    billing_address?: TCustomerAddress;
+    billingAddressId?: string;
+    countryCodeLock?: string;
+    shipToDifferentAddress?: boolean;
+    shipping_address?: AddressCreate;
+    shippingAddressId?: string;
+}) => boolean;
+export declare const countryLockController: CountryLockController;
+export {};

package/lib/cjs/utils/addressesManager.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.countryLockController=exports.shippingAddressController=exports.billingAddressController=void 0;const lodash_1=require("lodash"),validateFormFields_1=require("./validateFormFields"),AddressReducer_1=require("../reducers/AddressReducer"),billingAddressController=({billing_address,billingAddressId,errors,requiresBillingInfo=!1})=>{let billingDisable=!(0,lodash_1.isEmpty)(errors)||(0,lodash_1.isEmpty)(billing_address);if((0,lodash_1.isEmpty)(errors)&&!(0,lodash_1.isEmpty)(billing_address)){let billingInfo=[...AddressReducer_1.addressFields];requiresBillingInfo&&(billingInfo=[...billingInfo,"billing_info"]),billingDisable=!!(billing_address&&(0,validateFormFields_1.fieldsExist)(billing_address,billingInfo))}return billingDisable&&!(0,lodash_1.isEmpty)(billingAddressId)&&(0,lodash_1.isEmpty)(billing_address)&&(billingDisable=!1),billingDisable};exports.billingAddressController=billingAddressController;const shippingAddressController=({billingDisable,errors,shipToDifferentAddress,shipping_address,shippingAddressId})=>{let shippingDisable=!!(!billingDisable&&shipToDifferentAddress);return shippingDisable&&(0,lodash_1.isEmpty)(errors)&&!(0,lodash_1.isEmpty)(shipping_address)&&(shippingDisable=!!(shipping_address&&(0,validateFormFields_1.fieldsExist)(shipping_address))),shippingDisable&&!(0,lodash_1.isEmpty)(shippingAddressId)&&(0,lodash_1.isEmpty)(shipping_address)&&(shippingDisable=!1),shippingDisable};exports.shippingAddressController=shippingAddressController;const countryLockController=({addresses,billing_address,billingAddressId,countryCodeLock,shipToDifferentAddress,shipping_address,shippingAddressId})=>{if(countryCodeLock&&!(0,lodash_1.isEmpty)(addresses)&&billingAddressId&&!shipToDifferentAddress){const addressLocked=addresses?.find(a=>(a?.id===billingAddressId||a?.reference===billingAddressId)&&a?.country_code!==countryCodeLock);if(!(0,lodash_1.isEmpty)(addressLocked))return!0}if(countryCodeLock&&!(0,lodash_1.isEmpty)(billing_address)&&!shipToDifferentAddress)return billing_address?.country_code!==countryCodeLock;if(countryCodeLock&&!(0,lodash_1.isEmpty)(shipping_address)&&shipToDifferentAddress)return shipping_address?.country_code!==countryCodeLock;if(countryCodeLock&&!(0,lodash_1.isEmpty)(addresses)&&shippingAddressId&&shipToDifferentAddress){const addressLocked=addresses?.find(a=>(a?.id===shippingAddressId||a?.reference===shippingAddressId)&&a?.country_code!==countryCodeLock);if(!(0,lodash_1.isEmpty)(addressLocked))return!0}return!1};exports.countryLockController=countryLockController;

package/lib/cjs/utils/baseReducer.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const baseReducer=(state,action,actionTypes)=>{if(actionTypes.indexOf(action.type)!==-1){const data=action.payload;state={...state,...data}}return state};exports.default=baseReducer;

package/lib/cjs/utils/browserInfo.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});function getBrowserInfo(){const screenWidth=window&&window.screen?window.screen.width:"",screenHeight=window&&window.screen?window.screen.height:"",colorDepth=window&&window.screen?window.screen.colorDepth:"",userAgent=window&&window.navigator?window.navigator.userAgent:"",javaEnabled=window&&window.navigator?navigator.javaEnabled():!1;let language="";window&&window.navigator&&(language=window.navigator.language);const timeZoneOffset=new Date().getTimezoneOffset();return{screenWidth,screenHeight,colorDepth,userAgent,timeZoneOffset,language,javaEnabled}}exports.default=getBrowserInfo;

package/lib/cjs/utils/checkIncludeResource.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});function checkIncludeResources({order,resourceInclude}){const checkKeys=[];return resourceInclude.forEach(v=>{if(v.includes(".")){const[first]=v.split(".");order?.[first]===void 0&&checkKeys.push(!1)}else order?.[v]===void 0&&checkKeys.push(!1)}),checkKeys.length===0}exports.default=checkIncludeResources;

package/lib/cjs/utils/childrenTypes.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { Requireable } from 'prop-types';
+export interface CheckChildrenTypes {
+    (props: {
+        [key: string]: any;
+    }, propName: string, componentName: string, location: string, propFullName: string): Error | null;
+}
+declare const _default: Requireable<ReactNode | (() => JSX.Element)>;
+export default _default;

package/lib/cjs/utils/childrenTypes.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});const tslib_1=require("tslib"),react_1=require("react"),lodash_1=require("lodash"),components_1=tslib_1.__importDefault(require("../config/components")),checkChildrenTypes=(props,propName,componentName)=>{let error=null;const children=props[propName],cpName=componentName.replace("CL","");return((0,lodash_1.isEmpty)(children)&&typeof children!="function"||typeof children=="function"&&!children)&&props.isRequired&&(error=new Error(`The prop '${propName}' is marked as required in '${cpName}', but its value is '${children}'.`)),react_1.Children.map(children,c=>{if(error)return error;const type=c?.type,itemTypes=(0,lodash_1.get)(components_1.default,`${cpName}.permittedChildren`),errorMsg=`Invalid prop '${propName}' supplied to ${cpName}. Only components ${itemTypes.join(", ")} are allowed.`;if((0,lodash_1.isFunction)(type)&&(0,lodash_1.has)(type,"displayName")){const displayName=(0,lodash_1.get)(type,"displayName"),childComponentName=type.name;displayName&&displayName===`${childComponentName}`&&(itemTypes.includes(childComponentName)||(error=new Error(errorMsg)))}!(0,react_1.isValidElement)(c)&&c!==null&&(error=new Error(errorMsg))}),error},childrenTypes=checkChildrenTypes;childrenTypes.isRequired=(props,propName,componentName,location,propFullName)=>checkChildrenTypes({...props,isRequired:!0},propName,componentName,location,propFullName),exports.default=childrenTypes;

package/lib/cjs/utils/compareObjAttribute.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});function sortObj(obj){return Object.keys(obj).sort().reduce((result,key)=>(result[key]=obj[key],result),{})}function compareObjAttribute({attributes,object}){const returnObj={};return Object.keys(object).forEach(v=>{const element=attributes[v],compare=object[v];if(typeof element=="object"&&element){const elementSorted=sortObj(element),compareSorted=sortObj(compare);JSON.stringify(elementSorted)!==JSON.stringify(compareSorted)&&(returnObj[v]=element)}typeof element!="object"&&element&&element!==compare&&(returnObj[v]=element)}),returnObj}exports.default=compareObjAttribute;