@liquidcommercedev/rmn-sdk 1.5.0-beta.10 → 1.5.0-beta.12

package/dist/index.esm.js

@@ -65,7 +65,9 @@ var RMN_SPOT_EVENT;
     RMN_SPOT_EVENT["PURCHASE"] = "PURCHASE";
     RMN_SPOT_EVENT["ADD_TO_CART"] = "ADD_TO_CART";
     RMN_SPOT_EVENT["REMOVE_FROM_CART"] = "REMOVE_FROM_CART";
+    RMN_SPOT_EVENT["ADD_TO_CART_FROM_DETAILS"] = "ADD_TO_CART_FROM_DETAILS";
     RMN_SPOT_EVENT["ADD_TO_WISHLIST"] = "ADD_TO_WISHLIST";
+    RMN_SPOT_EVENT["EXPAND_PRODUCT"] = "EXPAND_PRODUCT";
     RMN_SPOT_EVENT["BUY_NOW"] = "BUY_NOW";
 })(RMN_SPOT_EVENT || (RMN_SPOT_EVENT = {}));
 var RMN_ENV;
@@ -580,6 +582,69 @@ const RB_SPOTS_SELECTION_EXAMPLE = {
         },
     ],
 };
+const IAB_SPOTS_SELECTION_EXAMPLE = {
+    banner: [],
+    billboard: [
+        {
+            id: 'kol567',
+            spot: RMN_SPOT_TYPE.BILLBOARD,
+            variant: `${RMN_SPOT_TYPE.BILLBOARD}V2`,
+            width: 1140,
+            height: 640,
+            header: 'Holiday Gift Guide',
+            description: 'Perfect spirits for every occasion',
+            ctaText: 'Shop Gifts',
+            textColor: '#ffffff',
+            ctaTextColor: '#ffffff',
+            primaryImage: 'https://placehold.co/1140x640/png?text=Gift+Guide',
+            mobilePrimaryImage: 'https://placehold.co/640x640/png?text=Mobile+Gifts',
+            events: SPOT_EVENTS_EXAMPLE,
+            productIds: [25, 26],
+        },
+        {
+            id: 'hpm390',
+            spot: RMN_SPOT_TYPE.BILLBOARD,
+            variant: `${RMN_SPOT_TYPE.BILLBOARD}V2`,
+            width: 1140,
+            height: 640,
+            header: 'Summer Wine Festival',
+            description: 'Refreshing wines for summer',
+            ctaText: 'Shop Festival',
+            textColor: '#ffffff',
+            ctaTextColor: '#ffffff',
+            primaryImage: 'https://placehold.co/1140x640/png?text=Wine+Festival',
+            mobilePrimaryImage: 'https://placehold.co/640x640/png?text=Mobile+Festival',
+            events: SPOT_EVENTS_EXAMPLE,
+            productIds: [27, 28],
+        },
+    ],
+    button2: [],
+    featurePhoneLargeBanner: [],
+    featurePhoneMediumBanner: [],
+    featurePhoneSmallBanner: [],
+    halfPage: [],
+    inText: [],
+    largeLeaderboard: [],
+    largeRectangle: [],
+    leaderboard: [],
+    mediumRectangle: [],
+    microBar: [],
+    mobilePhoneInterstitial1: [],
+    mobilePhoneInterstitial2: [],
+    mobilePhoneInterstitial3: [],
+    popUp: [],
+    portrait: [],
+    rbProductUpcs: [],
+    skyscraper: [],
+    smallRectangle: [],
+    smallSquare: [],
+    smartphoneBanner1: [],
+    smartphoneBanner2: [],
+    square: [],
+    verticalBanner: [],
+    verticalRectangle: [],
+    wideSkyscraper: [],
+};
 
 const REQUEST_CLOUD_PARTNER_SITE = 'X-Liquid-Partner-Site';
 const REQUEST_CLOUD_PROTECTED_KEY = 'X-Liquid-Protected';
@@ -6543,6 +6608,94 @@ axios.HttpStatusCode = HttpStatusCode;
 
 axios.default = axios;
 
