@liquidcommerce/elements-sdk 2.1.0-beta.49

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

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

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

@@ -0,0 +1,6 @@
+export declare const API_CLIENT_URL: {
+    local: string;
+    development: string;
+    staging: string;
+    production: string;
+};

package/dist/types/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './core.constant';
+export * from './z-index.constant';

package/dist/types/constants/z-index.constant.d.ts

@@ -0,0 +1,24 @@
+export declare const Z_INDEX: {
+    readonly DRAWER_WRAPPER: 2147483640;
+    readonly DRAWER_CONTENT: 5952;
+    readonly DRAWER_BACKDROP: 5951;
+    readonly ADDRESS_SUGGESTIONS: 5850;
+    readonly PRODUCT_DRAWER: 5840;
+    readonly CART_LOADING: 5750;
+    readonly LOADING_SPINNER: 5740;
+    readonly LOADING_INDICATOR: 5730;
+    readonly ERROR_MESSAGE: 5650;
+    readonly ALERT_BANNER: 5640;
+    readonly NOTIFICATION: 5630;
+    readonly CAROUSEL_CONTROLS: 5580;
+    readonly TOOLTIP: 5570;
+    readonly PROGRESS_BAR: 5560;
+    readonly CHECKOUT_HEADER: 5540;
+    readonly INDEPENDENT_BUTTON: 5530;
+    readonly CART_HEADER: 5540;
+    readonly TOGGLE_SLIDER: 5150;
+    readonly FORM_CONTROLS: 5130;
+    readonly ADDRESS_ACTIONS: 5050;
+    readonly SKELETON_WAVE: 5040;
+    readonly CONTENT_OVERLAY: 5030;
+};

package/dist/types/core/auth.service.d.ts

@@ -0,0 +1,29 @@
+import type { ElementsEnv } from '@/enums';
+export interface IAuthConfig {
+    apiKey: string;
+    env: ElementsEnv;
+    baseUrl: string;
+}
+export declare class AuthService {
+    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 constructor();
+    static getInstance(config: IAuthConfig): AuthService;
+    authenticate(): Promise<boolean>;
+    private requestWithoutAuth;
+    isTokenExpired(): boolean;
+    private request;
+    private buildUrl;
+    private getProxyHeaders;
+    get<T = any>(path: string, headers?: Record<string, string>): Promise<T>;
+    post<T = any>(path: string, body?: any, headers?: Record<string, string>): Promise<T>;
+    put<T = any>(path: string, body?: any, headers?: Record<string, string>): Promise<T>;
+    delete<T = any>(path: string, headers?: Record<string, string>): Promise<T>;
+}

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

