@mparticle/web-sdk 2.51.0 → 2.53.0

package/package.json

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

package/src/batchUploader.ts

@@ -257,15 +257,15 @@ export class BatchUploader {
             return;
         }
 
-        const { verbose } = this.mpInstance.Logger;
+        const { Logger } = this.mpInstance;
 
         this.eventsQueuedForProcessing.push(event);
         if (this.offlineStorageEnabled && this.eventVault) {
             this.eventVault.store(this.eventsQueuedForProcessing);
         }
 
-        verbose(`Queuing event: ${JSON.stringify(event)}`);
-        verbose(`Queued event count: ${this.eventsQueuedForProcessing.length}`);
+        Logger.verbose(`Queuing event: ${JSON.stringify(event)}`);
+        Logger.verbose(`Queued event count: ${this.eventsQueuedForProcessing.length}`);
 
         if (this.shouldTriggerImmediateUpload(event.EventDataType)) {
             this.prepareAndUpload(false, false);

package/src/cookieConsentManager.ts

@@ -0,0 +1,64 @@
+/**
+ * Cookie consent flags control SDK behavior based on user consent preferences for Rokt integration.
+ * @see https://docs.rokt.com/developers/integration-guides/web/cookie-consent-flags/
+ */
+export interface ICookieConsentFlags {
+    /**
+     * When true, indicates the user has opted out of functional cookies/tracking.
+     * Default: false (functional tracking is allowed)
+     */
+    noFunctional: boolean;
+
+    /**
+     * When true, indicates the user has opted out of targeting cookies/tracking.
+     * This flag is used to block cookie syncs and other targeting-related features.
+     * Default: false (targeting is allowed)
+     */
+    noTargeting: boolean;
+}
+
+export interface ICookieConsentManager {
+    /**
+     * Targeting is allowed when noTargeting is false (default)
+     */
+    getNoTargeting: () => boolean;
+
+    /**
+     * Functional tracking is allowed when noFunctional is false (default)
+     */
+    getNoFunctional: () => boolean;
+}
+
+/**
+ * CookieConsentManager handles storage and access of consent flags (noFunctional, noTargeting)
+ * that are passed via launcherOptions during SDK initialization.
+ *
+ * These flags allow Rokt integration to respect user privacy choices.
+ *
+ * Default behavior: Both flags default to false, meaning all features are allowed
+ * unless explicitly opted out by the user.
+ */
+export default class CookieConsentManager implements ICookieConsentManager {
+    constructor(private flags: ICookieConsentFlags) {
+        this.flags = {
+            noFunctional: flags.noFunctional === true,
+            noTargeting: flags.noTargeting === true,
+        };
+    }
+
+    /**
+     * Returns true if third-party targeting is disabled.
+     * Targeting is allowed when noTargeting is false (default).
+     */
+    getNoTargeting(): boolean {
+        return this.flags.noTargeting;
+    }
+
+    /**
+     * Returns true if functional tracking is disabled.
+     * Functional tracking is allowed when noFunctional is false (default).
+     */
+    getNoFunctional(): boolean {
+        return this.flags.noFunctional;
+    }
+}

package/src/cookieSyncManager.ts

@@ -13,6 +13,17 @@ const { InformationMessages } = Messages;
 
 export const DAYS_IN_MILLISECONDS = 1000 * 60 * 60 * 24;
 
+// Partner module IDs for cookie sync configurations
+export const PARTNER_MODULE_IDS = {
+    AdobeEventForwarder: 11,
+    DoubleclickDFP: 41,
+    AppNexus: 50,
+    Lotame: 58,
+    TradeDesk: 103,
+    VerizonMedia: 155,
+    Rokt: 1277,
+} as const;
+
 export type CookieSyncDates = Dictionary<number>; 
 
 export interface IPixelConfiguration {
@@ -98,6 +109,11 @@ export default function CookieSyncManager(
                 return;
             }
 
+            // For Rokt, block cookie sync when noTargeting privacy flag is true
+            if (moduleId === PARTNER_MODULE_IDS.Rokt && mpInstance._CookieConsentManager.getNoTargeting()) {
+                return;
+            }
+
             const { isEnabledForUserConsent } = mpInstance._Consent;
 
             if (!isEnabledForUserConsent(filteringConsentRuleValues, mpInstance.Identity.getCurrentUser())) {
@@ -111,8 +127,12 @@ export default function CookieSyncManager(
                 return;
             }
 
-            // Url for cookie sync pixel
-            const fullUrl = createCookieSyncUrl(mpid, pixelUrl, redirectUrl)
+            // The Trade Desk requires a URL parameter for GDPR enabled users.
+            // It is optional but to simplify the code, we add it for all Trade
+            // // Desk cookie syncs.
+            const domain = moduleId === PARTNER_MODULE_IDS.TradeDesk ? window.location.hostname : undefined;
+            // Add domain parameter for Trade Desk
+            const fullUrl = createCookieSyncUrl(mpid, pixelUrl, redirectUrl, domain);
 
             self.performCookieSync(
                 fullUrl,

package/src/identity.interfaces.ts

@@ -107,12 +107,14 @@ export interface IIdentityRequest {
     ): IdentityPreProcessResult;
 }
 
+export type AliasRequestScope = 'device' | 'mpid';
+
 export interface IAliasRequest {
     destinationMpid: MPID;
     sourceMpid: MPID;
     startTime: number;
     endTime: number;
-    scope?: string;
+    scope?: AliasRequestScope;
 }
 
 export interface IAliasCallback {
@@ -151,7 +153,8 @@ export interface SDKIdentityApi {
     ): void;
     createAliasRequest?(
         sourceUser: IMParticleUser,
-        destinationUser: IMParticleUser
+        destinationUser: IMParticleUser,
+        scope?: AliasRequestScope
     ): IAliasRequest;
 }
 

package/src/identity.js

@@ -195,6 +195,7 @@ export default function Identity(mpInstance) {
                 SourceMpid: aliasRequest.sourceMpid,
                 StartUnixtimeMs: aliasRequest.startTime,
                 EndUnixtimeMs: aliasRequest.endTime,
+                Scope: aliasRequest.scope,
             };
         },
 
@@ -744,7 +745,7 @@ export default function Identity(mpInstance) {
         after applying this adjustment it will be impossible to create an aliasRequest passes the aliasUsers() 
         validation that the startTime must be less than the endTime 
         */
-        createAliasRequest: function(sourceUser, destinationUser) {
+        createAliasRequest: function(sourceUser, destinationUser, scope) {
             try {
                 if (!destinationUser || !sourceUser) {
                     mpInstance.Logger.error(
@@ -788,6 +789,7 @@ export default function Identity(mpInstance) {
                     sourceMpid: sourceUser.getMPID(),
                     startTime: startTime,
                     endTime: endTime,
+                    scope: scope || 'device',
                 };
             } catch (e) {
                 mpInstance.Logger.error(

package/src/identityApiClient.ts

@@ -88,12 +88,12 @@ export default function IdentityAPIClient(
         aliasRequest: IAliasRequest,
         aliasCallback: IAliasCallback
     ) {
-        const { verbose, error } = mpInstance.Logger;
+        const { Logger } = mpInstance;
         const { invokeAliasCallback } = mpInstance._Helpers;
         const { aliasUrl } = mpInstance._Store.SDKConfig;
         const { devToken: apiKey } = mpInstance._Store;
 
-        verbose(Messages.InformationMessages.SendAliasHttp);
+        Logger.verbose(Messages.InformationMessages.SendAliasHttp);
 
         // https://go.mparticle.com/work/SQDSDKS-6750
         const uploadUrl = `https://${aliasUrl}${apiKey}/Alias`;
@@ -136,7 +136,7 @@ export default function IdentityAPIClient(
                         try {
                             aliasResponseBody = await response.json();
                         } catch (e) {
-                            verbose('The request has no response body');
+                            Logger.verbose('The request has no response body');
                         }
                     } else {
                         // https://go.mparticle.com/work/SQDSDKS-6568
@@ -171,11 +171,11 @@ export default function IdentityAPIClient(
 
             }
 
-            verbose(message);
+            Logger.verbose(message);
             invokeAliasCallback(aliasCallback, response.status, errorMessage);
         } catch (e) {
             const errorMessage = (e as Error).message || e.toString();
-            error('Error sending alias request to mParticle servers. ' + errorMessage);
+            Logger.error('Error sending alias request to mParticle servers. ' + errorMessage);
             invokeAliasCallback(
                 aliasCallback,
                 HTTPCodes.noHttpCoverage,
@@ -193,15 +193,14 @@ export default function IdentityAPIClient(
         mpid: MPID,
         knownIdentities: UserIdentities
     ) {
-        const { verbose, error } = mpInstance.Logger;
         const { invokeCallback } = mpInstance._Helpers;
-
-        verbose(Messages.InformationMessages.SendIdentityBegin);
+        const { Logger } = mpInstance;
+        Logger.verbose(Messages.InformationMessages.SendIdentityBegin);
         if (!identityApiRequest) {
-            error(Messages.ErrorMessages.APIRequestEmpty);
+            Logger.error(Messages.ErrorMessages.APIRequestEmpty);
             return;
         }
-        verbose(Messages.InformationMessages.SendIdentityHttp);
+        Logger.verbose(Messages.InformationMessages.SendIdentityHttp);
 
         if (mpInstance._Store.identityCallInFlight) {
             invokeCallback(
@@ -289,7 +288,7 @@ export default function IdentityAPIClient(
 
             mpInstance._Store.identityCallInFlight = false;
 
-            verbose(message);
+            Logger.verbose(message);
             parseIdentityResponse(
                 identityResponse,
                 previousMPID,
@@ -304,7 +303,7 @@ export default function IdentityAPIClient(
             
             const errorMessage = (err as Error).message || err.toString();
 
-            error('Error sending identity request to servers' + ' - ' + errorMessage);
+            Logger.error('Error sending identity request to servers' + ' - ' + errorMessage);
             invokeCallback(
                 callback,
                 HTTPCodes.noHttpCoverage,

package/src/logger.ts

@@ -0,0 +1,66 @@
+import { LogLevelType, SDKInitConfig, SDKLoggerApi } from './sdkRuntimeModels';
+
+export type ILoggerConfig = Pick<SDKInitConfig, 'logLevel' | 'logger'>;
+export type IConsoleLogger = Partial<Pick<SDKLoggerApi, 'error' | 'warning' | 'verbose'>>;
+
+export class Logger {
+    private logLevel: LogLevelType;
+    private logger: IConsoleLogger;
+
+    constructor(config: ILoggerConfig) {
+        this.logLevel = config.logLevel ?? LogLevelType.Warning;
+        this.logger = config.logger ?? new ConsoleLogger();
+    }
+
+    public verbose(msg: string): void {
+        if(this.logLevel === LogLevelType.None) 
+            return;
+
+        if (this.logger.verbose && this.logLevel === LogLevelType.Verbose) {
+            this.logger.verbose(msg);
+        }
+    }
+
+    public warning(msg: string): void {
+        if(this.logLevel === LogLevelType.None) 
+            return;
+
+        if (this.logger.warning && 
+            (this.logLevel === LogLevelType.Verbose || this.logLevel === LogLevelType.Warning)) {
+            this.logger.warning(msg);
+        }
+    }
+
+    public error(msg: string): void {
+        if(this.logLevel === LogLevelType.None) 
+            return;
+
+        if (this.logger.error) {
+            this.logger.error(msg);
+        }
+    }
+
+    public setLogLevel(newLogLevel: LogLevelType): void {
+        this.logLevel = newLogLevel;
+    }
+}
+
+export class ConsoleLogger implements IConsoleLogger {
+    public verbose(msg: string): void {
+        if (console && console.info) {
+            console.info(msg);
+        }
+    }
+
+    public error(msg: string): void {
+        if (console && console.error) {
+            console.error(msg);
+        }
+    }
+
+    public warning(msg: string): void {
+        if (console && console.warn) {
+            console.warn(msg);
+        }
+    }
+}

package/src/mp-instance.ts

@@ -25,7 +25,7 @@ import CookieSyncManager, { ICookieSyncManager } from './cookieSyncManager';
 import SessionManager, { ISessionManager } from './sessionManager';
 import Ecommerce from './ecommerce';
 import Store, { IStore } from './store';
-import Logger from './logger';
+import { Logger } from './logger';
 import Persistence from './persistence';
 import Events from './events';
 import Forwarders from './forwarders';
@@ -51,6 +51,7 @@ import { IPersistence } from './persistence.interfaces';
 import ForegroundTimer from './foregroundTimeTracker';
 import RoktManager, { IRoktOptions } from './roktManager';
 import filteredMparticleUser from './filteredMparticleUser';
+import CookieConsentManager, { ICookieConsentManager } from './cookieConsentManager';
 
 export interface IErrorLogMessage {
     message?: string;
@@ -82,6 +83,7 @@ export interface IMParticleWebSDKInstance extends MParticleWebSDK {
     _IntegrationCapture: IntegrationCapture;
     _NativeSdkHelpers: INativeSdkHelpers;
     _Persistence: IPersistence;
+    _CookieConsentManager: ICookieConsentManager;
     _RoktManager: RoktManager;
     _SessionManager: ISessionManager;
     _ServerModel: IServerModel;
@@ -227,6 +229,7 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         if (instance._Store) {
             delete instance._Store;
         }
+        instance.Logger = new Logger(config);
         instance._Store = new Store(config, instance);
         instance._Store.isLocalStorageAvailable = instance._Persistence.determineLocalStorageAvailability(
             window.localStorage
@@ -1554,6 +1557,10 @@ function runPreConfigFetchInitialization(mpInstance, apiKey, config) {
     window.mParticle.Store = mpInstance._Store;
     mpInstance.Logger.verbose(StartingInitialization);
 
+    // Initialize CookieConsentManager with privacy flags from launcherOptions
+    const { noFunctional, noTargeting } = config?.launcherOptions ?? {};
+    mpInstance._CookieConsentManager = new CookieConsentManager({ noFunctional, noTargeting });
+
     // Check to see if localStorage is available before main configuration runs
     // since we will need this for the current implementation of user persistence
     // TODO: Refactor this when we refactor User Identity Persistence

package/src/mparticle-instance-manager.ts

@@ -368,10 +368,10 @@ function mParticleInstanceManager(this: IMParticleInstanceManager) {
         aliasUsers: function(aliasRequest, callback) {
             self.getInstance().Identity.aliasUsers(aliasRequest, callback);
         },
-        createAliasRequest: function(sourceUser, destinationUser) {
+        createAliasRequest: function(sourceUser, destinationUser, scope) {
             return self
                 .getInstance()
-                .Identity.createAliasRequest(sourceUser, destinationUser);
+                .Identity.createAliasRequest(sourceUser, destinationUser, scope);
         },
         getCurrentUser: function() {
             return self.getInstance().Identity.getCurrentUser();

package/src/roktManager.ts

@@ -252,15 +252,51 @@ export default class RoktManager {
         }
     }
 
-    public hashAttributes(attributes: IRoktPartnerAttributes): Promise<IRoktPartnerAttributes> {
-        if (!this.isReady()) {
-            return this.deferredCall<IRoktPartnerAttributes>('hashAttributes', attributes);
-        }
-
+    /**
+     * Hashes attributes and returns both original and hashed versions
+     * with Rokt-compatible key names (like emailsha256, mobilesha256)
+     * 
+     * 
+     * @param {IRoktPartnerAttributes} attributes - Attributes to hash
+     * @returns {Promise<IRoktPartnerAttributes>} Object with both original and hashed attributes
+     * 
+     */
+    public async hashAttributes(attributes: IRoktPartnerAttributes): Promise<IRoktPartnerAttributes> {
         try {
-            return this.kit.hashAttributes(attributes);
+            if (!attributes || typeof attributes !== 'object') {
+                return {};
+            }
+            
+            // Get own property keys only
+            const keys = Object.keys(attributes);
+            
+            if (keys.length === 0) {
+                return {};
+            }
+            
+            // Hash all attributes in parallel
+            const hashPromises = keys.map(async (key) => {
+                const attributeValue = attributes[key];
+                const hashedValue = await this.hashSha256(attributeValue);
+                return { key, attributeValue, hashedValue };
+            });
+            
+            const results = await Promise.all(hashPromises);
+            
+            // Build the result object
+            const hashedAttributes: IRoktPartnerAttributes = {};
+            for (const { key, attributeValue, hashedValue } of results) {
+                hashedAttributes[key] = attributeValue;
+                if (hashedValue) {
+                    hashedAttributes[`${key}sha256`] = hashedValue;
+                }
+            }
+            return hashedAttributes;
+            
         } catch (error) {
-            return Promise.reject(error instanceof Error ? error : new Error('Unknown error occurred'));
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Failed to hashAttributes, returning an empty object: ${errorMessage}`);
+            return {};
         }
     }
 
@@ -290,6 +326,29 @@ export default class RoktManager {
         }
     }
 
+    /**
+     * Hashes an attribute using SHA-256
+     * 
+     * @param {string | number | boolean | undefined | null} attribute - The value to hash
+     * @returns {Promise<string | undefined | null>} SHA-256 hashed value or undefined/null
+     * 
+     */
+    public async hashSha256(attribute: string | number | boolean | undefined | null): Promise<string | undefined | null> {
+        if (attribute === null || attribute === undefined) {
+            this.logger.warning(`hashSha256 received null/undefined as input`);
+            return attribute as null | undefined;
+        }
+        
+        try {
+            const normalizedValue = String(attribute).trim().toLocaleLowerCase();
+            return await this.sha256Hex(normalizedValue);
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Failed to hashSha256, returning undefined: ${errorMessage}`);
+            return undefined;
+        }
+    }
+
     public getLocalSessionAttributes(): LocalSessionAttributes {
         return this.store.getLocalSessionAttributes();
     }
@@ -400,6 +459,37 @@ export default class RoktManager {
         this.messageQueue.delete(messageId);
     }
 
+    /**
+     * Hashes a string input using SHA-256 and returns the hex digest
+     * Uses the Web Crypto API for secure hashing
+     * 
+     * @param {string} input - The string to hash
+     * @returns {Promise<string>} The SHA-256 hash as a hexadecimal string
+     */
+    private async sha256Hex(input: string): Promise<string> {
+        const encoder = new TextEncoder();
+        const encodedInput = encoder.encode(input);
+        const digest = await crypto.subtle.digest('SHA-256', encodedInput);
+        return this.arrayBufferToHex(digest);
+    }
+
+    /**
+     * Converts an ArrayBuffer to a hexadecimal string representation
+     * Each byte is converted to a 2-character hex string with leading zeros
+     * 
+     * @param {ArrayBuffer} buffer - The buffer to convert
+     * @returns {string} The hexadecimal string representation
+     */
+    private arrayBufferToHex(buffer: ArrayBuffer): string {
+        const bytes = new Uint8Array(buffer);
+        let hexString = '';
+        for (let i = 0; i < bytes.length; i++) {
+            const hexByte = bytes[i].toString(16).padStart(2, '0');
+            hexString += hexByte;
+        }
+        return hexString;
+    }
+
     /**
      * Checks if an identity value has changed by comparing current and new values
      * 

package/src/sdkRuntimeModels.ts

@@ -40,6 +40,7 @@ import {  SDKECommerceAPI } from './ecommerce.interfaces';
 import { IErrorLogMessage, IMParticleWebSDKInstance, IntegrationDelays } from './mp-instance';
 import Constants from './constants';
 import RoktManager, { IRoktLauncherOptions } from './roktManager';
+import { IConsoleLogger } from './logger';
 
 // TODO: Resolve this with version in @mparticle/web-sdk
 export type SDKEventCustomFlags = Dictionary<any>;
@@ -259,7 +260,13 @@ export interface IMParticleInstanceManager extends MParticleWebSDK {
 export type BooleanStringLowerCase = 'false' | 'true';
 export type BooleanStringTitleCase = 'False' | 'True';
 
-export type LogLevelType = 'none' | 'verbose' | 'warning' | 'error';
+export type LogLevelType = (typeof LogLevelType)[keyof typeof LogLevelType];
+export const LogLevelType = {
+    None: 'none',
+    Verbose: 'verbose',
+    Warning: 'warning',
+    Error: 'error',
+} as const;
 
 // TODO: This should eventually be moved into wherever init logic lives
 // TODO: Replace/Merge this with MPConfiguration in @types/mparticle__web-sdk
@@ -306,6 +313,7 @@ export interface SDKInitConfig
     launcherOptions?: IRoktLauncherOptions;
 
     rq?: Function[] | any[];
+    logger?: IConsoleLogger;
 }
 
 export interface DataPlanConfig {