@mparticle/web-rokt-kit 1.13.1 → 1.15.0

package/dist/Rokt-Kit.common.js

@@ -19,6 +19,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var name = 'Rokt';
 var moduleId = 181;
+var EVENT_NAME_SELECT_PLACEMENTS = 'selectPlacements';
 
 var constructor = function () {
     var self = this;
@@ -40,8 +41,138 @@ var constructor = function () {
     self.userAttributes = {};
     self.testHelpers = null;
     self.placementEventMappingLookup = {};
+    self.placementEventAttributeMappingLookup = {};
     self.eventQueue = [];
 
+    function getEventAttributeValue(event, eventAttributeKey) {
+        var attributes = event && event.EventAttributes;
+        if (!attributes) {
+            return null;
+        }
+
+        if (typeof attributes[eventAttributeKey] === 'undefined') {
+            return null;
+        }
+
+        return attributes[eventAttributeKey];
+    }
+
+    function doesEventAttributeConditionMatch(condition, actualValue) {
+        if (!condition || !isString(condition.operator)) {
+            return false;
+        }
+
+        var operator = condition.operator.toLowerCase();
+        var expectedValue = condition.attributeValue;
+
+        if (operator === 'exists') {
+            return actualValue !== null;
+        }
+
+        if (actualValue == null) {
+            return false;
+        }
+
+        if (operator === 'equals') {
+            return String(actualValue) === String(expectedValue);
+        }
+
+        if (operator === 'contains') {
+            return String(actualValue).indexOf(String(expectedValue)) !== -1;
+        }
+
+        return false;
+    }
+
+    function doesEventMatchRule(event, rule) {
+        if (!rule || !isString(rule.eventAttributeKey)) {
+            return false;
+        }
+
+        var conditions = rule.conditions;
+        if (!Array.isArray(conditions)) {
+            return false;
+        }
+
+        var actualValue = getEventAttributeValue(event, rule.eventAttributeKey);
+
+        if (conditions.length === 0) {
+            return actualValue !== null;
+        }
+        for (var i = 0; i < conditions.length; i++) {
+            if (!doesEventAttributeConditionMatch(conditions[i], actualValue)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    function generateMappedEventAttributeLookup(
+        placementEventAttributeMapping
+    ) {
+        var mappedAttributeKeys = {};
+        if (!Array.isArray(placementEventAttributeMapping)) {
+            return mappedAttributeKeys;
+        }
+        for (var i = 0; i < placementEventAttributeMapping.length; i++) {
+            var mapping = placementEventAttributeMapping[i];
+            if (
+                !mapping ||
+                !isString(mapping.value) ||
+                !isString(mapping.map)
+            ) {
+                continue;
+            }
+
+            var mappedAttributeKey = mapping.value;
+            var eventAttributeKey = mapping.map;
+
+            if (!mappedAttributeKeys[mappedAttributeKey]) {
+                mappedAttributeKeys[mappedAttributeKey] = [];
+            }
+
+            mappedAttributeKeys[mappedAttributeKey].push({
+                eventAttributeKey: eventAttributeKey,
+                conditions: Array.isArray(mapping.conditions)
+                    ? mapping.conditions
+                    : [],
+            });
+        }
+        return mappedAttributeKeys;
+    }
+
+    function applyPlacementEventAttributeMapping(event) {
+        var mappedAttributeKeys = Object.keys(
+            self.placementEventAttributeMappingLookup
+        );
+        for (var i = 0; i < mappedAttributeKeys.length; i++) {
+            var mappedAttributeKey = mappedAttributeKeys[i];
+            var rulesForMappedAttributeKey =
+                self.placementEventAttributeMappingLookup[mappedAttributeKey];
+            if (isEmpty(rulesForMappedAttributeKey)) {
+                continue;
+            }
+
+            // Require ALL rules for the same key to match (AND).
+            var allMatch = true;
+            for (var j = 0; j < rulesForMappedAttributeKey.length; j++) {
+                if (!doesEventMatchRule(event, rulesForMappedAttributeKey[j])) {
+                    allMatch = false;
+                    break;
+                }
+            }
+            if (!allMatch) {
+                continue;
+            }
+
+            window.mParticle.Rokt.setLocalSessionAttribute(
+                mappedAttributeKey,
+                true
+            );
+        }
+    }
+
     /**
      * Generates the Rokt launcher script URL with optional domain override and extensions
      * @param {string} domain - The CNAME domain to use for overriding the launcher url
@@ -62,6 +193,14 @@ var constructor = function () {
         return baseUrl + '?extensions=' + extensions.join(',');
     }
 
+    /**
+     * Checks if Rokt launcher is available and ready to attach
+     * @returns {boolean} True if launcher can be attached
+     */
+    function isLauncherReadyToAttach() {
+        return window.Rokt && typeof window.Rokt.createLauncher === 'function';
+    }
+
     /**
      * Passes attributes to the Rokt Web SDK for client-side hashing
      * @see https://docs.rokt.com/developers/integration-guides/web/library/integration-launcher#hash-attributes
@@ -96,6 +235,12 @@ var constructor = function () {
             placementEventMapping
         );
 
+        var placementEventAttributeMapping = parseSettingsString(
+            settings.placementEventAttributeMapping
+        );
+        self.placementEventAttributeMappingLookup =
+            generateMappedEventAttributeLookup(placementEventAttributeMapping);
+
         // Set dynamic OTHER_IDENTITY based on server settings
         // Convert to lowercase since server sends TitleCase (e.g., 'Other' -> 'other')
         if (settings.hashedEmailUserIdentityType) {
@@ -119,12 +264,16 @@ var constructor = function () {
                 hashEventMessage: hashEventMessage,
                 parseSettingsString: parseSettingsString,
                 generateMappedEventLookup: generateMappedEventLookup,
+                generateMappedEventAttributeLookup:
+                    generateMappedEventAttributeLookup,
             };
             attachLauncher(accountId, launcherOptions);
             return;
         }
 
-        if (!window.Rokt || !(window.Rokt && window.Rokt.currentLauncher)) {
+        if (isLauncherReadyToAttach()) {
+            attachLauncher(accountId, launcherOptions);
+        } else {
             var target = document.head || document.body;
             var script = document.createElement('script');
             script.type = 'text/javascript';
@@ -135,12 +284,7 @@ var constructor = function () {
             script.id = 'rokt-launcher';
 
             script.onload = function () {
-                // Once the script loads, ensure the Rokt object is available
-                if (
-                    window.Rokt &&
-                    typeof window.Rokt.createLauncher === 'function' &&
-                    window.Rokt.currentLauncher === undefined
-                ) {
+                if (isLauncherReadyToAttach()) {
                     attachLauncher(accountId, launcherOptions);
                 } else {
                     console.error(
@@ -155,8 +299,6 @@ var constructor = function () {
 
             target.appendChild(script);
             captureTiming(PerformanceMarks.RoktScriptAppended);
-        } else {
-            console.warn('Unable to find Rokt on the page');
         }
     }
     /**
@@ -176,13 +318,18 @@ var constructor = function () {
 
     function returnLocalSessionAttributes() {
         if (
-            isEmpty(self.placementEventMappingLookup) ||
             !window.mParticle.Rokt ||
             typeof window.mParticle.Rokt.getLocalSessionAttributes !==
                 'function'
         ) {
             return {};
         }
+        if (
+            isEmpty(self.placementEventMappingLookup) &&
+            isEmpty(self.placementEventAttributeMappingLookup)
+        ) {
+            return {};
+        }
         return window.mParticle.Rokt.getLocalSessionAttributes();
     }
 
@@ -259,9 +406,38 @@ var constructor = function () {
             attributes: selectPlacementsAttributes,
         });
 
+        // Log custom event for selectPlacements call
+        logSelectPlacementsEvent(selectPlacementsAttributes);
+
         return self.launcher.selectPlacements(selectPlacementsOptions);
     }
 
+    /**
+     * Logs a custom event when selectPlacements is called
+     * This enables visibility and troubleshooting
+     * @param {Object} attributes - The attributes sent to Rokt
+     */
+    function logSelectPlacementsEvent(attributes) {
+        if (
+            !window.mParticle ||
+            typeof window.mParticle.logEvent !== 'function'
+        ) {
+            return;
+        }
+
+        if (!isObject(attributes)) {
+            return;
+        }
+
+        var EVENT_TYPE_OTHER = window.mParticle.EventType.Other;
+
+        window.mParticle.logEvent(
+            EVENT_NAME_SELECT_PLACEMENTS,
+            EVENT_TYPE_OTHER,
+            attributes
+        );
+    }
+
     /**
      * Enables optional Integration Launcher extensions before selecting placements
      * @param {string} extensionName - Name of the extension to enable
@@ -272,7 +448,7 @@ var constructor = function () {
             console.error('Rokt Kit: Not initialized');
             return Promise.reject(new Error('Rokt Kit: Not initialized'));
         }
-        if (!extensionName || typeof extensionName !== 'string') {
+        if (!extensionName || !isString(extensionName)) {
             return Promise.reject(
                 new Error('Rokt Kit: Invalid extension name')
             );
@@ -310,12 +486,19 @@ var constructor = function () {
         }
 
         if (
-            isEmpty(self.placementEventMappingLookup) ||
             typeof window.mParticle.Rokt.setLocalSessionAttribute !== 'function'
         ) {
             return;
         }
 
+        if (!isEmpty(self.placementEventAttributeMappingLookup)) {
+            applyPlacementEventAttributeMapping(event);
+        }
+
+        if (isEmpty(self.placementEventMappingLookup)) {
+            return;
+        }
+
         var hashedEvent = hashEventMessage(
             event.EventDataType,
             event.EventCategory,
@@ -478,7 +661,7 @@ var constructor = function () {
 
 function generateIntegrationName(customIntegrationName) {
     var coreSdkVersion = window.mParticle.getVersion();
-    var kitVersion = "1.13.1";
+    var kitVersion = "1.15.0";
     var name = 'mParticle_' + 'wsdkv_' + coreSdkVersion + '_kitv_' + kitVersion;
 
     if (customIntegrationName) {
@@ -584,6 +767,10 @@ function isEmpty(value) {
     return value == null || !(Object.keys(value) || value).length;
 }
 
+function isString(value) {
+    return typeof value === 'string';
+}
+
 if (window && window.mParticle && window.mParticle.addForwarder) {
     window.mParticle.addForwarder({
         name: name,

package/dist/Rokt-Kit.iife.js

@@ -18,6 +18,7 @@ var RoktKit = (function (exports) {
 
     var name = 'Rokt';
     var moduleId = 181;
+    var EVENT_NAME_SELECT_PLACEMENTS = 'selectPlacements';
 
     var constructor = function () {
         var self = this;
@@ -39,8 +40,138 @@ var RoktKit = (function (exports) {
         self.userAttributes = {};
         self.testHelpers = null;
         self.placementEventMappingLookup = {};
+        self.placementEventAttributeMappingLookup = {};
         self.eventQueue = [];
 
+        function getEventAttributeValue(event, eventAttributeKey) {
+            var attributes = event && event.EventAttributes;
+            if (!attributes) {
+                return null;
+            }
+
+            if (typeof attributes[eventAttributeKey] === 'undefined') {
+                return null;
+            }
+
+            return attributes[eventAttributeKey];
+        }
+
+        function doesEventAttributeConditionMatch(condition, actualValue) {
+            if (!condition || !isString(condition.operator)) {
+                return false;
+            }
+
+            var operator = condition.operator.toLowerCase();
+            var expectedValue = condition.attributeValue;
+
+            if (operator === 'exists') {
+                return actualValue !== null;
+            }
+
+            if (actualValue == null) {
+                return false;
+            }
+
+            if (operator === 'equals') {
+                return String(actualValue) === String(expectedValue);
+            }
+
+            if (operator === 'contains') {
+                return String(actualValue).indexOf(String(expectedValue)) !== -1;
+            }
+
+            return false;
+        }
+
+        function doesEventMatchRule(event, rule) {
+            if (!rule || !isString(rule.eventAttributeKey)) {
+                return false;
+            }
+
+            var conditions = rule.conditions;
+            if (!Array.isArray(conditions)) {
+                return false;
+            }
+
+            var actualValue = getEventAttributeValue(event, rule.eventAttributeKey);
+
+            if (conditions.length === 0) {
+                return actualValue !== null;
+            }
+            for (var i = 0; i < conditions.length; i++) {
+                if (!doesEventAttributeConditionMatch(conditions[i], actualValue)) {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        function generateMappedEventAttributeLookup(
+            placementEventAttributeMapping
+        ) {
+            var mappedAttributeKeys = {};
+            if (!Array.isArray(placementEventAttributeMapping)) {
+                return mappedAttributeKeys;
+            }
+            for (var i = 0; i < placementEventAttributeMapping.length; i++) {
+                var mapping = placementEventAttributeMapping[i];
+                if (
+                    !mapping ||
+                    !isString(mapping.value) ||
+                    !isString(mapping.map)
+                ) {
+                    continue;
+                }
+
+                var mappedAttributeKey = mapping.value;
+                var eventAttributeKey = mapping.map;
+
+                if (!mappedAttributeKeys[mappedAttributeKey]) {
+                    mappedAttributeKeys[mappedAttributeKey] = [];
+                }
+
+                mappedAttributeKeys[mappedAttributeKey].push({
+                    eventAttributeKey: eventAttributeKey,
+                    conditions: Array.isArray(mapping.conditions)
+                        ? mapping.conditions
+                        : [],
+                });
+            }
+            return mappedAttributeKeys;
+        }
+
+        function applyPlacementEventAttributeMapping(event) {
+            var mappedAttributeKeys = Object.keys(
+                self.placementEventAttributeMappingLookup
+            );
+            for (var i = 0; i < mappedAttributeKeys.length; i++) {
+                var mappedAttributeKey = mappedAttributeKeys[i];
+                var rulesForMappedAttributeKey =
+                    self.placementEventAttributeMappingLookup[mappedAttributeKey];
+                if (isEmpty(rulesForMappedAttributeKey)) {
+                    continue;
+                }
+
+                // Require ALL rules for the same key to match (AND).
+                var allMatch = true;
+                for (var j = 0; j < rulesForMappedAttributeKey.length; j++) {
+                    if (!doesEventMatchRule(event, rulesForMappedAttributeKey[j])) {
+                        allMatch = false;
+                        break;
+                    }
+                }
+                if (!allMatch) {
+                    continue;
+                }
+
+                window.mParticle.Rokt.setLocalSessionAttribute(
+                    mappedAttributeKey,
+                    true
+                );
+            }
+        }
+
         /**
          * Generates the Rokt launcher script URL with optional domain override and extensions
          * @param {string} domain - The CNAME domain to use for overriding the launcher url
@@ -61,6 +192,14 @@ var RoktKit = (function (exports) {
             return baseUrl + '?extensions=' + extensions.join(',');
         }
 
+        /**
+         * Checks if Rokt launcher is available and ready to attach
+         * @returns {boolean} True if launcher can be attached
+         */
+        function isLauncherReadyToAttach() {
+            return window.Rokt && typeof window.Rokt.createLauncher === 'function';
+        }
+
         /**
          * Passes attributes to the Rokt Web SDK for client-side hashing
          * @see https://docs.rokt.com/developers/integration-guides/web/library/integration-launcher#hash-attributes
@@ -95,6 +234,12 @@ var RoktKit = (function (exports) {
                 placementEventMapping
             );
 
+            var placementEventAttributeMapping = parseSettingsString(
+                settings.placementEventAttributeMapping
+            );
+            self.placementEventAttributeMappingLookup =
+                generateMappedEventAttributeLookup(placementEventAttributeMapping);
+
             // Set dynamic OTHER_IDENTITY based on server settings
             // Convert to lowercase since server sends TitleCase (e.g., 'Other' -> 'other')
             if (settings.hashedEmailUserIdentityType) {
@@ -118,12 +263,16 @@ var RoktKit = (function (exports) {
                     hashEventMessage: hashEventMessage,
                     parseSettingsString: parseSettingsString,
                     generateMappedEventLookup: generateMappedEventLookup,
+                    generateMappedEventAttributeLookup:
+                        generateMappedEventAttributeLookup,
                 };
                 attachLauncher(accountId, launcherOptions);
                 return;
             }
 
-            if (!window.Rokt || !(window.Rokt && window.Rokt.currentLauncher)) {
+            if (isLauncherReadyToAttach()) {
+                attachLauncher(accountId, launcherOptions);
+            } else {
                 var target = document.head || document.body;
                 var script = document.createElement('script');
                 script.type = 'text/javascript';
@@ -134,12 +283,7 @@ var RoktKit = (function (exports) {
                 script.id = 'rokt-launcher';
 
                 script.onload = function () {
-                    // Once the script loads, ensure the Rokt object is available
-                    if (
-                        window.Rokt &&
-                        typeof window.Rokt.createLauncher === 'function' &&
-                        window.Rokt.currentLauncher === undefined
-                    ) {
+                    if (isLauncherReadyToAttach()) {
                         attachLauncher(accountId, launcherOptions);
                     } else {
                         console.error(
@@ -154,8 +298,6 @@ var RoktKit = (function (exports) {
 
                 target.appendChild(script);
                 captureTiming(PerformanceMarks.RoktScriptAppended);
-            } else {
-                console.warn('Unable to find Rokt on the page');
             }
         }
         /**
@@ -175,13 +317,18 @@ var RoktKit = (function (exports) {
 
         function returnLocalSessionAttributes() {
             if (
-                isEmpty(self.placementEventMappingLookup) ||
                 !window.mParticle.Rokt ||
                 typeof window.mParticle.Rokt.getLocalSessionAttributes !==
                     'function'
             ) {
                 return {};
             }
+            if (
+                isEmpty(self.placementEventMappingLookup) &&
+                isEmpty(self.placementEventAttributeMappingLookup)
+            ) {
+                return {};
+            }
             return window.mParticle.Rokt.getLocalSessionAttributes();
         }
 
@@ -258,9 +405,38 @@ var RoktKit = (function (exports) {
                 attributes: selectPlacementsAttributes,
             });
 
+            // Log custom event for selectPlacements call
+            logSelectPlacementsEvent(selectPlacementsAttributes);
+
             return self.launcher.selectPlacements(selectPlacementsOptions);
         }
 
+        /**
+         * Logs a custom event when selectPlacements is called
+         * This enables visibility and troubleshooting
+         * @param {Object} attributes - The attributes sent to Rokt
+         */
+        function logSelectPlacementsEvent(attributes) {
+            if (
+                !window.mParticle ||
+                typeof window.mParticle.logEvent !== 'function'
+            ) {
+                return;
+            }
+
+            if (!isObject(attributes)) {
+                return;
+            }
+
+            var EVENT_TYPE_OTHER = window.mParticle.EventType.Other;
+
+            window.mParticle.logEvent(
+                EVENT_NAME_SELECT_PLACEMENTS,
+                EVENT_TYPE_OTHER,
+                attributes
+            );
+        }
+
         /**
          * Enables optional Integration Launcher extensions before selecting placements
          * @param {string} extensionName - Name of the extension to enable
@@ -271,7 +447,7 @@ var RoktKit = (function (exports) {
                 console.error('Rokt Kit: Not initialized');
                 return Promise.reject(new Error('Rokt Kit: Not initialized'));
             }
-            if (!extensionName || typeof extensionName !== 'string') {
+            if (!extensionName || !isString(extensionName)) {
                 return Promise.reject(
                     new Error('Rokt Kit: Invalid extension name')
                 );
@@ -309,12 +485,19 @@ var RoktKit = (function (exports) {
             }
 
             if (
-                isEmpty(self.placementEventMappingLookup) ||
                 typeof window.mParticle.Rokt.setLocalSessionAttribute !== 'function'
             ) {
                 return;
             }
 
+            if (!isEmpty(self.placementEventAttributeMappingLookup)) {
+                applyPlacementEventAttributeMapping(event);
+            }
+
+            if (isEmpty(self.placementEventMappingLookup)) {
+                return;
+            }
+
             var hashedEvent = hashEventMessage(
                 event.EventDataType,
                 event.EventCategory,
@@ -477,7 +660,7 @@ var RoktKit = (function (exports) {
 
     function generateIntegrationName(customIntegrationName) {
         var coreSdkVersion = window.mParticle.getVersion();
-        var kitVersion = "1.13.1";
+        var kitVersion = "1.15.0";
         var name = 'mParticle_' + 'wsdkv_' + coreSdkVersion + '_kitv_' + kitVersion;
 
         if (customIntegrationName) {
@@ -583,6 +766,10 @@ var RoktKit = (function (exports) {
         return value == null || !(Object.keys(value) || value).length;
     }
 
+    function isString(value) {
+        return typeof value === 'string';
+    }
+
     if (window && window.mParticle && window.mParticle.addForwarder) {
         window.mParticle.addForwarder({
             name: name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mparticle/web-rokt-kit",
-  "version": "1.13.1",
+  "version": "1.15.0",
   "description": "mParticle integration kit for Rokt",
   "main": "dist/Rokt-Kit.common.js",
   "files": [
@@ -19,13 +19,17 @@
     "test:debug": "npm run build && npm run build:test && DEBUG=true karma start test/karma.config.js"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true,
+    "registry": "https://registry.npmjs.org"
   },
   "devDependencies": {
     "@rollup/plugin-json": "^6.1.0",
-    "@semantic-release/changelog": "^5.0.1",
-    "@semantic-release/exec": "^5.0.0",
-    "@semantic-release/git": "^9.0.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/exec": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/npm": "^13.1.2",
+    "semantic-release": "^24.2.0",
     "mocha": "^5.2.0",
     "chai": "^4.2.0",
     "eslint": "^7.25.0",
@@ -46,7 +50,7 @@
     "watchify": "^3.11.0"
   },
   "dependencies": {
-    "@mparticle/web-sdk": "^2.36.0"
+    "@mparticle/web-sdk": "^2.56.0"
   },
   "license": "Apache-2.0"
 }