@@ -0,0 +1,93 @@
+import { ClientConfigService } from '@/core/client/client-config.service';
+import { LoggerFactory } from '@/core/logger/logger-factory';
+import { PubSubService } from '@/core/pubsub';
+import { type StorePaths, StoreService } from '@/core/store';
+import type { ComponentType } from '@/enums';
+import type { ConfigsKeyType, ConfigsType } from '@/interfaces/configs';
+import { ThemeProviderService } from '@/modules/theme-provider';
+import { CommandService } from './command/command.service';
+export interface IBaseComponentConfig {
+    type: ComponentType;
+    tagName: string;
+    useShadowDom?: boolean;
+}
+export interface ReactiveOptions {
+    watchStorePaths?: StorePaths[];
+    watchOnlyStorePaths?: StorePaths[];
+    autoDestroy?: boolean;
+    autoDestroyPath?: StorePaths;
+    autoDestroyDelay?: number;
+}
+export interface IOnStoreChanged {
+    path: string;
+    value: any;
+    oldValue: any;
+}
+export declare abstract class BaseComponent<TParams = Record<string, any>, TConfig = ConfigsType> extends HTMLElement {
+    protected readonly store: StoreService;
+    protected readonly commands: CommandService;
+    protected readonly themeProvider: ThemeProviderService;
+    protected readonly pubSub: PubSubService;
+    protected readonly logger: ReturnType<typeof LoggerFactory.get>;
+    protected readonly clientConfig: ClientConfigService;
+    private initialized;
+    private isDestroyed;
+    private renderScheduled;
+    private unsubscribers;
+    private renderTimeout?;
+    private autoDestroyTimeout?;
+    private lastRenderTrigger;
+    private renderCount;
+    private _initParams;
+    private _elementConfig;
+    protected container: HTMLElement | ShadowRoot;
+    protected reactiveOptions: ReactiveOptions;
+    protected get hostClasses(): string[];
+    protected get hostAttributes(): Record<string, string>;
+    constructor(reactiveOptions?: ReactiveOptions);
+    initialize({ data, config }: {
+        data: TParams;
+        config: IBaseComponentConfig;
+    }): void;
+    private interpolateStorePaths;
+    private interpolatePath;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private setup;
+    private cleanup;
+    private setupAutoDestroy;
+    private handleAutoDestroy;
+    private destroyComponent;
+    private setupStoreWatchers;
+    private setupNonRenderingWatchers;
+    private triggerRender;
+    private scheduleRender;
+    private render;
+    private logRenderInfo;
+    protected rerender(context?: string): void;
+    private updateHostClasses;
+    addHostClasses(...classes: string[]): void;
+    removeHostClasses(...classes: string[]): void;
+    toggleHostClasses(...classes: string[]): void;
+    addHostAttribute(key: string, value: string): void;
+    removeHostAttribute(key: string): void;
+    private updateHostAttributes;
+    protected get params(): TParams;
+    protected get config(): TConfig;
+    protected get elementConfig(): IBaseComponentConfig;
+    protected getConfigs<T = any>(type: ConfigsKeyType): T;
+    protected getStoreValue<T>(path: StorePaths): T;
+    protected setStoreValue<T>(path: StorePaths, value: T): boolean;
+    protected watchStore(path: StorePaths, callback: (value: any, oldValue: any) => void): () => void;
+    protected abstract template(): HTMLElement | HTMLElement[] | string;
+    protected beforeSetupStoreWatchers?(): void;
+    protected beforeConnected?(): void;
+    protected connected?(): void;
+    protected disconnected?(): void;
+    protected afterRender?(): void;
+    protected onStoreChanged?(changes: IOnStoreChanged[]): boolean | undefined;
+    protected onStoreWatch?(changes: IOnStoreChanged[]): void;
+    protected onError?(error: any, context: string): void;
+    protected beforeAutoDestroy?(path: StorePaths): void;
+    protected onAutoDestroy?(): void;
+}

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

@@ -0,0 +1,70 @@
+import type { IBaseCartEventData, IBaseProductEventData, ICheckoutDetails } from '@/core/pubsub';
+import { type FulfillmentType } from '@/enums';
+import type { IAddress, ICoords } from '@/interfaces/cloud';
+import type { IAddressData } from '@/modules/address';
+import type { BillingFieldName, CustomerFieldName, GiftFieldName } from '@/modules/checkout/components/checkout.type';
+export interface IProductActions {
+    getDetails: (identifier: string) => IBaseProductEventData;
+}
+export interface IAddressActions {
+    setAddressByPlacesId: (placesId: string) => Promise<void>;
+    setAddressManually: (address: Omit<IAddress, 'id'>, coordinates: ICoords) => Promise<void>;
+    clear: () => void;
+    getDetails: () => IAddressData | null;
+}
+export interface ICartActions {
+    openCart: () => void;
+    closeCart: () => void;
+    toggleCart: () => void;
+    addProduct: (params: Array<{
+        identifier: string;
+        fulfillmentType: FulfillmentType;
+        quantity: number;
+    }>, openCart?: boolean) => Promise<void>;
+    applyPromoCode: (promoCode: string) => Promise<void>;
+    removePromoCode: () => Promise<void>;
+    resetCart: () => Promise<void>;
+    getDetails: () => IBaseCartEventData;
+}
+export interface ICheckoutActions {
+    openCheckout: () => void;
+    closeCheckout: () => void;
+    toggleCheckout: () => void;
+    addProduct: (params: Array<{
+        identifier: string;
+        fulfillmentType: FulfillmentType;
+        quantity: number;
+    }>, openCheckout?: boolean) => Promise<void>;
+    applyPromoCode: (promoCode: string) => Promise<void>;
+    removePromoCode: () => Promise<void>;
+    applyGiftCard: (code: string) => Promise<void>;
+    removeGiftCard: (code: string) => Promise<void>;
+    toggleIsGift: (active?: boolean) => Promise<void>;
+    toggleBillingSameAsShipping: (active?: boolean) => Promise<void>;
+    toggleMarketingPreferences: (field: 'canEmail' | 'canSms', active: boolean) => void;
+    updateCustomerInfo: (params: Record<CustomerFieldName, string>) => void;
+    updateBillingInfo: (params: Record<BillingFieldName, string>) => void;
+    updateGiftInfo: (params: Record<GiftFieldName, string>) => void;
+    getDetails: () => ICheckoutDetails;
+}
+export declare class ClientActionService {
+    private readonly pubSub;
+    private readonly command;
+    private readonly store;
+    private readonly api;
+    private readonly themeProvider;
+    private readonly logger;
+    constructor();
+    static getInstance(): ClientActionService;
+    private getLocation;
+    private productActions;
+    private addressActions;
+    private cartActions;
+    private checkoutActions;
+    actions: {
+        product: IProductActions;
+        address: IAddressActions;
+        cart: ICartActions;
+        checkout: ICheckoutActions;
+    };
+}

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

