@mparticle/web-sdk 2.43.0 → 2.43.2

package/dist/mparticle.js

@@ -203,7 +203,7 @@ var mParticle = (function () {
       Base64: Base64$1
     };
 
-    var version = "2.43.0";
+    var version = "2.43.2";
 
     var Constants = {
       sdkVersion: version,
@@ -2844,6 +2844,25 @@ var mParticle = (function () {
       isValidKeyValue: function isValidKeyValue(key) {
         return Boolean(key && !isObject(key) && !Array.isArray(key) && !this.isFunction(key));
       },
+      removeFalsyIdentityValues: function removeFalsyIdentityValues(identityApiData, logger) {
+        if (!identityApiData || !identityApiData.userIdentities) {
+          return identityApiData;
+        }
+        var cleanedData = {};
+        var cleanedUserIdentities = __assign({}, identityApiData.userIdentities);
+        for (var identityType in identityApiData.userIdentities) {
+          if (identityApiData.userIdentities.hasOwnProperty(identityType)) {
+            var value = identityApiData.userIdentities[identityType];
+            // Check if value is falsy (undefined, false, 0, '', etc.) but not null
+            if (value !== null && !value) {
+              logger.warning("Identity value for '".concat(identityType, "' is falsy (").concat(value, "). This value will be removed from the request."));
+              delete cleanedUserIdentities[identityType];
+            }
+          }
+        }
+        cleanedData.userIdentities = cleanedUserIdentities;
+        return cleanedData;
+      },
       validateIdentities: function validateIdentities(identityApiData, method) {
         var validIdentityRequestKeys = {
           userIdentities: 1,
@@ -3473,6 +3492,164 @@ var mParticle = (function () {
       return new Date().getTime() > new Date(lastSyncDate).getTime() + frequencyCap * DAYS_IN_MILLISECONDS;
     };
 
+    var _a = Constants.IdentityMethods,
+      Identify$2 = _a.Identify,
+      Modify$3 = _a.Modify,
+      Login$2 = _a.Login,
+      Logout$2 = _a.Logout;
+    var CACHE_HEADER = 'x-mp-max-age';
+    var cacheOrClearIdCache = function cacheOrClearIdCache(method, knownIdentities, idCache, identityResponse, parsingCachedResponse) {
+      // when parsing a response that has already been cached, simply return instead of attempting another cache
+      if (parsingCachedResponse) {
+        return;
+      }
+      // default the expire timestamp to one day in milliseconds unless a header comes back
+      var expireTimestamp = getExpireTimestamp(identityResponse === null || identityResponse === void 0 ? void 0 : identityResponse.cacheMaxAge);
+      switch (method) {
+        case Login$2:
+        case Identify$2:
+          cacheIdentityRequest(method, knownIdentities, expireTimestamp, idCache, identityResponse);
+          break;
+        case Modify$3:
+        case Logout$2:
+          idCache.purge();
+          break;
+      }
+    };
+    var cacheIdentityRequest = function cacheIdentityRequest(method, identities, expireTimestamp, idCache, identityResponse) {
+      var responseText = identityResponse.responseText,
+        status = identityResponse.status;
+      var cache = idCache.retrieve() || {};
+      var cacheKey = concatenateIdentities(method, identities);
+      var hashedKey = generateHash(cacheKey);
+      var mpid = responseText.mpid,
+        is_logged_in = responseText.is_logged_in;
+      var cachedResponseBody = {
+        mpid: mpid,
+        is_logged_in: is_logged_in
+      };
+      cache[hashedKey] = {
+        responseText: JSON.stringify(cachedResponseBody),
+        status: status,
+        expireTimestamp: expireTimestamp
+      };
+      idCache.store(cache);
+    };
+    // We need to ensure that identities are concatenated in a deterministic way, so
+    // we sort the identities based on their enum.
+    // we create an array, set the user identity at the index of the user identity type
+    var concatenateIdentities = function concatenateIdentities(method, userIdentities) {
+      var DEVICE_APPLICATION_STAMP = 'device_application_stamp';
+      // set DAS first since it is not an official identity type
+      var cacheKey = "".concat(method, ":").concat(DEVICE_APPLICATION_STAMP, "=").concat(userIdentities.device_application_stamp, ";");
+      var idLength = Object.keys(userIdentities).length;
+      var concatenatedIdentities = '';
+      if (idLength) {
+        var userIDArray = new Array();
+        // create an array where each index is equal to the user identity type
+        for (var key in userIdentities) {
+          if (key === DEVICE_APPLICATION_STAMP) {
+            continue;
+          } else {
+            userIDArray[Types.IdentityType.getIdentityType(key)] = userIdentities[key];
+          }
+        }
+        concatenatedIdentities = userIDArray.reduce(function (prevValue, currentValue, index) {
+          var idName = Types.IdentityType.getIdentityName(index);
+          return "".concat(prevValue).concat(idName, "=").concat(currentValue, ";");
+        }, cacheKey);
+      }
+      return concatenatedIdentities;
+    };
+    var hasValidCachedIdentity = function hasValidCachedIdentity(method, proposedUserIdentities, idCache) {
+      // There is an edge case where multiple identity calls are taking place
+      // before identify fires, so there may not be a cache.  See what happens when
+      // the ? in idCache is removed to the following test
+      // "queued events contain login mpid instead of identify mpid when calling
+      // login immediately after mParticle initializes"
+      var cache = idCache === null || idCache === void 0 ? void 0 : idCache.retrieve();
+      // if there is no cache, then there is no valid cached identity
+      if (!cache) {
+        return false;
+      }
+      var cacheKey = concatenateIdentities(method, proposedUserIdentities);
+      var hashedKey = generateHash(cacheKey);
+      // if cache doesn't have the cacheKey, there is no valid cached identity
+      if (!cache.hasOwnProperty(hashedKey)) {
+        return false;
+      }
+      // If there is a valid cache key, compare the expireTimestamp to the current time.
+      // If the current time is greater than the expireTimestamp, it is not a valid
+      // cached identity.
+      var expireTimestamp = cache[hashedKey].expireTimestamp;
+      if (expireTimestamp < new Date().getTime()) {
+        return false;
+      } else {
+        return true;
+      }
+    };
+    var getCachedIdentity = function getCachedIdentity(method, proposedUserIdentities, idCache) {
+      var cacheKey = concatenateIdentities(method, proposedUserIdentities);
+      var hashedKey = generateHash(cacheKey);
+      var cache = idCache.retrieve();
+      var cachedIdentity = cache ? cache[hashedKey] : null;
+      return {
+        responseText: parseIdentityResponse(cachedIdentity.responseText),
+        expireTimestamp: cachedIdentity.expireTimestamp,
+        status: cachedIdentity.status
+      };
+    };
+    // https://go.mparticle.com/work/SQDSDKS-6079
+    var createKnownIdentities = function createKnownIdentities(identityApiData, deviceId) {
+      var identitiesResult = {};
+      if (isObject(identityApiData === null || identityApiData === void 0 ? void 0 : identityApiData.userIdentities)) {
+        for (var identity in identityApiData.userIdentities) {
+          identitiesResult[identity] = identityApiData.userIdentities[identity];
+        }
+      }
+      identitiesResult.device_application_stamp = deviceId;
+      return identitiesResult;
+    };
+    var removeExpiredIdentityCacheDates = function removeExpiredIdentityCacheDates(idCache) {
+      var cache = idCache.retrieve() || {};
+      var currentTime = new Date().getTime();
+      // Iterate over the cache and remove any key/value pairs that are expired
+      for (var key in cache) {
+        if (cache[key].expireTimestamp < currentTime) {
+          delete cache[key];
+        }
+      }
+      idCache.store(cache);
+    };
+    var tryCacheIdentity = function tryCacheIdentity(knownIdentities, idCache, parseIdentityResponse, mpid, callback, identityApiData, identityMethod) {
+      // https://go.mparticle.com/work/SQDSDKS-6095
+      var shouldReturnCachedIdentity = hasValidCachedIdentity(identityMethod, knownIdentities, idCache);
+      // If Identity is cached, then immediately parse the identity response
+      if (shouldReturnCachedIdentity) {
+        var cachedIdentity = getCachedIdentity(identityMethod, knownIdentities, idCache);
+        parseIdentityResponse(cachedIdentity, mpid, callback, identityApiData, identityMethod, knownIdentities, true);
+        return true;
+      }
+      return false;
+    };
+    var getExpireTimestamp = function getExpireTimestamp(maxAge) {
+      if (maxAge === void 0) {
+        maxAge = ONE_DAY_IN_SECONDS;
+      }
+      return new Date().getTime() + maxAge * MILLIS_IN_ONE_SEC;
+    };
+    var parseIdentityResponse = function parseIdentityResponse(responseText) {
+      return responseText ? JSON.parse(responseText) : {};
+    };
+    var hasIdentityRequestChanged = function hasIdentityRequestChanged(currentUser, newIdentityRequest) {
+      if (!currentUser || !(newIdentityRequest === null || newIdentityRequest === void 0 ? void 0 : newIdentityRequest.userIdentities)) {
+        return false;
+      }
+      var currentUserIdentities = currentUser.getUserIdentities().userIdentities;
+      var newIdentities = newIdentityRequest.userIdentities;
+      return JSON.stringify(currentUserIdentities) !== JSON.stringify(newIdentities);
+    };
+
     var Messages$6 = Constants.Messages;
     function SessionManager(mpInstance) {
       var self = this;
@@ -3484,9 +3661,10 @@ var mParticle = (function () {
             self.startNewSession();
           } else {
             // https://go.mparticle.com/work/SQDSDKS-6045
-            var persistence = mpInstance._Persistence.getPersistence();
-            if (persistence && !persistence.cu) {
-              // https://go.mparticle.com/work/SQDSDKS-6323
+            // https://go.mparticle.com/work/SQDSDKS-6323
+            var currentUser = mpInstance.Identity.getCurrentUser();
+            var sdkIdentityRequest = mpInstance._Store.SDKConfig.identifyRequest;
+            if (hasIdentityRequestChanged(currentUser, sdkIdentityRequest)) {
               mpInstance.Identity.identify(mpInstance._Store.SDKConfig.identifyRequest, mpInstance._Store.SDKConfig.identityCallback);
               mpInstance._Store.identifyCalled = true;
               mpInstance._Store.SDKConfig.identityCallback = null;
@@ -6158,10 +6336,10 @@ var mParticle = (function () {
     }
 
     var _Constants$IdentityMe = Constants.IdentityMethods,
-      Modify$3 = _Constants$IdentityMe.Modify,
-      Identify$2 = _Constants$IdentityMe.Identify,
-      Login$2 = _Constants$IdentityMe.Login,
-      Logout$2 = _Constants$IdentityMe.Logout;
+      Modify$2 = _Constants$IdentityMe.Modify,
+      Identify$1 = _Constants$IdentityMe.Identify,
+      Login$1 = _Constants$IdentityMe.Login,
+      Logout$1 = _Constants$IdentityMe.Logout;
     function Forwarders(mpInstance, kitBlocker) {
       var _this = this;
       var self = this;
@@ -6425,28 +6603,28 @@ var mParticle = (function () {
         mpInstance._Store.activeForwarders.forEach(function (forwarder) {
           var filteredUser = filteredMparticleUser(user.getMPID(), forwarder, mpInstance, kitBlocker);
           var filteredUserIdentities = filteredUser.getUserIdentities();
-          if (identityMethod === Identify$2) {
+          if (identityMethod === Identify$1) {
             if (forwarder.onIdentifyComplete) {
               result = forwarder.onIdentifyComplete(filteredUser, filteredUserIdentities);
               if (result) {
                 mpInstance.Logger.verbose(result);
               }
             }
-          } else if (identityMethod === Login$2) {
+          } else if (identityMethod === Login$1) {
             if (forwarder.onLoginComplete) {
               result = forwarder.onLoginComplete(filteredUser, filteredUserIdentities);
               if (result) {
                 mpInstance.Logger.verbose(result);
               }
             }
-          } else if (identityMethod === Logout$2) {
+          } else if (identityMethod === Logout$1) {
             if (forwarder.onLogoutComplete) {
               result = forwarder.onLogoutComplete(filteredUser, filteredUserIdentities);
               if (result) {
                 mpInstance.Logger.verbose(result);
               }
             }
-          } else if (identityMethod === Modify$3) {
+          } else if (identityMethod === Modify$2) {
             if (forwarder.onModifyComplete) {
               result = forwarder.onModifyComplete(filteredUser, filteredUserIdentities);
               if (result) {
@@ -6999,156 +7177,6 @@ var mParticle = (function () {
       }
     }
 
-    var _a = Constants.IdentityMethods,
-      Identify$1 = _a.Identify,
-      Modify$2 = _a.Modify,
-      Login$1 = _a.Login,
-      Logout$1 = _a.Logout;
-    var CACHE_HEADER = 'x-mp-max-age';
-    var cacheOrClearIdCache = function cacheOrClearIdCache(method, knownIdentities, idCache, identityResponse, parsingCachedResponse) {
-      // when parsing a response that has already been cached, simply return instead of attempting another cache
-      if (parsingCachedResponse) {
-        return;
-      }
-      // default the expire timestamp to one day in milliseconds unless a header comes back
-      var expireTimestamp = getExpireTimestamp(identityResponse === null || identityResponse === void 0 ? void 0 : identityResponse.cacheMaxAge);
-      switch (method) {
-        case Login$1:
-        case Identify$1:
-          cacheIdentityRequest(method, knownIdentities, expireTimestamp, idCache, identityResponse);
-          break;
-        case Modify$2:
-        case Logout$1:
-          idCache.purge();
-          break;
-      }
-    };
-    var cacheIdentityRequest = function cacheIdentityRequest(method, identities, expireTimestamp, idCache, identityResponse) {
-      var responseText = identityResponse.responseText,
-        status = identityResponse.status;
-      var cache = idCache.retrieve() || {};
-      var cacheKey = concatenateIdentities(method, identities);
-      var hashedKey = generateHash(cacheKey);
-      var mpid = responseText.mpid,
-        is_logged_in = responseText.is_logged_in;
-      var cachedResponseBody = {
-        mpid: mpid,
-        is_logged_in: is_logged_in
-      };
-      cache[hashedKey] = {
-        responseText: JSON.stringify(cachedResponseBody),
-        status: status,
-        expireTimestamp: expireTimestamp
-      };
-      idCache.store(cache);
-    };
-    // We need to ensure that identities are concatenated in a deterministic way, so
-    // we sort the identities based on their enum.
-    // we create an array, set the user identity at the index of the user identity type
-    var concatenateIdentities = function concatenateIdentities(method, userIdentities) {
-      var DEVICE_APPLICATION_STAMP = 'device_application_stamp';
-      // set DAS first since it is not an official identity type
-      var cacheKey = "".concat(method, ":").concat(DEVICE_APPLICATION_STAMP, "=").concat(userIdentities.device_application_stamp, ";");
-      var idLength = Object.keys(userIdentities).length;
-      var concatenatedIdentities = '';
-      if (idLength) {
-        var userIDArray = new Array();
-        // create an array where each index is equal to the user identity type
-        for (var key in userIdentities) {
-          if (key === DEVICE_APPLICATION_STAMP) {
-            continue;
-          } else {
-            userIDArray[Types.IdentityType.getIdentityType(key)] = userIdentities[key];
-          }
-        }
-        concatenatedIdentities = userIDArray.reduce(function (prevValue, currentValue, index) {
-          var idName = Types.IdentityType.getIdentityName(index);
-          return "".concat(prevValue).concat(idName, "=").concat(currentValue, ";");
-        }, cacheKey);
-      }
-      return concatenatedIdentities;
-    };
-    var hasValidCachedIdentity = function hasValidCachedIdentity(method, proposedUserIdentities, idCache) {
-      // There is an edge case where multiple identity calls are taking place
-      // before identify fires, so there may not be a cache.  See what happens when
-      // the ? in idCache is removed to the following test
-      // "queued events contain login mpid instead of identify mpid when calling
-      // login immediately after mParticle initializes"
-      var cache = idCache === null || idCache === void 0 ? void 0 : idCache.retrieve();
-      // if there is no cache, then there is no valid cached identity
-      if (!cache) {
-        return false;
-      }
-      var cacheKey = concatenateIdentities(method, proposedUserIdentities);
-      var hashedKey = generateHash(cacheKey);
-      // if cache doesn't have the cacheKey, there is no valid cached identity
-      if (!cache.hasOwnProperty(hashedKey)) {
-        return false;
-      }
-      // If there is a valid cache key, compare the expireTimestamp to the current time.
-      // If the current time is greater than the expireTimestamp, it is not a valid
-      // cached identity.
-      var expireTimestamp = cache[hashedKey].expireTimestamp;
-      if (expireTimestamp < new Date().getTime()) {
-        return false;
-      } else {
-        return true;
-      }
-    };
-    var getCachedIdentity = function getCachedIdentity(method, proposedUserIdentities, idCache) {
-      var cacheKey = concatenateIdentities(method, proposedUserIdentities);
-      var hashedKey = generateHash(cacheKey);
-      var cache = idCache.retrieve();
-      var cachedIdentity = cache ? cache[hashedKey] : null;
-      return {
-        responseText: parseIdentityResponse(cachedIdentity.responseText),
-        expireTimestamp: cachedIdentity.expireTimestamp,
-        status: cachedIdentity.status
-      };
-    };
-    // https://go.mparticle.com/work/SQDSDKS-6079
-    var createKnownIdentities = function createKnownIdentities(identityApiData, deviceId) {
-      var identitiesResult = {};
-      if (isObject(identityApiData === null || identityApiData === void 0 ? void 0 : identityApiData.userIdentities)) {
-        for (var identity in identityApiData.userIdentities) {
-          identitiesResult[identity] = identityApiData.userIdentities[identity];
-        }
-      }
-      identitiesResult.device_application_stamp = deviceId;
-      return identitiesResult;
-    };
-    var removeExpiredIdentityCacheDates = function removeExpiredIdentityCacheDates(idCache) {
-      var cache = idCache.retrieve() || {};
-      var currentTime = new Date().getTime();
-      // Iterate over the cache and remove any key/value pairs that are expired
-      for (var key in cache) {
-        if (cache[key].expireTimestamp < currentTime) {
-          delete cache[key];
-        }
-      }
-      idCache.store(cache);
-    };
-    var tryCacheIdentity = function tryCacheIdentity(knownIdentities, idCache, parseIdentityResponse, mpid, callback, identityApiData, identityMethod) {
-      // https://go.mparticle.com/work/SQDSDKS-6095
-      var shouldReturnCachedIdentity = hasValidCachedIdentity(identityMethod, knownIdentities, idCache);
-      // If Identity is cached, then immediately parse the identity response
-      if (shouldReturnCachedIdentity) {
-        var cachedIdentity = getCachedIdentity(identityMethod, knownIdentities, idCache);
-        parseIdentityResponse(cachedIdentity, mpid, callback, identityApiData, identityMethod, knownIdentities, true);
-        return true;
-      }
-      return false;
-    };
-    var getExpireTimestamp = function getExpireTimestamp(maxAge) {
-      if (maxAge === void 0) {
-        maxAge = ONE_DAY_IN_SECONDS;
-      }
-      return new Date().getTime() + maxAge * MILLIS_IN_ONE_SEC;
-    };
-    var parseIdentityResponse = function parseIdentityResponse(responseText) {
-      return responseText ? JSON.parse(responseText) : {};
-    };
-
     var AudienceManager = /** @class */function () {
       function AudienceManager(userAudienceUrl, apiKey, logger) {
         this.url = '';
@@ -7275,7 +7303,10 @@ var mParticle = (function () {
       this.IdentityRequest = {
         preProcessIdentityRequest: function preProcessIdentityRequest(identityApiData, callback, method) {
           mpInstance.Logger.verbose(Messages$2.InformationMessages.StartingLogEvent + ': ' + method);
-          var identityValidationResult = mpInstance._Helpers.Validators.validateIdentities(identityApiData, method);
+
+          // First, remove any falsy identity values and warn about them
+          var cleanedIdentityApiData = mpInstance._Helpers.Validators.removeFalsyIdentityValues(identityApiData, mpInstance.Logger);
+          var identityValidationResult = mpInstance._Helpers.Validators.validateIdentities(cleanedIdentityApiData, method);
           if (!identityValidationResult.valid) {
             mpInstance.Logger.error('ERROR: ' + identityValidationResult.error);
             return {
@@ -7292,7 +7323,8 @@ var mParticle = (function () {
             };
           }
           return {
-            valid: true
+            valid: true,
+            cleanedIdentities: cleanedIdentityApiData
           };
         },
         createIdentityRequest: function createIdentityRequest(identityApiData, platform, sdkVendor, sdkVersion, deviceId, context, mpid) {
@@ -7415,7 +7447,7 @@ var mParticle = (function () {
             mpid = currentUser.getMPID();
           }
           if (preProcessResult.valid) {
-            var identityApiRequest = mpInstance._Identity.IdentityRequest.createIdentityRequest(identityApiData, Constants.platform, Constants.sdkVendor, Constants.sdkVersion, mpInstance._Store.deviceId, mpInstance._Store.context, mpid);
+            var identityApiRequest = mpInstance._Identity.IdentityRequest.createIdentityRequest(preProcessResult.cleanedIdentities, Constants.platform, Constants.sdkVendor, Constants.sdkVersion, mpInstance._Store.deviceId, mpInstance._Store.context, mpid);
             if (mpInstance._Helpers.getFeatureFlag(Constants.FeatureFlags.CacheIdentity)) {
               var successfullyCachedIdentity = tryCacheIdentity(identityApiRequest.known_identities, self.idCache, self.parseIdentityResponse, mpid, callback, identityApiData, Identify);
               if (successfullyCachedIdentity) {
@@ -7454,7 +7486,7 @@ var mParticle = (function () {
           }
           if (preProcessResult.valid) {
             var evt,
-              identityApiRequest = mpInstance._Identity.IdentityRequest.createIdentityRequest(identityApiData, Constants.platform, Constants.sdkVendor, Constants.sdkVersion, mpInstance._Store.deviceId, mpInstance._Store.context, mpid);
+              identityApiRequest = mpInstance._Identity.IdentityRequest.createIdentityRequest(preProcessResult.cleanedIdentities, Constants.platform, Constants.sdkVendor, Constants.sdkVersion, mpInstance._Store.deviceId, mpInstance._Store.context, mpid);
             if (mpInstance._Helpers.canLog()) {
               if (mpInstance._Store.webviewBridgeEnabled) {
                 mpInstance._NativeSdkHelpers.sendToNative(Constants.NativeSdkPaths.Logout, JSON.stringify(mpInstance._Identity.IdentityRequest.convertToNative(identityApiData)));
@@ -7497,7 +7529,7 @@ var mParticle = (function () {
             mpid = currentUser.getMPID();
           }
           if (preProcessResult.valid) {
-            var identityApiRequest = mpInstance._Identity.IdentityRequest.createIdentityRequest(identityApiData, Constants.platform, Constants.sdkVendor, Constants.sdkVersion, mpInstance._Store.deviceId, mpInstance._Store.context, mpid);
+            var identityApiRequest = mpInstance._Identity.IdentityRequest.createIdentityRequest(preProcessResult.cleanedIdentities, Constants.platform, Constants.sdkVendor, Constants.sdkVersion, mpInstance._Store.deviceId, mpInstance._Store.context, mpid);
             if (mpInstance._Helpers.getFeatureFlag(Constants.FeatureFlags.CacheIdentity)) {
               var successfullyCachedIdentity = tryCacheIdentity(identityApiRequest.known_identities, self.idCache, self.parseIdentityResponse, mpid, callback, identityApiData, Login);
               if (successfullyCachedIdentity) {
@@ -7534,8 +7566,8 @@ var mParticle = (function () {
           if (currentUser) {
             mpid = currentUser.getMPID();
           }
-          var newUserIdentities = identityApiData && identityApiData.userIdentities ? identityApiData.userIdentities : {};
           if (preProcessResult.valid) {
+            var newUserIdentities = identityApiData && identityApiData.userIdentities ? preProcessResult.cleanedIdentities.userIdentities : {};
             var identityApiRequest = mpInstance._Identity.IdentityRequest.createModifyIdentityRequest(currentUser ? currentUser.getUserIdentities().userIdentities : {}, newUserIdentities, Constants.platform, Constants.sdkVendor, Constants.sdkVersion, mpInstance._Store.context);
             if (mpInstance._Helpers.canLog()) {
               if (mpInstance._Store.webviewBridgeEnabled) {
@@ -9689,7 +9721,7 @@ var mParticle = (function () {
         this.kit = null;
         this.filters = {};
         this.currentUser = null;
-        this.messageQueue = [];
+        this.messageQueue = new Map();
         this.sandbox = null;
         this.placementAttributesMapping = [];
       }
@@ -9763,11 +9795,7 @@ var mParticle = (function () {
             switch (_c.label) {
               case 0:
                 if (!this.isReady()) {
-                  this.queueMessage({
-                    methodName: 'selectPlacements',
-                    payload: options
-                  });
-                  return [2 /*return*/, Promise.resolve({})];
+                  return [2 /*return*/, this.deferredCall('selectPlacements', options)];
                 }
                 _c.label = 1;
               case 1:
@@ -9824,11 +9852,7 @@ var mParticle = (function () {
 
       RoktManager.prototype.hashAttributes = function (attributes) {
         if (!this.isReady()) {
-          this.queueMessage({
-            methodName: 'hashAttributes',
-            payload: attributes
-          });
-          return Promise.resolve({});
+          return this.deferredCall('hashAttributes', attributes);
         }
         try {
           return this.kit.hashAttributes(attributes);
@@ -9838,10 +9862,7 @@ var mParticle = (function () {
       };
       RoktManager.prototype.setExtensionData = function (extensionData) {
         if (!this.isReady()) {
-          this.queueMessage({
-            methodName: 'setExtensionData',
-            payload: extensionData
-          });
+          this.deferredCall('setExtensionData', extensionData);
           return;
         }
         try {
@@ -9886,29 +9907,57 @@ var mParticle = (function () {
       };
       RoktManager.prototype.processMessageQueue = function () {
         var _this = this;
-        if (this.messageQueue.length > 0 && this.isReady()) {
-          this.messageQueue.forEach(function (message) {
-            return __awaiter(_this, void 0, void 0, function () {
-              return __generator(this, function (_a) {
-                switch (_a.label) {
-                  case 0:
-                    if (!(this.kit && message.methodName in this.kit)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, this.kit[message.methodName](message.payload)];
-                  case 1:
-                    _a.sent();
-                    _a.label = 2;
-                  case 2:
-                    return [2 /*return*/];
-                }
-              });
-            });
-          });
-
-          this.messageQueue = [];
+        var _a;
+        if (!this.isReady() || this.messageQueue.size === 0) {
+          return;
         }
+        (_a = this.logger) === null || _a === void 0 ? void 0 : _a.verbose("RoktManager: Processing ".concat(this.messageQueue.size, " queued messages"));
+        this.messageQueue.forEach(function (message) {
+          var _a, _b, _c;
+          if (!(message.methodName in _this.kit) || !isFunction(_this.kit[message.methodName])) {
+            (_a = _this.logger) === null || _a === void 0 ? void 0 : _a.error("RoktManager: Method ".concat(message.methodName, " not found in kit"));
+            return;
+          }
+          (_b = _this.logger) === null || _b === void 0 ? void 0 : _b.verbose("RoktManager: Processing queued message: ".concat(message.methodName, " with payload: ").concat(JSON.stringify(message.payload)));
+          try {
+            var result = _this.kit[message.methodName](message.payload);
+            _this.completePendingPromise(message.messageId, result);
+          } catch (error) {
+            var errorMessage = error instanceof Error ? error.message : String(error);
+            (_c = _this.logger) === null || _c === void 0 ? void 0 : _c.error("RoktManager: Error processing message '".concat(message.methodName, "': ").concat(errorMessage));
+            _this.completePendingPromise(message.messageId, Promise.reject(error));
+          }
+        });
       };
       RoktManager.prototype.queueMessage = function (message) {
-        this.messageQueue.push(message);
+        this.messageQueue.set(message.messageId, message);
+      };
+      RoktManager.prototype.deferredCall = function (methodName, payload) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+          var messageId = "".concat(methodName, "_").concat(generateUniqueId());
+          _this.queueMessage({
+            messageId: messageId,
+            methodName: methodName,
+            payload: payload,
+            resolve: resolve,
+            reject: reject
+          });
+        });
+      };
+      RoktManager.prototype.completePendingPromise = function (messageId, resultOrError) {
+        if (!messageId || !this.messageQueue.has(messageId)) {
+          return;
+        }
+        var message = this.messageQueue.get(messageId);
+        if (message.resolve) {
+          Promise.resolve(resultOrError).then(function (result) {
+            return message.resolve(result);
+          })["catch"](function (error) {
+            return message.reject(error);
+          });
+        }
+        this.messageQueue["delete"](messageId);
       };
       return RoktManager;
     }();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.43.0",
+    "version": "2.43.2",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [
@@ -28,7 +28,9 @@
         "build:npm": "cross-env ENVIRONMENT=prod BUILD=cjs rollup --config rollup.config.js",
         "build:esm": "cross-env ENVIRONMENT=prod BUILD=esm rollup --config rollup.config.js",
         "build:stub": "cross-env ENVIRONMENT=prod BUILD=stub rollup --config rollup.config.js",
-        "build:snippet": "uglifyjs snippet.js -m -o snippet.min.js",
+        "build:snippet": "npm run build:snippet:mp && npm run build:snippet:rokt",
+        "build:snippet:mp": "uglifyjs snippet.js -m -o snippet.min.js",
+        "build:snippet:rokt": "uglifyjs snippet.rokt.js -m -o snippet.rokt.min.js",
         "build:tests": "cross-env ENVIRONMENT=prod TESTTYPE=main rollup --config rollup.test.config.js",
         "build:test-bundle": "cross-env TESTTYPE=main ENVIRONMENT=prod rollup --config rollup.test.config.js",
         "build:browserify:cjs": "browserify test/integrations/cjs/browserify/index.js -o test/integrations/cjs/dist/browserify-output.js",

package/src/identity-user-interfaces.ts

@@ -1,4 +1,4 @@
-import { AllUserAttributes, MPID, Product, User } from '@mparticle/web-sdk';
+import { AllUserAttributes, MPID, User } from '@mparticle/web-sdk';
 import { SDKIdentityTypeEnum } from './identity.interfaces';
 import { MessageType } from './types';
 import { BaseEvent, SDKProduct } from './sdkRuntimeModels';

package/src/identity-utils.ts

@@ -7,10 +7,11 @@ import {
     UserIdentities,
     IdentityCallback,
 } from '@mparticle/web-sdk';
-import { IdentityAPIMethod } from './identity.interfaces';
+import { IdentityAPIMethod, IIdentityRequest } from './identity.interfaces';
 import {
     IdentityResultBody,
     IIdentityResponse,
+    IMParticleUser,
 } from './identity-user-interfaces';
 
 const { Identify, Modify, Login, Logout } = Constants.IdentityMethods;
@@ -279,3 +280,21 @@ const getExpireTimestamp = (maxAge: number = ONE_DAY_IN_SECONDS): number =>
 
 const parseIdentityResponse = (responseText: string): IdentityResultBody =>
     responseText ? JSON.parse(responseText) : ({} as IdentityResultBody);
+
+export const hasIdentityRequestChanged = (
+    currentUser: IMParticleUser,
+    newIdentityRequest: IdentityApiData
+): boolean => {
+    if (!currentUser || !newIdentityRequest?.userIdentities) {
+        return false;
+    }
+
+    const currentUserIdentities =
+        currentUser.getUserIdentities().userIdentities;
+
+    const newIdentities = newIdentityRequest.userIdentities;
+
+    return (
+        JSON.stringify(currentUserIdentities) !== JSON.stringify(newIdentities)
+    );
+};