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

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

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

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

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

package/lib/esm/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/esm/typings/errors.d.ts

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

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

package/lib/esm/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/esm/utils/PropsType.d.ts

@@ -0,0 +1,33 @@
+import PropTypes from 'prop-types';
+declare type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
+declare type Defined<T> = T extends undefined ? never : T;
+/**
+ * Get the type that represents the props with the defaultProps included.
+ *
+ * Alternatively, we could have done something like this:
+ * ```
+ * export type WithDefaultProps<P, DP extends Partial<P>> = Omit<P, keyof DP> &
+ *   Required<Pick<P, Extract<keyof DP, keyof P>>>;
+ * ```
+ * But there were usages of `null` in `defaultProps` that would need to be changed to `undefined`
+ * to meet the `DP extends Partial<P>` constraint.
+ * So, instead we take the union type in cases when a property in defaultProps does not extend
+ * the corresponding property in the Props declaration.
+ */
+declare type WithDefaultProps<P, DP> = Omit<P, keyof DP> & {
+    [K in Extract<keyof DP, keyof P>]: DP[K] extends Defined<P[K]> ? Defined<P[K]> : Defined<P[K]> | DP[K];
+};
+/**
+ * Get the props type from propTypes and defaultProps.
+ *
+ * Usage:
+ * ```
+ * // Without defaultProps
+ * type Props = PropsType<typeof propTypes>;
+ *
+ * // With defaultProps
+ * type Props = PropsType<typeof propTypes, typeof defaultProps>;
+ * ```
+ */
+export declare type PropsType<PT, DP = {}> = WithDefaultProps<PropTypes.InferProps<PT>, DP>;
+export {};

package/lib/esm/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/esm/utils/addressesManager.js

@@ -0,0 +1 @@
+import{isEmpty}from"lodash";import{fieldsExist}from"./validateFormFields";import{addressFields}from"../reducers/AddressReducer";export const billingAddressController=({billing_address,billingAddressId,errors,requiresBillingInfo=!1})=>{let billingDisable=!isEmpty(errors)||isEmpty(billing_address);if(isEmpty(errors)&&!isEmpty(billing_address)){let billingInfo=[...addressFields];requiresBillingInfo&&(billingInfo=[...billingInfo,"billing_info"]),billingDisable=!!(billing_address&&fieldsExist(billing_address,billingInfo))}return billingDisable&&!isEmpty(billingAddressId)&&isEmpty(billing_address)&&(billingDisable=!1),billingDisable},shippingAddressController=({billingDisable,errors,shipToDifferentAddress,shipping_address,shippingAddressId})=>{let shippingDisable=!!(!billingDisable&&shipToDifferentAddress);return shippingDisable&&isEmpty(errors)&&!isEmpty(shipping_address)&&(shippingDisable=!!(shipping_address&&fieldsExist(shipping_address))),shippingDisable&&!isEmpty(shippingAddressId)&&isEmpty(shipping_address)&&(shippingDisable=!1),shippingDisable},countryLockController=({addresses,billing_address,billingAddressId,countryCodeLock,shipToDifferentAddress,shipping_address,shippingAddressId})=>{if(countryCodeLock&&!isEmpty(addresses)&&billingAddressId&&!shipToDifferentAddress){const addressLocked=addresses?.find(a=>(a?.id===billingAddressId||a?.reference===billingAddressId)&&a?.country_code!==countryCodeLock);if(!isEmpty(addressLocked))return!0}if(countryCodeLock&&!isEmpty(billing_address)&&!shipToDifferentAddress)return billing_address?.country_code!==countryCodeLock;if(countryCodeLock&&!isEmpty(shipping_address)&&shipToDifferentAddress)return shipping_address?.country_code!==countryCodeLock;if(countryCodeLock&&!isEmpty(addresses)&&shippingAddressId&&shipToDifferentAddress){const addressLocked=addresses?.find(a=>(a?.id===shippingAddressId||a?.reference===shippingAddressId)&&a?.country_code!==countryCodeLock);if(!isEmpty(addressLocked))return!0}return!1};

package/lib/esm/utils/baseReducer.d.ts

@@ -0,0 +1,3 @@
+import { BaseReducer } from '../typings/index';
+declare const baseReducer: BaseReducer;
+export default baseReducer;

package/lib/esm/utils/browserInfo.d.ts

@@ -0,0 +1,9 @@
+export default function getBrowserInfo(): {
+    screenWidth: string | number;
+    screenHeight: string | number;
+    colorDepth: string | number;
+    userAgent: string;
+    timeZoneOffset: number;
+    language: string;
+    javaEnabled: boolean;
+};

