@mparticle/web-rokt-kit 1.14.0 → 1.16.0

package/dist/Rokt-Kit.common.js

@@ -41,7 +41,138 @@ var constructor = function () {
     self.userAttributes = {};
     self.testHelpers = null;
     self.placementEventMappingLookup = {};
+    self.placementEventAttributeMappingLookup = {};
     self.eventQueue = [];
+    self.integrationName = null;
+
+    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
@@ -105,6 +236,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) {
@@ -117,9 +254,10 @@ var constructor = function () {
             {},
             window.mParticle.Rokt.launcherOptions || {}
         );
-        launcherOptions.integrationName = generateIntegrationName(
+        self.integrationName = generateIntegrationName(
             launcherOptions.integrationName
         );
+        launcherOptions.integrationName = self.integrationName;
 
         if (testMode) {
             self.testHelpers = {
@@ -128,6 +266,8 @@ var constructor = function () {
                 hashEventMessage: hashEventMessage,
                 parseSettingsString: parseSettingsString,
                 generateMappedEventLookup: generateMappedEventLookup,
+                generateMappedEventAttributeLookup:
+                    generateMappedEventAttributeLookup,
             };
             attachLauncher(accountId, launcherOptions);
             return;
@@ -180,13 +320,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();
     }
 
@@ -305,7 +450,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')
             );
@@ -343,12 +488,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,
@@ -511,7 +663,7 @@ var constructor = function () {
 
 function generateIntegrationName(customIntegrationName) {
     var coreSdkVersion = window.mParticle.getVersion();
-    var kitVersion = "1.14.0";
+    var kitVersion = "1.16.0";
     var name = 'mParticle_' + 'wsdkv_' + coreSdkVersion + '_kitv_' + kitVersion;
 
     if (customIntegrationName) {
@@ -617,6 +769,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

@@ -40,7 +40,138 @@ var RoktKit = (function (exports) {
         self.userAttributes = {};
         self.testHelpers = null;
         self.placementEventMappingLookup = {};
+        self.placementEventAttributeMappingLookup = {};
         self.eventQueue = [];
+        self.integrationName = null;
+
+        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
@@ -104,6 +235,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) {
@@ -116,9 +253,10 @@ var RoktKit = (function (exports) {
                 {},
                 window.mParticle.Rokt.launcherOptions || {}
             );
-            launcherOptions.integrationName = generateIntegrationName(
+            self.integrationName = generateIntegrationName(
                 launcherOptions.integrationName
             );
+            launcherOptions.integrationName = self.integrationName;
 
             if (testMode) {
                 self.testHelpers = {
@@ -127,6 +265,8 @@ var RoktKit = (function (exports) {
                     hashEventMessage: hashEventMessage,
                     parseSettingsString: parseSettingsString,
                     generateMappedEventLookup: generateMappedEventLookup,
+                    generateMappedEventAttributeLookup:
+                        generateMappedEventAttributeLookup,
                 };
                 attachLauncher(accountId, launcherOptions);
                 return;
@@ -179,13 +319,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();
         }
 
@@ -304,7 +449,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')
                 );
@@ -342,12 +487,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,
@@ -510,7 +662,7 @@ var RoktKit = (function (exports) {
 
     function generateIntegrationName(customIntegrationName) {
         var coreSdkVersion = window.mParticle.getVersion();
-        var kitVersion = "1.14.0";
+        var kitVersion = "1.16.0";
         var name = 'mParticle_' + 'wsdkv_' + coreSdkVersion + '_kitv_' + kitVersion;
 
         if (customIntegrationName) {
@@ -616,6 +768,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.14.0",
+  "version": "1.16.0",
   "description": "mParticle integration kit for Rokt",
   "main": "dist/Rokt-Kit.common.js",
   "files": [