@mparticle/web-sdk 2.32.0 → 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.32.0";
+    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`
@@ -3300,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(/&/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) {
@@ -7853,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;
@@ -8050,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);
@@ -9033,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) {
@@ -9109,7 +9078,7 @@ var mParticle = (function () {
           }
         });
       });
-    }
+    };
 
     var HTTPCodes$1 = Constants.HTTPCodes,
       Messages$1 = Constants.Messages;
@@ -9430,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.32.0",
+    "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
                     );

package/src/identityApiClient.interfaces.ts

@@ -0,0 +1,44 @@
+import { IdentityApiData, MPID, UserIdentities } from '@mparticle/web-sdk';
+import {
+    IdentityCallback,
+    IIdentityResponse,
+} from './identity-user-interfaces';
+import {
+    IAliasRequest,
+    IAliasCallback,
+    IIdentityRequest,
+    IdentityAPIMethod,
+    IIdentity,
+} from './identity.interfaces';
+import { MParticleWebSDK } from './sdkRuntimeModels';
+
+export interface IIdentityApiClient {
+    sendAliasRequest: (
+        aliasRequest: IAliasRequest,
+        aliasCallback: IAliasCallback
+    ) => Promise<void>;
+    sendIdentityRequest: (
+        identityApiRequest: IIdentityRequest,
+        method: IdentityAPIMethod,
+        callback: IdentityCallback,
+        originalIdentityApiData: IdentityApiData,
+        parseIdentityResponse: IIdentity['parseIdentityResponse'],
+        mpid: MPID,
+        knownIdentities: UserIdentities
+    ) => Promise<void>;
+    getUploadUrl: (method: IdentityAPIMethod, mpid: MPID) => string;
+    getIdentityResponseFromFetch: (
+        response: Response,
+        responseBody: string
+    ) => IIdentityResponse;
+    getIdentityResponseFromXHR: (response: Response) => IIdentityResponse;
+}
+
+// https://go.mparticle.com/work/SQDSDKS-6568
+// https://go.mparticle.com/work/SQDSDKS-6679
+// Combine with `sendIdentityRequest` above once module is fully migrated
+export type IIdentityApiClientSendAliasRequest = (
+    mpInstance: MParticleWebSDK,
+    aliasRequest: IAliasRequest,
+    aliasCallback: IAliasCallback
+) => Promise<void>;

package/src/nativeSdkHelpers.interfaces.ts

@@ -0,0 +1,13 @@
+export interface INativeSdkHelpers {
+    initializeSessionAttributes: (apiKey: string) => void;
+    isBridgeV2Available: (bridgeName: string) => boolean;
+    isWebviewEnabled: (
+        requiredWebviewBridgeName: string,
+        minWebviewBridgeVersion: number
+    ) => boolean;
+    isBridgeV1Available: () => boolean;
+    sendToNative: (path: string, value: string) => void;
+    sendViaBridgeV1: (path: string, value: string) => void;
+    sendViaIframeToIOS: (path: string, value: string) => void;
+    sendViaBridgeV2: (path: string, value: string, requiredWebviewBridgeName: boolean) => void;
+}

package/src/persistence.interfaces.ts

@@ -14,6 +14,7 @@ import {
 import { Dictionary } from './utils';
 import { IMinifiedConsentJSONObject } from './consent';
 import { UserAttributes } from './identity-user-interfaces';
+import { CookieSyncDates } from './cookieSyncManager';
 
 export type UploadsTable = Dictionary<any>;
 export interface iForwardingStatsBatches {
@@ -79,10 +80,8 @@ export interface IPersistenceMinified extends Dictionary {
     // };
 }
 
-export type CookieSyncDate = Dictionary<number>;
-
 export interface IUserPersistenceMinified extends Dictionary {
-    csd: CookieSyncDate; // Cookie Sync Dates // list of timestamps for last cookie sync
+    csd: CookieSyncDates; // list of timestamps for last cookie sync per module
     con: IMinifiedConsentJSONObject; // Consent State
     ui: UserIdentities; // User Identities
     ua: UserAttributes; // User Attributes
@@ -121,7 +120,7 @@ export interface IPersistence {
     getDomain(doc: string, locationHostname: string): string;
     getCartProducts(mpid: MPID): Product[];
     setCartProducts(allProducts: Product[]): void;
-    saveUserCookieSyncDatesToPersistence(mpid: MPID, csd: CookieSyncDate): void;
+    saveUserCookieSyncDatesToPersistence(mpid: MPID, csd: CookieSyncDates): void;
     savePersistence(persistance: IPersistenceMinified): void;
     getPersistence(): IPersistenceMinified;
     getFirstSeenTime(mpid: MPID): string | null;

package/src/sdkRuntimeModels.ts

@@ -31,6 +31,8 @@ import {
 } from './identity-user-interfaces';
 import { IIdentityType } from './types.interfaces';
 import IntegrationCapture from './integrationCapture';
+import { INativeSdkHelpers } from './nativeSdkHelpers.interfaces';
+import { ICookieSyncManager, IPixelConfiguration } from './cookieSyncManager';
 
 // TODO: Resolve this with version in @mparticle/web-sdk
 export type SDKEventCustomFlags = Dictionary<any>;
@@ -158,6 +160,7 @@ export interface MParticleWebSDK {
     Logger: SDKLoggerApi;
     MPSideloadedKit: IMPSideloadedKit;
     _APIClient: any; // TODO: Set up API Client
+    _CookieSyncManager: ICookieSyncManager;
     _Store: IStore;
     _Forwarders: any;
     _Helpers: SDKHelpersApi;
@@ -167,7 +170,7 @@ export interface MParticleWebSDK {
     _SessionManager: ISessionManager;
     _Consent: SDKConsentApi;
     Consent: SDKConsentApi;
-    _NativeSdkHelpers: any; // TODO: Set up API
+    _NativeSdkHelpers: INativeSdkHelpers;
     _Persistence: IPersistence;
     _preInit: any; // TODO: Set up API
     _instances?: Dictionary<MParticleWebSDK>;
@@ -228,6 +231,7 @@ export interface SDKInitConfig
     sideloadedKits?: MPForwarder[];
     dataPlanOptions?: KitBlockerOptions;
     flags?: Dictionary;
+    pixelConfigs?: IPixelConfiguration[];
 
     aliasMaxWindow?: number;
     deviceId?: string;

package/src/store.ts

@@ -37,6 +37,7 @@ import {
     IGlobalStoreV2MinifiedKeys,
     IPersistenceMinified,
 } from './persistence.interfaces';
+import { CookieSyncDates, IPixelConfiguration } from './cookieSyncManager';
 
 // This represents the runtime configuration of the SDK AFTER
 // initialization has been complete and all settings and
@@ -118,7 +119,6 @@ function createSDKConfig(config: SDKInitConfig): SDKConfig {
 
 // TODO: Placeholder Types to be filled in as we migrate more modules
 //       to TypeScript
-export type PixelConfiguration = Dictionary;
 export type ServerSettings = Dictionary;
 export type SessionAttributes = Dictionary;
 export type IntegrationAttributes = Dictionary<Dictionary<string>>;
@@ -168,7 +168,7 @@ export interface IStore {
     identifyCalled: boolean;
     isLoggedIn: boolean;
     sideloadedKitsCount?: number;
-    cookieSyncDates: Dictionary<number>;
+    cookieSyncDates: CookieSyncDates;
     integrationAttributes: IntegrationAttributes;
     requireDelay: boolean;
     isLocalStorageAvailable: boolean | null;
@@ -178,7 +178,7 @@ export interface IStore {
     kits: Dictionary<MPForwarder>;
     sideloadedKits: MPForwarder[];
     configuredForwarders: MPForwarder[];
-    pixelConfigurations: PixelConfiguration[];
+    pixelConfigurations: IPixelConfiguration[];
     integrationDelayTimeoutStart: number; // UNIX Timestamp
     webviewBridgeEnabled?: boolean;
     wrapperSDKInfo: WrapperSDKInfo;