package/lib/esm/utils/checkIncludeResource.d.ts

@@ -0,0 +1,8 @@
+import { ResourceIncluded } from '../reducers/OrderReducer';
+import type { Order } from '@commercelayer/sdk';
+declare type Params = {
+    order: Order;
+    resourceInclude: ResourceIncluded[];
+};
+export default function checkIncludeResources({ order, resourceInclude, }: Params): boolean;
+export {};

package/lib/esm/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/esm/utils/compareObjAttribute.d.ts

@@ -0,0 +1,7 @@
+declare type Item = Record<string, any>;
+declare type TArgs<A, B> = {
+    attributes: A;
+    object: B;
+};
+export default function compareObjAttribute<A extends Item, B extends Item>({ attributes, object, }: TArgs<A, B>): Item;
+export {};

package/lib/esm/utils/countryStateCity.d.ts

@@ -0,0 +1,9 @@
+export declare function getCountries(): {
+    label: string;
+    value: string;
+}[];
+export declare function getStateOfCountry(country_code: string): {
+    label: string;
+    value: string;
+}[];
+export declare function isValidState(state_code: string, country_code: string): boolean;

package/lib/esm/utils/customMessages.d.ts

@@ -0,0 +1,2 @@
+import { BaseError } from '../typings/errors';
+export default function customMessages(messages: BaseError[] | undefined, v: BaseError): BaseError | null;

package/lib/esm/utils/customerOrderOptions.d.ts

@@ -0,0 +1,3 @@
+export declare function saveToWallet(): boolean;
+export declare function saveBillingAddress(): boolean;
+export declare function saveShippingAddress(): boolean;

package/lib/esm/utils/getAmount.d.ts

@@ -0,0 +1,9 @@
+export interface GetAmountInterface<T = any> {
+    (base: string, type: string, format: string, obj: Record<string, any>): T extends number ? number : string;
+}
+export default function getAmount<T = string>(args: {
+    base: string;
+    type: string;
+    format: string;
+    obj: Record<string, any>;
+}): T extends number ? number : string;

package/lib/esm/utils/getCardDetails.d.ts

@@ -0,0 +1,15 @@
+import { IconBrand } from '../context/PaymentSourceContext';
+import { PaymentResource } from '../reducers/PaymentMethodReducer';
+import { CustomerPaymentSource } from '@commercelayer/sdk';
+declare type CardDetails = {
+    brand: IconBrand | string;
+    last4: string;
+    exp_month: number | string;
+    exp_year: number | string;
+};
+declare type Args = {
+    paymentType: PaymentResource;
+    customerPayment: Partial<CustomerPaymentSource>;
+};
+export default function getCardDetails({ paymentType, customerPayment, }: Args): CardDetails;
+export {};

package/lib/esm/utils/getCartLink.d.ts

@@ -0,0 +1,7 @@
+declare type TArgs = {
+    orderId: string;
+    accessToken: string;
+    slug: string;
+};
+export default function getCartLink({ orderId, accessToken, slug }: TArgs): string;
+export {};

package/lib/esm/utils/getCurrentItemKey.d.ts

@@ -0,0 +1,6 @@
+import { Items } from '../reducers/ItemReducer';
+export interface GetCurrentItemKey {
+    (item: Items): string;
+}
+declare const getCurrentItemKey: GetCurrentItemKey;
+export default getCurrentItemKey;

package/lib/esm/utils/getErrors.d.ts

@@ -0,0 +1,11 @@
+import { BaseError, ResourceErrorType } from '../typings/errors';
+import { Dispatch } from 'react';
+export default function getErrors(error: any, resource: ResourceErrorType, field?: string): BaseError[];
+declare type SetErrorsArgs<D> = {
+    currentErrors?: BaseError[];
+    newErrors?: BaseError[];
+    dispatch?: D;
+    filterBy?: string;
+};
+export declare function setErrors<D extends Dispatch<any>>({ currentErrors, newErrors, dispatch, filterBy, }: SetErrorsArgs<D>): BaseError[] | void;
+export {};

package/lib/esm/utils/getLineItemsCount.d.ts

@@ -0,0 +1,10 @@
+import type { LineItem } from '@commercelayer/sdk';
+import { LineItemType } from '../typings/index';
+export declare type TypeAccepted = Extract<LineItemType, 'skus' | 'gift_cards' | 'bundles' | 'adjustments'>;
+interface Args {
+    lineItems: LineItem[];
+    quantity?: number;
+    typeAccepted?: TypeAccepted[];
+}
+export default function getLineItemsCount({ lineItems, quantity, typeAccepted }: Args): number;
+export {};

