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

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;
@@ -6543,6 +6545,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.
@@ -6701,12 +6791,319 @@ class ObjectHelper {
      *
      * @return {void} - This method does not return any value.
      */
-    innerMerge(target, source) {
-        for (const key of Object.keys(source)) {
-            target[key] = this.mergeValue(target[key], source[key]);
-        }
+    innerMerge(target, source) {
+        for (const key of Object.keys(source)) {
+            target[key] = this.mergeValue(target[key], source[key]);
+        }
+    }
+}
+
+/**
+ * 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;
+        }
+        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 : {};
 
@@ -15580,301 +15977,100 @@ class BaseApi extends BaseApiAbstract {
         let timestamp = 0;
         if ((response === null || response === void 0 ? void 0 : response.headers) &&
             ((_a = response === null || response === void 0 ? void 0 : response.headers) === null || _a === void 0 ? void 0 : _a.has) &&
-            ((_b = response === null || response === void 0 ? void 0 : response.headers) === null || _b === void 0 ? void 0 : _b.has(REQUEST_CLOUD_PROTECTED_KEY)) &&
-            ((_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;
+            ((_b = response === null || response === void 0 ? void 0 : response.headers) === null || _b === void 0 ? void 0 : _b.has(REQUEST_CLOUD_PROTECTED_KEY)) &&
+            ((_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 (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();
@@ -16865,141 +17061,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 +18943,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 +18952,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 +19136,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) {