@@ -0,0 +1,47 @@
+import { type ElementsEnv } from '@/enums';
+import type { IClientCustomThemeConfig, IElementsProxyConfig, IPromoTicker } from '@/interfaces/core.interface';
+export type DeviceType = 'desktop' | 'tablet' | 'mobile';
+export interface IClientConfigs {
+    apiKey: string;
+    env: ElementsEnv;
+    isBuilder: boolean;
+    enableDebugging: boolean;
+    baseUrl: string;
+    customTheme: IClientCustomThemeConfig | null;
+    proxy: IElementsProxyConfig | null;
+    deviceType: DeviceType;
+    userDeviceId?: string;
+    isLocalStorageAvailable?: boolean;
+    version?: string;
+    clientPrepared: boolean;
+    promoTicker: IPromoTicker | null;
+}
+export interface IClientConfigInput {
+    env?: ElementsEnv;
+    isBuilder?: boolean;
+    enableDebugging?: boolean;
+    customTheme?: IClientCustomThemeConfig;
+    proxy?: IElementsProxyConfig;
+    promoTicker?: IPromoTicker;
+}
+export declare class ClientConfigService {
+    private config;
+    static getInstance(): ClientConfigService;
+    initialize(apiKey: string, configInput?: IClientConfigInput): void;
+    getConfigs(): IClientConfigs;
+    get<K extends keyof IClientConfigs>(key: K): IClientConfigs[K];
+    set<K extends keyof IClientConfigs>(key: K, value: IClientConfigs[K]): void;
+    isDevelopment(): boolean;
+    isStaging(): boolean;
+    isProduction(): boolean;
+    isBuilder(): boolean;
+    isDebuggingEnabled(): boolean;
+    debuggingDisabled(): boolean;
+    hasCustomTheme(): boolean;
+    isMobile(): boolean;
+    isLocalStorageAvailable(): boolean;
+    getProxyConfig(): IElementsProxyConfig | null;
+    private validateInputs;
+    private buildConfiguration;
+    private detectDeviceType;
+}

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

@@ -0,0 +1,17 @@
+import { ClientConfigService } from '@/core/client/client-config.service';
+import { GoogleTagManagerService } from '@/core/google-tag-manager.service';
+import { LoggerFactory } from '@/core/logger/logger-factory';
+import { PubSubService } from '@/core/pubsub';
+import { StoreService } from '@/core/store';
+import type { ILoc } from '@/interfaces/cloud';
+import { ApiClientService } from '@/modules/api-client/api-client.service';
+export declare abstract class BaseCommand {
+    protected store: StoreService;
+    protected api: ApiClientService;
+    protected logger: ReturnType<typeof LoggerFactory.get>;
+    protected pubSub: PubSubService;
+    protected googleTagManager: GoogleTagManagerService;
+    protected clientConfig: ClientConfigService;
+    constructor();
+    protected getLocation(): ILoc | undefined;
+}

package/dist/types/core/command/command.service.d.ts

@@ -0,0 +1,16 @@
+import { AddressCommands } from '@/modules/address/address.command';
+import { CartCommands } from '@/modules/cart/cart.commands';
+import { CheckoutCommands } from '@/modules/checkout/checkout.commands';
+import { ProductCommands } from '@/modules/product/product.commands';
+import { UICommands } from '@/modules/ui-components/ui.commands';
+import { CommonCommands } from './common-command.service';
+export declare class CommandService {
+    readonly ui: UICommands;
+    readonly address: AddressCommands;
+    readonly product: ProductCommands;
+    readonly cart: CartCommands;
+    readonly checkout: CheckoutCommands;
+    readonly common: CommonCommands;
+    constructor();
+    static getInstance(): CommandService;
+}

package/dist/types/core/command/common-command.service.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from './base-command.service';
+export declare class CommonCommands extends BaseCommand {
+    static getInstance(): CommonCommands;
+    loadCart(): Promise<void>;
+}

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

