@liquidcommerce/elements-sdk 2.6.0-beta.6 → 2.6.0-beta.61

package/dist/ssr-stub.checkout.esm.js

@@ -0,0 +1,18 @@
+const ELEMENTS_ENV = {
+    DEVELOPMENT: 'development',
+    STAGING: 'staging',
+    PRODUCTION: 'production',
+};
+const DEBUG_MODE = {
+    NONE: 'none',
+    CONSOLE: 'console',
+    PANEL: 'panel',
+};
+
+const SSR_WARN = '[LiquidCommerce Checkout] This SDK is designed for the browser. ' + 'Calls made during SSR return null. The SDK will initialize on the client.';
+async function ElementsCheckout(..._args) {
+    console.warn(SSR_WARN);
+    return null;
+}
+
+export { DEBUG_MODE, ELEMENTS_ENV, ElementsCheckout };

package/dist/ssr-stub.esm.js

@@ -0,0 +1,270 @@
+class SDKError extends Error {
+    constructor(message, reThrow = false) {
+        super(message);
+        this.name = 'SDKError';
+        this.isSdk = true;
+        this.reThrow = reThrow;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, SDKError);
+        }
+        Object.setPrototypeOf(this, SDKError.prototype);
+    }
+}
+function isSDKError(error, source) {
+    if ((error === null || error === void 0 ? void 0 : error.isSdk) === true) {
+        if (error instanceof SDKError && error.reThrow) {
+            return false;
+        }
+        return true;
+    }
+    if (!error || typeof error !== 'object') {
+        return source ? isSDKSource(source) : false;
+    }
+    const message = String((error === null || error === void 0 ? void 0 : error.message) || '');
+    const hasSDKMessage = /liquidcommerce\s+elements/i.test(message);
+    const stack = String((error === null || error === void 0 ? void 0 : error.stack) || '');
+    const errorSource = (error === null || error === void 0 ? void 0 : error.source) || source || '';
+    const sdkPathPatterns = [
+        /@[/\\](?:core|modules|constants|enums|interfaces|utils|static)[/\\]/,
+        /[./]*[/\\](?:core|modules|constants|enums|interfaces|utils|static)[/\\]/,
+        /node_modules[/\\]@liquidcommerce[/\\]elements-sdk[/\\]/i,
+        /elements-sdk[/\\](?:src[/\\])?(?:core|modules)[/\\]/i,
+        /chunk-[a-z0-9]+.*elements/i,
+    ];
+    const sdkClassPatterns = [
+        /\bElements\b(?!\w)/,
+        /\bElementsBuilder\b/,
+        /\bLiquidCommerceElements\b/,
+        /BaseComponent/,
+        /Elements(?:Base)?Client/,
+        /(?:Auth|Store|Command|ApiClient|Telemetry|FingerPrint|GoogleTagManager|ClientConfig|ThemeProvider|ComponentFactory|PubSub|SingletonManager|DebugPanel)Service/,
+        /(?:Cart|Product|Checkout|Address|ProductList|UI|Common)Commands/,
+        /(?:Product|Cart|Checkout|Address|ProductList).*Component/,
+    ];
+    const sdkFilePatterns = [
+        /(?:service|commands|component)\.(?:ts|js)/,
+        /auto-initialize\/(?:main|checkout)\.(?:ts|js)/,
+        /elements-(?:base-|builder-)?client\.(?:ts|js)/,
+    ];
+    const sdkDirPatterns = [
+        /elements-sdk[/\\]/i,
+        /modules[/\\](?:cart|product|checkout|address|product-list|theme-provider|ui-components)[/\\]/,
+        /core[/\\](?:auth|store|command|api-client|telemetry|fingerprint|google-tag-manager|client|component-factory|pubsub|singleton-manager|debug-panel)[/\\]/,
+        /@liquidcommerce[/\\]elements-sdk/i,
+    ];
+    const hasSDKSource = isSDKSource(errorSource);
+    const hasSDKPathPattern = sdkPathPatterns.some((p) => p.test(stack));
+    const hasSDKClassPattern = sdkClassPatterns.some((p) => p.test(stack));
+    const hasSDKFilePattern = sdkFilePatterns.some((p) => p.test(stack));
+    const hasSDKDirPattern = sdkDirPatterns.some((p) => p.test(stack));
+    return hasSDKMessage || hasSDKSource || hasSDKPathPattern || hasSDKClassPattern || hasSDKFilePattern || hasSDKDirPattern;
+}
+function isSDKSource(source) {
+    if (!source || typeof source !== 'string') {
+        return false;
+    }
+    const sdkSourcePatterns = [
+        /\/elements\.js$/i,
+        /\/index\.esm\.js$/i,
+        /@liquidcommerce\/elements-sdk/i,
+        /node_modules[/\\]@liquidcommerce[/\\]elements-sdk/i,
+        /@liquidcommerce[/\\]elements-sdk[/\\]/i,
+        /\/elements-sdk[/\\]/i,
+        /elements-sdk[/\\]src/i,
+        /elements[-.]?[a-z0-9]*\.js$/i,
+        /chunk.*elements/i,
+        /elements.*chunk/i,
+        /\?.*elements\.js/i,
+        /#.*elements\.js/i,
+    ];
+    return sdkSourcePatterns.some((pattern) => pattern.test(source));
+}
+
+const ELEMENTS_ENV = {
+    DEVELOPMENT: 'development',
+    STAGING: 'staging',
+    PRODUCTION: 'production',
+};
+const ELEMENTS_ACTIONS_EVENT = {
+    CLIENT_READY: 'client_ready',
+    ADDRESS_UPDATED: 'address_updated',
+    ADDRESS_CLEARED: 'address_cleared',
+    ADDRESS_FAILED: 'address_failed',
+    PRODUCT_LOADED: 'product_loaded',
+    PRODUCT_QUANTITY_INCREASE: 'product_quantity_increase',
+    PRODUCT_QUANTITY_DECREASE: 'product_quantity_decrease',
+    PRODUCT_ADD_TO_CART: 'product_add_to_cart',
+    PRODUCT_SIZE_CHANGED: 'product_size_changed',
+    PRODUCT_FULFILLMENT_TYPE_CHANGED: 'product_fulfillment_type_changed',
+    PRODUCT_FULFILLMENT_CHANGED: 'product_fulfillment_changed',
+    CART_LOADED: 'cart_loaded',
+    CART_CLOSED: 'cart_closed',
+    CART_OPENED: 'cart_opened',
+    CART_UPDATED: 'cart_updated',
+    CART_FAILED: 'cart_failed',
+    CART_RESET: 'cart_reset',
+    CART_ITEM_ADDED: 'cart_item_added',
+    CART_ITEM_REMOVED: 'cart_item_removed',
+    CART_ITEM_QUANTITY_INCREASE: 'cart_item_quantity_increase',
+    CART_ITEM_QUANTITY_DECREASE: 'cart_item_quantity_decrease',
+    CART_ITEM_ENGRAVING_UPDATED: 'cart_item_engraving_updated',
+    CART_PROMO_CODE_APPLIED: 'cart_promo_code_applied',
+    CART_PROMO_CODE_REMOVED: 'cart_promo_code_removed',
+    CART_PROMO_CODE_FAILED: 'cart_promo_code_failed',
+    CART_PRODUCT_ADD_SUCCESS: 'cart_product_add_success',
+    CART_PRODUCT_ADD_FAILED: 'cart_product_add_failed',
+    INTERNAL_CART_TO_CHECKOUT: 'internal_cart_to_checkout',
+    CHECKOUT_LOADED: 'checkout_loaded',
+    CHECKOUT_OPENED: 'checkout_opened',
+    CHECKOUT_CLOSED: 'checkout_closed',
+    CHECKOUT_FAILED: 'checkout_failed',
+    CHECKOUT_IS_GIFT_TOGGLED: 'checkout_is_gift_toggled',
+    CHECKOUT_BILLING_SAME_AS_SHIPPING_TOGGLED: 'checkout_billing_same_as_shipping_toggled',
+    CHECKOUT_MARKETING_PREFERENCES_TOGGLED: 'checkout_marketing_preferences_toggled',
+    CHECKOUT_CUSTOMER_INFORMATION_UPDATED: 'checkout_customer_information_updated',
+    CHECKOUT_GIFT_INFORMATION_UPDATED: 'checkout_gift_information_updated',
+    CHECKOUT_BILLING_INFORMATION_UPDATED: 'checkout_billing_information_updated',
+    CHECKOUT_ITEM_REMOVED: 'checkout_item_removed',
+    CHECKOUT_ITEM_QUANTITY_INCREASE: 'checkout_item_quantity_increase',
+    CHECKOUT_ITEM_QUANTITY_DECREASE: 'checkout_item_quantity_decrease',
+    CHECKOUT_ITEM_ENGRAVING_UPDATED: 'checkout_item_engraving_updated',
+    CHECKOUT_TIP_UPDATED: 'checkout_tip_updated',
+    CHECKOUT_SUBMIT_STARTED: 'checkout_submit_started',
+    CHECKOUT_SUBMIT_COMPLETED: 'checkout_submit_completed',
+    CHECKOUT_SUBMIT_FAILED: 'checkout_submit_failed',
+    CHECKOUT_PROMO_CODE_APPLIED: 'checkout_promo_code_applied',
+    CHECKOUT_PROMO_CODE_REMOVED: 'checkout_promo_code_removed',
+    CHECKOUT_PROMO_CODE_FAILED: 'checkout_promo_code_failed',
+    CHECKOUT_GIFT_CARD_APPLIED: 'checkout_gift_card_applied',
+    CHECKOUT_GIFT_CARD_REMOVED: 'checkout_gift_card_removed',
+    CHECKOUT_GIFT_CARD_FAILED: 'checkout_gift_card_failed',
+    CHECKOUT_PRODUCT_ADD_SUCCESS: 'checkout_product_add_success',
+    CHECKOUT_PRODUCT_ADD_FAILED: 'checkout_product_add_failed',
+};
+const ELEMENTS_FORM = {
+    CUSTOMER: 'customer',
+    GIFT: 'gift',
+    BILLING: 'billing',
+};
+const COMPONENT_TYPE = {
+    DRAWER: 'drawer',
+    INPUT: 'input',
+    ENGRAVING_FORM: 'engraving-form',
+    ENGRAVING_VIEW: 'engraving-view',
+    BUTTONS_CART_OPEN: 'buttons-cart-open',
+    POWERED_BY: 'powered-by',
+    LCE_ELEMENT: 'lce-element',
+    PURCHASE_MIN_ALERT: 'purchase-min-alert',
+    ALERT: 'alert',
+    PROMO_CODE_TICKER: 'promo-code-ticker',
+    ADDRESS: 'address',
+    ADDRESS_INPUT: 'address-input',
+    ADDRESS_DISPLAY: 'address-display',
+    PRODUCT: 'product',
+    PRODUCT_IMAGE_CAROUSEL: 'product-image-carousel',
+    PRODUCT_OPTIONS: 'product-options',
+    PRODUCT_INTERACTIONS: 'product-interactions',
+    PRODUCT_DESCRIPTION: 'product-description',
+    PRODUCT_RETAILERS: 'product-retailers',
+    PRODUCT_RETAILERS_CAROUSEL: 'product-retailers-carousel',
+    PRODUCT_RETAILERS_POPUP: 'product-retailers-popup',
+    PRODUCT_RETAILERS_POPUP_LIST: 'product-retailers-popup-list',
+    PRODUCT_PRICE: 'product-price',
+    PRODUCT_ADD_TO_CART_SECTION: 'product-add-to-cart-section',
+    PRODUCT_DRAWER: 'product-drawer',
+    PRODUCT_LOADING: 'product-loading',
+    PRODUCT_LIST: 'product-list',
+    PRODUCT_LIST_CARD: 'product-list-card',
+    PRODUCT_LIST_FILTERS: 'product-list-filters',
+    PRODUCT_LIST_SEARCH: 'product-list-search',
+    PRODUCT_LIST_CARD_LOADING: 'product-list-card-loading',
+    PRODUCT_LIST_ENGRAVING_FORM: 'product-list-engraving-form',
+    PRODUCT_LIST_PRODUCT_PRE_CART: 'product-list-product-pre-cart',
+    PRODUCT_LIST_PRODUCT_ENGRAVING_LINES: 'product-list-product-engraving-lines',
+    PRODUCT_LIST_SIZE_SELECTOR: 'product-list-size-selector',
+    CART: 'cart',
+    CART_RETAILER: 'cart-retailer',
+    CART_ITEM: 'cart-item',
+    CART_FOOTER: 'cart-footer',
+    CART_ITEM_QUANTITY_PRICE: 'cart-item-quantity-price',
+    CART_RETAILER_SUBTOTAL: 'cart-retailer-subtotal',
+    CART_PROMO_CODE: 'cart-promo-code',
+    CART_HEADER: 'cart-header',
+    CART_BODY: 'cart-body',
+    CART_FULFILLMENT: 'cart-fulfillment',
+    CHECKOUT: 'checkout',
+    CHECKOUT_INFORMATION: 'checkout-information',
+    CHECKOUT_STRIPE_HANDLER: 'checkout-stripe-handler',
+    CHECKOUT_STRIPE_FORM: 'checkout-stripe-form',
+    CHECKOUT_PAYMENT: 'checkout-payment',
+    CHECKOUT_PAYMENT_SUMMARY: 'checkout-payment-summary',
+    CHECKOUT_BILLING: 'checkout-billing',
+    CHECKOUT_ORDER_SUMMARY: 'checkout-order-summary',
+    CHECKOUT_PROMO_CODE: 'checkout-promo-code',
+    CHECKOUT_GIFT_CARDS: 'checkout-gift-cards',
+    CHECKOUT_AMOUNTS: 'checkout-amounts',
+    CHECKOUT_ITEMS: 'checkout-items',
+    CHECKOUT_COMPLETED: 'checkout-completed',
+    CHECKOUT_DELIVER_TO: 'checkout-deliver-to',
+    CHECKOUT_DELIVER_TO_SUMMARY: 'checkout-deliver-to-summary',
+    CHECKOUT_BUYER: 'checkout-buyer',
+    CHECKOUT_BUYER_SUMMARY: 'checkout-buyer-summary',
+    CHECKOUT_TIPS: 'checkout-tips',
+    CHECKOUT_PC_GC: 'checkout-pc-gc',
+    CHECKOUT_ITEM: 'checkout-item',
+    CHECKOUT_ITEM_QUANTITY: 'checkout-item-quantity',
+    CHECKOUT_PLACE_ORDER_BUTTON: 'checkout-place-order-button',
+    CHECKOUT_HEADER: 'checkout-header',
+    CHECKOUT_PRESALE_COUNTDOWN: 'checkout-presale-countdown',
+    CHECKOUT_PRESALE_EXPIRED: 'checkout-presale-expired',
+    CHECKOUT_SEND_AS_GIFT: 'checkout-send-as-gift',
+};
+const FULFILLMENT_TYPE = {
+    ON_DEMAND: 'onDemand',
+    SHIPPING: 'shipping',
+};
+const DEBUG_MODE = {
+    NONE: 'none',
+    CONSOLE: 'console',
+    PANEL: 'panel',
+};
+const CART_EVENT_TYPE = {
+    GENERIC: 'generic',
+    PROMO_CODE: 'promo-code',
+};
+const CART_EVENT_LEVEL = {
+    SUCCESS: 'success',
+    WARNING: 'warning',
+    ERROR: 'error',
+};
+const CHECKOUT_EVENT_TYPE = {
+    GENERIC: 'generic',
+    PROMO_CODE: 'promo-code',
+    GIFT_CARD: 'gift-card',
+};
+const CHECKOUT_EVENT_LEVEL = {
+    SUCCESS: 'success',
+    WARNING: 'warning',
+    ERROR: 'error',
+};
+const DISPLAY_MODE = {
+    MODAL: 'modal',
+    DRAWER: 'drawer',
+};
+const NAVIGATION_SOURCE = {
+    PRODUCT: 'product',
+    PRODUCT_LIST_CARD: 'product-list-card',
+    PRE_CART: 'pre-cart',
+};
+
+const SSR_WARN = '[LiquidCommerce Elements] This SDK is designed for the browser. ' + 'Calls made during SSR return null. The SDK will initialize on the client.';
+async function Elements(..._args) {
+    console.warn(SSR_WARN);
+    return null;
+}
+async function ElementsBuilder(..._args) {
+    console.warn(SSR_WARN);
+    return null;
+}
+
+export { CART_EVENT_LEVEL, CART_EVENT_TYPE, CHECKOUT_EVENT_LEVEL, CHECKOUT_EVENT_TYPE, COMPONENT_TYPE, DEBUG_MODE, DISPLAY_MODE, ELEMENTS_ACTIONS_EVENT, ELEMENTS_ENV, ELEMENTS_FORM, Elements, ElementsBuilder, FULFILLMENT_TYPE, NAVIGATION_SOURCE, SDKError, isSDKError };

