@liquidcommercedev/rmn-sdk 1.5.0-beta.16 → 1.5.0-beta.18

package/dist/index.cjs

@@ -6130,6 +6130,120 @@ function getEventTypeFromRawEvent(event) {
     return null;
 }
 
+// Configuration object with target field names
+const extractorConfig = {
+    ids: [
+        // Universal product identifiers
+        'gtin',
+        'gtin8',
+        'gtin12',
+        'gtin13',
+        'gtin14',
+        'mpn',
+        'sku',
+        'upc',
+        'ean',
+        'isbn',
+        'isbn10',
+        'isbn13',
+        'asin',
+        // Product codes and references
+        'coupon',
+        'barcode',
+        'product_code',
+        'part_number',
+        'model_number',
+        'item_variant',
+        'item_number',
+        'article_number',
+        'reference',
+        'groupingId',
+    ],
+    price: [
+        'price',
+        'unitPrice',
+        'cost',
+        'current_price',
+        'sale_price',
+        'price_value',
+        'sale_price_value',
+        'regular_price',
+        'discount_price',
+        'unit_price',
+        'original_price',
+        'final_price',
+        'retail_price',
+    ],
+};
+/**
+ * Extracts deep values from an object based on specified target type
+ * @param data - The source data object to extract values from
+ * @param target - The type of values to extract ('ids' or 'price')
+ * @param options - Optional configuration for the extraction process
+ * @returns Array of extracted values or a single value if onlyFirst is true
+ */
+function extractDeepValues(data, target, options = {}) {
+    const { 
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    onlyFirst = false, shouldIncludeZero = false, } = options;
+    const values = [];
+    const targetProperties = new Set(extractorConfig[target].map((name) => name.toLowerCase()));
+    /**
+     * Checks if a property name matches the target criteria
+     */
+    const isTargetField = (key) => {
+        const normalizedKey = key.toLowerCase();
+        const hasTarget = targetProperties.has(normalizedKey);
+        if (target === 'ids') {
+            return normalizedKey.endsWith('id') || normalizedKey.endsWith('ids') || hasTarget;
+        }
+        return hasTarget;
+    };
+    /**
+     * Validates and normalizes extracted values
+     */
+    const validateValue = (value) => {
+        if (typeof value === 'string') {
+            return value.trim().length > 0;
+        }
+        if (typeof value === 'number') {
+            return !isNaN(value) && (shouldIncludeZero || value !== 0);
+        }
+        return false;
+    };
+    /**
+     * Processes a value and extracts matching fields
+     */
+    const processValue = (value, currentKey) => {
+        // Early exit conditions
+        if (value == null || (onlyFirst && values.length > 0))
+            return;
+        // Process current value if it matches target criteria
+        if (currentKey && isTargetField(currentKey)) {
+            if (Array.isArray(value)) {
+                const validValues = value.filter(validateValue);
+                values.push(...validValues);
+            }
+            else if (validateValue(value)) {
+                values.push(value);
+            }
+            return;
+        }
+        // Recursive processing for nested structures
+        if (Array.isArray(value)) {
+            value.forEach((item) => processValue(item));
+        }
+        else if (typeof value === 'object') {
+            Object.entries(value).forEach(([key, val]) => processValue(val, key));
+        }
+    };
+    processValue(data);
+    // Return based on options
+    if (values.length === 0)
+        return undefined;
+    return onlyFirst ? values[0] : values;
+}
+
 class SingletonManager {
     /**
      * Retrieves an instance of the specified class using the provided instance creator function.
@@ -6295,97 +6409,6 @@ class ObjectHelper {
     }
 }
 
-/**
- * Recursively extracts ID values from a nested data structure.
- * Searches for specified property names and collects their primitive values (strings/numbers).
- * Captures properties ending with 'id' and any additional specified property names.
- *
- * @param data - The data structure to search through (can be nested objects/arrays)
- * @param propertyNames - Array of additional property names to look for (optional)
- * @returns Array of extracted ID values (strings/numbers only)
- *
- * @example
- * const data = {
- *   id: [1, 2, 3],
- *   nested: { id: 'abc', userId: 123 },
- *   items: [{ id: 456, productId: '789', sku: 'ABC123' }]
- * };
- * extractDeepIds(data); // Returns [1, 2, 3, 'abc', 123, 456, '789', 'ABC123']
- */
-function extractDeepIds(data, propertyNames) {
-    const ids = [];
-    const defaultPropertyNames = [
-        // Universal product identifiers
-        'gtin', // Global Trade Item Number
-        'gtin8', // 8-digit GTIN
-        'gtin12', // 12-digit GTIN (UPC)
-        'gtin13', // 13-digit GTIN (EAN)
-        'gtin14', // 14-digit GTIN
-        'mpn', // Manufacturer Part Number
-        'sku', // Stock Keeping Unit
-        'upc', // Universal Product Code
-        'ean', // European Article Number
-        'isbn', // International Standard Book Number
-        'isbn10', // 10-digit ISBN
-        'isbn13', // 13-digit ISBN
-        'asin', // Amazon Standard Identification Number
-        // Product codes and references
-        'coupon',
-        'barcode',
-        'product_code',
-        'part_number',
-        'model_number',
-        'item_variant',
-        'item_number',
-        'article_number',
-        'reference',
-        'groupingId',
-    ];
-    // Convert property names to lowercase for consistent comparison
-    const additionalProperties = new Set((defaultPropertyNames).map((name) => name.toLowerCase()));
-    /**
-     * Checks if a property name is an ID field
-     * @param key - The property name to check
-     * @returns boolean indicating if the key is an ID field
-     */
-    const isIdField = (key) => {
-        const lowercaseKey = key.toLowerCase();
-        return lowercaseKey.endsWith('id') || additionalProperties.has(lowercaseKey);
-    };
-    /**
-     * 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 && isIdField(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;
-}
 // Fallback method using fetch if sendBeacon isn't available
 async function fallbackEventFire(url) {
     try {
@@ -6411,22 +6434,49 @@ async function fallbackEventFire(url) {
         return false;
     }
 }
+/**
+ * Helper function to decode base64 string and parse JSON
+ *
+ * @param {string} base64String - The base64 encoded JSON string
+ * @returns {T | null} - Decoded and parsed object or null if invalid
+ */
+function decodeBase64Json(base64String) {
+    try {
+        return JSON.parse(atob(base64String));
+    }
+    catch (_a) {
+        return null;
+    }
+}
 /**
  * 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.
+ * @throws {Error} - If URL is malformed or payload is invalid.
  */
 function getRedirectUrlFromPayload(url) {
+    if (!url)
+        return null;
     try {
-        const base64String = new URL(url).searchParams.get('e');
-        if (!base64String) {
+        // Extract initial payload
+        const payload = new URL(url).searchParams.get('p');
+        if (!payload)
             return null;
-        }
-        const data = JSON.parse(atob(base64String));
-        return data.ur || null;
+        // Decode first layer
+        const decodedData = decodeBase64Json(payload);
+        if (!(decodedData === null || decodedData === void 0 ? void 0 : decodedData.u))
+            return null;
+        // Extract URL from nested query
+        const eventPayload = new URLSearchParams(decodedData.u).get('e');
+        if (!eventPayload)
+            return null;
+        // Decode second layer
+        const eventData = decodeBase64Json(eventPayload);
+        return (eventData === null || eventData === void 0 ? void 0 : eventData.ur) || null;
     }
     catch (_a) {
+        console.warn('RmnSdk: Failed to extract redirect URL from payload.');
         return null;
     }
 }
@@ -6486,6 +6536,23 @@ function calculateScaleFactor(elementScale) {
     // Math.max ensures the value isn't less than minScale
     return Math.max(minScale, Math.min(maxScale, scaleFactor));
 }
+/**
+ * Converts an object to a query string.
+ *
+ * @param {Record<string, string|number|undefined|null>} obj - The object to be converted to a query string.
+ * @returns {string} - The query string.
+ */
+function objectToQueryParams(obj) {
+    return Object.entries(obj !== null && obj !== void 0 ? obj : {})
+        .map(([key, value]) => {
+        if (value == null) {
+            return '';
+        }
+        return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+    })
+        .filter(Boolean)
+        .join('&');
+}
 
 class UniqueIdGenerator {
     /**
@@ -15783,7 +15850,11 @@ class LocalStorageService {
     }
     // ======================== Utility functions ======================== //
     getUserId() {
-        return LocalStorageService.localStorageKey.replace(`${LocalStorageService.localStorageKeyPrefix}_`, '');
+        const key = LocalStorageService.localStorageKey;
+        if (!key) {
+            this.setUserId();
+        }
+        return key.replace(`${LocalStorageService.localStorageKeyPrefix}_`, '');
     }
     /**
      * Sets the user ID in the local storage.
@@ -18654,11 +18725,27 @@ class DataLayerMonitor {
         if (!eventName) {
             return null;
         }
-        const productIds = extractDeepIds(data);
-        return {
+        const productIds = extractDeepValues(data, 'ids', {
+            onlyFirst: false,
+            shouldIncludeZero: true,
+        });
+        if (Array.isArray(productIds) && productIds.length === 0) {
+            return null;
+        }
+        const normalizedData = {
             event: eventName,
             productIds,
         };
+        if (eventName === exports.RMN_SPOT_EVENT.PURCHASE) {
+            const productPrice = extractDeepValues(data, 'price', {
+                onlyFirst: true,
+                shouldIncludeZero: true,
+            });
+            if (productPrice) {
+                normalizedData.productPrice = productPrice;
+            }
+        }
+        return normalizedData;
     }
     stop() {
         if (this.originalPush) {
@@ -18712,16 +18799,19 @@ class MonitorService {
             if (!spot.productIds.length)
                 continue;
             const hasCommonProductIds = spot.productIds.find((productId) => eventProductIds.has(String(productId)));
-            if (hasCommonProductIds) {
-                if (Object.values(exports.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,
-                    });
-                }
+            if (!hasCommonProductIds || !Object.values(exports.RMN_SPOT_EVENT).includes(eventData.event)) {
+                continue;
             }
+            const eventUrl = (_b = (_a = spot.events.find((event) => event.event === eventData.event)) === null || _a === void 0 ? void 0 : _a.url) !== null && _b !== void 0 ? _b : '';
+            const additionalQueryParams = objectToQueryParams({
+                override: eventData.productPrice,
+            });
+            await this.fireAndPublishSpotEvent({
+                spotEvent: eventData.event,
+                eventUrl: `${eventUrl}${additionalQueryParams ? `&${additionalQueryParams}` : ''}`,
+                placementId: spot.placementId,
+                spotId: spot.spotId,
+            });
         }
     }
     async fireAndPublishSpotEvent({ spotEvent, eventUrl, placementId, spotId, }) {
@@ -18945,6 +19035,9 @@ class SelectionService extends BaseApi {
      * @return {Promise<ISpots | { error: string }>} - The spots response object.
      */
     async spotSelection(data) {
+        if (data.userId === undefined) {
+            data.userId = this.getUserId();
+        }
         const { isOk, val, isErr } = await this.post(SELECTION_API_PATH, data, {});
         if (isErr) {
             return { error: `There was an error during spot selection: (${isErr === null || isErr === void 0 ? void 0 : isErr.errorMessage})` };
@@ -18956,6 +19049,14 @@ class SelectionService extends BaseApi {
         }
         return { error: 'Spot selection response was not successful' };
     }
+    getUserId() {
+        const isWeb = typeof window !== 'undefined';
+        if (isWeb) {
+            const localStorageService = LocalStorageService.getInstance();
+            return localStorageService.getUserId();
+        }
+        return undefined;
+    }
 }
 
 const SPOT_EVENTS_EXAMPLE = [
@@ -19621,9 +19722,18 @@ async function waitForDOM() {
         });
     });
 }