+/**
+ * Keyword patterns for each RMN_SPOT_EVENT.
+ * Each event type has required keywords that must be present and optional ones.
+ *
+ * Note: The order of checks matters - more specific patterns must be checked before general ones
+ * to avoid incorrect matches.
+ */
+const EVENT_KEYWORDS = {
+    [RMN_SPOT_EVENT.ADD_TO_CART_FROM_DETAILS]: {
+        required: ['add', 'cart'],
+        optional: ['details', 'detail', 'single', 'profile', 'page', 'pdp'],
+    },
+    [RMN_SPOT_EVENT.BUY_NOW]: {
+        required: ['buy', 'now'],
+    },
+    [RMN_SPOT_EVENT.EXPAND_PRODUCT]: {
+        required: ['product'],
+        optional: ['details', 'expand', 'modal', 'popup', 'quickview', 'view'],
+    },
+    [RMN_SPOT_EVENT.ADD_TO_WISHLIST]: {
+        required: ['add', 'wishlist'],
+    },
+    [RMN_SPOT_EVENT.REMOVE_FROM_CART]: {
+        required: ['remove', 'cart'],
+    },
+    [RMN_SPOT_EVENT.PURCHASE]: {
+        required: ['purchase'],
+    },
+    [RMN_SPOT_EVENT.ADD_TO_CART]: {
+        required: ['add', 'cart'],
+    },
+};
+/**
+ * Normalizes an event name by converting to lowercase, removing special characters,
+ * and splitting into words.
+ */
+function normalizeEventName(event) {
+    return event
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]+/g, ' ') // Replace special chars with spaces
+        .split(/\s+/) // Split on whitespace
+        .filter(Boolean); // Remove empty strings
+}
+/**
+ * Checks if a word matches a keyword, considering word boundaries.
+ * This prevents partial word matches (e.g., "card" shouldn't match "cart").
+ */
+function wordMatchesKeyword(word, keyword) {
+    // Create a RegExp that matches the keyword as a whole word
+    const keywordRegex = new RegExp(`^${keyword}s?$|${keyword}s?\\W|\\W${keyword}s?$|\\W${keyword}s?\\W`);
+    return keywordRegex.test(` ${word} `); // Add spaces to handle word boundaries
+}
+/**
+ * Checks if all required keywords and at least one optional keyword (if specified) are present.
+ */
+function matchesKeywordPattern(words, required, optional) {
+    // Check if all required keywords are present as whole words
+    const hasAllRequired = required.every((keyword) => words.some((word) => wordMatchesKeyword(word, keyword)));
+    if (!hasAllRequired) {
+        return false;
+    }
+    // If no optional keywords are specified, return true
+    if (!(optional === null || optional === void 0 ? void 0 : optional.length)) {
+        return true;
+    }
+    // If optional keywords exist, check if at least one matches as a whole word
+    return optional.some((keyword) => words.some((word) => wordMatchesKeyword(word, keyword)));
+}
+/**
+ * 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
+ */
+function getEventTypeFromRawEvent(event) {
+    if (!(event === null || event === void 0 ? void 0 : event.trim())) {
+        return null;
+    }
+    const words = normalizeEventName(event);
+    // Use Object.entries to maintain the exact order defined in EVENT_KEYWORDS
+    for (const [eventType, { required, optional }] of Object.entries(EVENT_KEYWORDS)) {
+        if (matchesKeywordPattern(words, required, optional)) {
+            return eventType;
+        }
+    }
+    return null;
+}
+
 class SingletonManager {
     /**
      * Retrieves an instance of the specified class using the provided instance creator function.
@@ -6708,107 +6861,414 @@ class ObjectHelper {
     }
 }
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function getAugmentedNamespace(n) {
-  if (n.__esModule) return n;
-  var f = n.default;
-	if (typeof f == "function") {
-		var a = function a () {
-			if (this instanceof a) {
-        return Reflect.construct(f, arguments, this.constructor);
-			}
-			return f.apply(this, arguments);
-		};
-		a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
+/**
+ * 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]
+ */
+function extractDeepIds(data, propertyNames) {
+    const ids = [];
+    const defaulPropertyNames = [
+        'id',
+        'upc',
+        'groupingId',
+        'sku',
+        'productId',
+        'item_id',
+        'isbn',
+        'asin',
+        'mpn',
+        'model_number',
+        'article_number',
+        'variant_id',
+        'item_number',
+        'catalog_id',
+        'reference_id',
+    ];
+    // Set for faster property name lookups
+    const propertySet = new Set(defaulPropertyNames);
+    /**
+     * Processes a value and extracts IDs if it matches criteria
+     * @param value - The value to process
+     * @param currentKey - The property name of the current value
+     */
+    const processValue = (value, currentKey) => {
+        // Early exit for null/undefined values
+        if (value == null)
+            return;
+        // If current key matches our target properties
+        if (currentKey && propertySet.has(currentKey)) {
+            if (Array.isArray(value)) {
+                // Filter and push valid array values in one pass
+                ids.push(...value.filter((item) => typeof item === 'string' || typeof item === 'number'));
+            }
+            else if (typeof value === 'string' || typeof value === 'number') {
+                ids.push(value);
+            }
+            return; // Stop processing this branch after handling the ID
+        }
+        // Recursively process nested structures
+        if (Array.isArray(value)) {
+            value.forEach((item) => processValue(item));
+        }
+        else if (typeof value === 'object') {
+            // Process all enumerable properties
+            for (const [key, val] of Object.entries(value)) {
+                processValue(val, key);
+            }
+        }
+    };
+    processValue(data);
+    return ids; // No need to filter nulls as we handle that during collection
 }
-
-var cryptoJs = {exports: {}};
-
-function commonjsRequire(path) {
-	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+// Fallback method using fetch if sendBeacon isn't available
+async function fallbackEventFire(url) {
+    try {
+        const racePromise = Promise.race([
+            // Promise #1: The fetch request
+            fetch(url, {
+                method: 'POST',
+                keepalive: true,
+            }),
+            // Promise #2: The timeout
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Request timeout')), 2000)),
+        ]);
+        /**
+         * Prevent requests from hanging indefinitely
+         * Improve user experience by failing fast
+         * Handle slow network conditions gracefully
+         * Ensure resources are freed up in a timely manner
+         */
+        const response = await racePromise;
+        return response.ok;
+    }
+    catch (_a) {
+        return false;
+    }
 }
-
-var core = {exports: {}};
-
-var _polyfillNode_crypto = {};
-
-var _polyfillNode_crypto$1 = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  default: _polyfillNode_crypto
-});
-
-var require$$0 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_crypto$1);
-
-var hasRequiredCore;
-
-function requireCore () {
-	if (hasRequiredCore) return core.exports;
-	hasRequiredCore = 1;
-	(function (module, exports) {
-(function (root, factory) {
-			{
-				// CommonJS
-				module.exports = factory();
-			}
-		}(commonjsGlobal, function () {
-
-			/*globals window, global, require*/
-
-			/**
-			 * CryptoJS core components.
-			 */
-			var CryptoJS = CryptoJS || (function (Math, undefined$1) {
-
-			    var crypto;
-
-			    // Native crypto from window (Browser)
-			    if (typeof window !== 'undefined' && window.crypto) {
-			        crypto = window.crypto;
-			    }
-
-			    // Native crypto in web worker (Browser)
-			    if (typeof self !== 'undefined' && self.crypto) {
-			        crypto = self.crypto;
-			    }
-
-			    // Native crypto from worker
-			    if (typeof globalThis !== 'undefined' && globalThis.crypto) {
-			        crypto = globalThis.crypto;
-			    }
-
-			    // Native (experimental IE 11) crypto from window (Browser)
-			    if (!crypto && typeof window !== 'undefined' && window.msCrypto) {
-			        crypto = window.msCrypto;
-			    }
-
-			    // Native crypto from global (NodeJS)
-			    if (!crypto && typeof commonjsGlobal !== 'undefined' && commonjsGlobal.crypto) {
-			        crypto = commonjsGlobal.crypto;
-			    }
-
-			    // Native crypto import via require (NodeJS)
-			    if (!crypto && typeof commonjsRequire === 'function') {
-			        try {
-			            crypto = require$$0;
-			        } catch (err) {}
-			    }
-
-			    /*
-			     * Cryptographically secure pseudorandom number generator
-			     *
+/**
+ * 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.
+ */
+function getRedirectUrlFromPayload(url) {
+    try {
+        const base64String = new URL(url).searchParams.get('e');
+        if (!base64String) {
+            return null;
+        }
+        const data = JSON.parse(atob(base64String));
+        return data.ur || null;
+    }
+    catch (_a) {
+        return 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.
+ */
+async function fireEvent({ event, eventUrl }) {
+    var _a;
+    try {
+        const didFireEvent = ((_a = navigator === null || navigator === void 0 ? void 0 : navigator.sendBeacon) === null || _a === void 0 ? void 0 : _a.call(navigator, eventUrl)) || (await fallbackEventFire(eventUrl));
+        if (!didFireEvent) {
+            return;
+        }
+        if (event === RMN_SPOT_EVENT.CLICK) {
+            const redirectUrl = getRedirectUrlFromPayload(eventUrl);
+            if (redirectUrl) {
+                window.location.href = redirectUrl;
+            }
+        }
+    }
+    catch (_b) {
+        // Handle errors silently
+    }
+}
+function calculateScaleFactor(elementScale) {
+    // Step 1: Apply square root for non-linear scaling
+    // This creates a more gradual scaling effect, especially for larger changes
+    // For example:
+    // - elementScale of 0.25 (1/4 size) becomes 0.5
+    // - elementScale of 1 (unchanged) remains 1
+    // - elementScale of 4 (4x size) becomes 2
+    const baseFactor = Math.sqrt(elementScale);
+    // Step 2: Apply additional dampening to further soften the scaling effect
+    // The dampening factor (0.5) can be adjusted:
+    // - Lower values (closer to 0) make scaling more subtle
+    // - Higher values (closer to 1) make scaling more pronounced
+    const dampening = 0.35;
+    // Calculate the scaleFactor:
+    // 1. (baseFactor - 1) represents the change from the original size
+    // 2. Multiply by dampening to reduce the effect
+    // 3. Add 1 to center the scaling around the original size
+    // For example, if baseFactor is 2:
+    // scaleFactor = 1 + (2 - 1) * 0.5 = 1.5
+    const scaleFactor = 1 + (baseFactor - 1) * dampening;
+    // Step 3: Define the allowed range for the scale factor
+    // This ensures that the font size never changes too drastically
+    const minScale = 0.35; // Font will never be smaller than 50% of original
+    const maxScale = 1.5; // Font will never be larger than 150% of original
+    // Step 4: Clamp the scale factor to the defined range
+    // Math.min ensures the value doesn't exceed maxScale
+    // Math.max ensures the value isn't less than minScale
+    return Math.max(minScale, Math.min(maxScale, scaleFactor));
+}
+
+class UniqueIdGenerator {
+    /**
+     * Initialize the generator with a node ID
+     * @param nodeId Number between 0-1023 to identify this instance
+     */
+    static initialize(nodeId = Math.floor(Math.random() * 1024)) {
+        if (nodeId < 0 || nodeId >= 1 << this.nodeBits) {
+            throw new Error(`Node ID must be between 0 and ${(1 << this.nodeBits) - 1}`);
+        }
+        this.nodeId = nodeId;
+    }
+    /**
+     * Convert a number to base32 string with specified length
+     */
+    static toBase32(num, length) {
+        let result = '';
+        while (num > 0) {
+            result = this.base32Chars[Number(num % BigInt(32))] + result;
+            // @ts-expect-error - TS doesn't support bigint division
+            num = num / 32n;
+        }
+        return result.padStart(length, '0');
+    }
+    /**
+     * Generate a cryptographically secure random number
+     */
+    static getSecureRandom() {
+        if (typeof crypto !== 'undefined') {
+            const buffer = new Uint32Array(1);
+            crypto.getRandomValues(buffer);
+            return buffer[0];
+        }
+        return Math.floor(Math.random() * 0xffffffff);
+    }
+    /**
+     * Wait until next millisecond
+     */
+    static waitNextMillis(lastTimestamp) {
+        let timestamp = Date.now();
+        while (timestamp <= lastTimestamp) {
+            timestamp = Date.now();
+        }
+        return timestamp;
+    }
+    /**
+     * Generates a highly unique ID with the following format:
+     * TTTTTTTTTTCCCCNNNNNRRRR
+     * T: Timestamp (10 chars)
+     * C: Counter (4 chars)
+     * N: Node ID (5 chars)
+     * R: Random (4 chars)
+     *
+     * Total length: 23 characters, always uppercase alphanumeric
+     */
+    static generate() {
+        if (this.nodeId === undefined) {
+            this.initialize();
+        }
+        let timestamp = Date.now() - this.epoch;
+        // Handle clock moving backwards or same millisecond
+        if (timestamp < this.lastTimestamp) {
+            throw new Error('Clock moved backwards. Refusing to generate ID.');
+        }
+        if (timestamp === this.lastTimestamp) {
+            this.sequence = (this.sequence + 1) & ((1 << this.sequenceBits) - 1);
+            if (this.sequence === 0) {
+                timestamp = this.waitNextMillis(this.lastTimestamp);
+            }
+        }
+        else {
+            this.sequence = 0;
+        }
+        this.lastTimestamp = timestamp;
+        // Generate random component
+        const random = this.getSecureRandom() & 0xffff; // 16 bits of randomness
+        // Combine all components into a BigInt
+        // const id =
+        //   (BigInt(timestamp) << BigInt(this.nodeBits + this.sequenceBits + 16)) |
+        //   (BigInt(this.nodeId) << BigInt(this.sequenceBits + 16)) |
+        //   (BigInt(this.sequence) << BigInt(16)) |
+        //   BigInt(random);
+        // Convert to base32 representation
+        const timeComponent = this.toBase32(BigInt(timestamp), 10);
+        const counterComponent = this.toBase32(BigInt(this.sequence), 4);
+        const nodeComponent = this.toBase32(BigInt(this.nodeId), 5);
+        const randomComponent = this.toBase32(BigInt(random), 4);
+        return `${timeComponent}${counterComponent}${nodeComponent}${randomComponent}`;
+    }
+    /**
+     * Validates if a string matches the expected ID format
+     */
+    static isValid(id) {
+        if (!/^[0-9A-HJ-NP-Z]{23}$/.test(id))
+            return false;
+        try {
+            const timeComponent = id.slice(0, 10);
+            const timestamp = this.decodeBase32(timeComponent);
+            const now = Date.now() - this.epoch;
+            return timestamp >= 0 && timestamp <= now;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    /**
+     * Decode base32 string to number
+     */
+    static decodeBase32(str) {
+        let result = 0;
+        for (const char of str) {
+            result = result * 32 + this.base32Chars.indexOf(char);
+        }
+        return result;
+    }
+    /**
+     * Extract timestamp from ID
+     */
+    static getTimestamp(id) {
+        if (!this.isValid(id))
+            throw new Error('Invalid ID format');
+        const timeComponent = id.slice(0, 10);
+        const timestamp = this.decodeBase32(timeComponent);
+        return new Date(timestamp + this.epoch);
+    }
+}
+// Constants for bit manipulation
+UniqueIdGenerator.epoch = 1577836800000; // 2020-01-01 as epoch
+UniqueIdGenerator.nodeBits = 10;
+UniqueIdGenerator.sequenceBits = 12;
+// Instance variables
+UniqueIdGenerator.lastTimestamp = -1;
+UniqueIdGenerator.sequence = 0;
+// Character set for base32 encoding (excluding similar looking characters)
+UniqueIdGenerator.base32Chars = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+        return Reflect.construct(f, arguments, this.constructor);
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var cryptoJs = {exports: {}};
+
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+var core = {exports: {}};
+
+var _polyfillNode_crypto = {};
+
+var _polyfillNode_crypto$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  default: _polyfillNode_crypto
+});
+
+var require$$0 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_crypto$1);
+
+var hasRequiredCore;
+
+function requireCore () {
+	if (hasRequiredCore) return core.exports;
+	hasRequiredCore = 1;
+	(function (module, exports) {
+(function (root, factory) {
+			{
+				// CommonJS
+				module.exports = factory();
+			}
+		}(commonjsGlobal, function () {
+
+			/*globals window, global, require*/
+
+			/**
+			 * CryptoJS core components.
+			 */
+			var CryptoJS = CryptoJS || (function (Math, undefined$1) {
+
+			    var crypto;
+
+			    // Native crypto from window (Browser)
+			    if (typeof window !== 'undefined' && window.crypto) {
+			        crypto = window.crypto;
+			    }
+
+			    // Native crypto in web worker (Browser)
+			    if (typeof self !== 'undefined' && self.crypto) {
+			        crypto = self.crypto;
+			    }
+
+			    // Native crypto from worker
+			    if (typeof globalThis !== 'undefined' && globalThis.crypto) {
+			        crypto = globalThis.crypto;
+			    }
+
+			    // Native (experimental IE 11) crypto from window (Browser)
+			    if (!crypto && typeof window !== 'undefined' && window.msCrypto) {
+			        crypto = window.msCrypto;
+			    }
+
+			    // Native crypto from global (NodeJS)
+			    if (!crypto && typeof commonjsGlobal !== 'undefined' && commonjsGlobal.crypto) {
+			        crypto = commonjsGlobal.crypto;
+			    }
+
+			    // Native crypto import via require (NodeJS)
+			    if (!crypto && typeof commonjsRequire === 'function') {
+			        try {
+			            crypto = require$$0;
+			        } catch (err) {}
+			    }
+
+			    /*
+			     * Cryptographically secure pseudorandom number generator
+			     *
 			     * As Math.random() is cryptographically not safe to use
 			     */
 			    var cryptoSecureRandomInt = function () {
@@ -15584,297 +16044,96 @@ class BaseApi extends BaseApiAbstract {
             ((_c = response === null || response === void 0 ? void 0 : response.headers) === null || _c === void 0 ? void 0 : _c.has(REQUEST_CLOUD_PROTECTED_TIMESTAMP)) &&
             ((_d = response === null || response === void 0 ? void 0 : response.headers) === null || _d === void 0 ? void 0 : _d.get)) {
             isEncrypted = ((_e = response === null || response === void 0 ? void 0 : response.headers) === null || _e === void 0 ? void 0 : _e.get(REQUEST_CLOUD_PROTECTED_KEY)) === 'true';
-            timestamp = ((_f = response === null || response === void 0 ? void 0 : response.headers) === null || _f === void 0 ? void 0 : _f.get(REQUEST_CLOUD_PROTECTED_TIMESTAMP))
-                ? Number((_g = response === null || response === void 0 ? void 0 : response.headers) === null || _g === void 0 ? void 0 : _g.get(REQUEST_CLOUD_PROTECTED_TIMESTAMP))
-                : 0;
-        }
-        if (responseData &&
-            isEncrypted &&
-            this.objectHelper.includes(responseData, 't') &&
-            timestamp > 0) {
-            const { t: encryptedPayload } = responseData;
-            const decryptedData = await this.encryptedApi.handleDecryption(encryptedPayload, timestamp);
-            if (decryptedData === null || decryptedData === void 0 ? void 0 : decryptedData.payload) {
-                delete decryptedData.payload.exp;
-                delete decryptedData.payload.iat;
-                responseData = decryptedData.payload;
-            }
-        }
-        return { isOk: true, val: responseData, isErr: false };
-    }
-    /**
-     * Creates a URL by concatenating the base URL with the provided path.
-     *
-     * @param {string | null} path - The path to be appended to the base URL.
-     * @return {string} The concatenated URL.
-     */
-    createURL(path) {
-        const formattedPath = path && path[0] !== '/' ? `/${path}` : path;
-        return `${this.baseUrl}/api${formattedPath}`;
-    }
-}
-
-const AUTH_API_PATH = '/auth';
-
-class AuthService extends BaseApi {
-    constructor(apiKey, env) {
-        super({
-            authenticated: false,
-            apiKey,
-            token: '',
-            env,
-        });
-    }
-    /**
-     * Retrieves the singleton instance of the AuthService class.
-     *
-     * @param {string} apiKey - The API key used for authentication.
-     * @param {RMN_ENV} env - The environment enum value.
-     * @returns {AuthService} The singleton instance of the AuthService class.
-     */
-    static getInstance(apiKey, env) {
-        return SingletonManager.getInstance('AuthService', () => new AuthService(apiKey, env));
-    }
-    /**
-     * Initializes the authentication process.
-     *
-     * @returns {Promise<IAuthCredentials>} A Promise that resolves to the authenticated credentials.
-     * @throws {Error} If there is an error during authentication or the authentication response is unsuccessful.
-     */
-    async initialize() {
-        const { isOk, isErr, val } = await this.get(AUTH_API_PATH, {
-            headers: {
-                [SDK_CONFIG.apiHeader]: this.authInfo.apiKey,
-            },
-        });
-        if (isErr) {
-            throw new Error(`There was an error during authentication: (${isErr === null || isErr === void 0 ? void 0 : isErr.errorMessage})`);
-        }
-        if (isOk && (val === null || val === void 0 ? void 0 : val.data.token)) {
-            this.authInfo.token = val.data.token;
-            this.authInfo.authenticated = true;
-        }
-        else {
-            throw new Error('Auth response was not successful');
-        }
-        return this.authInfo;
-    }
-}
-
-const SPOT_ELEMENT_TAG = 'spot-element';
-const CAROUSEL_ELEMENT_TAG = 'spot-carousel-element';
-const GFONT_PRECONNECT = `
-  <link rel="preconnect" href="https://fonts.googleapis.com">
-  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-`;
-const GFONT_SOURCE_SANS_3 = `
-  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Source+Sans+3:ital,wght@0,200..900;1,200..900&display=swap">
-`;
-const GFONT_CORMORANT = `
-  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Cormorant:ital,wght@0,300..700;1,300..700&family=Source+Sans+3:ital,wght@0,200..900;1,200..900&display=swap">
-`;
-
-/**
- * Determines the event type from a raw event string.
- *
- * @param {string} [event] - The raw event string to evaluate.
- * @returns {RMN_SPOT_EVENT | null} - The corresponding RMN_SPOT_EVENT or null if no match is found.
- */
-function getEventTypeFromRawEvent(event) {
-    if (!event) {
-        return null;
-    }
-    if (event.includes('cart')) {
-        if (event.includes('add')) {
-            return RMN_SPOT_EVENT.ADD_TO_CART;
-        }
-        if (event.includes('remove')) {
-            return RMN_SPOT_EVENT.REMOVE_FROM_CART;
-        }
-    }
-    if (event.includes('purchase')) {
-        return RMN_SPOT_EVENT.PURCHASE;
-    }
-    // if(event.includes('refund')) {
-    //   return RMN_SPOT_EVENT.REFUND;
-    // }
-    if (event.includes('wishlist') && event.includes('add')) {
-        return RMN_SPOT_EVENT.ADD_TO_WISHLIST;
-    }
-    return null;
-}
-/**
- * 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]
- */
-function extractDeepIds(data, propertyNames) {
-    const ids = [];
-    const defaulPropertyNames = [
-        'id',
-        'upc',
-        'groupingId',
-        'sku',
-        'productId',
-        'item_id',
-        'isbn',
-        'asin',
-        'mpn',
-        'model_number',
-        'article_number',
-        'variant_id',
-        'item_number',
-        'catalog_id',
-        'reference_id',
-    ];
-    // Set for faster property name lookups
-    const propertySet = new Set(defaulPropertyNames);
-    /**
-     * Processes a value and extracts IDs if it matches criteria
-     * @param value - The value to process
-     * @param currentKey - The property name of the current value
-     */
-    const processValue = (value, currentKey) => {
-        // Early exit for null/undefined values
-        if (value == null)
-            return;
-        // If current key matches our target properties
-        if (currentKey && propertySet.has(currentKey)) {
-            if (Array.isArray(value)) {
-                // Filter and push valid array values in one pass
-                ids.push(...value.filter((item) => typeof item === 'string' || typeof item === 'number'));
-            }
-            else if (typeof value === 'string' || typeof value === 'number') {
-                ids.push(value);
-            }
-            return; // Stop processing this branch after handling the ID
-        }
-        // Recursively process nested structures
-        if (Array.isArray(value)) {
-            value.forEach((item) => processValue(item));
-        }
-        else if (typeof value === 'object') {
-            // Process all enumerable properties
-            for (const [key, val] of Object.entries(value)) {
-                processValue(val, key);
-            }
-        }
-    };
-    processValue(data);
-    return ids; // No need to filter nulls as we handle that during collection
-}
-// Fallback method using fetch if sendBeacon isn't available
-async function fallbackEventFire(url) {
-    try {
-        const racePromise = Promise.race([
-            // Promise #1: The fetch request
-            fetch(url, {
-                method: 'POST',
-                keepalive: true,
-            }),
-            // Promise #2: The timeout
-            new Promise((_, reject) => setTimeout(() => reject(new Error('Request timeout')), 2000)),
-        ]);
-        /**
-         * Prevent requests from hanging indefinitely
-         * Improve user experience by failing fast
-         * Handle slow network conditions gracefully
-         * Ensure resources are freed up in a timely manner
-         */
-        const response = await racePromise;
-        return response.ok;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-/**
- * 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.
- */
-function getRedirectUrlFromPayload(url) {
-    try {
-        const base64String = new URL(url).searchParams.get('e');
-        if (!base64String) {
-            return null;
-        }
-        const data = JSON.parse(atob(base64String));
-        return data.ur || null;
-    }
-    catch (_a) {
-        return 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.
- */
-async function fireEvent({ event, eventUrl }) {
-    var _a;
-    try {
-        const didFireEvent = ((_a = navigator === null || navigator === void 0 ? void 0 : navigator.sendBeacon) === null || _a === void 0 ? void 0 : _a.call(navigator, eventUrl)) || (await fallbackEventFire(eventUrl));
-        if (!didFireEvent) {
-            return;
+            timestamp = ((_f = response === null || response === void 0 ? void 0 : response.headers) === null || _f === void 0 ? void 0 : _f.get(REQUEST_CLOUD_PROTECTED_TIMESTAMP))
+                ? Number((_g = response === null || response === void 0 ? void 0 : response.headers) === null || _g === void 0 ? void 0 : _g.get(REQUEST_CLOUD_PROTECTED_TIMESTAMP))
+                : 0;
         }
-        if (event === RMN_SPOT_EVENT.CLICK) {
-            const redirectUrl = getRedirectUrlFromPayload(eventUrl);
-            if (redirectUrl) {
-                window.location.href = redirectUrl;
+        if (responseData &&
+            isEncrypted &&
+            this.objectHelper.includes(responseData, 't') &&
+            timestamp > 0) {
+            const { t: encryptedPayload } = responseData;
+            const decryptedData = await this.encryptedApi.handleDecryption(encryptedPayload, timestamp);
+            if (decryptedData === null || decryptedData === void 0 ? void 0 : decryptedData.payload) {
+                delete decryptedData.payload.exp;
+                delete decryptedData.payload.iat;
+                responseData = decryptedData.payload;
             }
         }
+        return { isOk: true, val: responseData, isErr: false };
     }
-    catch (_b) {
-        // Handle errors silently
+    /**
+     * Creates a URL by concatenating the base URL with the provided path.
+     *
+     * @param {string | null} path - The path to be appended to the base URL.
+     * @return {string} The concatenated URL.
+     */
+    createURL(path) {
+        const formattedPath = path && path[0] !== '/' ? `/${path}` : path;
+        return `${this.baseUrl}/api${formattedPath}`;
     }
 }
-function calculateScaleFactor(elementScale) {
-    // Step 1: Apply square root for non-linear scaling
-    // This creates a more gradual scaling effect, especially for larger changes
-    // For example:
-    // - elementScale of 0.25 (1/4 size) becomes 0.5
-    // - elementScale of 1 (unchanged) remains 1
-    // - elementScale of 4 (4x size) becomes 2
-    const baseFactor = Math.sqrt(elementScale);
-    // Step 2: Apply additional dampening to further soften the scaling effect
-    // The dampening factor (0.5) can be adjusted:
-    // - Lower values (closer to 0) make scaling more subtle
-    // - Higher values (closer to 1) make scaling more pronounced
-    const dampening = 0.35;
-    // Calculate the scaleFactor:
-    // 1. (baseFactor - 1) represents the change from the original size
-    // 2. Multiply by dampening to reduce the effect
-    // 3. Add 1 to center the scaling around the original size
-    // For example, if baseFactor is 2:
-    // scaleFactor = 1 + (2 - 1) * 0.5 = 1.5
-    const scaleFactor = 1 + (baseFactor - 1) * dampening;
-    // Step 3: Define the allowed range for the scale factor
-    // This ensures that the font size never changes too drastically
-    const minScale = 0.35; // Font will never be smaller than 50% of original
-    const maxScale = 1.5; // Font will never be larger than 150% of original
-    // Step 4: Clamp the scale factor to the defined range
-    // Math.min ensures the value doesn't exceed maxScale
-    // Math.max ensures the value isn't less than minScale
-    return Math.max(minScale, Math.min(maxScale, scaleFactor));
+
+const AUTH_API_PATH = '/auth';
+
+class AuthService extends BaseApi {
+    constructor(apiKey, env) {
+        super({
+            authenticated: false,
+            apiKey,
+            token: '',
+            env,
+        });
+    }
+    /**
+     * Retrieves the singleton instance of the AuthService class.
+     *
+     * @param {string} apiKey - The API key used for authentication.
+     * @param {RMN_ENV} env - The environment enum value.
+     * @returns {AuthService} The singleton instance of the AuthService class.
+     */
+    static getInstance(apiKey, env) {
+        return SingletonManager.getInstance('AuthService', () => new AuthService(apiKey, env));
+    }
+    /**
+     * Initializes the authentication process.
+     *
+     * @returns {Promise<IAuthCredentials>} A Promise that resolves to the authenticated credentials.
+     * @throws {Error} If there is an error during authentication or the authentication response is unsuccessful.
+     */
+    async initialize() {
+        const { isOk, isErr, val } = await this.get(AUTH_API_PATH, {
+            headers: {
+                [SDK_CONFIG.apiHeader]: this.authInfo.apiKey,
+            },
+        });
+        if (isErr) {
+            throw new Error(`There was an error during authentication: (${isErr === null || isErr === void 0 ? void 0 : isErr.errorMessage})`);
+        }
+        if (isOk && (val === null || val === void 0 ? void 0 : val.data.token)) {
+            this.authInfo.token = val.data.token;
+            this.authInfo.authenticated = true;
+        }
+        else {
+            throw new Error('Auth response was not successful');
+        }
+        return this.authInfo;
+    }
 }
 
+const SPOT_ELEMENT_TAG = 'spot-element';
+const CAROUSEL_ELEMENT_TAG = 'spot-carousel-element';
+const GFONT_PRECONNECT = `
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+`;
+const GFONT_SOURCE_SANS_3 = `
+  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Source+Sans+3:ital,wght@0,200..900;1,200..900&display=swap">
+`;
+const GFONT_CORMORANT = `
+  <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Cormorant:ital,wght@0,300..700;1,300..700&family=Source+Sans+3:ital,wght@0,200..900;1,200..900&display=swap">
+`;
+
 class IntersectionObserverService {
     constructor(defaultOptions = {}) {
         this.observers = new Map();
@@ -15924,6 +16183,17 @@ var ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX;
     ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX[ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX["PRODUCT_IDS"] = 4] = "PRODUCT_IDS";
     ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX[ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX["CREATED_AT"] = 5] = "CREATED_AT";
 })(ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX || (ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX = {}));
+const LOCAL_STORAGE_SPOT_EVENTS_ARRAY_INDEX = {
+    [RMN_SPOT_EVENT.IMPRESSION]: 0,
+    [RMN_SPOT_EVENT.CLICK]: 1,
+    [RMN_SPOT_EVENT.PURCHASE]: 2,
+    [RMN_SPOT_EVENT.ADD_TO_CART]: 3,
+    [RMN_SPOT_EVENT.REMOVE_FROM_CART]: 4,
+    [RMN_SPOT_EVENT.ADD_TO_CART_FROM_DETAILS]: 5,
+    [RMN_SPOT_EVENT.ADD_TO_WISHLIST]: 6,
+    [RMN_SPOT_EVENT.EXPAND_PRODUCT]: 7,
+    [RMN_SPOT_EVENT.BUY_NOW]: 8,
+};
 class LocalStorageService {
     constructor() {
         if (typeof window.localStorage === 'undefined') {
@@ -15951,7 +16221,7 @@ class LocalStorageService {
                 if (parsedData && typeof parsedData === 'object') {
                     const data = {};
                     for (const [key, value] of Object.entries(parsedData)) {
-                        data[key] = this.arrayToObject(value);
+                        data[key] = this.spotArrayToObject(value);
                     }
                     this.spots = this.objectToMap(data);
                 }
@@ -15991,7 +16261,7 @@ class LocalStorageService {
         const data = this.mapToObject(this.spots);
         const dataArray = {};
         for (const [key, value] of Object.entries(data)) {
-            dataArray[key] = this.objectToArray(value);
+            dataArray[key] = this.spotObjectToArray(value);
         }
         try {
             const encryptedData = this.encryptData(JSON.stringify(dataArray));
@@ -16022,15 +16292,34 @@ class LocalStorageService {
     objectToMap(obj) {
         return new Map(Object.entries(obj));
     }
-    objectToArray(obj) {
-        return [obj.placementId, obj.spotId, obj.spotType, obj.events, obj.productIds, obj.createdAt];
+    spotEventObjectToArray(events) {
+        return Object.keys(LOCAL_STORAGE_SPOT_EVENTS_ARRAY_INDEX).map((type) => {
+            const result = events.find((item) => item.event === type);
+            return result && result.event === type ? result.url : '';
+        });
+    }
+    spotEventArrayToObject(arr) {
+        return Object.keys(LOCAL_STORAGE_SPOT_EVENTS_ARRAY_INDEX).map((type) => ({
+            event: type,
+            url: arr[LOCAL_STORAGE_SPOT_EVENTS_ARRAY_INDEX[type]],
+        }));
     }
-    arrayToObject(arr) {
+    spotObjectToArray(obj) {
+        return [
+            obj.placementId,
+            obj.spotId,
+            obj.spotType,
+            this.spotEventObjectToArray(obj.events),
+            obj.productIds,
+            obj.createdAt,
+        ];
+    }
+    spotArrayToObject(arr) {
         return {
             placementId: arr[ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX.PLACEMENT_ID],
             spotId: arr[ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX.SPOT_ID],
             spotType: arr[ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX.SPOT_TYPE],
-            events: arr[ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX.EVENTS],
+            events: this.spotEventArrayToObject(arr[ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX.EVENTS]),
             productIds: arr[ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX.PRODUCT_IDS],
             createdAt: arr[ENUM_LOCAL_STORAGE_SPOT_ARRAY_INDEX.CREATED_AT],
         };
@@ -16040,16 +16329,14 @@ class LocalStorageService {
             return data;
         // For now, we are using base64 encoding to encrypt the data
         // Later we will use Jose encryption
-        const encryptedData = btoa(data);
-        return encryptedData;
+        return btoa(data);
     }
     decryptData(data) {
         if (!LocalStorageService.encryptData)
             return data;
         // For now, we are using base64 encoding to encrypt
         // Later we will use Jose encryption
-        const decryptedData = atob(data);
-        return decryptedData;
+        return atob(data);
     }
 }
 LocalStorageService.localStorageKey = 'lc_rmn';
@@ -16865,141 +17152,6 @@ class ElementService {
     }
 }
 
-class UniqueIdGenerator {
-    /**
-     * Initialize the generator with a node ID
-     * @param nodeId Number between 0-1023 to identify this instance
-     */
-    static initialize(nodeId = Math.floor(Math.random() * 1024)) {
-        if (nodeId < 0 || nodeId >= 1 << this.nodeBits) {
-            throw new Error(`Node ID must be between 0 and ${(1 << this.nodeBits) - 1}`);
-        }
-        this.nodeId = nodeId;
-    }
-    /**
-     * Convert a number to base32 string with specified length
-     */
-    static toBase32(num, length) {
-        let result = '';
-        while (num > 0) {
-            result = this.base32Chars[Number(num % BigInt(32))] + result;
-            // @ts-expect-error - TS doesn't support bigint division
-            num = num / 32n;
-        }
-        return result.padStart(length, '0');
-    }
-    /**
-     * Generate a cryptographically secure random number
-     */
-    static getSecureRandom() {
-        if (typeof crypto !== 'undefined') {
-            const buffer = new Uint32Array(1);
-            crypto.getRandomValues(buffer);
-            return buffer[0];
-        }
-        return Math.floor(Math.random() * 0xffffffff);
-    }
-    /**
-     * Wait until next millisecond
-     */
-    static waitNextMillis(lastTimestamp) {
-        let timestamp = Date.now();
-        while (timestamp <= lastTimestamp) {
-            timestamp = Date.now();
-        }
-        return timestamp;
-    }
-    /**
-     * Generates a highly unique ID with the following format:
-     * TTTTTTTTTTCCCCNNNNNRRRR
-     * T: Timestamp (10 chars)
-     * C: Counter (4 chars)
-     * N: Node ID (5 chars)
-     * R: Random (4 chars)
-     *
-     * Total length: 23 characters, always uppercase alphanumeric
-     */
-    static generate() {
-        if (this.nodeId === undefined) {
-            this.initialize();
-        }
-        let timestamp = Date.now() - this.epoch;
-        // Handle clock moving backwards or same millisecond
-        if (timestamp < this.lastTimestamp) {
-            throw new Error('Clock moved backwards. Refusing to generate ID.');
-        }
-        if (timestamp === this.lastTimestamp) {
-            this.sequence = (this.sequence + 1) & ((1 << this.sequenceBits) - 1);
-            if (this.sequence === 0) {
-                timestamp = this.waitNextMillis(this.lastTimestamp);
-            }
-        }
-        else {
-            this.sequence = 0;
-        }
-        this.lastTimestamp = timestamp;
-        // Generate random component
-        const random = this.getSecureRandom() & 0xffff; // 16 bits of randomness
-        // Combine all components into a BigInt
-        // const id =
-        //   (BigInt(timestamp) << BigInt(this.nodeBits + this.sequenceBits + 16)) |
-        //   (BigInt(this.nodeId) << BigInt(this.sequenceBits + 16)) |
-        //   (BigInt(this.sequence) << BigInt(16)) |
-        //   BigInt(random);
-        // Convert to base32 representation
-        const timeComponent = this.toBase32(BigInt(timestamp), 10);
-        const counterComponent = this.toBase32(BigInt(this.sequence), 4);
-        const nodeComponent = this.toBase32(BigInt(this.nodeId), 5);
-        const randomComponent = this.toBase32(BigInt(random), 4);
-        return `${timeComponent}${counterComponent}${nodeComponent}${randomComponent}`;
-    }
-    /**
-     * Validates if a string matches the expected ID format
-     */
-    static isValid(id) {
-        if (!/^[0-9A-HJ-NP-Z]{23}$/.test(id))
-            return false;
-        try {
-            const timeComponent = id.slice(0, 10);
-            const timestamp = this.decodeBase32(timeComponent);
-            const now = Date.now() - this.epoch;
-            return timestamp >= 0 && timestamp <= now;
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    /**
-     * Decode base32 string to number
-     */
-    static decodeBase32(str) {
-        let result = 0;
-        for (const char of str) {
-            result = result * 32 + this.base32Chars.indexOf(char);
-        }
-        return result;
-    }
-    /**
-     * Extract timestamp from ID
-     */
-    static getTimestamp(id) {
-        if (!this.isValid(id))
-            throw new Error('Invalid ID format');
-        const timeComponent = id.slice(0, 10);
-        const timestamp = this.decodeBase32(timeComponent);
-        return new Date(timestamp + this.epoch);
-    }
-}
-// Constants for bit manipulation
-UniqueIdGenerator.epoch = 1577836800000; // 2020-01-01 as epoch
-UniqueIdGenerator.nodeBits = 10;
-UniqueIdGenerator.sequenceBits = 12;
-// Instance variables
-UniqueIdGenerator.lastTimestamp = -1;
-UniqueIdGenerator.sequence = 0;
-// Character set for base32 encoding (excluding similar looking characters)
-UniqueIdGenerator.base32Chars = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
-
 function convertHexToRgba(hex, opacity = 1) {
     // Remove # if present
     const cleanHex = hex.replace('#', '');
@@ -18882,7 +19034,7 @@ class MonitorService {
         this.implementedMonitor.start();
     }
     async matchAndFireEvent(eventData, spots) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b;
         if (!spots)
             return;
         const eventProductIds = new Set(eventData.productIds);
@@ -18891,47 +19043,13 @@ class MonitorService {
                 continue;
             const hasCommonProductIds = spot.productIds.find((productId) => eventProductIds.has(productId));
             if (hasCommonProductIds) {
-                switch (eventData.event) {
-                    case RMN_SPOT_EVENT.ADD_TO_CART:
-                        await this.fireAndPublishSpotEvent({
-                            spotEvent: RMN_SPOT_EVENT.ADD_TO_CART,
-                            eventUrl: (_b = (_a = spot.events.find((event) => event.event === RMN_SPOT_EVENT.ADD_TO_CART)) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : '',
-                            placementId: spot.placementId,
-                            spotId: spot.spotId,
-                        });
-                        break;
-                    case RMN_SPOT_EVENT.REMOVE_FROM_CART:
-                        await this.fireAndPublishSpotEvent({
-                            spotEvent: RMN_SPOT_EVENT.REMOVE_FROM_CART,
-                            eventUrl: (_d = (_c = spot.events.find((event) => event.event === RMN_SPOT_EVENT.REMOVE_FROM_CART)) === null || _c === void 0 ? void 0 : _c.url) !== null && _d !== void 0 ? _d : '',
-                            placementId: spot.placementId,
-                            spotId: spot.spotId,
-                        });
-                        break;
-                    case RMN_SPOT_EVENT.PURCHASE:
-                        await this.fireAndPublishSpotEvent({
-                            spotEvent: RMN_SPOT_EVENT.PURCHASE,
-                            eventUrl: (_f = (_e = spot.events.find((event) => event.event === RMN_SPOT_EVENT.PURCHASE)) === null || _e === void 0 ? void 0 : _e.url) !== null && _f !== void 0 ? _f : '',
-                            placementId: spot.placementId,
-                            spotId: spot.spotId,
-                        });
-                        break;
-                    case RMN_SPOT_EVENT.ADD_TO_WISHLIST:
-                        await this.fireAndPublishSpotEvent({
-                            spotEvent: RMN_SPOT_EVENT.ADD_TO_WISHLIST,
-                            eventUrl: (_h = (_g = spot.events.find((event) => event.event === RMN_SPOT_EVENT.ADD_TO_WISHLIST)) === null || _g === void 0 ? void 0 : _g.url) !== null && _h !== void 0 ? _h : '',
-                            placementId: spot.placementId,
-                            spotId: spot.spotId,
-                        });
-                        break;
-                    case RMN_SPOT_EVENT.BUY_NOW:
-                        await this.fireAndPublishSpotEvent({
-                            spotEvent: RMN_SPOT_EVENT.BUY_NOW,
-                            eventUrl: (_k = (_j = spot.events.find((event) => event.event === RMN_SPOT_EVENT.BUY_NOW)) === null || _j === void 0 ? void 0 : _j.url) !== null && _k !== void 0 ? _k : '',
-                            placementId: spot.placementId,
-                            spotId: spot.spotId,
-                        });
-                        break;
+                if (Object.values(RMN_SPOT_EVENT).includes(eventData.event)) {
+                    await this.fireAndPublishSpotEvent({
+                        spotEvent: eventData.event,
+                        eventUrl: (_b = (_a = spot.events.find((event) => event.event === eventData.event)) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : '',
+                        placementId: spot.placementId,
+                        spotId: spot.spotId,
+                    });
                 }
             }
         }
@@ -19109,7 +19227,7 @@ class EventService {
             spotId: spot.id,
             spotType: spot.spot,
             events: spot.events,
-            productIds: (_c = spot.productIds) !== null && _c !== void 0 ? _c : [],
+            productIds: (_c = spot.productIds) !== null && _c !== void 0 ? _c : [1, 2, 3],
         });
     }
     handleIntersectionObserver(placementId, _spot, spotElement) {
@@ -19531,7 +19649,7 @@ class LiquidCommerceRmnClient {
         }
     }
     useSpotSelectionExample(inject) {
-        const examples = RB_SPOTS_SELECTION_EXAMPLE;
+        const examples = { ...RB_SPOTS_SELECTION_EXAMPLE, ...IAB_SPOTS_SELECTION_EXAMPLE };
         const data = {};
         inject.map((item) => {
             var _a, _b, _c;