package/dist/types/auto-initialize/checkout.d.ts

@@ -0,0 +1,2 @@
+export declare function ElementsCheckoutAutoInitialize(): Promise<void>;
+export declare function triggerElementsCheckoutAutoInit(): void;

package/dist/types/auto-initialize/shared-utils.d.ts

@@ -0,0 +1,46 @@
+import type { IAddProductParams } from '@/core/client/actions/client-cart-action.service';
+import type { IAnonymousCheckoutAddProductItem } from '@/interfaces/api/checkout.interface';
+import type { IInjectedComponent } from '@/interfaces/component.interface';
+import type { IClientCustomThemeConfig, ILiquidCommerceElementsDevelopmentConfig } from '@/interfaces/config.interface';
+import type { IInjectCheckoutParams } from '@/interfaces/injection.interface';
+export interface IQueryParamActions {
+    addProduct: (params: IAddProductParams[], open?: boolean) => Promise<void>;
+    applyPromoCode: (promoCode: string) => Promise<void>;
+}
+export declare const SHARED_ATTR: {
+    readonly SCRIPT: {
+        readonly MAIN: "data-liquid-commerce-elements";
+        readonly TOKEN: "data-token";
+        readonly ENV: "data-env";
+        readonly DEBUG_MODE: "data-debug-mode";
+        readonly PRODUCT_PARAM: "data-product-param";
+        readonly PRODUCT_FULFILLMENT_TYPE_PARAM: "data-product-fulfillment-type-param";
+        readonly PRODUCT_QUANTITY_PARAM: "data-product-quantity-param";
+        readonly PROMO_CODE_PARAM: "data-promo-code-param";
+        readonly CHECKOUT_PARAM: "data-checkout-param";
+        readonly CHECKOUT_URL: "data-checkout-url";
+    };
+    readonly ELEMENT: {
+        readonly CHECKOUT: "data-lce-checkout";
+        readonly HIDE_HEADER: "hide-header";
+        readonly EXIT_CHECKOUT: "data-lce-exit-checkout";
+    };
+    readonly JSON_SCRIPT: {
+        readonly DEVELOPMENT: "data-liquid-commerce-elements-development";
+        readonly CUSTOM_THEME: "data-liquid-commerce-elements-custom-theme";
+    };
+};
+export declare function startsWithLcePrefix(value: string | null): boolean;
+export declare function getDevelopmentConfigs(): ILiquidCommerceElementsDevelopmentConfig | undefined;
+export declare function getCustomThemeConfig(): IClientCustomThemeConfig | undefined;
+export declare function triggerAutoInit(initFunction: () => Promise<void>, errorPrefix: string): void;
+export declare function setupCheckout(script: HTMLScriptElement, injectFn: (params: IInjectCheckoutParams) => Promise<IInjectedComponent | null>, exitCheckoutFn: () => void, options: {
+    errorPrefix: string;
+}): Promise<void>;
+export declare function setupExitCheckoutHandlers(exitCheckoutFn: () => void): void;
+export declare function addProductViaQueryParam(actions: IQueryParamActions, script: HTMLScriptElement, errorPrefix: string): Promise<void>;
+export declare function extractAnonymousProductFromQueryParams(script: HTMLScriptElement, errorPrefix: string): {
+    item: IAnonymousCheckoutAddProductItem;
+    promoCode?: string;
+} | null;
+export declare function applyPromoCodeViaQueryParam(actions: IQueryParamActions, script: HTMLScriptElement, errorPrefix: string): Promise<void>;