+// Sets the id for the user who is browsing the website
+// This id is used to identify the user and provide personalized content
+function setUserId() {
+    if (isBrowserEnvironment()) {
+        const localStorageService = LocalStorageService.getInstance();
+        localStorageService.setUserId();
+    }
+}
 
 /**
  * LiquidCommerce Rmn Client
+ *
  * @class
  */
 class LiquidCommerceRmnClient {
@@ -19752,7 +19862,8 @@ class LiquidCommerceRmnClient {
              * If it is near, make the spot selection request.
              */
             this.intersectionObserver.observe(placement, spotPlacementIsNearCallback, {
-                rootMargin: '500px',
+                rootMargin: '1000px',
+                threshold: 0,
             });
         }
     }
@@ -19928,7 +20039,6 @@ class LiquidCommerceRmnClient {
      */
     async injectSpotSelectionRequest(params) {
         const { inject, filter, config } = params;
-        const localStorageService = LocalStorageService.getInstance();
         const spots = inject.map((item) => ({
             placementId: item.placementId,
             spot: item.spotType,
@@ -19936,7 +20046,6 @@ class LiquidCommerceRmnClient {
             ...item === null || item === void 0 ? void 0 : item.filter,
         }));
         const request = {
-            userId: localStorageService.getUserId(),
             url: config === null || config === void 0 ? void 0 : config.url,
             filter,
             spots,
@@ -19955,6 +20064,7 @@ class LiquidCommerceRmnClient {
 async function RmnClient(apiKey, config) {
     const authService = AuthService.getInstance(apiKey, config.env);
     const credentials = await authService.initialize();
+    setUserId();
     return new LiquidCommerceRmnClient(credentials);
 }
 /**