@mparticle/web-sdk 2.57.0 → 2.59.0

package/src/mp-instance.ts

@@ -37,8 +37,8 @@ import KitBlocker from './kitBlocking';
 import ConfigAPIClient, { IKitConfigs } from './configAPIClient';
 import IdentityAPIClient from './identityApiClient';
 import { isFunction, parseConfig, valueof, generateDeprecationMessage } from './utils';
-import { LocalStorageVault } from './vault';
-import { removeExpiredIdentityCacheDates } from './identity-utils';
+import { DisabledVault, LocalStorageVault } from './vault';
+import { removeExpiredIdentityCacheDates, hasExplicitIdentifier } from './identity-utils';
 import IntegrationCapture from './integrationCapture';
 import { IPreInit, processReadyQueue } from './pre-init-utils';
 import { BaseEvent, MParticleWebSDK, SDKHelpersApi } from './sdkRuntimeModels';
@@ -52,6 +52,7 @@ import ForegroundTimer from './foregroundTimeTracker';
 import RoktManager, { IRoktOptions } from './roktManager';
 import filteredMparticleUser from './filteredMparticleUser';
 import CookieConsentManager, { ICookieConsentManager } from './cookieConsentManager';
+import { ReportingLogger } from './logging/reportingLogger';
 
 export interface IErrorLogMessage {
     message?: string;
@@ -84,16 +85,19 @@ export interface IMParticleWebSDKInstance extends MParticleWebSDK {
     _NativeSdkHelpers: INativeSdkHelpers;
     _Persistence: IPersistence;
     _CookieConsentManager: ICookieConsentManager;
+    _ReportingLogger: ReportingLogger;
     _RoktManager: RoktManager;
     _SessionManager: ISessionManager;
     _ServerModel: IServerModel;
     _Store: IStore;
     _instanceName: string;
     _preInit: IPreInit;
-    _timeOnSiteTimer: ForegroundTimer; 
+    _timeOnSiteTimer: ForegroundTimer;
     setLauncherInstanceGuid: () => void;
+    getLauncherInstanceGuid: () => string;
     captureTiming(metricName: string);
     processQueueOnIdentityFailure?: () => void;
+    processQueueOnNoFunctional?: () => void;
 }
 
 const { Messages, HTTPCodes, FeatureFlags, CaptureIntegrationSpecificIdsV2Modes } = Constants;
@@ -147,13 +151,30 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         if (self._Store?.isInitialized) {
             return;
         }
-        
+
         if (self._Store?.identityCallFailed && self._RoktManager?.isReady()) {
             self._RoktManager.processMessageQueue();
             self._preInit.readyQueue = processReadyQueue(self._preInit.readyQueue);
         }
     };
 
+    /**
+     * Drains the ready queue for noFunctional sessions with no explicit identity.
+     */
+    this.processQueueOnNoFunctional = function() {
+        if (self._Store?.isInitialized) {
+            return;
+        }
+
+        const noFunctionalWithoutId =
+            self._CookieConsentManager?.getNoFunctional() &&
+            !hasExplicitIdentifier(self._Store);
+
+        if (noFunctionalWithoutId) {
+            self._preInit.readyQueue = processReadyQueue(self._preInit.readyQueue);
+        }
+    };
+
     // required for forwarders once they reference the mparticle instance
     this.IdentityType = IdentityType;
     this.EventType = EventType;
@@ -245,12 +266,14 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         }
     };
 
