@mparticle/web-sdk 2.31.1 → 2.32.1

package/dist/mparticle.js

@@ -393,7 +393,7 @@ var mParticle = (function () {
         return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
     };
 
-    var version = "2.31.1";
+    var version = "2.32.1";
 
     var Constants = {
       sdkVersion: version,
@@ -705,6 +705,19 @@ var mParticle = (function () {
     var replaceQuotesWithApostrophes = function replaceQuotesWithApostrophes(value) {
       return value.replace(/\"/g, "'");
     };
+    var replaceMPID = function replaceMPID(value, mpid) {
+      return value.replace('%%mpid%%', mpid);
+    };
+    var replaceAmpWithAmpersand = function replaceAmpWithAmpersand(value) {
+      return value.replace(/&/g, '&');
+    };
+    var createCookieSyncUrl = function createCookieSyncUrl(mpid, pixelUrl, redirectUrl) {
+      var modifiedPixelUrl = replaceAmpWithAmpersand(pixelUrl);
+      var modifiedDirectUrl = redirectUrl ? replaceAmpWithAmpersand(redirectUrl) : null;
+      var url = replaceMPID(modifiedPixelUrl, mpid);
+      var redirect = modifiedDirectUrl ? replaceMPID(modifiedDirectUrl, mpid) : '';
+      return url + encodeURIComponent(redirect);
+    };
     // FIXME: REFACTOR for V3
     // only used in store.js to sanitize server-side formatting of
     // booleans when checking for `isDevelopmentMode`
@@ -1495,6 +1508,8 @@ var mParticle = (function () {
       SDKIdentityTypeEnum["phoneNumber3"] = "phone_number_3";
     })(SDKIdentityTypeEnum || (SDKIdentityTypeEnum = {}));
 
+    var FeatureFlags$2 = Constants.FeatureFlags;
+    var CaptureIntegrationSpecificIds$1 = FeatureFlags$2.CaptureIntegrationSpecificIds;
     function convertEvents(mpid, sdkEvents, mpInstance) {
       if (!mpid) {
         return null;
@@ -1502,6 +1517,9 @@ var mParticle = (function () {
       if (!sdkEvents || sdkEvents.length < 1) {
         return null;
       }
+      var _IntegrationCapture = mpInstance._IntegrationCapture,
+        _Helpers = mpInstance._Helpers;
+      var getFeatureFlag = _Helpers.getFeatureFlag;
       var user = mpInstance.Identity.getCurrentUser();
       var uploadEvents = [];
       var lastEvent = null;
@@ -1558,6 +1576,13 @@ var mParticle = (function () {
           }
         };
       }
+      var isIntegrationCaptureEnabled = getFeatureFlag && Boolean(getFeatureFlag(CaptureIntegrationSpecificIds$1));
+      if (isIntegrationCaptureEnabled) {
+        var capturedPartnerIdentities = _IntegrationCapture === null || _IntegrationCapture === void 0 ? void 0 : _IntegrationCapture.getClickIdsAsPartnerIdentities();
+        if (!isEmpty(capturedPartnerIdentities)) {
+          upload.partner_identities = capturedPartnerIdentities;
+        }
+      }
       return upload;
     }
     function convertConsentState(sdkConsentState) {
@@ -3288,124 +3313,80 @@ var mParticle = (function () {
     }
 
     var Messages$8 = Constants.Messages;
-    function cookieSyncManager(mpInstance) {
+    var InformationMessages = Messages$8.InformationMessages;
+    var DAYS_IN_MILLISECONDS = 1000 * 60 * 60 * 24;
+    function CookieSyncManager(mpInstance) {
       var self = this;
-
       // Public
-      this.attemptCookieSync = function (previousMPID, mpid, mpidIsNotInCookies) {
-        // TODO: These should move inside the for loop
-        var pixelConfig, lastSyncDateForModule, url, redirect, urlWithRedirect, requiresConsent;
-
-        // TODO: Make this exit quicker instead of nested
-        if (mpid && !mpInstance._Store.webviewBridgeEnabled) {
-          mpInstance._Store.pixelConfigurations.forEach(function (pixelSettings) {
-            // set requiresConsent to false to start each additional pixel configuration
-            // set to true only if filteringConsenRuleValues.values.length exists
-            requiresConsent = false;
-
-            // TODO: Replace with isEmpty
-            if (pixelSettings.filteringConsentRuleValues && pixelSettings.filteringConsentRuleValues.values && pixelSettings.filteringConsentRuleValues.values.length) {
-              requiresConsent = true;
-            }
-            pixelConfig = {
-              // Kit Module ID
-              moduleId: pixelSettings.moduleId,
-              // Tells you how often we should do a cookie sync (in days)
-              frequencyCap: pixelSettings.frequencyCap,
-              // Url for cookie sync pixel
-              pixelUrl: self.replaceAmp(pixelSettings.pixelUrl),
-              // TODO: Document requirements for redirectUrl
-              redirectUrl: pixelSettings.redirectUrl ? self.replaceAmp(pixelSettings.redirectUrl) : null,
-              // Filtering rules as defined in UI
-              filteringConsentRuleValues: pixelSettings.filteringConsentRuleValues
-            };
-
-            // TODO: combine replaceMPID and replaceAmp into sanitizeUrl function
-            url = self.replaceMPID(pixelConfig.pixelUrl, mpid);
-            redirect = pixelConfig.redirectUrl ? self.replaceMPID(pixelConfig.redirectUrl, mpid) : '';
-            urlWithRedirect = url + encodeURIComponent(redirect);
-
-            // TODO: Refactor so that Persistence is only called once
-            //       outside of the loop
-            var persistence = mpInstance._Persistence.getPersistence();
-
-            // TODO: Is there a historic reason for checking for previousMPID?
-            //       it does not appear to be passed in anywhere
-            if (previousMPID && previousMPID !== mpid) {
-              if (persistence && persistence[mpid]) {
-                if (!persistence[mpid].csd) {
-                  persistence[mpid].csd = {};
-                }
-                self.performCookieSync(urlWithRedirect, pixelConfig.moduleId, mpid, persistence[mpid].csd, pixelConfig.filteringConsentRuleValues, mpidIsNotInCookies, requiresConsent);
-              }
-              return;
-            } else {
-              // TODO: Refactor to check for the inverse and exit early
-              //       rather than nesting
-              if (persistence[mpid]) {
-                if (!persistence[mpid].csd) {
-                  persistence[mpid].csd = {};
-                }
-                lastSyncDateForModule = persistence[mpid].csd[pixelConfig.moduleId.toString()] ? persistence[mpid].csd[pixelConfig.moduleId.toString()] : null;
-                if (lastSyncDateForModule) {
-                  // Check to see if we need to refresh cookieSync
-                  if (
-                  // TODO: Turn this into a convenience method for readability?
-                  //       We use similar comparisons elsewhere in the SDK,
-                  //       so perhaps we can make a time comparison convenience method
-                  new Date().getTime() > new Date(lastSyncDateForModule).getTime() + pixelConfig.frequencyCap *
-                  // TODO: Turn these numbers into a constant so
-                  //       we can remember what this number is for
-                  60 * 1000 * 60 * 24) {
-                    self.performCookieSync(urlWithRedirect, pixelConfig.moduleId, mpid, persistence[mpid].csd, pixelConfig.filteringConsentRuleValues, mpidIsNotInCookies, requiresConsent);
-                  }
-                } else {
-                  self.performCookieSync(urlWithRedirect, pixelConfig.moduleId, mpid, persistence[mpid].csd, pixelConfig.filteringConsentRuleValues, mpidIsNotInCookies, requiresConsent);
-                }
-              }
-            }
-          });
-        }
-      };
-
-      // Private
-      this.replaceMPID = function (string, mpid) {
-        return string.replace('%%mpid%%', mpid);
-      };
-
-      // Private
-      // TODO: Rename function to replaceAmpWithAmpersand
-      this.replaceAmp = function (string) {
-        return string.replace(/&amp;/g, '&');
-      };
-
-      // Private
-      this.performCookieSync = function (url, moduleId, mpid, cookieSyncDates, filteringConsentRuleValues, mpidIsNotInCookies, requiresConsent) {
-        // if MPID is new to cookies, we should not try to perform the cookie sync
-        // because a cookie sync can only occur once a user either consents or doesn't
-        // we should not check if its enabled if the user has a blank consent
-        // TODO: We should do this check outside of this function
-        if (requiresConsent && mpidIsNotInCookies) {
+      this.attemptCookieSync = function (mpid, mpidIsNotInCookies) {
+        var _a = mpInstance._Store,
+          pixelConfigurations = _a.pixelConfigurations,
+          webviewBridgeEnabled = _a.webviewBridgeEnabled;
+        if (!mpid || webviewBridgeEnabled) {
           return;
         }
-
-        // TODO: Refactor so that check is made outside of the function.
-        //       Cache or store the boolean so that it only gets called once per
-        //       cookie sync attempt per module.
-        //       Currently, attemptCookieSync is called as a loop and therefore this
-        //       function polls the user object and consent multiple times.
-        if (mpInstance._Consent.isEnabledForUserConsent(filteringConsentRuleValues, mpInstance.Identity.getCurrentUser())) {
-          var img = document.createElement('img');
-          mpInstance.Logger.verbose(Messages$8.InformationMessages.CookieSync);
-          img.onload = function () {
-            // TODO: Break this out into a convenience method so we can unit test
-            cookieSyncDates[moduleId.toString()] = new Date().getTime();
-            mpInstance._Persistence.saveUserCookieSyncDatesToPersistence(mpid, cookieSyncDates);
-          };
-          img.src = url;
+        var persistence = mpInstance._Persistence.getPersistence();
+        if (isEmpty(persistence)) {
+          return;
         }
+        pixelConfigurations.forEach(function (pixelSettings) {
+          var _a, _b;
+          // set requiresConsent to false to start each additional pixel configuration
+          // set to true only if filteringConsenRuleValues.values.length exists
+          var requiresConsent = false;
+          // Filtering rules as defined in UI
+          var filteringConsentRuleValues = pixelSettings.filteringConsentRuleValues,
+            pixelUrl = pixelSettings.pixelUrl,
+            redirectUrl = pixelSettings.redirectUrl,
+            moduleId = pixelSettings.moduleId,
+            // Tells you how often we should do a cookie sync (in days)
+            frequencyCap = pixelSettings.frequencyCap;
+          var values = (filteringConsentRuleValues || {}).values;
+          if (isEmpty(pixelUrl)) {
+            return;
+          }
+          if (!isEmpty(values)) {
+            requiresConsent = true;
+          }
+          // If MPID is new to cookies, we should not try to perform the cookie sync
+          // because a cookie sync can only occur once a user either consents or doesn't.
+          // we should not check if it's enabled if the user has a blank consent
+          if (requiresConsent && mpidIsNotInCookies) {
+            return;
+          }
+          var isEnabledForUserConsent = mpInstance._Consent.isEnabledForUserConsent;
+          if (!isEnabledForUserConsent(filteringConsentRuleValues, mpInstance.Identity.getCurrentUser())) {
+            return;
+          }
+          var cookieSyncDates = (_b = (_a = persistence[mpid]) === null || _a === void 0 ? void 0 : _a.csd) !== null && _b !== void 0 ? _b : {};
+          var lastSyncDateForModule = cookieSyncDates[moduleId] || null;
+          if (!isLastSyncDateExpired(frequencyCap, lastSyncDateForModule)) {
+            return;
+          }
+          // Url for cookie sync pixel
+          var fullUrl = createCookieSyncUrl(mpid, pixelUrl, redirectUrl);
+          self.performCookieSync(fullUrl, moduleId.toString(), mpid, cookieSyncDates);
+        });
+      };
+      // Private
+      this.performCookieSync = function (url, moduleId, mpid, cookieSyncDates) {
+        var img = document.createElement('img');
+        mpInstance.Logger.verbose(InformationMessages.CookieSync);
+        img.onload = function () {
+          cookieSyncDates[moduleId] = new Date().getTime();
+          mpInstance._Persistence.saveUserCookieSyncDatesToPersistence(mpid, cookieSyncDates);
+        };
+        img.src = url;
       };
     }
+    var isLastSyncDateExpired = function isLastSyncDateExpired(frequencyCap, lastSyncDate) {
+      // If there is no lastSyncDate, then there is no previous cookie sync, so we should sync the cookie
+      if (!lastSyncDate) {
+        return true;
+      }
+      // Otherwise, compare the last sync date to determine if it should do a cookie sync again
+      return new Date().getTime() > new Date(lastSyncDate).getTime() + frequencyCap * DAYS_IN_MILLISECONDS;
+    };
 
     var Messages$7 = Constants.Messages;
     function SessionManager(mpInstance) {
@@ -7841,7 +7822,7 @@ var mParticle = (function () {
           setConsentState: function setConsentState(state) {
             mpInstance._Store.setConsentState(mpid, state);
             mpInstance._Forwarders.initForwarders(this.getUserIdentities().userIdentities, mpInstance._APIClient.prepareForwardingStats);
-            mpInstance._CookieSyncManager.attemptCookieSync(null, this.getMPID());
+            mpInstance._CookieSyncManager.attemptCookieSync(this.getMPID());
           },
           isLoggedIn: function isLoggedIn() {
             return _isLoggedIn;
@@ -8038,7 +8019,7 @@ var mParticle = (function () {
                 mpInstance._Persistence.setFirstSeenTime(identityApiResult.mpid);
               }
               mpInstance._Store.addMpidToSessionHistory(identityApiResult.mpid, previousMPID);
-              mpInstance._CookieSyncManager.attemptCookieSync(previousMPID, identityApiResult.mpid, mpidIsNotInCookies);
+              mpInstance._CookieSyncManager.attemptCookieSync(identityApiResult.mpid, mpidIsNotInCookies);
               mpInstance._Persistence.swapCurrentUser(previousMPID, identityApiResult.mpid, mpInstance._Store.currentSessionMPIDs);
               if (identityApiData && !isEmpty(identityApiData.userIdentities)) {
                 newIdentitiesByType = self.IdentityRequest.combineUserIdentities(incomingUIByName, identityApiData.userIdentities);
@@ -9021,7 +9002,7 @@ var mParticle = (function () {
 
     var HTTPCodes$2 = Constants.HTTPCodes,
       Messages$2 = Constants.Messages;
-    function sendAliasRequest(mpInstance, aliasRequest, aliasCallback) {
+    var sendAliasRequest = function sendAliasRequest(mpInstance, aliasRequest, aliasCallback) {
       return __awaiter(this, void 0, void 0, function () {
         var _a, verbose, error, invokeAliasCallback, aliasUrl, apiKey, uploadUrl, uploader, uploadPayload, response, message, aliasResponseBody, xhrResponse, errorMessage, e_2, err;
         return __generator(this, function (_b) {
@@ -9097,7 +9078,7 @@ var mParticle = (function () {
           }
         });
       });
-    }
+    };
 
     var HTTPCodes$1 = Constants.HTTPCodes,
       Messages$1 = Constants.Messages;
@@ -9247,32 +9228,57 @@ var mParticle = (function () {
       var _timestamp = timestamp || Date.now();
       return "fb.".concat(subdomainIndex, ".").concat(_timestamp, ".").concat(clickId);
     };
+    // Integration outputs are used to determine how click ids are used within the SDK
+    // CUSTOM_FLAGS are sent out when an Event is created via ServerModel.createEventObject
+    // PARTNER_IDENTITIES are sent out in a Batch when a group of events are converted to a Batch
+    var IntegrationOutputs = {
+      CUSTOM_FLAGS: 'custom_flags',
+      PARTNER_IDENTITIES: 'partner_identities'
+    };
     var integrationMapping = {
       // Facebook / Meta
       fbclid: {
         mappedKey: 'Facebook.ClickId',
-        processor: facebookClickIdProcessor
+        processor: facebookClickIdProcessor,
+        output: IntegrationOutputs.CUSTOM_FLAGS
       },
       _fbp: {
-        mappedKey: 'Facebook.BrowserId'
+        mappedKey: 'Facebook.BrowserId',
+        output: IntegrationOutputs.CUSTOM_FLAGS
       },
       _fbc: {
-        mappedKey: 'Facebook.ClickId'
+        mappedKey: 'Facebook.ClickId',
+        output: IntegrationOutputs.CUSTOM_FLAGS
       },
       // Google
       gclid: {
-        mappedKey: 'GoogleEnhancedConversions.Gclid'
+        mappedKey: 'GoogleEnhancedConversions.Gclid',
+        output: IntegrationOutputs.CUSTOM_FLAGS
       },
       gbraid: {
-        mappedKey: 'GoogleEnhancedConversions.Gbraid'
+        mappedKey: 'GoogleEnhancedConversions.Gbraid',
+        output: IntegrationOutputs.CUSTOM_FLAGS
       },
       wbraid: {
-        mappedKey: 'GoogleEnhancedConversions.Wbraid'
+        mappedKey: 'GoogleEnhancedConversions.Wbraid',
+        output: IntegrationOutputs.CUSTOM_FLAGS
+      },
+      // TIKTOK
+      ttclid: {
+        mappedKey: 'TikTok.Callback',
+        output: IntegrationOutputs.CUSTOM_FLAGS
+      },
+      _ttp: {
+        mappedKey: 'tiktok_cookie_id',
+        output: IntegrationOutputs.PARTNER_IDENTITIES
       }
     };
     var IntegrationCapture = /** @class */function () {
       function IntegrationCapture() {
         this.initialTimestamp = Date.now();
+        // Cache filtered mappings for faster access
+        this.filteredPartnerIdentityMappings = this.filterMappings(IntegrationOutputs.PARTNER_IDENTITIES);
+        this.filteredCustomFlagMappings = this.filterMappings(IntegrationOutputs.CUSTOM_FLAGS);
       }
       /**
        * Captures Integration Ids from cookies and query params and stores them in clickIds object
@@ -9313,21 +9319,31 @@ var mParticle = (function () {
        * @returns {SDKEventCustomFlags} The custom flags.
        */
       IntegrationCapture.prototype.getClickIdsAsCustomFlags = function () {
+        return this.getClickIds(this.clickIds, this.filteredCustomFlagMappings);
+      };
+      /**
+       * Returns only the `partner_identities` mapped integration output.
+       * @returns {Dictionary<string>} The partner identities.
+       */
+      IntegrationCapture.prototype.getClickIdsAsPartnerIdentities = function () {
+        return this.getClickIds(this.clickIds, this.filteredPartnerIdentityMappings);
+      };
+      IntegrationCapture.prototype.getClickIds = function (clickIds, mappingList) {
         var _a;
-        var customFlags = {};
-        if (!this.clickIds) {
-          return customFlags;
+        var mappedClickIds = {};
+        if (!clickIds) {
+          return mappedClickIds;
         }
-        for (var _i = 0, _b = Object.entries(this.clickIds); _i < _b.length; _i++) {
+        for (var _i = 0, _b = Object.entries(clickIds); _i < _b.length; _i++) {
           var _c = _b[_i],
             key = _c[0],
             value = _c[1];
-          var mappedKey = (_a = integrationMapping[key]) === null || _a === void 0 ? void 0 : _a.mappedKey;
+          var mappedKey = (_a = mappingList[key]) === null || _a === void 0 ? void 0 : _a.mappedKey;
           if (!isEmpty(mappedKey)) {
-            customFlags[mappedKey] = value;
+            mappedClickIds[mappedKey] = value;
           }
         }
-        return customFlags;
+        return mappedClickIds;
       };
       IntegrationCapture.prototype.applyProcessors = function (clickIds, url, timestamp) {
         var _a;
@@ -9345,6 +9361,12 @@ var mParticle = (function () {
         }
         return processedClickIds;
       };
+      IntegrationCapture.prototype.filterMappings = function (outputType) {
+        return Object.fromEntries(Object.entries(integrationMapping).filter(function (_a) {
+          var value = _a[1];
+          return value.output === outputType;
+        }));
+      };
       return IntegrationCapture;
     }();
 
@@ -9377,7 +9399,7 @@ var mParticle = (function () {
       this._Persistence = new _Persistence(this);
       this._Helpers = new Helpers(this);
       this._Events = new Events(this);
-      this._CookieSyncManager = new cookieSyncManager(this);
+      this._CookieSyncManager = new CookieSyncManager(this);
       this._ServerModel = new ServerModel(this);
       this._Ecommerce = new Ecommerce(this);
       this._ForwardingStatsUploader = new forwardingStatsUploader(this);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.31.1",
+    "version": "2.32.1",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [

package/src/aliasRequestApiClient.ts

@@ -3,6 +3,7 @@ import { MParticleWebSDK } from "./sdkRuntimeModels";
 import Constants from './constants';
 import { FetchUploader, XHRUploader } from './uploaders';
 import { HTTP_ACCEPTED, HTTP_OK } from "./constants";
+import { IIdentityApiClientSendAliasRequest } from "./identityApiClient.interfaces";
 
 
 const { HTTPCodes, Messages } = Constants;
@@ -11,7 +12,7 @@ interface IAliasResponseBody {
     message?: string
 }
 
-export async function sendAliasRequest (mpInstance: MParticleWebSDK, aliasRequest: IAliasRequest, aliasCallback: IAliasCallback) {
+export const sendAliasRequest: IIdentityApiClientSendAliasRequest = async function  (mpInstance: MParticleWebSDK, aliasRequest: IAliasRequest, aliasCallback: IAliasCallback): Promise<void> {
         const { verbose, error } = mpInstance.Logger;
         const { invokeAliasCallback } = mpInstance._Helpers;
         const { aliasUrl } = mpInstance._Store.SDKConfig;

package/src/configAPIClient.ts

@@ -13,6 +13,7 @@ import {
     FetchUploader,
     XHRUploader,
 } from './uploaders';
+import { IPixelConfiguration } from './cookieSyncManager';
 
 export interface IKitConfigs extends IKitFilterSettings {
     name: string;
@@ -65,17 +66,6 @@ export interface IConsentRuleValue {
     hasConsented: boolean;
 }
 
-export interface IPixelConfig {
-    name: string;
-    moduleId: number;
-    esId: number;
-    isDebug: boolean;
-    isProduction: boolean;
-    settings: Dictionary;
-    frequencyCap: number;
-    pixelUrl: string;
-    redirectUrl: string;
-}
 
 export interface IConfigResponse {
     appName: string;
@@ -85,7 +75,7 @@ export interface IConfigResponse {
     secureServiceUrl: string;
     minWebviewBridgeVersion: number;
     workspaceToken: string;
-    pixelConfigs: IPixelConfig[];
+    pixelConfigs: IPixelConfiguration[];
     flags: SDKEventCustomFlags;
 }
 

package/src/consent.ts

@@ -38,6 +38,10 @@ export interface SDKConsentApi {
     createConsentState: (consentState?: ConsentState) => ConsentState;
     ConsentSerialization: IConsentSerialization;
     createPrivacyConsent: ICreatePrivacyConsentFunction;
+    isEnabledForUserConsent: (
+        consentRules: IConsentRules,
+        user: IMParticleUser
+    ) => boolean;
 }
 
 export interface IConsentSerialization {

package/src/cookieSyncManager.ts

@@ -0,0 +1,162 @@
+import {
+    Dictionary,
+    isEmpty,
+    createCookieSyncUrl,
+} from './utils';
+import Constants from './constants';
+import { MParticleWebSDK } from './sdkRuntimeModels';
+import { MPID } from '@mparticle/web-sdk';
+import { IConsentRules } from './consent';
+
+const { Messages } = Constants;
+const { InformationMessages } = Messages;
+
+export const DAYS_IN_MILLISECONDS = 1000 * 60 * 60 * 24;
+
+export type CookieSyncDates = Dictionary<number>; 
+
+export interface IPixelConfiguration {
+    name?: string;
+    moduleId: number;
+    esId?: number;
+    isDebug?: boolean;
+    isProduction?: boolean;
+    settings: Dictionary<string>;
+    frequencyCap: number;
+    pixelUrl: string;
+    redirectUrl: string;
+    filteringConsentRuleValues?: IConsentRules;
+}
+export interface ICookieSyncManager {
+    attemptCookieSync: (
+        mpid: MPID,
+        mpidIsNotInCookies?: boolean
+    ) => void;
+    performCookieSync: (
+        url: string,
+        moduleId: string,
+        mpid: MPID,
+        cookieSyncDates: CookieSyncDates,
+    ) => void;
+    combineUrlWithRedirect: (
+        mpid: MPID,
+        pixelUrl: string,
+        redirectUrl: string
+    ) => string;
+}
+
+export default function CookieSyncManager(
+    this: ICookieSyncManager,
+    mpInstance: MParticleWebSDK
+) {
+    const self = this;
+
+    // Public
+    this.attemptCookieSync = (
+        mpid: MPID,
+        mpidIsNotInCookies?: boolean
+    ): void => {
+        const { pixelConfigurations, webviewBridgeEnabled } = mpInstance._Store;
+
+        if (!mpid || webviewBridgeEnabled) {
+            return;
+        }
+
+        const persistence = mpInstance._Persistence.getPersistence();
+
+        if (isEmpty(persistence)) {
+            return;
+        }
+
+        pixelConfigurations.forEach((pixelSettings: IPixelConfiguration) => {
+            // set requiresConsent to false to start each additional pixel configuration
+            // set to true only if filteringConsenRuleValues.values.length exists
+            let requiresConsent = false;
+            // Filtering rules as defined in UI
+            const {
+                filteringConsentRuleValues,
+                pixelUrl,
+                redirectUrl,
+                moduleId,
+                // Tells you how often we should do a cookie sync (in days)
+                frequencyCap,
+            } = pixelSettings;
+            const { values } = filteringConsentRuleValues || {};
+
+            if (isEmpty(pixelUrl)) {
+                return;
+            }
+
+            if (!isEmpty(values)) {
+                requiresConsent = true;
+            }
+
+            // If MPID is new to cookies, we should not try to perform the cookie sync
+            // because a cookie sync can only occur once a user either consents or doesn't.
+            // we should not check if it's enabled if the user has a blank consent
+            if (requiresConsent && mpidIsNotInCookies) {
+                return;
+            }
+
+            const { isEnabledForUserConsent } = mpInstance._Consent;
+
+            if (!isEnabledForUserConsent(filteringConsentRuleValues, mpInstance.Identity.getCurrentUser())) {
+                return;
+            }
+
+            const cookieSyncDates: CookieSyncDates = persistence[mpid]?.csd ?? {};
+            const lastSyncDateForModule: number = cookieSyncDates[moduleId] || null;
+
+            if (!isLastSyncDateExpired(frequencyCap, lastSyncDateForModule)) {
+                return;
+            }
+
+            // Url for cookie sync pixel
+            const fullUrl = createCookieSyncUrl(mpid, pixelUrl, redirectUrl)
+
+            self.performCookieSync(
+                fullUrl,
+                moduleId.toString(),
+                mpid,
+                cookieSyncDates
+            );
+        });
+    };
+
+    // Private
+    this.performCookieSync = (
+        url: string,
+        moduleId: string,
+        mpid: MPID,
+        cookieSyncDates: CookieSyncDates,
+    ): void => {
+        const img = document.createElement('img');
+
+        mpInstance.Logger.verbose(InformationMessages.CookieSync);
+        img.onload = function() {
+            cookieSyncDates[moduleId] = new Date().getTime();
+
+            mpInstance._Persistence.saveUserCookieSyncDatesToPersistence(
+                mpid,
+                cookieSyncDates
+            );
+        };
+        img.src = url;
+    };
+}
+
+export const isLastSyncDateExpired = (
+    frequencyCap: number,
+    lastSyncDate?: number
+): boolean => {
+    // If there is no lastSyncDate, then there is no previous cookie sync, so we should sync the cookie
+    if (!lastSyncDate) {
+        return true;
+    }
+
+    // Otherwise, compare the last sync date to determine if it should do a cookie sync again
+    return (
+        new Date().getTime() >
+        new Date(lastSyncDate).getTime() + frequencyCap * DAYS_IN_MILLISECONDS
+    );
+};

package/src/identity.js

@@ -1231,10 +1231,7 @@ export default function Identity(mpInstance) {
                     this.getUserIdentities().userIdentities,
                     mpInstance._APIClient.prepareForwardingStats
                 );
-                mpInstance._CookieSyncManager.attemptCookieSync(
-                    null,
-                    this.getMPID()
-                );
+                mpInstance._CookieSyncManager.attemptCookieSync(this.getMPID());
             },
             isLoggedIn: function() {
                 return isLoggedIn;
@@ -1563,7 +1560,6 @@ export default function Identity(mpInstance) {
                     );
 
                     mpInstance._CookieSyncManager.attemptCookieSync(
-                        previousMPID,
                         identityApiResult.mpid,
                         mpidIsNotInCookies
                     );