package/lib/esm/utils/getLoaderComponent.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { LoaderType } from '../typings/index';
+export default function getLoaderComponent(Loader: LoaderType): JSX.Element;

package/lib/esm/utils/getLoaderComponent.js

@@ -0,0 +1 @@
+import{Fragment as _Fragment,jsx as _jsx}from"react/jsx-runtime";export default function getLoaderComponent(Loader){return _jsx(_Fragment,{children:Loader})}

package/lib/esm/utils/getPrices.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { Price } from '@commercelayer/sdk';
+import { PTemplateProps } from '../components/utils/PriceTemplate';
+export declare function getPriceByCode(skuPrices: Price[], code?: string): Price | undefined;
+export declare function getPricesComponent(skuPrices: Price[], props: PTemplateProps): JSX.Element[] | JSX.Element;
+export default function getPrices<P extends Price>(prices: P[]): Record<string, P[]>;

package/lib/esm/utils/getPrices.js

@@ -0,0 +1 @@
+import{createElement as _createElement}from"react";import{jsx as _jsx}from"react/jsx-runtime";import{isEmpty,first,isArray,has}from"lodash";import PriceTemplate from"../components/utils/PriceTemplate";export function getPriceByCode(skuPrices,code=""){return code?first(skuPrices.filter(p=>p.currency_code===code)):first(skuPrices)}export function getPricesComponent(skuPrices,props){return isEmpty(skuPrices)?_jsx(PriceTemplate,{...props}):skuPrices.map((p,k)=>{const showCompare=typeof props.showCompare>"u"&&p?.compare_at_amount_cents>p?.amount_cents||props.showCompare;return _createElement(PriceTemplate,{...props,key:k,showCompare,formattedAmount:p.formatted_amount,formattedCompare:p.formatted_compare_at_amount,skuCode:p.sku_code})})}export default function getPrices(prices){const obj={};return isArray(prices)&&prices.forEach(p=>{const sku=p.sku_code;has(obj,sku)?obj[sku].push(p):obj[sku]=[p]}),obj}

package/lib/esm/utils/getSdk.d.ts

@@ -0,0 +1,3 @@
+import Sdk from '@commercelayer/sdk';
+import { CommerceLayerConfig } from '../context/CommerceLayerContext';
+export default function getSdk({ endpoint, accessToken }: CommerceLayerConfig): ReturnType<typeof Sdk>;

package/lib/esm/utils/getSkus.d.ts

@@ -0,0 +1,3 @@
+import { Sku } from '@commercelayer/sdk';
+declare const getSkus: (skus: Sku[], sortBy: string[]) => Record<string, any>;
+export default getSkus;

package/lib/esm/utils/hooks/useExternalScript.d.ts

@@ -0,0 +1 @@
+export default function useExternalScript(url: string): boolean;

package/lib/esm/utils/icons.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+export declare const sortDescIcon: JSX.Element;
+export declare const sortAscIcon: JSX.Element;

package/lib/esm/utils/icons.js

@@ -0,0 +1 @@
+import{jsx as _jsx}from"react/jsx-runtime";export const sortDescIcon=_jsx("svg",{xmlns:"http://www.w3.org/2000/svg",width:20,fill:"none",viewBox:"0 0 24 24",stroke:"currentColor",children:_jsx("path",{strokeLinecap:"round",strokeLinejoin:"round",strokeWidth:2,d:"M3 4h13M3 8h9m-9 4h9m5-4v12m0 0l-4-4m4 4l4-4"})}),sortAscIcon=_jsx("svg",{xmlns:"http://www.w3.org/2000/svg",width:20,fill:"none",viewBox:"0 0 24 24",stroke:"currentColor",children:_jsx("path",{strokeLinecap:"round",strokeLinejoin:"round",strokeWidth:2,d:"M3 4h13M3 8h9m-9 4h6m4 0l4-4m0 0l4 4m-4-4v12"})});

package/lib/esm/utils/isDate.d.ts

@@ -0,0 +1 @@
+export default function isDate(value: string): boolean;

package/lib/esm/utils/isDate.js

@@ -0,0 +1 @@
+export default function isDate(value){return!isNaN(Date.parse(value))}

package/lib/esm/utils/isEmptyStates.d.ts

@@ -0,0 +1 @@
+export default function isEmptyStates(countryCode: string): boolean;

package/lib/esm/utils/isJSON.d.ts

@@ -0,0 +1 @@
+export default function isJSON(str: string): boolean;