-    this._resetForTests = function(config, keepPersistence, instance) {
+    this._resetForTests = function(config, keepPersistence, instance, reportingLogger?: ReportingLogger) {
         if (instance._Store) {
             delete instance._Store;
         }
-        instance.Logger = new Logger(config);
+        instance.Logger = new Logger(config, reportingLogger);
         instance._Store = new Store(config, instance);
+        // Update ReportingLogger with the new Store reference to avoid stale data
+        reportingLogger?.setStore(instance._Store);
         instance._Store.isLocalStorageAvailable = instance._Persistence.determineLocalStorageAvailability(
             window.localStorage
         );
@@ -275,11 +298,16 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
      * @param {Function} f Callback to execute
      */
     this.ready = function(f) {
+        const noFunctionalWithoutId =
+            self._CookieConsentManager?.getNoFunctional() &&
+            !hasExplicitIdentifier(self._Store);
+
         const shouldExecute = isFunction(f) && (
-            self._Store?.isInitialized || 
-            (self._Store?.identityCallFailed && self._RoktManager.isReady())
+            self._Store?.isInitialized ||
+            (self._Store?.identityCallFailed && self._RoktManager.isReady()) ||
+            noFunctionalWithoutId
         );
-        
+
         if (shouldExecute) {
             f();
         } else {
@@ -1130,11 +1158,16 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
      * @param {String or Number} value value for session attribute
      */
     this.setSessionAttribute = function(key, value) {
-        const queued = queueIfNotInitialized(function() {
-            self.setSessionAttribute(key, value);
-        }, self);
+        const skipQueue =
+            self._CookieConsentManager?.getNoFunctional() &&
+            !hasExplicitIdentifier(self._Store);
 
-        if (queued) return;
+        if (!skipQueue) {
+            const queued = queueIfNotInitialized(function() {
+                self.setSessionAttribute(key, value);
+            }, self);
+            if (queued) return;
+        }
 
         // Logs to cookie
         // And logs to in-memory object
@@ -1372,7 +1405,7 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
             };
         }
     };
-    
+
     const launcherInstanceGuidKey = Constants.Rokt.LauncherInstanceGuidKey;
     this.setLauncherInstanceGuid = function() {
         if (!window[launcherInstanceGuidKey] 
@@ -1381,6 +1414,10 @@ export default function mParticleInstance(this: IMParticleWebSDKInstance, instan
         }
     };
 
+    this.getLauncherInstanceGuid = function() {
+        return window[launcherInstanceGuidKey];
+    };
+
     this.captureTiming = function(metricsName) {
         if (typeof window !== 'undefined' && window.performance?.mark) {
             window.performance.mark(metricsName);
@@ -1446,6 +1483,8 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
         // Configure Rokt Manager with user and filtered user
         const roktConfig: IKitConfigs = parseConfig(config, 'Rokt', 181);
         if (roktConfig) {
+            const accountId = roktConfig.settings?.accountId;
+            mpInstance._Store.setRoktAccountId(accountId);
             const { userAttributeFilters } = roktConfig;
             const roktFilteredUser = filteredMparticleUser(
                 currentUserMPID,
@@ -1501,6 +1540,10 @@ function completeSDKInitialization(apiKey, config, mpInstance) {
         );
     }
 
+    // For noFunctional sessions with no identity, drain any pre-init ready callbacks
+    // that were queued before _CookieConsentManager was available to evaluate the condition.
+    mpInstance.processQueueOnNoFunctional?.();
+
     // https://go.mparticle.com/work/SQDSDKS-6040
     if (mpInstance._Store.isFirstRun) {
         mpInstance._Store.isFirstRun = false;
@@ -1573,15 +1616,30 @@ function createKitBlocker(config, mpInstance) {
 }
 
 function createIdentityCache(mpInstance) {
+    // Identity expects mpInstance._Identity.idCache to always exist. DisabledVault
+    // ensures no identity response data is written to localStorage when noFunctional is true
+    if (mpInstance._CookieConsentManager?.getNoFunctional()) {
+        return new DisabledVault(`${mpInstance._Store.storageName}-id-cache`, {
+            logger: mpInstance.Logger,
+        });
+    }
+    
     return new LocalStorageVault(`${mpInstance._Store.storageName}-id-cache`, {
         logger: mpInstance.Logger,
     });
 }
 
 function runPreConfigFetchInitialization(mpInstance, apiKey, config) {
-    mpInstance.Logger = new Logger(config);
+    mpInstance._ReportingLogger = new ReportingLogger(
+        config,
+        Constants.sdkVersion,
+        undefined,
+        mpInstance.getLauncherInstanceGuid(),
+    );
+    mpInstance.Logger = new Logger(config, mpInstance._ReportingLogger);
     mpInstance._Store = new Store(config, mpInstance, apiKey);
     window.mParticle.Store = mpInstance._Store;
+    mpInstance._ReportingLogger.setStore(mpInstance._Store);
     mpInstance.Logger.verbose(StartingInitialization);
 
     // Initialize CookieConsentManager with privacy flags from launcherOptions
@@ -1646,15 +1704,21 @@ function processIdentityCallback(
 }
 
 function queueIfNotInitialized(func, self) {
-    // Core SDK methods must wait for Store initialization
-    if (!self._Store?.isInitialized) {
-        self._preInit.readyQueue.push(function() {
-            if (self._Store?.isInitialized) {
-                func();
-            }
-        });
-        return true;
+    // When noFunctional is true with no explicit identifier, the SDK will never
+    // receive an MPID. Let these calls through so events can still reach forwarders immediately.
+    // sendEventToServer handles queuing for the MP server upload path separately.
+    const noFunctionalWithoutId =
+        self._CookieConsentManager?.getNoFunctional() &&
+        !hasExplicitIdentifier(self._Store);
+
+    if (self._Store?.isInitialized || noFunctionalWithoutId) {
+        return false;
     }
-    return false;
+    self._preInit.readyQueue.push(function() {
+        if (self._Store?.isInitialized) {
+            func();
+        }
+    });
+    return true;
 }
 

package/src/persistence.js

@@ -230,6 +230,11 @@ export default function _Persistence(mpInstance) {
             return;
         }
 
+        // Block mprtcl-v4 localStorage when noFunctional is true
+        if (mpInstance._CookieConsentManager?.getNoFunctional()) {
+            return;
+        }
+
         var key = mpInstance._Store.storageName,
             localStorageData = self.getLocalStorage() || {},
             currentUser = mpInstance.Identity.getCurrentUser(),
@@ -398,6 +403,11 @@ export default function _Persistence(mpInstance) {
     // https://go.mparticle.com/work/SQDSDKS-5022
     // https://go.mparticle.com/work/SQDSDKS-6021
     this.setCookie = function() {
+        // Block mprtcl-v4 cookies when noFunctional is true
+        if (mpInstance._CookieConsentManager?.getNoFunctional()) {
+            return;
+        }
+
         var mpid,
             currentUser = mpInstance.Identity.getCurrentUser();
         if (currentUser) {
@@ -803,6 +813,11 @@ export default function _Persistence(mpInstance) {
 
     // https://go.mparticle.com/work/SQDSDKS-6021
     this.savePersistence = function(persistence) {
+        // Block mprtcl-v4 persistence when noFunctional is true
+        if (mpInstance._CookieConsentManager?.getNoFunctional()) {
+            return;
+        }
+
         var encodedPersistence = self.encodePersistence(
                 JSON.stringify(persistence)
             ),

package/src/roktManager.ts

@@ -59,6 +59,12 @@ export interface RoktKitFilterSettings {
     filteredUser?: IMParticleUser | null;
 }
 
+export interface IRoktKitSettings {
+    accountId?: string;
+    placementAttributesMapping?: string;
+    hashedEmailUserIdentityType?: string;
+}
+
 export interface IRoktKit {
     filters: RoktKitFilterSettings;
     filteredUser: IMParticleUser | null;
@@ -69,6 +75,8 @@ export interface IRoktKit {
     setExtensionData<T>(extensionData: IRoktPartnerExtensionData<T>): void;
     use: <T>(name: string) => Promise<T>;
     launcherOptions?: Dictionary<any>;
+    settings?: IRoktKitSettings;
+    integrationName?: string;
 }
 
 export interface IRoktOptions {
@@ -181,6 +189,15 @@ export default class RoktManager {
 
     public attachKit(kit: IRoktKit): void {
         this.kit = kit;
+
+        if (kit.settings?.accountId) {
+            this.store.setRoktAccountId(kit.settings.accountId);
+        }
+
+        if (kit.integrationName) {
+            this.store?.setIntegrationName(kit.integrationName);
+        }
+
         this.processMessageQueue();
 
         try {
@@ -588,4 +605,4 @@ export default class RoktManager {
         
         return false; // Values are the same
     }
-}
+}

package/src/sdkRuntimeModels.ts

@@ -7,18 +7,24 @@ import {
     SDKEventAttrs,
     Callback,
 } from '@mparticle/web-sdk';
-import { IntegrationAttribute, IntegrationAttributes, IStore, WrapperSDKTypes } from './store';
+import {
+    IntegrationAttribute,
+    IntegrationAttributes,
+    IStore,
+    WrapperSDKTypes,
+} from './store';
 import Validators from './validators';
 import { Dictionary, valueof } from './utils';
 import { IKitConfigs } from './configAPIClient';
 import { SDKConsentApi, SDKConsentState } from './consent';
 import MPSideloadedKit from './sideloadedKit';
 import { ISessionManager } from './sessionManager';
-import { ConfiguredKit, MPForwarder, UnregisteredKit } from './forwarders.interfaces';
 import {
-    SDKIdentityApi,
-    IAliasCallback,
-} from './identity.interfaces';
+    ConfiguredKit,
+    MPForwarder,
+    UnregisteredKit,
+} from './forwarders.interfaces';
+import { SDKIdentityApi, IAliasCallback } from './identity.interfaces';
 import {
     ISDKUserAttributeChangeData,
     ISDKUserIdentityChanges,
@@ -36,11 +42,16 @@ import {
 } from './types';
 import { IPixelConfiguration } from './cookieSyncManager';
 import _BatchValidator from './mockBatchCreator';
-import {  SDKECommerceAPI } from './ecommerce.interfaces';
-import { IErrorLogMessage, IMParticleWebSDKInstance, IntegrationDelays } from './mp-instance';
+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';
+import { ErrorCodes } from './logging/types';
 
 // TODO: Resolve this with version in @mparticle/web-sdk
 export type SDKEventCustomFlags = Dictionary<any>;
@@ -83,6 +94,7 @@ export interface SDKEvent {
     ExpandedEventCount: number;
     ActiveTimeOnSite: number;
     IsBackgroundAST?: boolean;
+    AlreadySentToForwarders?: boolean;
 }
 
 export interface SDKGeoLocation {
@@ -178,7 +190,7 @@ export interface MParticleWebSDK {
     _resetForTests(
         MPConfig?: SDKInitConfig,
         keepPersistence?: boolean,
-        instance?: IMParticleWebSDKInstance,
+        instance?: IMParticleWebSDKInstance
     ): void;
     configurePixel(config: IPixelConfiguration): void;
     endSession(): void;
@@ -207,9 +219,24 @@ export interface MParticleWebSDK {
     ): void;
     logBaseEvent(event: BaseEvent, eventOptions?: SDKEventOptions): void;
     logError(error: IErrorLogMessage, attrs?: SDKEventAttrs): void;
-    logLink(selector: string, eventName: string, eventType: valueof<typeof EventType>, eventInfo: SDKEventAttrs): void;
-    logForm(selector: string, eventName: string, eventType: valueof<typeof EventType>, eventInfo: SDKEventAttrs): void;
-    logPageView(eventName?: string, attrs?: SDKEventAttrs, customFlags?: SDKEventCustomFlags, eventOptions?: SDKEventOptions): void;
+    logLink(
+        selector: string,
+        eventName: string,
+        eventType: valueof<typeof EventType>,
+        eventInfo: SDKEventAttrs
+    ): void;
+    logForm(
+        selector: string,
+        eventName: string,
+        eventType: valueof<typeof EventType>,
+        eventInfo: SDKEventAttrs
+    ): void;
+    logPageView(
+        eventName?: string,
+        attrs?: SDKEventAttrs,
+        customFlags?: SDKEventCustomFlags,
+        eventOptions?: SDKEventOptions
+    ): void;
     setOptOut(isOptingOut: boolean): void;
     eCommerce: SDKECommerceAPI;
     isInitialized(): boolean;
@@ -227,7 +254,10 @@ export interface MParticleWebSDK {
 
     stopTrackingLocation(): void;
     generateHash(value: string): string;
-    setIntegrationAttribute(integrationModuleId: number, attrs: IntegrationAttribute): void;
+    setIntegrationAttribute(
+        integrationModuleId: number,
+        attrs: IntegrationAttribute
+    ): void;
     getIntegrationAttributes(integrationModuleId: number): IntegrationAttribute;
     captureTiming(metricName: string): void;
 }
@@ -248,14 +278,13 @@ export interface IMParticleInstanceManager extends MParticleWebSDK {
     MPSideloadedKit: typeof MPSideloadedKit;
     Rokt: RoktManager;
     // https://go.mparticle.com/work/SQDSDKS-7060
-    sessionManager: Pick<ISessionManager, 'getSession'>; 
+    sessionManager: Pick<ISessionManager, 'getSession'>;
     Store: IStore;
 
     // Public Methods
     getInstance(instanceName?: string): IMParticleWebSDKInstance;
 }
 
-
 // Used in cases where server requires booleans as strings
 export type BooleanStringLowerCase = 'false' | 'true';
 export type BooleanStringTitleCase = 'False' | 'True';
@@ -311,6 +340,7 @@ export interface SDKInitConfig
     identityCallback?: IdentityCallback;
 
     launcherOptions?: IRoktLauncherOptions;
+    isLoggingEnabled?: boolean;
 
     rq?: Function[] | any[];
     logger?: IConsoleLogger;
@@ -361,9 +391,9 @@ export interface SDKHelpersApi {
 }
 
 export interface SDKLoggerApi {
-    error(arg0: string): void;
-    verbose(arg0: string): void;
-    warning(arg0: string): void;
+    error(msg: string, code?: ErrorCodes): void;
+    verbose(msg: string): void;
+    warning(msg: string): void;
     setLogLevel(logLevel: LogLevelType): void;
 }
 

package/src/sessionManager.ts

@@ -5,7 +5,7 @@ import Types from './types';
 import { generateDeprecationMessage } from './utils';
 import { IMParticleUser } from './identity-user-interfaces';
 import { IMParticleWebSDKInstance } from './mp-instance';
-import { hasIdentityRequestChanged } from './identity-utils';
+import { hasIdentityRequestChanged, hasExplicitIdentifier } from './identity-utils';
 
 const { Messages } = Constants;
 
@@ -45,7 +45,12 @@ export default function SessionManager(
                 const currentUser = mpInstance.Identity.getCurrentUser();
                 const sdkIdentityRequest = SDKConfig.identifyRequest;
 
+                const shouldSuppressIdentify = 
+                    mpInstance._CookieConsentManager?.getNoFunctional() &&
+                    !hasExplicitIdentifier(mpInstance._Store);
+
                 if (
+                    !shouldSuppressIdentify &&
                     hasIdentityRequestChanged(currentUser, sdkIdentityRequest)
                 ) {
                     mpInstance.Identity.identify(
@@ -102,7 +107,11 @@ export default function SessionManager(
 
             self.setSessionTimer();
 
-            if (!mpInstance._Store.identifyCalled) {
+            const shouldSuppressIdentify = 
+                mpInstance._CookieConsentManager?.getNoFunctional() &&
+                !hasExplicitIdentifier(mpInstance._Store);
+
+            if (!mpInstance._Store.identifyCalled && !shouldSuppressIdentify) {
                 mpInstance.Identity.identify(
                     mpInstance._Store.SDKConfig.identifyRequest,
                     mpInstance._Store.SDKConfig.identityCallback

package/src/store.ts

@@ -96,6 +96,9 @@ export interface SDKConfig {
     webviewBridgeName?: string;
     workspaceToken?: string;
     requiredWebviewBridgeName?: string;
+    loggingUrl?: string;
+    errorUrl?: string;
+    isLoggingEnabled?: boolean;
 }
 
 function createSDKConfig(config: SDKInitConfig): SDKConfig {
@@ -120,6 +123,9 @@ function createSDKConfig(config: SDKInitConfig): SDKConfig {
         sdkConfig[prop] = Constants.DefaultBaseUrls[prop];
     }
 
+    // Always initialize flags to at least an empty object to prevent undefined access
+    sdkConfig.flags = sdkConfig.flags || {};
+
     return sdkConfig;
 }
 
@@ -202,6 +208,8 @@ export interface IStore {
     integrationDelayTimeoutStart: number; // UNIX Timestamp
     webviewBridgeEnabled?: boolean;
     wrapperSDKInfo: WrapperSDKInfo;
+    roktAccountId: string | null;
+    integrationName: string | null;
 
     persistenceData?: IPersistenceMinified;
 
@@ -223,6 +231,10 @@ export interface IStore {
     setUserAttributes?(mpid: MPID, attributes: UserAttributes): void;
     getUserIdentities?(mpid: MPID): UserIdentities;
     setUserIdentities?(mpid: MPID, userIdentities: UserIdentities): void;
+    getRoktAccountId?(): string;
+    setRoktAccountId?(accountId: string): void;
+    getIntegrationName?(): string;
+    setIntegrationName?(integrationName: string): void;
 
     addMpidToSessionHistory?(mpid: MPID, previousMpid?: MPID): void;
     hasInvalidIdentifyRequest?: () => boolean;
@@ -289,6 +301,8 @@ export default function Store(
             version: null,
             isInfoSet: false,
         },
+        roktAccountId: null,
+        integrationName: null,
 
         // Placeholder for in-memory persistence model
         persistenceData: {
@@ -311,10 +325,6 @@ export default function Store(
             this.SDKConfig.flags = {};
         }
 
-        // We process the initial config that is passed via the SDK init
-        // and then we will reprocess the config within the processConfig
-        // function when the config is updated from the server
-        // https://go.mparticle.com/work/SQDSDKS-6317
         this.SDKConfig.flags = processFlags(config);
 
         if (config.deviceId) {
@@ -338,10 +348,6 @@ export default function Store(
             this.SDKConfig[baseUrlKeys] = baseUrls[baseUrlKeys];
         }
 
-        if (config.hasOwnProperty('logLevel')) {
-            this.SDKConfig.logLevel = config.logLevel;
-        }
-
         this.SDKConfig.useNativeSdk = !!config.useNativeSdk;
 
         this.SDKConfig.kits = config.kits || {};
@@ -667,6 +673,16 @@ export default function Store(
     this.setUserIdentities = (mpid: MPID, userIdentities: UserIdentities) => {
         this._setPersistence(mpid, 'ui', userIdentities);
     };
+    
+    this.getRoktAccountId = () => this.roktAccountId;
+    this.setRoktAccountId = (accountId: string) => {
+        this.roktAccountId = accountId;
+    };
+
+    this.getIntegrationName = () => this.integrationName;
+    this.setIntegrationName = (integrationName: string) => {
+        this.integrationName = integrationName;
+    };
 
     this.addMpidToSessionHistory = (mpid: MPID, previousMPID?: MPID): void => {
         const indexOfMPID = this.currentSessionMPIDs.indexOf(mpid);
@@ -699,7 +715,10 @@ export default function Store(
         // We should reprocess the flags and baseUrls in case they have changed when we request an updated config
         // such as if the SDK is being self-hosted and the flags are different on the server config
         // https://go.mparticle.com/work/SQDSDKS-6317
-        this.SDKConfig.flags = processFlags(config);
+        // Only update flags if the config actually has flags (don't overwrite with empty object)
+        if (config.flags) {
+            this.SDKConfig.flags = processFlags(config);
+        }
 
         const baseUrls: Dictionary<string> = processBaseUrls(
             config,
@@ -713,7 +732,8 @@ export default function Store(
 
         if (workspaceToken) {
             this.SDKConfig.workspaceToken = workspaceToken;
-            mpInstance._timeOnSiteTimer = new ForegroundTimer(workspaceToken);
+            const noFunctional = config?.launcherOptions?.noFunctional === true;
+            mpInstance._timeOnSiteTimer = new ForegroundTimer(workspaceToken, noFunctional);
         } else {
             mpInstance.Logger.warning(
                 'You should have a workspaceToken on your config object for security purposes.'
@@ -842,7 +862,7 @@ function processDirectBaseUrls(
     for (let baseUrlKey in defaultBaseUrls) {
         // Any custom endpoints passed to mpConfig will take priority over direct
         // mapping to the silo.  The most common use case is a customer provided CNAME.
-        if (baseUrlKey === 'configUrl') {
+        if (baseUrlKey === 'configUrl' || baseUrlKey === 'loggingUrl' || baseUrlKey === 'errorUrl') {
             directBaseUrls[baseUrlKey] =
                 config[baseUrlKey] || defaultBaseUrls[baseUrlKey];
             continue;

package/src/uploaders.ts

@@ -5,6 +5,7 @@ export interface IFetchPayload {
     headers: {
         Accept: string;
         'Content-Type'?: string;
+        'rokt-account-id'?: string;
     };
     body?: string;
 }

package/src/vault.ts

@@ -102,4 +102,25 @@ 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;
+        this.storageObject.removeItem(this._storageKey);
+    }
+
+    public store(_item: StorableItem): void {
+        this.contents = null;
+    }
+
+    public retrieve(): StorableItem | null {
+        return this.contents;
+    }
+
+    public purge(): void {
+        this.contents = null;
+    }
 }