package/dist/types/{elements-base-client.d.ts → clients/base.d.ts}

@@ -1,3 +1,9 @@
+import '@/modules/theme-provider/styles/register-styles';
+import '@/modules/address/styles/register-styles';
+import '@/modules/cart/styles/register-styles';
+import '@/modules/checkout/styles/register-styles';
+import '@/modules/product/styles/register-styles';
+import '@/modules/product-list/styles/register-styles';
 import { ApiClientService } from '@/core/api/api-client.service';
 import { AuthClientService } from '@/core/api/auth-client.service';
 import { ClientActionService } from '@/core/client/client-action.service';
@@ -10,7 +16,9 @@ import { LoggerFactory } from '@/core/logger/logger-factory';
 import { StoreService } from '@/core/store/store.service';
 import { TelemetryService } from '@/core/telemetry/telemetry.service';
 import { type ComponentType } from '@/enums';
-import type { IInjectedComponent, IInjectProductElement, IInjectProductListParams, ILiquidCommerceElementsActions, IProcessInjectElementParams } from '@/interfaces/core.interface';
+import type { ILiquidCommerceElementsActions } from '@/interfaces/client.interface';
+import type { IInjectedComponent } from '@/interfaces/component.interface';
+import type { IInjectProductElement, IInjectProductListFiltersParams, IInjectProductListParams, IInjectProductListSearchParams, IProcessInjectElementParams } from '@/interfaces/injection.interface';
 import { ThemeProviderService } from '@/modules/theme-provider/theme-provider.service';
 export declare abstract class ElementsBaseClient {
     protected readonly authClient: AuthClientService;
@@ -27,7 +35,8 @@ export declare abstract class ElementsBaseClient {
     protected readonly logger: ReturnType<typeof LoggerFactory.get>;
     protected clientPrepared: boolean;
     protected componentFactoryInitialized: boolean;
-    protected cartDrawerCreated: boolean;
+    protected cartDrawerElement: HTMLElement | null;
+    private heavyInitTimeoutId;
     protected injectedComponents: Map<string, IInjectedComponent>;
     constructor(clientConfigs: IClientConfigs);
     prepare(): Promise<void>;
@@ -38,9 +47,13 @@ export declare abstract class ElementsBaseClient {
     protected processInjectElement(params: IProcessInjectElementParams): Promise<IInjectedComponent | null>;
     protected processInjectProduct(params: IInjectProductElement[]): Promise<IInjectedComponent[]>;
     injectProductList(params: IInjectProductListParams): Promise<void>;
+    injectProductListSearch(params: IInjectProductListSearchParams): Promise<void>;
+    injectProductListFilters(params: IInjectProductListFiltersParams): Promise<void>;
     protected ensureCartDrawerExists(): void;
     protected ensureAllComponentsRegistered(): void;
+    private getServerListConfig;
     protected createInjectedComponentWrapper(containerId: string, type: ComponentType, element: HTMLElement): IInjectedComponent;
+    destroy(): void;
     protected rerenderInjectedComponentsByType(type: ComponentType): void;
     protected isElementsEnabled(): boolean;
     protected injectDisabledElementsError(containerId: string, componentName: ComponentType): void;

package/dist/types/clients/builder.d.ts

@@ -0,0 +1,3 @@
+import type { ILiquidCommerceElementsBuilderClient } from '@/interfaces/client.interface';
+import type { ILiquidCommerceElementsBuilderConfig } from '@/interfaces/config.interface';
+export declare function ElementsBuilder(apiKey: string, config: ILiquidCommerceElementsBuilderConfig): Promise<ILiquidCommerceElementsBuilderClient | null>;

package/dist/types/clients/checkout.d.ts

@@ -0,0 +1,6 @@
+import type { IElementsCheckoutClient } from '@/interfaces/client.interface';
+import type { ILiquidCommerceElementsCheckoutClientConfig } from '@/interfaces/config.interface';
+import '@/modules/theme-provider/styles/register-styles';
+import '@/modules/address/styles/register-styles';
+import '@/modules/checkout/styles/register-styles';
+export declare function ElementsCheckout(apiKey: string, config: ILiquidCommerceElementsCheckoutClientConfig): Promise<IElementsCheckoutClient | null>;

package/dist/types/{elements-client-helper.d.ts → clients/helpers.d.ts}

@@ -1,4 +1,5 @@
 import { type ComponentType } from '@/enums';
-export declare function deepMergeConfigs<T extends Record<string, any>>(target: T, source: Partial<T>): T;
+export declare function normalizeProductListLists<T extends Record<string, any>>(data: T): T;
+export declare function deepMergeConfigs<T extends Record<string, any>>(target: T, source: Partial<T>, currentPath?: string): T;
 export declare const layoutFieldToComponentTypes: Map<string, ComponentType[]>;
 export declare function getComponentTypesForLayoutFields(parentPath: string, layoutFields: Record<string, any>): ComponentType[];

package/dist/types/clients/main.d.ts

@@ -0,0 +1,3 @@
+import type { ILiquidCommerceElementsClient } from '@/interfaces/client.interface';
+import type { ILiquidCommerceElementsConfig } from '@/interfaces/config.interface';
+export declare function Elements(apiKey: string, config: ILiquidCommerceElementsConfig): Promise<ILiquidCommerceElementsClient | null>;

package/dist/types/constants/core.constant.d.ts

@@ -3,13 +3,9 @@ export declare const API_CLIENT_URL: {
     staging: string;
     production: string;
 };
-export declare const PRODUCT_LIST_CARD_VARIANT: {
-    STANDARD: string;
-};
 export declare const PRODUCT_LIST_FILTER_TYPES: {
-    PERSONALIZATION: string;
-    PRE_ORDER: string;
-    DELIVERY_OPTIONS: string;
+    ENGRAVING: string;
+    FULFILLMENT: string;
     PRICE: string;
     BRANDS: string;
     CATEGORIES: string;

package/dist/types/core/api/api-client.service.d.ts

@@ -1,30 +1,31 @@
+import type { ApiResult } from '@/core/api/api-result';
 import type { AuthClientService } from '@/core/api/auth-client.service';
-import type { IPersistedStore } from '@/core/store/interfaces/core.interface';
+import type { IPersistedStore, IPersistedStoreAction } from '@/core/store/interfaces/core.interface';
 import type { IAddressAutocompleteResult, IAddressDetailsResult, ILocation } from '@/interfaces/api/address.interface';
+import type { ICart, ICartUpdateParams } from '@/interfaces/api/cart.interface';
+import type { IAnonymousCheckoutAddProductParams, IAnonymousCheckoutAddProductResponse, ICheckoutComplete, ICheckoutItemsUpdateParams, ICheckoutItemsUpdateResponse, ICheckoutPaymentConfirm, ICheckoutPaymentConfirmParams, ICheckoutPaymentSession, ICheckoutPrepare, ICheckoutPrepareParams } from '@/interfaces/api/checkout.interface';
 import type { IProductAvailabilityResponse } from '@/interfaces/api/product.interface';
-import type { ICart, ICartUpdateParams, ICatalog, ICatalogParams, ICheckoutCompleteParams, ICheckoutCompleteResponse, ICheckoutPrepareParams, ICheckoutPrepareResponse, ILiquidPaymentToken } from '@/interfaces/cloud';
-import type { IUserPaymentSession, IUserSession } from '@/interfaces/cloud/user.interface';
-import type { IAllConfigs } from '@/interfaces/configs';
+import type { IProductSearchParams, IProductSearchResponse } from '@/interfaces/api/product-list.interface';
 export declare class ApiClientService {
     private client;
     private readonly logger;
     constructor();
     static getInstance(): ApiClientService;
     setClient(client: AuthClientService): Promise<void>;
-    getAllConfigs(): Promise<IAllConfigs>;
-    setPersistedStore(userDeviceId: string, data: IPersistedStore): Promise<void>;
-    getPersistedStore(userDeviceId: string): Promise<IPersistedStore | null>;
-    deletePersistedStore(userDeviceId: string): Promise<void>;
-    getAddressSuggestions(input: string): Promise<IAddressAutocompleteResult[]>;
-    getAddressDetails(id: string): Promise<IAddressDetailsResult>;
-    getProductsData(identifier: string[], location?: ILocation): Promise<IProductAvailabilityResponse | null>;
-    catalogSearch(params: ICatalogParams): Promise<ICatalog>;
-    getCartData(id: string | null): Promise<ICart>;
-    updateCart(params: ICartUpdateParams & {
-        loc?: ILocation;
-    }): Promise<ICart>;
-    prepareCheckout(params: ICheckoutPrepareParams): Promise<ICheckoutPrepareResponse>;
-    getPaymentSession(params: IUserPaymentSession): Promise<IUserSession>;
-    confirmPaymentSession(confirmationTokenId: string, setupIntentId: string): Promise<ILiquidPaymentToken>;
-    checkoutComplete(params: Partial<ICheckoutCompleteParams>): Promise<ICheckoutCompleteResponse>;
+    setPersistedStore(userDeviceId: string, data: IPersistedStore): Promise<ApiResult<IPersistedStoreAction>>;
+    getPersistedStore(userDeviceId: string): Promise<ApiResult<IPersistedStore>>;
+    deletePersistedStore(userDeviceId: string): Promise<ApiResult<IPersistedStoreAction>>;
+    getAddressSuggestions(input: string): Promise<ApiResult<IAddressAutocompleteResult[]>>;
+    getAddressDetails(id: string): Promise<ApiResult<IAddressDetailsResult>>;
+    getProductsData(identifier: string[], location?: ILocation): Promise<ApiResult<IProductAvailabilityResponse>>;
+    productListSearch(params: IProductSearchParams): Promise<ApiResult<IProductSearchResponse>>;
+    getProductAvailabilityByState(identifiers: string[], state?: string): Promise<ApiResult<IProductAvailabilityResponse>>;
+    getCartData(id: string | null): Promise<ApiResult<ICart>>;
+    updateCart(params: ICartUpdateParams): Promise<ApiResult<ICart>>;
+    prepareCheckout(params: ICheckoutPrepareParams): Promise<ApiResult<ICheckoutPrepare>>;
+    updateCheckoutItems(params: ICheckoutItemsUpdateParams): Promise<ApiResult<ICheckoutItemsUpdateResponse>>;
+    getPaymentSession(cartId: string): Promise<ApiResult<ICheckoutPaymentSession>>;
+    confirmPaymentSession(params: ICheckoutPaymentConfirmParams): Promise<ApiResult<ICheckoutPaymentConfirm>>;
+    addAnonymousProduct(params: IAnonymousCheckoutAddProductParams): Promise<ApiResult<IAnonymousCheckoutAddProductResponse>>;
+    checkoutComplete(token: string): Promise<ApiResult<ICheckoutComplete>>;
 }

package/dist/types/core/api/api-result.d.ts

@@ -0,0 +1,19 @@
+export interface IApiErrorDetail {
+    field?: string;
+    message: string;
+    code?: string;
+}
+export interface ApiError {
+    status: number;
+    message: string;
+    errors: IApiErrorDetail[];
+}
+export type ApiResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: ApiError;
+};
+export declare function apiSuccess<T>(data: T): ApiResult<T>;
+export declare function apiError<T = never>(status: number, message: string, errors?: IApiErrorDetail[]): ApiResult<T>;

package/dist/types/core/api/auth-client.service.d.ts

@@ -1,4 +1,6 @@
+import { type ApiResult } from '@/core/api/api-result';
 import type { ElementsEnv } from '@/enums';
+import type { IAllConfigs } from '@/interfaces/configs/global.interface';
 export interface IAuthConfig {
     apiKey: string;
     env: ElementsEnv;
@@ -9,34 +11,59 @@ export interface IHttpRequestOptions {
     body?: any;
 }
 export interface IAuth {
-    token: string;
-    exp: number;
-    type: 'ACCESS_TOKEN';
-}
-export interface IApiResponseBase {
-    message: string;
+    accessToken: string;
+    expiration: number;
 }
 export interface IApiResponse<T> {
     message: string;
     data: T;
 }
+export interface IApiErrorDetail {
+    field?: string;
+    message: string;
+    code?: string;
+}
+export interface IApiError {
+    statusCode: number;
+    message: string;
+    errors: IApiErrorDetail[];
+}
+export interface IAuthWithConfigs {
+    auth: IAuth;
+    configs: IAllConfigs;
+}
 export declare class AuthClientService {
+    private static readonly TOKEN_EXPIRATION_BUFFER_MS;
+    private static readonly MAX_RETRIES;
+    private static readonly RETRY_DELAY_MS;
     private readonly apiKey;
     private readonly baseUrl;
     private readonly env;
-    private accessToken;
-    private tokenExpiration;
-    private isAuthenticating;
     private readonly httpClient;
     private readonly logger;
     private readonly clientConfig;
+    private accessToken;
+    private tokenExpiration;
+    private refreshPromise;
     private constructor();
     static getInstance(config: IAuthConfig): AuthClientService;
-    authenticate(): Promise<boolean>;
-    isTokenExpired(): boolean;
+    authenticateAndGetConfigs(): Promise<{
+        success: boolean;
+        configs?: IAllConfigs;
+    }>;
+    refreshToken(): Promise<boolean>;
+    get<TData = unknown>(path: string, options?: IHttpRequestOptions): Promise<ApiResult<TData>>;
+    post<TData = unknown>(path: string, options?: IHttpRequestOptions): Promise<ApiResult<TData>>;
+    private performTokenRefresh;
     private request;
+    private handleSuccessResponse;
+    private handleAuthError;
+    private handleErrorResponse;
+    private isTokenExpired;
+    private clearToken;
     private buildUrl;
+    private buildHeaders;
     private getProxyHeaders;
-    get<T = any>(path: string, options?: IHttpRequestOptions): Promise<T>;
-    post<T = any>(path: string, options?: IHttpRequestOptions): Promise<T>;
+    private isAuthError;
+    private shouldRetryNonAuth;
 }

package/dist/types/core/api/http-client.service.d.ts

@@ -37,7 +37,6 @@ export declare class HttpClientService {
     private logNetworkError;
     private diagnosePossibleCauses;
     private enhanceError;
-    private sanitizeHeaders;
     private delay;
     private getFetchImplementation;
     private fetchAdapter;

package/dist/types/core/base-component.service.d.ts

@@ -7,6 +7,7 @@ import { TelemetryService } from '@/core/telemetry/telemetry.service';
 import type { ComponentType } from '@/enums';
 import type { ConfigsKeyType, ConfigsType } from '@/interfaces/configs';
 import { ThemeProviderService } from '@/modules/theme-provider/theme-provider.service';
+import { SafeHTMLElement } from '@/utils/dom-compat';
 import { CommandService } from './command/command.service';
 export interface IBaseComponentConfig {
     type: ComponentType;
@@ -25,7 +26,7 @@ export interface IOnStoreChanged {
     value: any;
     oldValue: any;
 }
-export declare abstract class BaseComponent<TParams = Record<string, any>, TConfig = ConfigsType> extends HTMLElement {
+export declare abstract class BaseComponent<TParams = Record<string, any>, TConfig = ConfigsType> extends SafeHTMLElement {
     protected readonly store: StoreService;
     protected readonly commands: CommandService;
     protected readonly themeProvider: ThemeProviderService;

package/dist/types/core/client/actions/base-action.service.d.ts

@@ -0,0 +1,15 @@
+import { ApiClientService } from '@/core/api/api-client.service';
+import { LoggerFactory } from '@/core/logger/logger-factory';
+import { PubSubService } from '@/core/pubsub/pubsub.service';
+import { StoreService } from '@/core/store/store.service';
+import type { ILocation } from '@/interfaces/api/address.interface';
+import { ThemeProviderService } from '@/modules/theme-provider/theme-provider.service';
+export declare abstract class BaseActionService {
+    protected readonly pubSub: PubSubService;
+    protected readonly store: StoreService;
+    protected readonly api: ApiClientService;
+    protected readonly themeProvider: ThemeProviderService;
+    protected readonly logger: ReturnType<typeof LoggerFactory.get>;
+    constructor(loggerName: string);
+    protected getLocation(): ILocation | undefined;
+}

package/dist/types/core/client/actions/client-address-action.service.d.ts

@@ -0,0 +1,18 @@
+import type { IAddressAddress, IAddressCoordinates, IAddressData } from '@/interfaces/api/address.interface';
+import { BaseActionService } from './base-action.service';
+export interface IAddressActions {
+    setAddressByPlacesId: (placesId: string) => Promise<void>;
+    setAddressManually: (address: IAddressAddress, coordinates: IAddressCoordinates) => Promise<void>;
+    clear: () => Promise<void>;
+    getDetails: () => IAddressData | null;
+}
+export declare class ClientAddressActionService extends BaseActionService {
+    private readonly command;
+    constructor();
+    static getInstance(): ClientAddressActionService;
+    get actions(): IAddressActions;
+    private setAddressByPlacesId;
+    private setAddressManually;
+    private clear;
+    private getDetails;
+}