@liquidcommercedev/rmn-sdk 1.5.0-beta.1 → 1.5.0-beta.11

package/dist/types/common/helpers/event-type.helper.d.ts

@@ -0,0 +1,8 @@
+import { RMN_SPOT_EVENT } from 'enums';
+/**
+ * Determines the event type from a raw event string by checking for keyword patterns.
+ *
+ * @param {string} [event] - The raw event string to evaluate
+ * @returns {RMN_SPOT_EVENT | null} - The corresponding RMN_SPOT_EVENT or null if no match
+ */
+export declare function getEventTypeFromRawEvent(event?: string): RMN_SPOT_EVENT | null;

package/dist/types/common/helpers/index.d.ts

@@ -1,2 +1,6 @@
+export * from './event-type.helper';
+export * from './helpers.interface';
 export * from './object.helper';
 export * from './string.helper';
+export * from './utils.helper';
+export * from './uuid.helper';

package/dist/types/common/helpers/utils.helper.d.ts

@@ -0,0 +1,37 @@
+import type { IFireEventParams } from 'modules/event';
+/**
+ * Recursively extracts ID values from a nested data structure.
+ * Searches for specified property names and collects their primitive values (strings/numbers).
+ *
+ * @param data - The data structure to search through (can be nested objects/arrays)
+ * @param propertyNames - Array of property names to look for
+ * @returns Array of extracted ID values (strings/numbers only)
+ *
+ * @example
+ * const data = {
+ *   id: [1, 2, 3],
+ *   nested: { id: 'abc' },
+ *   items: [{ id: 456 }]
+ * };
+ * extractDeepIds(data); // Returns [1, 2, 3, 'abc', 456]
+ */
+export declare function extractDeepIds(data: any, propertyNames?: string[]): Array<string | number>;
+export declare function fallbackEventFire(url: string): Promise<boolean>;
+/**
+ * Extracts and decodes a URL from a base64-encoded query parameter.
+ *
+ * @param {string} url - The URL containing the base64-encoded query parameter.
+ * @returns {string | null} - The decoded URL or null if not found or invalid.
+ */
+export declare function getRedirectUrlFromPayload(url: string): string | null;
+/**
+ * Fires an event using the navigator.sendBeacon method or a fallback method if sendBeacon is not available.
+ * If the event is a click event and a redirect URL is found, it redirects the user to that URL.
+ *
+ * @param {IFireEventParams} params - The parameters for firing the event.
+ * @param {RMN_SPOT_EVENT} params.event - The event type.
+ * @param {string} params.eventUrl - The URL to which the event is sent.
+ * @returns {Promise<void>} - A promise that resolves when the event is fired.
+ */
+export declare function fireEvent({ event, eventUrl }: IFireEventParams): Promise<void>;
+export declare function calculateScaleFactor(elementScale: number): number;

package/dist/types/enums.d.ts

