refactor: migrate helpers, polyfill, forwardingStatsUploader, filteredMparticleUser to TS

Author: jaissica12

src/consent.ts

@@ -89,7 +89,7 @@ export interface IConsentStateV2DTO {
 }
 
 export interface IConsentRulesValues {
-    consentPurpose: string;
+    consentPurpose: string | number;
     hasConsented: boolean;
 }
 export interface IConsentRules {

src/filteredMparticleUser.js

@@ -0,0 +1,114 @@
+import Types from './types';
+import { IMParticleWebSDKInstance } from './mp-instance';
+import { MPID } from '@mparticle/web-sdk';
+import { Dictionary } from './utils';
+import KitBlocker from './kitBlocking';
+import { MPForwarder } from './forwarders.interfaces';
+
+interface IFilteredMparticleUser {
+    getUserIdentities(): { userIdentities: Dictionary<string> };
+    getMPID(): MPID;
+    getUserAttributesLists(forwarder: MPForwarder): Dictionary<string[]>;
+    getAllUserAttributes(): Dictionary;
+}
+
+export default function filteredMparticleUser(
+    mpid: MPID,
+    forwarder: MPForwarder | { userAttributeFilters: number[] },
+    mpInstance: IMParticleWebSDKInstance,
+    kitBlocker?: KitBlocker
+): IFilteredMparticleUser {
+    return {
+        getUserIdentities: function(): { userIdentities: Dictionary<string> } {
+            let currentUserIdentities: Dictionary<string> = {};
+            const identities = mpInstance._Store.getUserIdentities(mpid);
+
+            for (const identityType in identities) {
+                if (identities.hasOwnProperty(identityType)) {
+                    const identityName = Types.IdentityType.getIdentityName(
+                        mpInstance._Helpers.parseNumber(identityType)
+                    );
+                    if (
+                        !kitBlocker ||
+                        (kitBlocker &&
+                            !kitBlocker.isIdentityBlocked(identityName))
+                    )
+                        //if identity type is not blocked
+                        currentUserIdentities[identityName] =
+                            identities[identityType];
+                }
+            }
+
+            currentUserIdentities = (mpInstance._Helpers.filterUserIdentitiesForForwarders as Function)(
+                currentUserIdentities,
+                (forwarder as MPForwarder).userIdentityFilters
+            );
+
+            return {
+                userIdentities: currentUserIdentities,
+            };
+        },
+        getMPID: function(): MPID {
+            return mpid;
+        },
+        getUserAttributesLists: function(forwarder: MPForwarder): Dictionary<string[]> {
+            let userAttributes: Dictionary;
+            let userAttributesLists: Dictionary<string[]> = {};
+
+            userAttributes = getAllUserAttributes();
+            for (const key in userAttributes) {
+                if (
+                    userAttributes.hasOwnProperty(key) &&
+                    Array.isArray(userAttributes[key])
+                ) {
+                    if (
+                        !kitBlocker ||
+                        (kitBlocker && !kitBlocker.isAttributeKeyBlocked(key))
+                    ) {
+                        userAttributesLists[key] = userAttributes[key].slice();
+                    }
+                }
+            }
+
+            userAttributesLists = (mpInstance._Helpers.filterUserAttributes as Function)(
+                userAttributesLists,
+                forwarder.userAttributeFilters
+            );
+
+            return userAttributesLists;
+        },
+        getAllUserAttributes: getAllUserAttributes,
+    };
+
+    function getAllUserAttributes(): Dictionary {
+        let userAttributesCopy: Dictionary = {};
+        const userAttributes = mpInstance._Store.getUserAttributes(mpid);
+
+        if (userAttributes) {
+            for (const prop in userAttributes) {
+                if (userAttributes.hasOwnProperty(prop)) {
+                    if (
+                        !kitBlocker ||
+                        (kitBlocker &&
+                            !kitBlocker.isAttributeKeyBlocked(prop))
+                    ) {
+                        if (Array.isArray(userAttributes[prop])) {
+                            userAttributesCopy[prop] = (userAttributes[
+                                prop
+                            ] as string[]).slice();
+                        } else {
+                            userAttributesCopy[prop] = userAttributes[prop];
+                        }
+                    }
+                }
+            }
+        }
+
+        userAttributesCopy = (mpInstance._Helpers.filterUserAttributes as Function)(
+            userAttributesCopy,
+            (forwarder as MPForwarder).userAttributeFilters
+        );
+
+        return userAttributesCopy;
+    }
+}

src/filteredMparticleUser.ts

@@ -1,26 +1,36 @@
-export default function forwardingStatsUploader(mpInstance) {
-    this.startForwardingStatsTimer = function() {
-        mParticle._forwardingStatsTimer = setInterval(function() {
+import { IMParticleWebSDKInstance } from './mp-instance';
+import { Dictionary } from './utils';
+
+export interface IForwardingStatsUploader {
+    startForwardingStatsTimer(): void;
+}
+
+export default function forwardingStatsUploader(
+    this: IForwardingStatsUploader,
+    mpInstance: IMParticleWebSDKInstance
+): void {
+    this.startForwardingStatsTimer = function(): void {
+        (window.mParticle as Dictionary)._forwardingStatsTimer = setInterval(function() {
             prepareAndSendForwardingStatsBatch();
-        }, mpInstance._Store.SDKConfig.forwarderStatsTimeout);
+        }, (mpInstance._Store.SDKConfig as Dictionary).forwarderStatsTimeout);
     };
 
-    function prepareAndSendForwardingStatsBatch() {
-        var forwarderQueue = mpInstance._Forwarders.getForwarderStatsQueue(),
-            uploadsTable =
-                mpInstance._Persistence.forwardingStatsBatches.uploadsTable,
-            now = Date.now();
+    function prepareAndSendForwardingStatsBatch(): void {
+        const forwarderQueue = mpInstance._Forwarders.getForwarderStatsQueue();
+        const uploadsTable =
+            mpInstance._Persistence.forwardingStatsBatches.uploadsTable;
+        const now = Date.now();
 
         if (forwarderQueue.length) {
             uploadsTable[now] = { uploading: false, data: forwarderQueue };
             mpInstance._Forwarders.setForwarderStatsQueue([]);
         }
 
-        for (var date in uploadsTable) {
-            (function(date) {
+        for (const date in uploadsTable) {
+            (function(date: string) {
                 if (uploadsTable.hasOwnProperty(date)) {
                     if (uploadsTable[date].uploading === false) {
-                        var xhrCallback = function() {
+                        const xhrCallback = function(): void {
                             if (xhr.readyState === 4) {
                                 if (xhr.status === 200 || xhr.status === 202) {
                                     mpInstance.Logger.verbose(
@@ -39,8 +49,8 @@ export default function forwardingStatsUploader(mpInstance) {
                             }
                         };
 
-                        var xhr = mpInstance._Helpers.createXHR(xhrCallback);
-                        var forwardingStatsData = uploadsTable[date].data;
+                        const xhr = mpInstance._Helpers.createXHR(xhrCallback);
+                        const forwardingStatsData = uploadsTable[date].data;
                         uploadsTable[date].uploading = true;
                         mpInstance._APIClient.sendBatchForwardingStatsToServer(
                             forwardingStatsData,