@@ -0,0 +1,27 @@
+import { type ComponentType } from '@/enums';
+import type { IBaseComponentConfig } from './base-component.service';
+interface ICreateComponentParams extends Omit<IBaseComponentConfig, 'tagName'> {
+    tagName?: string;
+    productId?: string;
+    cartId?: string;
+    checkoutId?: string;
+    isIndependentComponent?: boolean;
+    wrapInLceElement?: boolean;
+    [key: string]: any;
+}
+export declare class ComponentFactoryService {
+    private static _logger;
+    private static _clientConfig;
+    private static componentRegistry;
+    private static get logger();
+    private static get clientConfig();
+    private static getComponentRegistry;
+    static registerComponent(type: ComponentType, componentClass: any): void;
+    static createElement<T = any>(params: ICreateComponentParams & T): HTMLElement;
+    static componentError({ componentType, message }: {
+        componentType: ComponentType;
+        message: string;
+    }): HTMLElement;
+    static getDefaultTagName(type: ComponentType): string;
+}
+export {};

package/dist/types/core/fingerprint.service.d.ts

@@ -0,0 +1,28 @@
+interface FingerprintData {
+    screen: string;
+    webgl: string;
+    canvas: string;
+    browser: string;
+    timezone: string;
+}
+export declare class FingerPrintService {
+    private readonly keyPrefix;
+    private isLocalStorageAvailable;
+    static getInstance(): FingerPrintService;
+    getId(partnerCode: string): Promise<string>;
+    getFingerprintData(): Promise<FingerprintData>;
+    isLocalStorageWebApiAvailable(): boolean;
+    private _createComposedId;
+    private _checkLocalStorageAvailability;
+    private _findIdByPrefix;
+    private _generateFingerprint;
+    private _getScreen;
+    private _getWebGL;
+    private _getCanvas;
+    private _getBrowser;
+    private _getTimezone;
+    private _hash;
+    private _quickHash;
+    private _simpleHash;
+}
+export {};

package/dist/types/core/google-tag-manager.service.d.ts

@@ -0,0 +1,93 @@
+declare global {
+    interface Window {
+        dataLayer: any[];
+        gtag: (...args: any[]) => void;
+    }
+}
+interface GTMConfig {
+    partnerName: string;
+    partnerGtmId?: string;
+    partnerEnableGaTracking: boolean;
+    liquidCommerceEnableGaTracking: boolean;
+    liquidCommerceGtmId: string;
+}
+interface BaseItem {
+    item_id?: string;
+    item_name?: string;
+    affiliation?: string;
+    coupon?: string;
+    discount?: number;
+    index?: number;
+    item_brand?: string;
+    item_category?: string;
+    item_category2?: string;
+    item_category3?: string;
+    item_category4?: string;
+    item_category5?: string;
+    item_list_id?: string;
+    item_list_name?: string;
+    item_variant?: string;
+    location_id?: string;
+    price?: number;
+    quantity?: number;
+    item_type?: string;
+    item_subtype?: string;
+    upc?: string;
+    grouping_id?: string;
+    product_id?: string;
+}
+interface PurchaseData {
+    transaction_id: string;
+    items: BaseItem[];
+    value: number;
+    tax?: number;
+    shipping?: number;
+    coupon?: string;
+}
+export declare class GoogleTagManagerService {
+    private partnerName?;
+    private partnerGtmId?;
+    private liquidCommerceGtmId?;
+    private partnerEnableGaTracking;
+    private liquidCommerceEnableGaTracking;
+    private isInitialized;
+    private isInitializing;
+    private initializationPromise?;
+    private readonly currency;
+    private readonly logger;
+    private eventQueue;
+    private readonly clientConfigService;
+    constructor();
+    static getInstance(): GoogleTagManagerService;
+    private waitForDOMReady;
+    private isGTMAlreadyLoaded;
+    private isContainerLoaded;
+    private initializeGtag;
+    private loadGTMScript;
+    private processEventQueue;
+    private getSendToTargets;
+    initialize(config: GTMConfig): Promise<void>;
+    private doInitialize;
+    private executeEvent;
+    private calculateValue;
+    viewItem(item: BaseItem): void;
+    viewItemList(items: BaseItem[], listId?: string, listName?: string): void;
+    selectItem(item: BaseItem, listId?: string, listName?: string): void;
+    addToCart(item: BaseItem): void;
+    viewCart(items: BaseItem[]): void;
+    removeFromCart(item: BaseItem): void;
+    beginCheckout(items: BaseItem[], coupon?: string): void;
+    addShippingInfo(items: BaseItem[], coupon?: string): void;
+    addShippingInfoWithCustomerData(value: number, coupon?: string, customerData?: {
+        phone?: string;
+        email?: string;
+        birth_date?: string;
+        customer_id?: string;
+    }): void;
+    addPaymentInfo(items: BaseItem[], paymentType?: string, coupon?: string): void;
+    addPaymentInfoWithoutItems(value: number, paymentType?: string, coupon?: string): void;
+    purchase(purchaseData: PurchaseData): void;
+    increaseQuantity(item: BaseItem): void;
+    decreaseQuantity(item: BaseItem): void;
+}
+export {};

