@mparticle/web-sdk 2.45.0 → 2.47.0

package/src/integrationCapture.ts

@@ -1,4 +1,5 @@
 import { SDKEventCustomFlags } from './sdkRuntimeModels';
+import Constants from './constants';
 import { IntegrationAttributes } from './store';
 import {
     Dictionary,
@@ -73,7 +74,7 @@ interface IntegrationIdMapping {
     [key: string]: IntegrationMappingItem;
 }
 
-const integrationMapping: IntegrationIdMapping = {
+const integrationMappingExternal: IntegrationIdMapping = {
     // Facebook / Meta
     fbclid: {
         mappedKey: 'Facebook.ClickId',
@@ -103,6 +104,25 @@ const integrationMapping: IntegrationIdMapping = {
         output: IntegrationOutputs.CUSTOM_FLAGS,
     },
 
+    // TIKTOK
+    ttclid: {
+        mappedKey: 'TikTok.Callback',
+        output: IntegrationOutputs.CUSTOM_FLAGS,
+    },
+    _ttp: {
+        mappedKey: 'tiktok_cookie_id',
+        output: IntegrationOutputs.PARTNER_IDENTITIES,
+    },
+
+    // Snapchat
+    // https://businesshelp.snapchat.com/s/article/troubleshooting-click-id?language=en_US
+    ScCid: {
+        mappedKey: 'SnapchatConversions.ClickId',
+        output: IntegrationOutputs.CUSTOM_FLAGS,
+    },
+};
+
+const integrationMappingRokt: IntegrationIdMapping = {
     // Rokt
     // https://docs.rokt.com/developers/integration-guides/web/advanced/rokt-id-tag/
     // https://go.mparticle.com/work/SQDSDKS-7167
@@ -121,23 +141,6 @@ const integrationMapping: IntegrationIdMapping = {
         output: IntegrationOutputs.INTEGRATION_ATTRIBUTES,
         moduleId: 1277,
     },
-
-    // TIKTOK
-    ttclid: {
-        mappedKey: 'TikTok.Callback',
-        output: IntegrationOutputs.CUSTOM_FLAGS,
-    },
-    _ttp: {
-        mappedKey: 'tiktok_cookie_id',
-        output: IntegrationOutputs.PARTNER_IDENTITIES,
-    },
-
-    // Snapchat
-    // https://businesshelp.snapchat.com/s/article/troubleshooting-click-id?language=en_US
-    ScCid: {
-        mappedKey: 'SnapchatConversions.ClickId',
-        output: IntegrationOutputs.CUSTOM_FLAGS,
-    },
 };
 
 export default class IntegrationCapture {
@@ -146,9 +149,11 @@ export default class IntegrationCapture {
     public readonly filteredPartnerIdentityMappings: IntegrationIdMapping;
     public readonly filteredCustomFlagMappings: IntegrationIdMapping;
     public readonly filteredIntegrationAttributeMappings: IntegrationIdMapping;
+    public captureMode?: valueof<typeof Constants.CaptureIntegrationSpecificIdsV2Modes>;
 
-    constructor() {
+    constructor(captureMode: valueof<typeof Constants.CaptureIntegrationSpecificIdsV2Modes>) {
         this.initialTimestamp = Date.now();
+        this.captureMode = captureMode;
 
         // Cache filtered mappings for faster access
         this.filteredPartnerIdentityMappings = this.filterMappings(IntegrationOutputs.PARTNER_IDENTITIES);
@@ -205,7 +210,8 @@ export default class IntegrationCapture {
      * Captures cookies based on the integration ID mapping.
      */
     public captureCookies(): Dictionary<string> {
-        const cookies = getCookies(Object.keys(integrationMapping));
+        const integrationKeys = this.getAllowedKeysForMode();
+        const cookies = getCookies(integrationKeys);
         return this.applyProcessors(cookies, getHref(), this.initialTimestamp);
     }
 
@@ -221,8 +227,9 @@ export default class IntegrationCapture {
      * Captures local storage based on the integration ID mapping.
      */
     public captureLocalStorage(): Dictionary<string> {
+        const integrationKeys = this.getAllowedKeysForMode();
         let localStorageItems: Dictionary<string> = {};
-        for (const key in integrationMapping) {
+        for (const key of integrationKeys) {
             const localStorageItem = localStorage.getItem(key);
             if (localStorageItem) {
                 localStorageItems[key] = localStorageItem;
@@ -237,7 +244,8 @@ export default class IntegrationCapture {
      * @returns {Dictionary<string>} The query parameters.
      */
     public getQueryParams(): Dictionary<string> {
-        return queryStringParser(getHref(), Object.keys(integrationMapping));
+        const integrationKeys = this.getAllowedKeysForMode();
+        return queryStringParser(getHref(), integrationKeys);
     }
 
     /**
@@ -316,15 +324,15 @@ export default class IntegrationCapture {
         timestamp?: number
     ): Dictionary<string> {
         const processedClickIds: Dictionary<string> = {};
-
+        const integrationKeys = this.getActiveIntegrationMapping();
+    
         for (const key in clickIds) {
             if (clickIds.hasOwnProperty(key)) {
                 const value = clickIds[key];
-                const processor = integrationMapping[key]?.processor;
+                const processor = integrationKeys[key]?.processor;
                 processedClickIds[key] = processor ? processor(value, url, timestamp) : value;
             }
         }
-
         return processedClickIds;
     }
 
@@ -332,11 +340,36 @@ export default class IntegrationCapture {
         outputType: valueof<typeof IntegrationOutputs>
     ): IntegrationIdMapping {
         const filteredMappings: IntegrationIdMapping = {};
-        for (const key in integrationMapping) {
-            if (integrationMapping[key].output === outputType) {
-                filteredMappings[key] = integrationMapping[key];
+        const integrationKeys = this.getActiveIntegrationMapping();
+        for (const key in integrationKeys) {
+            if (integrationKeys[key].output === outputType) {
+                filteredMappings[key] = integrationKeys[key];
             }
         }
         return filteredMappings;
     }
+
+    /**
+     * Returns the allowed keys to capture based on the current mode.
+     * For RoktOnly, limit capture to Rokt keys; for All, capture all mapped keys.
+     */
+    private getAllowedKeysForMode(): string[] {
+        return Object.keys(this.getActiveIntegrationMapping());
+    }
+    
+    /**
+    * Selects the active integration mapping for the current captureMode.
+    * - 'roktonly': only Rokt IDs are considered
+    * - 'all': both External and Rokt IDs are considered
+    * - else: returns an empty mapping and nothing will be captured
+    */
+    private getActiveIntegrationMapping(): IntegrationIdMapping {
+        if (this.captureMode === Constants.CaptureIntegrationSpecificIdsV2Modes.RoktOnly) {
+            return integrationMappingRokt;
+        }
+        if (this.captureMode === Constants.CaptureIntegrationSpecificIdsV2Modes.All) {
+            return { ...integrationMappingExternal, ...integrationMappingRokt };
+        }
+        return {};
+    }
 }

package/src/mp-instance.ts

@@ -36,8 +36,8 @@ import Consent, { IConsent } from './consent';
 import KitBlocker from './kitBlocking';
 import ConfigAPIClient, { IKitConfigs } from './configAPIClient';
 import IdentityAPIClient from './identityApiClient';
-import { isFunction, parseConfig } from './utils';
-import { LocalStorageVault } from './vault';
+import { isFunction, parseConfig, valueof } from './utils';
+import { DisabledVault, LocalStorageVault } from './vault';
 import { removeExpiredIdentityCacheDates } from './identity-utils';
 import IntegrationCapture from './integrationCapture';
 import { IPreInit, processReadyQueue } from './pre-init-utils';
@@ -91,8 +91,8 @@ export interface IMParticleWebSDKInstance extends MParticleWebSDK {
     _timeOnSiteTimer: ForegroundTimer; 
 }
 
-const { Messages, HTTPCodes, FeatureFlags } = Constants;
-const { ReportBatching, CaptureIntegrationSpecificIds } = FeatureFlags;
+const { Messages, HTTPCodes, FeatureFlags, CaptureIntegrationSpecificIdsV2Modes } = Constants;
+const { ReportBatching, CaptureIntegrationSpecificIds, CaptureIntegrationSpecificIdsV2 } = FeatureFlags;
 const { StartingInitialization } = Messages.InformationMessages;
 
 /**
@@ -128,7 +128,6 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         integrationDelays: {},
         forwarderConstructors: [],
     };
-    this._IntegrationCapture = new IntegrationCapture();
     this._RoktManager = new RoktManager();
 
     // required for forwarders once they reference the mparticle instance
@@ -1354,6 +1353,7 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
 // Some (server) config settings need to be returned before they are set on SDKConfig in a self hosted environment
 function completeSDKInitialization(apiKey, config, mpInstance) {
     const kitBlocker = createKitBlocker(config, mpInstance);
+    const { getFeatureFlag } = mpInstance._Helpers;
 
     mpInstance._APIClient = new APIClient(mpInstance, kitBlocker);
     mpInstance._Forwarders = new Forwarders(mpInstance, kitBlocker);
@@ -1386,11 +1386,22 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
             ? { userIdentities: currentUserIdentities }
             : mpInstance._Store.SDKConfig.identifyRequest;
 
-        if (mpInstance._Helpers.getFeatureFlag(ReportBatching)) {
+        if (getFeatureFlag(ReportBatching)) {
             mpInstance._ForwardingStatsUploader.startForwardingStatsTimer();
         }
-
-        if (mpInstance._Helpers.getFeatureFlag(CaptureIntegrationSpecificIds)) {
+        // https://go.mparticle.com/work/SQDSDKS-7639
+        const integrationSpecificIds = getFeatureFlag(CaptureIntegrationSpecificIds) as boolean;
+        const integrationSpecificIdsV2 = getFeatureFlag(CaptureIntegrationSpecificIdsV2) as string;
+        
+        const isIntegrationCaptureEnabled = (integrationSpecificIdsV2 && integrationSpecificIdsV2 !== CaptureIntegrationSpecificIdsV2Modes.None) || integrationSpecificIds === true;
+        if (isIntegrationCaptureEnabled) {
+            let captureMode: valueof<typeof CaptureIntegrationSpecificIdsV2Modes> | undefined;
+            if (integrationSpecificIds || integrationSpecificIdsV2 === CaptureIntegrationSpecificIdsV2Modes.All) {
+                captureMode = 'all';
+            } else if (integrationSpecificIdsV2 === CaptureIntegrationSpecificIdsV2Modes.RoktOnly) {
+                captureMode = 'roktonly';
+            }
+            mpInstance._IntegrationCapture = new IntegrationCapture(captureMode);
             mpInstance._IntegrationCapture.capture();
         }
 
@@ -1523,9 +1534,11 @@ function createKitBlocker(config, mpInstance) {
 }
 
 function createIdentityCache(mpInstance) {
-    return new LocalStorageVault(`${mpInstance._Store.storageName}-id-cache`, {
-        logger: mpInstance.Logger,
-    });
+    const cacheKey = `${mpInstance._Store.storageName}-id-cache`;
+    if (mpInstance._Store.getPrivacyFlag('IdentityCache')) {
+        return new DisabledVault(cacheKey, { logger: mpInstance.Logger });
+    }
+    return new LocalStorageVault(cacheKey, { logger: mpInstance.Logger });
 }
 
 function runPreConfigFetchInitialization(mpInstance, apiKey, config) {

package/src/persistence.js

@@ -35,6 +35,10 @@ export default function _Persistence(mpInstance) {
                 mpInstance._Store.isFirstRun = false;
             }
 
+            if (mpInstance._Store.getPrivacyFlag('SDKState')) {
+                return;
+            }
+
             // https://go.mparticle.com/work/SQDSDKS-6045
             if (!mpInstance._Store.isLocalStorageAvailable) {
                 mpInstance._Store.SDKConfig.useCookieStorage = true;
@@ -142,7 +146,10 @@ export default function _Persistence(mpInstance) {
     };
 
     this.update = function() {
-        if (!mpInstance._Store.webviewBridgeEnabled) {
+        if (
+            !mpInstance._Store.webviewBridgeEnabled &&
+            !mpInstance._Store.getPrivacyFlag('SDKState')
+        ) {
             if (mpInstance._Store.SDKConfig.useCookieStorage) {
                 self.setCookie();
             }
@@ -962,6 +969,9 @@ export default function _Persistence(mpInstance) {
 
     // https://go.mparticle.com/work/SQDSDKS-6021
     this.savePersistence = function(persistence) {
+        if (mpInstance._Store.getPrivacyFlag('SDKState')) {
+            return;
+        }
         var encodedPersistence = self.encodePersistence(
                 JSON.stringify(persistence)
             ),
@@ -1006,6 +1016,9 @@ export default function _Persistence(mpInstance) {
     };
 
     this.getPersistence = function() {
+        if (mpInstance._Store.getPrivacyFlag('SDKState')) {
+            return null;
+        }
         var persistence = this.useLocalStorage()
             ? this.getLocalStorage()
             : this.getCookie();

package/src/roktManager.ts

@@ -319,15 +319,15 @@ export default class RoktManager {
         this.logger?.verbose(`RoktManager: Processing ${this.messageQueue.size} queued messages`);
 
         this.messageQueue.forEach((message) => {
-            if(!(message.methodName in this.kit) || !isFunction(this.kit[message.methodName])) {
-                this.logger?.error(`RoktManager: Method ${message.methodName} not found in kit`);
+            if(!(message.methodName in this) || !isFunction(this[message.methodName])) {
+                this.logger?.error(`RoktManager: Method ${message.methodName} not found`);
                 return;
             }
 
             this.logger?.verbose(`RoktManager: Processing queued message: ${message.methodName} with payload: ${JSON.stringify(message.payload)}`);
 
             try {
-                const result = (this.kit[message.methodName] as Function)(message.payload);
+                const result = (this[message.methodName] as Function)(message.payload);
                 this.completePendingPromise(message.messageId, result);
             } catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
@@ -335,6 +335,9 @@ export default class RoktManager {
                 this.completePendingPromise(message.messageId, Promise.reject(error));
             }
         });
+
+        // Clear the queue after processing all messages
+        this.messageQueue.clear();
     }
 
     private queueMessage(message: IRoktMessage): void {

package/src/sdkToEventsApiConverter.ts

@@ -18,11 +18,10 @@ import { SDKIdentityTypeEnum } from './identity.interfaces';
 import Constants from './constants';
 import { IMParticleWebSDKInstance } from './mp-instance';
 
-const { 
-    FeatureFlags
-} = Constants;
+const { FeatureFlags } = Constants;
 const {
-    CaptureIntegrationSpecificIds
+    CaptureIntegrationSpecificIds, 
+    CaptureIntegrationSpecificIdsV2,
 } = FeatureFlags;
 
 type PartnerIdentities = Dictionary<string>;
@@ -127,8 +126,12 @@ export function convertEvents(
             },
         };
     }
+    // https://go.mparticle.com/work/SQDSDKS-7639
+    const integrationSpecificIds = getFeatureFlag && Boolean(getFeatureFlag(CaptureIntegrationSpecificIds));
+    const integrationSpecificIdsV2 = getFeatureFlag && (getFeatureFlag(CaptureIntegrationSpecificIdsV2) as string);
+        
+    const isIntegrationCaptureEnabled = (integrationSpecificIdsV2 && integrationSpecificIdsV2 !== Constants.CaptureIntegrationSpecificIdsV2Modes.None) || integrationSpecificIds === true;
 
-    const isIntegrationCaptureEnabled: boolean = getFeatureFlag && Boolean(getFeatureFlag(CaptureIntegrationSpecificIds));
     if (isIntegrationCaptureEnabled) {
         const capturedPartnerIdentities: PartnerIdentities = _IntegrationCapture?.getClickIdsAsPartnerIdentities();
         if (!isEmpty(capturedPartnerIdentities)) {

package/src/serverModel.ts

@@ -276,18 +276,22 @@ export default function ServerModel(
             let customFlags: SDKEventCustomFlags = {...event.customFlags};
             let integrationAttributes: IntegrationAttributes = mpInstance._Store.integrationAttributes;
 
+            const { getFeatureFlag } = mpInstance._Helpers;
             // https://go.mparticle.com/work/SQDSDKS-5053
-            if (mpInstance._Helpers.getFeatureFlag && mpInstance._Helpers.getFeatureFlag(Constants.FeatureFlags.CaptureIntegrationSpecificIds)) {
-
+            // https://go.mparticle.com/work/SQDSDKS-7639
+            const integrationSpecificIds = getFeatureFlag && (getFeatureFlag(Constants.FeatureFlags.CaptureIntegrationSpecificIds) as boolean);
+            const integrationSpecificIdsV2 = getFeatureFlag && ((getFeatureFlag(Constants.FeatureFlags.CaptureIntegrationSpecificIdsV2) as string) || '');
+            const isIntegrationCaptureEnabled = (integrationSpecificIdsV2 && integrationSpecificIdsV2 !== Constants.CaptureIntegrationSpecificIdsV2Modes.None) || integrationSpecificIds === true;     
+            if (isIntegrationCaptureEnabled) {
                 // Attempt to recapture click IDs in case a third party integration
                 // has added or updated  new click IDs since the last event was sent.
                 mpInstance._IntegrationCapture.capture();
                 const transformedClickIDs = mpInstance._IntegrationCapture.getClickIdsAsCustomFlags();
-                customFlags = {...transformedClickIDs, ...customFlags};
-
+                customFlags = { ...transformedClickIDs, ...customFlags };
                 const transformedIntegrationAttributes = mpInstance._IntegrationCapture.getClickIdsAsIntegrationAttributes();
-                integrationAttributes = {...transformedIntegrationAttributes, ...integrationAttributes};
+                integrationAttributes = { ...transformedIntegrationAttributes, ...integrationAttributes };
             }
+            
 
             if (event.hasOwnProperty('toEventAPIObject')) {
                 eventObject = event.toEventAPIObject();

package/src/store.ts

@@ -8,7 +8,7 @@ import {
     UserIdentities,
 } from '@mparticle/web-sdk';
 import { IKitConfigs } from './configAPIClient';
-import Constants from './constants';
+import Constants, { PrivacyControl, StoragePrivacyMap, StorageTypes } from './constants';
 import {
     DataPlanResult,
     KitBlockerOptions,
@@ -145,6 +145,7 @@ export interface IFeatureFlags {
     directURLRouting?: boolean;
     cacheIdentity?: boolean;
     captureIntegrationSpecificIds?: boolean;
+    captureIntegrationSpecificIdsV2?: string;
     astBackgroundEvents?: boolean;
 }
 
@@ -215,6 +216,7 @@ export interface IStore {
     setNoFunctional?(noFunctional: boolean): void;
     getNoTargeting?(): boolean;
     setNoTargeting?(noTargeting: boolean): void;
+    getPrivacyFlag?(storageType: StorageTypes): boolean;
 
     getDeviceId?(): string;
     setDeviceId?(deviceId: string): void;
@@ -607,6 +609,17 @@ export default function Store(
         this.noTargeting = noTargeting;
     };
 
+    this.getPrivacyFlag = (storageType: StorageTypes): boolean => {
+        const privacyControl: PrivacyControl = StoragePrivacyMap[storageType];
+        if (privacyControl === 'functional') {
+            return this.getNoFunctional();
+        }
+        if (privacyControl === 'targeting') {
+            return this.getNoTargeting();
+        }
+        return false;
+    };
+
     this.getDeviceId = () => this.deviceId;
     this.setDeviceId = (deviceId: string) => {
         this.deviceId = deviceId;
@@ -727,9 +740,21 @@ export default function Store(
             this.SDKConfig[baseUrlKeys] = baseUrls[baseUrlKeys];
         }
 
+        const { noFunctional, noTargeting } = config?.launcherOptions ?? {};
+
+        if (noFunctional != null) {
+            this.setNoFunctional(noFunctional);
+        }
+        
+        if (noTargeting != null) {
+            this.setNoTargeting(noTargeting);
+        }
+
         if (workspaceToken) {
             this.SDKConfig.workspaceToken = workspaceToken;
-            mpInstance._timeOnSiteTimer = new ForegroundTimer(workspaceToken);
+            if (!this.getPrivacyFlag('TimeOnSite')) {
+                mpInstance._timeOnSiteTimer = new ForegroundTimer(workspaceToken);
+            }
         } else {
             mpInstance.Logger.warning(
                 'You should have a workspaceToken on your config object for security purposes.'
@@ -739,15 +764,6 @@ export default function Store(
         this.storageName = createMainStorageName(workspaceToken);
         this.prodStorageName = createProductStorageName(workspaceToken);
 
-        // Extract privacy flags directly from config into Store
-        if (config.hasOwnProperty('noFunctional')) {
-            this.setNoFunctional(config.noFunctional);
-        }
-
-        if (config.hasOwnProperty('noTargeting')) {
-            this.setNoTargeting(config.noTargeting);
-        }
-
         this.SDKConfig.requiredWebviewBridgeName =
             requiredWebviewBridgeName || workspaceToken;
 
@@ -771,6 +787,7 @@ export function processFlags(config: SDKInitConfig): IFeatureFlags {
         CacheIdentity,
         AudienceAPI,
         CaptureIntegrationSpecificIds,
+        CaptureIntegrationSpecificIdsV2,
         AstBackgroundEvents
     } = Constants.FeatureFlags;
 
@@ -790,8 +807,8 @@ export function processFlags(config: SDKInitConfig): IFeatureFlags {
     flags[CacheIdentity] = config.flags[CacheIdentity] === 'True';
     flags[AudienceAPI] = config.flags[AudienceAPI] === 'True';
     flags[CaptureIntegrationSpecificIds] = config.flags[CaptureIntegrationSpecificIds] === 'True';
+    flags[CaptureIntegrationSpecificIdsV2] = (config.flags[CaptureIntegrationSpecificIdsV2] || 'none');
     flags[AstBackgroundEvents] = config.flags[AstBackgroundEvents] === 'True';
-
     return flags;
 }
 

package/src/vault.ts

@@ -102,4 +102,20 @@ export class SessionStorageVault<StorableItem> extends BaseVault<StorableItem> {
     constructor(storageKey: string, options?: IVaultOptions) {
         super(storageKey, window.sessionStorage, options);
     }
+}
+
+// DisabledVault is used when persistence is disabled by privacy flags.
+export class DisabledVault<StorableItem> extends BaseVault<StorableItem> {
+    constructor(storageKey: string, options?: IVaultOptions) {
+        super(storageKey, window.localStorage, options);
+        this.contents = null;
+    }
+
+    public store(_item: StorableItem): void {
+        this.contents = null;
+    }
+
+    public retrieve(): StorableItem | null {
+        return this.contents;
+    }
 }