@mparticle/web-sdk 2.18.2 → 2.19.0

package/package.json

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

package/src/{apiClient.js → apiClient.ts}

@@ -1,15 +1,51 @@
 import Constants from './constants';
 import Types from './types';
 import { BatchUploader } from './batchUploader';
+import {
+    MParticleUser,
+    MParticleWebSDK,
+    MPForwarder,
+    SDKEvent,
+} from './sdkRuntimeModels';
+import KitBlocker from './kitBlocking';
+import { Dictionary } from './utils';
+import { IUploadObject } from './serverModel';
 
-var Messages = Constants.Messages;
+const Messages = Constants.Messages;
 
-export default function APIClient(mpInstance, kitBlocker) {
+export type ForwardingStatsData = Dictionary<any>;
+
+export interface IAPIClient {
+    uploader: BatchUploader | null;
+    queueEventForBatchUpload: (event: SDKEvent) => void;
+    shouldEnableBatching: () => boolean;
+    processQueuedEvents: () => void;
+    appendUserInfoToEvents: (user: MParticleUser, events: SDKEvent[]) => void;
+    sendEventToServer: (event: SDKEvent, _options?: Dictionary<any>) => void;
+    sendSingleEventToServer: (event: SDKEvent) => void;
+    sendBatchForwardingStatsToServer: (
+        forwardingStatsData: ForwardingStatsData,
+        xhr: XMLHttpRequest
+    ) => void;
+    sendSingleForwardingStatsToServer: (
+        forwardingStatsData: ForwardingStatsData
+    ) => void;
+    prepareForwardingStats: (
+        forwarder: MPForwarder,
+        event: IUploadObject
+    ) => void;
+}
+
+export default function APIClient(
+    this: IAPIClient,
+    mpInstance: MParticleWebSDK,
+    kitBlocker: KitBlocker
+) {
     this.uploader = null;
-    var self = this;
-    this.queueEventForBatchUpload = function(event) {
+    const self = this;
+    this.queueEventForBatchUpload = function(event: SDKEvent) {
         if (!this.uploader) {
-            var millis = mpInstance._Helpers.getFeatureFlag(
+            const millis = mpInstance._Helpers.getFeatureFlag(
                 Constants.FeatureFlags.EventBatchingIntervalMillis
             );
             this.uploader = new BatchUploader(mpInstance, millis);
@@ -22,7 +58,7 @@ export default function APIClient(mpInstance, kitBlocker) {
     this.shouldEnableBatching = function() {
         // Returns a string of a number that must be parsed
         // Invalid strings will be parsed to NaN which is falsey
-        var eventsV3Percentage = parseInt(
+        const eventsV3Percentage = parseInt(
             mpInstance._Helpers.getFeatureFlag(Constants.FeatureFlags.EventsV3),
             10
         );
@@ -31,20 +67,20 @@ export default function APIClient(mpInstance, kitBlocker) {
             return false;
         }
 
-        var rampNumber = mpInstance._Helpers.getRampNumber(
+        const rampNumber = mpInstance._Helpers.getRampNumber(
             mpInstance._Store.deviceId
         );
         return eventsV3Percentage >= rampNumber;
     };
 
     this.processQueuedEvents = function() {
-        var mpid,
+        let mpid,
             currentUser = mpInstance.Identity.getCurrentUser();
         if (currentUser) {
             mpid = currentUser.getMPID();
         }
         if (mpInstance._Store.eventQueue.length && mpid) {
-            var localQueueCopy = mpInstance._Store.eventQueue;
+            const localQueueCopy = mpInstance._Store.eventQueue;
             mpInstance._Store.eventQueue = [];
             this.appendUserInfoToEvents(currentUser, localQueueCopy);
             localQueueCopy.forEach(function(event) {
@@ -62,10 +98,10 @@ export default function APIClient(mpInstance, kitBlocker) {
     };
 
     this.sendEventToServer = function(event, _options) {
-        var defaultOptions = {
+        const defaultOptions = {
             shouldUploadEvent: true,
         };
-        var options = mpInstance._Helpers.extend(defaultOptions, _options);
+        const options = mpInstance._Helpers.extend(defaultOptions, _options);
 
         if (mpInstance._Store.webviewBridgeEnabled) {
             mpInstance._NativeSdkHelpers.sendToNative(
@@ -75,7 +111,7 @@ export default function APIClient(mpInstance, kitBlocker) {
             return;
         }
 
-        var mpid,
+        let mpid,
             currentUser = mpInstance.Identity.getCurrentUser();
         if (currentUser) {
             mpid = currentUser.getMPID();
@@ -126,7 +162,7 @@ export default function APIClient(mpInstance, kitBlocker) {
         if (event.EventDataType === Types.MessageType.Media) {
             return;
         }
-        var xhr,
+        let xhr,
             xhrCallback = function() {
                 if (xhr.readyState === 4) {
                     mpInstance.Logger.verbose(
@@ -153,7 +189,9 @@ export default function APIClient(mpInstance, kitBlocker) {
                 );
                 xhr.send(
                     JSON.stringify(
-                        mpInstance._ServerModel.convertEventToDTO(event)
+                        mpInstance._ServerModel.convertEventToDTO(
+                            event as IUploadObject
+                        )
                     )
                 );
             } catch (e) {
@@ -165,7 +203,8 @@ export default function APIClient(mpInstance, kitBlocker) {
     };
 
     this.sendBatchForwardingStatsToServer = function(forwardingStatsData, xhr) {
-        var url, data;
+        let url;
+        let data;
         try {
             url = mpInstance._Helpers.createServiceUrl(
                 mpInstance._Store.SDKConfig.v2SecureServiceUrl,
@@ -188,9 +227,10 @@ export default function APIClient(mpInstance, kitBlocker) {
     };
 
     this.sendSingleForwardingStatsToServer = function(forwardingStatsData) {
-        var url, data;
+        let url;
+        let data;
         try {
-            var xhrCallback = function() {
+            const xhrCallback = function() {
                 if (xhr.readyState === 4) {
                     if (xhr.status === 202) {
                         mpInstance.Logger.verbose(
@@ -201,7 +241,7 @@ export default function APIClient(mpInstance, kitBlocker) {
                     }
                 }
             };
-            var xhr = mpInstance._Helpers.createXHR(xhrCallback);
+            const xhr = mpInstance._Helpers.createXHR(xhrCallback);
             url = mpInstance._Helpers.createServiceUrl(
                 mpInstance._Store.SDKConfig.v1SecureServiceUrl,
                 mpInstance._Store.devToken
@@ -220,8 +260,8 @@ export default function APIClient(mpInstance, kitBlocker) {
     };
 
     this.prepareForwardingStats = function(forwarder, event) {
-        var forwardingStatsData,
-            queue = mpInstance._Forwarders.getForwarderStatsQueue();
+        let forwardingStatsData;
+        const queue = mpInstance._Forwarders.getForwarderStatsQueue();
 
         if (forwarder && forwarder.isVisible) {
             forwardingStatsData = {

package/src/batchUploader.ts

@@ -9,17 +9,35 @@ import { convertEvents } from './sdkToEventsApiConverter';
 import Types from './types';
 import { isEmpty } from './utils';
 
+/**
+ * BatchUploader contains all the logic to upload batches to mParticle.
+ * It queues events as they come in and at set intervals turns them into batches.
+ * It then attempts to upload them to mParticle.
+ *
+ * These uploads happen on an interval basis using window.fetch or XHR
+ * requests, depending on what is available in the browser.
+ *
+ * Uploads can also be triggered on browser visibility/focus changes via an
+ * event listener, which then uploads to mPartice via the browser's Beacon API.
+ */
+
 export class BatchUploader {
-    //we upload JSON, but this content type is required to avoid a CORS preflight request
+    // We upload JSON, but this content type is required to avoid a CORS preflight request
     static readonly CONTENT_TYPE: string = 'text/plain;charset=UTF-8';
     static readonly MINIMUM_INTERVAL_MILLIS: number = 500;
     uploadIntervalMillis: number;
-    pendingEvents: SDKEvent[];
-    pendingUploads: Batch[];
+    eventsQueuedForProcessing: SDKEvent[];
+    batchesQueuedForProcessing: Batch[];
     mpInstance: MParticleWebSDK;
     uploadUrl: string;
     batchingEnabled: boolean;
+    private uploader: AsyncUploader;
 
+    /**
+     * Creates an instance of a BatchUploader
+     * @param {MParticleWebSDK} mpInstance - the mParticle SDK instance
+     * @param {number} uploadInterval - the desired upload interval in milliseconds
+     */
     constructor(mpInstance: MParticleWebSDK, uploadInterval: number) {
         this.mpInstance = mpInstance;
         this.uploadIntervalMillis = uploadInterval;
@@ -28,8 +46,8 @@ export class BatchUploader {
         if (this.uploadIntervalMillis < BatchUploader.MINIMUM_INTERVAL_MILLIS) {
             this.uploadIntervalMillis = BatchUploader.MINIMUM_INTERVAL_MILLIS;
         }
-        this.pendingEvents = [];
-        this.pendingUploads = [];
+        this.eventsQueuedForProcessing = [];
+        this.batchesQueuedForProcessing = [];
 
         const { SDKConfig, devToken } = this.mpInstance._Store;
         const baseUrl = this.mpInstance._Helpers.createServiceUrl(
@@ -38,15 +56,20 @@ export class BatchUploader {
         );
         this.uploadUrl = `${baseUrl}/events`;
 
-        setTimeout(() => {
-            this.prepareAndUpload(true, false);
-        }, this.uploadIntervalMillis);
+        this.uploader = window.fetch
+            ? new FetchUploader(this.uploadUrl)
+            : new XHRUploader(this.uploadUrl);
+
+        this.triggerUploadInterval(true, false);
         this.addEventListeners();
     }
 
+    // Adds listeners to be used trigger Navigator.sendBeacon if the browser
+    // loses focus for any reason, such as closing browser tab or minimizing window
     private addEventListeners() {
         const _this = this;
 
+        // visibility change is a document property, not window
         document.addEventListener('visibilitychange', () => {
             _this.prepareAndUpload(false, _this.isBeaconAvailable());
         });
@@ -65,16 +88,32 @@ export class BatchUploader {
         return false;
     }
 
+    // Triggers a setTimeout for prepareAndUpload
+    private triggerUploadInterval(
+        triggerFuture: boolean = false,
+        useBeacon: boolean = false
+    ): void {
+        setTimeout(() => {
+            this.prepareAndUpload(triggerFuture, useBeacon);
+        }, this.uploadIntervalMillis);
+    }
+
+    /**
+     * This method will queue a single Event which will eventually be processed into a Batch
+     * @param event event that should be queued
+     */
     queueEvent(event: SDKEvent): void {
         if (!isEmpty(event)) {
-            this.pendingEvents.push(event);
+            this.eventsQueuedForProcessing.push(event);
             this.mpInstance.Logger.verbose(
                 `Queuing event: ${JSON.stringify(event)}`
             );
             this.mpInstance.Logger.verbose(
-                `Queued event count: ${this.pendingEvents.length}`
+                `Queued event count: ${this.eventsQueuedForProcessing.length}`
             );
 
+            // TODO: Remove this check once the v2 code path is removed
+            //       https://go.mparticle.com/work/SQDSDKS-3720
             if (
                 !this.batchingEnabled ||
                 Types.TriggerUploadType[event.EventDataType]
@@ -93,7 +132,7 @@ export class BatchUploader {
      * @param sdkEvents current pending events
      * @param defaultUser the user to reference for events that are missing data
      */
-    private static createNewUploads(
+    private static createNewBatches(
         sdkEvents: SDKEvent[],
         defaultUser: MParticleUser,
         mpInstance: MParticleWebSDK
@@ -141,9 +180,8 @@ export class BatchUploader {
                     mpInstance._Store.SDKConfig.onCreateBatch;
 
                 if (onCreateBatchCallback) {
-                    uploadBatchObject = onCreateBatchCallback(
-                        uploadBatchObject
-                    );
+                    uploadBatchObject =
+                        onCreateBatchCallback(uploadBatchObject);
                     if (uploadBatchObject) {
                         uploadBatchObject.modified = true;
                     } else {
@@ -169,112 +207,122 @@ export class BatchUploader {
      * @param triggerFuture whether to trigger the loop again - for manual/forced uploads this should be false
      * @param useBeacon whether to use the beacon API - used when the page is being unloaded
      */
-    private async prepareAndUpload(triggerFuture: boolean, useBeacon: boolean) {
+    private async prepareAndUpload(
+        triggerFuture: boolean,
+        useBeacon: boolean
+    ): Promise<void> {
         const currentUser = this.mpInstance.Identity.getCurrentUser();
 
-        const currentEvents = this.pendingEvents;
-        this.pendingEvents = [];
-        const newUploads = BatchUploader.createNewUploads(
+        const currentEvents = this.eventsQueuedForProcessing;
+        this.eventsQueuedForProcessing = [];
+
+        const newBatches = BatchUploader.createNewBatches(
             currentEvents,
             currentUser,
             this.mpInstance
         );
-        if (newUploads && newUploads.length) {
-            this.pendingUploads.push(...newUploads);
+        if (!isEmpty(newBatches)) {
+            this.batchesQueuedForProcessing.push(...newBatches);
         }
 
-        const currentUploads = this.pendingUploads;
-        this.pendingUploads = [];
-        const remainingUploads: Batch[] = await this.upload(
-            this.mpInstance.Logger,
-            currentUploads,
-            useBeacon
-        );
-        if (remainingUploads && remainingUploads.length) {
-            this.pendingUploads.unshift(...remainingUploads);
+        const batchesToUpload = this.batchesQueuedForProcessing;
+        const batchesThatDidNotUpload: Batch[] = [];
+        this.batchesQueuedForProcessing = [];
+
+        // Create an array of promises as we try to upload each batch indvidually
+        const promises: Promise<Batch>[] = batchesToUpload.map((upload) => {
+            return this.upload(this.mpInstance.Logger, upload, useBeacon);
+        });
+
+        // Iterate through fulfilled promises and store any remaining batches
+        // for future re-transmission attempts
+        if (!isEmpty(promises)) {
+            Promise.all(promises)
+                .then((batchResponses) => {
+                    batchResponses.forEach((batch) =>
+                        !isEmpty(batch)
+                            ? batchesThatDidNotUpload.push(batch)
+                            : null
+                    );
+                })
+                .catch((error) => {
+                    this.mpInstance.Logger.error(
+                        `Error processing batches during upload attempt: ${error}`
+                    );
+                })
+                .finally(() => {
+                    // Any batches that did not upload should be put back into the queue for processing
+                    if (!isEmpty(batchesThatDidNotUpload)) {
+                        this.batchesQueuedForProcessing.unshift(
+                            ...batchesThatDidNotUpload
+                        );
+                    }
+                });
         }
 
         if (triggerFuture) {
-            setTimeout(() => {
-                this.prepareAndUpload(true, false);
-            }, this.uploadIntervalMillis);
+            this.triggerUploadInterval(triggerFuture, false);
         }
     }
 
     private async upload(
         logger: SDKLoggerApi,
-        _uploads: Batch[],
+        batch: Batch,
         useBeacon: boolean
-    ): Promise<Batch[]> {
-        let uploader;
-
-        // Filter out any batches that don't have events
-        const uploads = _uploads.filter(upload => !isEmpty(upload.events));
-
-        if (isEmpty(uploads)) {
+    ): Promise<Batch | null> {
+        if (isEmpty(batch) || isEmpty(batch.events)) {
             return null;
         }
 
-        logger.verbose(`Uploading batches: ${JSON.stringify(uploads)}`);
-        logger.verbose(`Batch count: ${uploads.length}`);
-
-        for (let i = 0; i < uploads.length; i++) {
-            const fetchPayload: fetchPayload = {
-                method: 'POST',
-                headers: {
-                    Accept: BatchUploader.CONTENT_TYPE,
-                    'Content-Type': 'text/plain;charset=UTF-8',
-                },
-                body: JSON.stringify(uploads[i]),
-            };
+        logger.verbose(`Uploading batches: ${JSON.stringify(batch)}`);
+
+        const fetchPayload: fetchPayload = {
+            method: 'POST',
+            headers: {
+                Accept: BatchUploader.CONTENT_TYPE,
+                'Content-Type': 'text/plain;charset=UTF-8',
+            },
+            body: JSON.stringify(batch),
+        };
+
+        // TODO: Make beacon its own function
+        // beacon is only used on onbeforeunload onpagehide events
+        if (useBeacon && this.isBeaconAvailable()) {
+            let blob = new Blob([fetchPayload.body], {
+                type: 'text/plain;charset=UTF-8',
+            });
+            navigator.sendBeacon(this.uploadUrl, blob);
+        } else {
+            try {
+                const response = await this.uploader.upload(fetchPayload);
+
+                // TODO: Should we make this a switch statement instead?
+                if (response.status >= 200 && response.status < 300) {
+                    logger.verbose(
+                        `Upload success for request ID: ${batch.source_request_id}`
+                    );
 
-            // beacon is only used on onbeforeunload onpagehide events
-            if (useBeacon && this.isBeaconAvailable()) {
-                let blob = new Blob([fetchPayload.body], {
-                    type: 'text/plain;charset=UTF-8',
-                });
-                navigator.sendBeacon(this.uploadUrl, blob);
-            } else {
-                if (!uploader) {
-                    if (window.fetch) {
-                        uploader = new FetchUploader(this.uploadUrl, logger);
-                    } else {
-                        uploader = new XHRUploader(this.uploadUrl, logger);
-                    }
-                }
-                try {
-                    const response = await uploader.upload(
-                        fetchPayload,
-                        uploads,
-                        i
+                    return null;
+                } else if (response.status >= 500 || response.status === 429) {
+                    logger.error(
+                        `HTTP error status ${response.status} received`
                     );
 
-                    if (response.status >= 200 && response.status < 300) {
-                        logger.verbose(
-                            `Upload success for request ID: ${uploads[i].source_request_id}`
-                        );
-                    } else if (
-                        response.status >= 500 ||
-                        response.status === 429
-                    ) {
-                        logger.error(
-                            `HTTP error status ${response.status} received`
-                        );
-                        //server error, add back current events and try again later
-                        return uploads.slice(i, uploads.length);
-                    } else if (response.status >= 401) {
-                        logger.error(
-                            `HTTP error status ${response.status} while uploading - please verify your API key.`
-                        );
-                        //if we're getting a 401, assume we'll keep getting a 401 and clear the uploads.
-                        return null;
-                    }
-                } catch (e) {
+                    // Server error, return current batch and try again later
+                    return batch;
+                } else if (response.status >= 401) {
                     logger.error(
-                        `Error sending event to mParticle servers. ${e}`
+                        `HTTP error status ${response.status} while uploading - please verify your API key.`
                     );
-                    return uploads.slice(i, uploads.length);
+                    // if we're getting a 401, assume we'll keep getting a 401
+                    // so return the upload so it can be stored for later use
+                    return batch;
                 }
+            } catch (error) {
+                logger.error(
+                    `Error sending event to mParticle servers. ${error}`
+                );
+                return batch;
             }
         }
         return null;
@@ -283,34 +331,24 @@ export class BatchUploader {
 
 abstract class AsyncUploader {
     url: string;
-    logger: SDKLoggerApi;
+    public abstract upload(fetchPayload: fetchPayload): Promise<XHRResponse>;
 
-    constructor(url: string, logger: SDKLoggerApi) {
+    constructor(url: string) {
         this.url = url;
-        this.logger = logger;
     }
 }
 
 class FetchUploader extends AsyncUploader {
-    private async upload(
-        fetchPayload: fetchPayload,
-        uploads: Batch[],
-        i: number
-    ) {
+    public async upload(fetchPayload: fetchPayload): Promise<XHRResponse> {
         const response: XHRResponse = await fetch(this.url, fetchPayload);
         return response;
     }
 }
 
 class XHRUploader extends AsyncUploader {
-    private async upload(
-        fetchPayload: fetchPayload,
-        uploads: Batch[],
-        i: number
-    ) {
+    public async upload(fetchPayload: fetchPayload): Promise<XHRResponse> {
         const response: XHRResponse = await this.makeRequest(
             this.url,
-            this.logger,
             fetchPayload.body
         );
         return response;
@@ -318,7 +356,6 @@ class XHRUploader extends AsyncUploader {
 
     private async makeRequest(
         url: string,
-        logger: SDKLoggerApi,
         data: string
     ): Promise<XMLHttpRequest> {
         const xhr: XMLHttpRequest = new XMLHttpRequest();

package/src/consent.interfaces.ts

@@ -0,0 +1,89 @@
+// TODO: Migrate this to Consent.ts when that is created
+import { ConsentState, PrivacyConsentState } from '@mparticle/web-sdk';
+
+export interface IGDPRConsentObject {
+    purpose: string;
+}
+
+export interface ICCPAConsentObject {
+    purpose: string;
+}
+
+export interface IConsentJSONObject {
+    gdpr?: Partial<IGDPRConsentObject>;
+    ccpa?: Partial<ICCPAConsentObject>;
+}
+
+interface ICreatePrivacyConsentFunction {
+    (
+        consented: boolean,
+        timestamp?: number,
+        consentDocument?: string,
+        location?: string,
+        hardwareId?: string
+    ): PrivacyConsentState | null;
+}
+
+// TODO: Refactor this with Consent Namespace in @types/mparticle-web-sdk
+//       https://go.mparticle.com/work/SQDSDKS-5009
+export interface SDKConsentApi {
+    createGDPRConsent: ICreatePrivacyConsentFunction;
+    createCCPAConsent: ICreatePrivacyConsentFunction;
+    createConsentState: (consentState?: ConsentState) => ConsentState;
+    ConsentSerialization: IConsentSerialization;
+    createPrivacyConsent: ICreatePrivacyConsentFunction;
+}
+
+export interface IConsentSerialization {
+    toMinifiedJsonObject: (state: ConsentState) => IConsentJSONObject;
+    fromMinifiedJsonObject: (json: IConsentJSONObject) => ConsentState;
+}
+
+// TODO: Resolve discrepency between ConsentState and SDKConsentState
+//       https://go.mparticle.com/work/SQDSDKS-5009
+export interface SDKConsentState
+    extends Omit<ConsentState, 'getGDPRConsentState' | 'getCCPAConsentState'> {
+    getGDPRConsentState(): SDKGDPRConsentState;
+    getCCPAConsentState(): SDKCCPAConsentState;
+}
+
+export interface SDKGDPRConsentState {
+    [key: string]: SDKConsentStateData;
+}
+
+// TODO: Resolve discrepency between ConsentState and SDKConsentState
+//       https://go.mparticle.com/work/SQDSDKS-5009
+//       Specifically PrivacyConsentState, GDPRConsentState and CCPAConsentState
+//       Treat all attributes as required, but we had to override this
+//       to be optional for a bugfix:
+//       https://github.com/mParticle/mparticle-web-sdk/commit/3b11ead79f25b417737442a4fabd6435750f46b8
+export interface SDKConsentStateData {
+    Consented: boolean;
+    Timestamp?: number;
+    ConsentDocument?: string;
+    Location?: string;
+    HardwareId?: string;
+}
+
+export interface SDKCCPAConsentState extends SDKConsentStateData {}
+
+export interface IPrivacyV2DTO {
+    c: boolean; // Consented
+    ts: number; // Timestamp
+    d: string; // Document
+    l: string; // Location
+    h: string; // HardwareID
+}
+
+export interface IGDPRConsentStateDTO {
+    [key: string]: IPrivacyV2DTO;
+}
+
+export interface ICCPAConsentStateDTO {
+    data_sale_opt_out: IPrivacyV2DTO;
+}
+
+export interface IConsentStateDTO {
+    gdpr?: IGDPRConsentStateDTO;
+    ccpa?: ICCPAConsentStateDTO;
+}

package/src/mockBatchCreator.ts

@@ -7,15 +7,15 @@ import * as EventsApi from '@mparticle/event-models';
 
 const mockFunction = function () {
     return null;
-}
+};
 export default class _BatchValidator {
     private getMPInstance() {
         return {
             // Certain Helper, Store, and Identity properties need to be mocked to be used in the `returnBatch` method
             _Helpers: {
-                sanitizeAttributes: window.mParticle.getInstance()._Helpers
-                    .sanitizeAttributes,
-                generateUniqueId: function() {
+                sanitizeAttributes:
+                    window.mParticle.getInstance()._Helpers.sanitizeAttributes,
+                generateUniqueId: function () {
                     return 'mockId';
                 },
                 extend: window.mParticle.getInstance()._Helpers.extend,
@@ -28,6 +28,11 @@ export default class _BatchValidator {
             _resetForTests: mockFunction,
             _APIClient: null,
             _Consent: null,
+            _Forwarders: null,
+            _NativeSdkHelpers: null,
+            _Persistence: null,
+            _preInit: null,
+            Consent: null,
             _ServerModel: null,
             _SessionManager: null,
             _Store: {