package/dist/types/core/logger/logger-factory.d.ts

@@ -0,0 +1,8 @@
+import { LoggerService } from './logger.service';
+export declare class LoggerFactory {
+    private static instances;
+    private static enableLoggingGlobally;
+    private static getInstances;
+    static get(context: string): LoggerService;
+    static setEnableLogging(enable: boolean): void;
+}

package/dist/types/core/logger/logger.service.d.ts

@@ -0,0 +1,17 @@
+export declare class LoggerService {
+    private readonly prefix;
+    private readonly colors;
+    private readonly context;
+    private enableLogging;
+    private constructor();
+    static getInstance(context: string): LoggerService;
+    setEnableLogging(enable: boolean): void;
+    private getPrefix;
+    debug(...args: any[]): void;
+    log(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    group(label: string, collapsed?: boolean): void;
+    groupEnd(): void;
+}

package/dist/types/core/pubsub/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interfaces';
+export * from './pubsub.service';

package/dist/types/core/pubsub/interfaces/address.interface.d.ts

@@ -0,0 +1,16 @@
+export interface IAddressActionEventData {
+    googlePlacesId: string;
+    formattedAddress: string;
+    address: {
+        one: string;
+        two: string;
+        city: string;
+        state: string;
+        zip: string;
+        country: string;
+    };
+    coordinates: {
+        lat: number;
+        long: number;
+    };
+}

package/dist/types/core/pubsub/interfaces/cart.interface.d.ts

@@ -0,0 +1,107 @@
+import type { ICartItemAttributes } from '@/interfaces/cloud';
+export interface ICartItemEventData {
+    id: string;
+    variantId: string;
+    liquidId: string;
+    retailerId: string;
+    partNumber: string;
+    fulfillmentId: string;
+    upc: string;
+    sku: string;
+    salsifyGrouping: string;
+    catPath: string;
+    volume: string;
+    uom: string;
+    pack: boolean;
+    packDesc: string;
+    container: string;
+    containerType: string;
+    name: string;
+    brand: string;
+    size: string;
+    price: number;
+    quantity: number;
+    maxQuantity: number;
+    unitPrice: number;
+    mainImage: string;
+    attributes: ICartItemAttributes;
+}
+export interface IBaseCartEventData {
+    id: string | null;
+    promoCode: string;
+    items: Record<string, ICartItemEventData>;
+    location: {
+        placesId: string;
+        address: {
+            one: string;
+            two: string;
+            city: string;
+            state: string;
+            zip: string;
+            country: string;
+        };
+        coordinates: {
+            latitude: number;
+            longitude: number;
+        };
+    };
+    amounts: {
+        deliveryFee: number;
+        discounts: number;
+        engravingFee: number;
+        giftCardTotal: number;
+        platformFee: number;
+        shippingFee: number;
+        subtotal: number;
+        total: number;
+    };
+    updatedAt: string;
+    createdAt: string;
+}
+export interface ICartLoadedEventData extends IBaseCartEventData {
+}
+export interface ICartFailedEventData {
+    message: string;
+}
+export interface ICartUpdatedEventData {
+    previous: IBaseCartEventData;
+    current: IBaseCartEventData;
+}
+export interface ICartItemAddedEventData {
+    id: string;
+    upc: string;
+    fulfillmentId: string;
+    partNumber: string;
+    quantity: number;
+    engravingLines?: string[];
+}
+export interface ICartItemRemovedEventData {
+    id: string;
+}
+export interface ICartItemQuantityChangedEventData {
+    id: string;
+    quantity: number;
+    previousQuantity: number;
+}
+export interface ICartItemEngravingUpdatedEventData {
+    id: string;
+    engravingLines: string[];
+    previousEngravingLines: string[];
+}
+export interface ICartPromoCodeEventData {
+    discountAmount?: number;
+    newTotal?: number;
+    applied: boolean;
+}
+export interface ICartPromoCodeFailedEventData {
+    error: string;
+    attempted: boolean;
+}
+export interface ICartProductAddEventData {
+    itemsAdded: number;
+    identifiers: string[];
+}
+export interface ICartProductAddFailedEventData {
+    identifiers: string[];
+    error: string;
+}