@@ -1,4 +1,5 @@
 export declare enum RMN_SPOT_TYPE {
+    RB_HOMEPAGE_HERO = "rbHomepageHero",
     RB_HOMEPAGE_HERO_THREE_TILE = "rbHomepageHeroThreeTile",
     RB_HOMEPAGE_HERO_TWO_TILE = "rbHomepageHeroTwoTile",
     RB_HOMEPAGE_HERO_FULL_IMAGE = "rbHomepageHeroFullImage",
@@ -48,13 +49,19 @@ export declare enum RMN_FILTER_PROPERTIES {
     PUBLISHERS = "publishers",
     SECTION = "section"
 }
-export declare enum RMN_SPOT_EVENT {
+export declare enum RMN_EVENT {
     LIFECYCLE_STATE = "LIFECYCLE_STATE",
+    SPOT_EVENT = "SPOT_EVENT"
+}
+export declare enum RMN_SPOT_EVENT {
     IMPRESSION = "IMPRESSION",
     CLICK = "CLICK",
     PURCHASE = "PURCHASE",
     ADD_TO_CART = "ADD_TO_CART",
+    REMOVE_FROM_CART = "REMOVE_FROM_CART",
+    ADD_TO_CART_FROM_DETAILS = "ADD_TO_CART_FROM_DETAILS",
     ADD_TO_WISHLIST = "ADD_TO_WISHLIST",
+    EXPAND_PRODUCT = "EXPAND_PRODUCT",
     BUY_NOW = "BUY_NOW"
 }
 export declare enum RMN_ENV {

package/dist/types/modules/element/element.interface.d.ts

@@ -1,4 +1,4 @@
-import type { RMN_SPOT_TYPE } from 'enums';
+import type { RMN_FILTER_PROPERTIES, RMN_SPOT_TYPE } from 'enums';
 import type { ICarouselOptions, ICreateCarouselElementParams } from 'modules/element/component/carousel';
 import type { ICreateSpotElementParams } from 'modules/element/component/spot';
 import type { RmnFilterType } from 'modules/selection';
@@ -21,12 +21,15 @@ export interface IInjectSpotElementConfig {
     overlay?: ISpotOverlay;
     carousel?: ICarouselOptions;
 }
+export type IInjectSpotElementFilterType = Partial<Omit<RmnFilterType, RMN_FILTER_PROPERTIES.KEYWORDS> & {
+    exactMatch?: string;
+}>;
 export interface IInjectSpotElement {
     placementId: string;
     spotType: RMN_SPOT_TYPE | string;
     count?: number;
     config?: Omit<IInjectSpotElementConfig, 'url'>;
-    filter?: Partial<RmnFilterType>;
+    filter?: IInjectSpotElementFilterType;
 }
 export interface ICreateElementConfig {
     spot?: RMN_SPOT_TYPE;

package/dist/types/modules/event/event.interface.d.ts

@@ -1,4 +1,4 @@
-import type { RMN_SPOT_EVENT } from 'enums';
+import type { RMN_EVENT, RMN_SPOT_EVENT } from 'enums';
 import type { ISpot } from '../selection';
 export interface IFireEventParams {
     event: RMN_SPOT_EVENT;
@@ -30,40 +30,14 @@ export interface ILifecycleState {
     state?: Partial<ILSState>;
     displayConfig?: Partial<ILSDisplayConfig>;
 }
-export interface IClickEvent {
-    placementId: string;
-    spotId: string;
-    spotElement: HTMLElement;
-}
-export interface IImpressionEvent {
-    placementId: string;
-    spotId: string;
-    spotElement: HTMLElement;
-}
-export interface IAddToCartEvent {
-    placementId: string;
-    spotId: string;
-}
-export interface IAddToWishlistEvent {
-    placementId: string;
-    spotId: string;
-}
-export interface IPurchaseEvent {
-    placementId: string;
-    spotId: string;
-}
-export interface IBuyNowEvent {
+export interface IRmnSpotEvent {
+    eventType: RMN_SPOT_EVENT;
     placementId: string;
     spotId: string;
 }
-export interface IEventMap {
-    [RMN_SPOT_EVENT.LIFECYCLE_STATE]: ILifecycleState;
-    [RMN_SPOT_EVENT.CLICK]: IClickEvent;
-    [RMN_SPOT_EVENT.IMPRESSION]: IImpressionEvent;
-    [RMN_SPOT_EVENT.ADD_TO_CART]: IAddToCartEvent;
-    [RMN_SPOT_EVENT.ADD_TO_WISHLIST]: IAddToWishlistEvent;
-    [RMN_SPOT_EVENT.PURCHASE]: IPurchaseEvent;
-    [RMN_SPOT_EVENT.BUY_NOW]: IBuyNowEvent;
+export interface IRmnEventMap {
+    [RMN_EVENT.LIFECYCLE_STATE]: ILifecycleState;
+    [RMN_EVENT.SPOT_EVENT]: IRmnSpotEvent;
 }
 export interface IRegisterSpotParams {
     placementId: string;

package/dist/types/modules/event/event.service.d.ts

@@ -1,16 +1,16 @@
-import { RMN_SPOT_EVENT } from 'enums';
-import type { IEventMap, ILifecycleState, IRegisterSpotParams } from './event.interface';
+import { RMN_EVENT } from 'enums';
+import type { ILifecycleState, IRegisterSpotParams, IRmnEventMap } from './event.interface';
 export declare class EventService {
     private static instance;
-    private pubSub;
-    private localStorage;
+    private pubSubService;
+    private localStorageService;
     private intersectionObserver;
     private spotStates;
     private activeSpots;
     private constructor();
     static getInstance(): EventService;
-    subscribe(eventType: RMN_SPOT_EVENT, callback: (data: IEventMap[RMN_SPOT_EVENT]) => void): () => void;
-    publish(eventType: RMN_SPOT_EVENT, data: IEventMap[RMN_SPOT_EVENT]): void;
+    subscribe(eventType: RMN_EVENT, callback: (data: IRmnEventMap[RMN_EVENT]) => void): () => void;
+    publish(eventType: RMN_EVENT, data: IRmnEventMap[RMN_EVENT]): void;
     registerSpot(params: IRegisterSpotParams): void;
     unregisterSpot(placementId: string): void;
     /**
@@ -23,23 +23,8 @@ export declare class EventService {
      * @returns {void}
      */
     handleSpotState(placementId: string, updates: Partial<ILifecycleState>, publish?: boolean): void;
+    private deepMerge;
     private handleClick;
     private handleIntersectionObserver;
     private fireImpressionEvent;
-    /**
-     * Fires an event using the navigator.sendBeacon method and redirects the user if the event is a click event.
-     *
-     * @param {IFireEventParams} params - The parameters for firing the event.
-     * @param {RMN_SPOT_EVENT} params.event - The event type.
-     * @param {string} params.eventUrl - The URL to which the event is sent.
-     * @returns {Promise<void>} - A promise that resolves when the event is fired.
-     */
-    private fireEvent;
-    /**
-     * Extracts and decodes a URL from a base64-encoded query parameter.
-     *
-     * @param {string} url - The URL containing the base64-encoded query parameter.
-     * @returns {string} - The decoded URL or an empty string if decoding fails.
-     */
-    private getRedirectUrlFromPayload;
 }

package/dist/types/modules/event/index.d.ts

@@ -1,4 +1,3 @@
 export * from './event.constant';
 export * from './event.interface';
 export * from './event.service';
-export * from './helpers';

package/dist/types/modules/{event/helpers → helper-service}/index.d.ts

@@ -1,3 +1,4 @@
 export * from './intersection.service';
 export * from './localstorage.service';
+export * from './pubsub.service';
 export * from './resize.service';

package/dist/types/modules/{event/helpers → helper-service}/intersection.service.d.ts

@@ -1,6 +1,6 @@
 export declare class IntersectionObserverService {
     private observers;
-    private defaultOptions;
+    private readonly defaultOptions;
     constructor(defaultOptions?: IntersectionObserverInit);
     observe(element: HTMLElement, callback: (entry: IntersectionObserverEntry) => void, options?: IntersectionObserverInit): void;
     unobserve(element: HTMLElement): void;

package/dist/types/modules/helper-service/localstorage.service.d.ts

@@ -0,0 +1,56 @@
+import type { RMN_SPOT_TYPE } from 'enums';
+import type { ISpotEvent } from 'modules/selection';
+export interface ILocalStorageSpot {
+    placementId: string;
+    spotId: string;
+    spotType: RMN_SPOT_TYPE;
+    events: ISpotEvent[];
+    productIds: Array<string | number>;
+    createdAt?: number;
+}
+export type LocalStorageSpotsMapType = Map<string, // spotId
+ILocalStorageSpot>;
+export type LocalStorageSpotsObjectType = Record<string, // spotId
+ILocalStorageSpot>;
+export type LocalStorageSpotArray = [
+    string,
+    string,
+    RMN_SPOT_TYPE,
+    ISpotEvent[],
+    Array<string | number>,
+    // PRODUCT_IDS = 4
+    number | undefined
+];
+export declare enum ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX {
+    PLACEMENT_ID = 0,
+    SPOT_ID = 1,
+    SPOT_TYPE = 2,
+    EVENTS = 3,
+    PRODUCT_IDS = 4,
+    CREATED_AT = 5
+}
+export type LocalStorageSpotsArrayType = Record<string, // spotId
+LocalStorageSpotArray>;
+export declare class LocalStorageService {
+    private spots?;
+    private static instance;
+    private static readonly localStorageKey;
+    private static readonly spotExpirationTime;
+    private static readonly encryptData;
+    private constructor();
+    static getInstance(): LocalStorageService;
+    private syncLocalStorage;
+    setSpot(spotId: string, data: ILocalStorageSpot): void;
+    removeSpot(spotId: string): void;
+    getSpot(spotId: string): ILocalStorageSpot | undefined;
+    getSpots(): LocalStorageSpotsObjectType | undefined;
+    private updateLocalStorage;
+    private clearLocalStorage;
+    private removeExpiredSpots;
+    private mapToObject;
+    private objectToMap;
+    private objectToArray;
+    private arrayToObject;
+    private encryptData;
+    private decryptData;
+}

package/dist/types/modules/{event/pubsub.d.ts → helper-service/pubsub.service.d.ts}

@@ -8,13 +8,13 @@ export type PubSubCallback<T> = (data: T) => void;
  */
 export type PubSubUnsubscribe = () => void;
 /**
- * PubSub class
+ * PubsubService class
  * Manages event subscriptions and publications
- * @template IEventMap A record type defining the structure of events and their data
+ * @template IRmnEventMap A record type defining the structure of events and their data
  */
-export declare class PubSub<IEventMap> {
+export declare class PubsubService<IRmnEventMap> {
     private static instance;
-    static getInstance<IEventMap>(): PubSub<IEventMap>;
+    static getInstance<IRmnEventMap>(): PubsubService<IRmnEventMap>;
     /**
      * Object to store subscribers for each event type
      */
@@ -30,7 +30,7 @@ export declare class PubSub<IEventMap> {
      *   console.log(`User ${data.username} logged in`);
      * });
      */
-    subscribe<K extends keyof IEventMap>(eventType: K, callback: PubSubCallback<IEventMap[K]>): PubSubUnsubscribe;
+    subscribe<K extends keyof IRmnEventMap>(eventType: K, callback: PubSubCallback<IRmnEventMap[K]>): PubSubUnsubscribe;
     /**
      * Publish an event
      * @param eventType - The type of event to publish
@@ -39,17 +39,17 @@ export declare class PubSub<IEventMap> {
      * @Example:
      * pubSub.publish('userLogin', { username: 'john_doe', timestamp: Date.now() });
      */
-    publish<K extends keyof IEventMap>(eventType: K, data: IEventMap[K]): void;
+    publish<K extends keyof IRmnEventMap>(eventType: K, data: IRmnEventMap[K]): void;
 }
 /**
  * Usage Example:
  *
- * interface IEventMap {
+ * interface IRmnEventMap {
  *   userLogin: { username: string; timestamp: number };
  *   pageView: { url: string; timestamp: number };
  * }
  *
- * const pubSub = new PubSub<IEventMap>();
+ * const pubSub = new PubsubService<IRmnEventMap>();
  *
  * // Subscribe to events
  * const unsubscribeLogin = pubSub.subscribe('userLogin', (data) => {

package/dist/types/modules/{event/helpers → helper-service}/resize.service.d.ts

@@ -18,7 +18,7 @@ export interface ISizeChangedEvent extends CustomEvent {
 }
 export declare class ResizeObserverService {
     private element;
-    private container;
+    private readonly container;
     private resizeObserver;
     private maxSize;
     private minSize;

package/dist/types/modules/monitor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './monitor.interface';
+export * from './monitor.service';

package/dist/types/modules/monitor/monitor.enums.d.ts

@@ -0,0 +1,4 @@
+export declare enum AnalyticsTool {
+    GoogleAnalytics = "google-analytics",
+    Other = "Other"
+}

package/dist/types/modules/monitor/monitor.interface.d.ts

@@ -0,0 +1,11 @@
+import type { RMN_SPOT_EVENT } from 'enums';
+export interface INormalizedEventData {
+    event: RMN_SPOT_EVENT;
+    productIds: Array<string | number>;
+}
+export interface IFireAndPublishSpotEventParams {
+    spotEvent: RMN_SPOT_EVENT;
+    eventUrl: string;
+    placementId: string;
+    spotId: string;
+}

package/dist/types/modules/monitor/monitor.service.d.ts

@@ -0,0 +1,12 @@
+export declare class MonitorService {
+    private static instance;
+    private readonly implementedMonitor?;
+    private readonly pubSubService?;
+    private readonly localStorageService?;
+    private constructor();
+    static getInstance(): MonitorService;
+    start(): void;
+    private matchAndFireEvent;
+    private fireAndPublishSpotEvent;
+    private detectAnalyticsTool;
+}

package/dist/types/modules/monitor/monitors/datalayer.monitor.d.ts

@@ -0,0 +1,12 @@
+import type { INormalizedEventData } from '../monitor.interface';
+export declare class DataLayerMonitor {
+    private static instance;
+    private readonly originalPush;
+    private listener?;
+    private constructor();
+    static getInstance(): DataLayerMonitor;
+    setListener(listener: (data: INormalizedEventData) => void): void;
+    start(): void;
+    private cleanEventData;
+    stop(): void;
+}

package/dist/types/modules/selection/selection.interface.d.ts

@@ -30,7 +30,9 @@ export interface ISpot {
     mobilePrimaryImage?: string;
     mobileSecondaryImage?: string;
     productIds?: Array<string | number>;
-    productUpcs?: string[];
+    rbProductUpcs?: Array<string | number>;
+    rbProductSalsifyGroupings?: Array<string | number>;
+    rbProductSalsifyPids?: Array<string | number>;
 }
 export type ISpots = Record<PlacementIdType, ISpot[]>;
 export interface ISelectionService {

package/dist/types/rmn-client.d.ts

@@ -14,7 +14,7 @@ export declare class LiquidCommerceRmnClient implements IRmnClient {
      *
      * @param {ISpotSelectionParams} params - Spots selection parameters.
      *
-     * @return {Promise<ISpots | {error : string}>} - The spots response object.
+     * @return {Promise<ISpots | { error : string }>} - The spots response object.
      */
     spotSelection(params: ISpotSelectionParams): Promise<ISpots | {
         error: string;

package/dist/types/types.d.ts

@@ -1,10 +1,11 @@
-import type { IEventMap } from './modules/event';
 export type { IInjectSpotElement, IInjectSpotElementConfig, IInjectSpotElementParams, IRmnCreateSpotElementConfig, ISpotColors, ISpotOverlay, } from 'modules/element';
 export type { CarouselNavPositionType, ICarouselButtonOptions, ICarouselDotOptions, ICarouselOptions, } from 'modules/element/component/carousel';
+export type { ILifecycleState, ILSDisplayConfig, ILSDom, ILSIdentifier, ILSState, IRmnEventMap, IRmnSpotEvent, } from 'modules/event';
 export type { ISpots, RmnFilterType, RmnSpotType } from 'modules/selection';
 export { ISpot, ISpotEvent, ISpotSelectionParams } from 'modules/selection';
-import type { RMN_ENV, RMN_SPOT_EVENT } from 'enums';
+import type { RMN_ENV, RMN_EVENT } from 'enums';
 import type { IInjectSpotElementParams } from 'modules/element';
+import type { IRmnEventMap } from 'modules/event';
 import type { ISpots, ISpotSelectionParams } from 'modules/selection';
 export interface IRmnClient {
     spotSelection(params: ISpotSelectionParams): Promise<ISpots | {
@@ -13,8 +14,8 @@ export interface IRmnClient {
     injectSpotElement(params: IInjectSpotElementParams): Promise<void>;
 }
 export interface IRmnEventManager {
-    subscribe: (eventType: RMN_SPOT_EVENT, callback: (data: IEventMap[RMN_SPOT_EVENT]) => void) => () => void;
-    publish: (eventType: RMN_SPOT_EVENT, data: IEventMap[RMN_SPOT_EVENT]) => void;
+    subscribe: (eventType: RMN_EVENT, callback: (data: IRmnEventMap[RMN_EVENT]) => void) => () => void;
+    publish: (eventType: RMN_EVENT, data: IRmnEventMap[RMN_EVENT]) => void;
     destroySpot: (placementId: string) => void;
 }
 export interface IRmnConfig {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@liquidcommercedev/rmn-sdk",
   "description": "LiquidCommerce RMN SDK",
   "author": "LiquidCommerce Tech",
-  "version": "1.5.0-beta.1",
+  "version": "1.5.0-beta.11",
   "homepage": "https://docs.liquidcommerce.co/rmn-sdk",
   "main": "./dist/index.cjs",
   "module": "./dist/index.esm.js",