@mparticle/web-sdk 2.16.0 → 2.16.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mparticle/web-sdk",
-    "version": "2.16.0",
+    "version": "2.16.3",
     "description": "mParticle core SDK for web applications",
     "license": "Apache-2.0",
     "keywords": [
@@ -27,7 +27,6 @@
         "build:npm": "cross-env ENVIRONMENT=prod BUILD=cjs rollup --config rollup.config.js",
         "build:esm": "cross-env ENVIRONMENT=prod BUILD=esm rollup --config rollup.config.js",
         "build:stub": "cross-env ENVIRONMENT=prod BUILD=stub rollup --config rollup.config.js",
-        "build:docs": "yuidoc src/",
         "build:snippet": "uglifyjs snippet.js -nm -o snippet.min.js",
         "build:browserify:cjs": "browserify test/integrations/cjs/browserify/index.js -o test/integrations/cjs/dist/browserify-output.js  && npm run test:karma:browserify:cjs",
         "build:rollup:cjs": "rollup --config test/integrations/cjs/rollup/rollup.config.js  && npm run test:karma:rollup:cjs",
@@ -55,34 +54,45 @@
         "lint": "eslint src/ test/src/",
         "gts:check": "gts check",
         "gts:fix": "gts fix",
-        "prettier": "node_modules/.bin/prettier --check \"**/*.js\""
+        "prettier": "node_modules/.bin/prettier --check \"**/*.js\"",
+        "uglify": "npx uglify-js dist/mparticle.js --output dist/mparticle.min.js",
+        "gzip": "gzip -c dist/mparticle.min.js > dist/mparticle.min.js.gz",
+        "bundle": "npm run uglify && npm run gzip",
+        "report:bundled": "ls -l dist/mparticle.min.js.gz | awk '{print $5}'",
+        "report:bundled:human": "ls -lh dist/mparticle.min.js.gz | awk '{print $5}'"
     },
     "pre-commit": [
         "lint"
     ],
     "devDependencies": {
-        "@babel/core": "^7.6.0",
+        "@babel/core": "^7.18.6",
+        "@babel/eslint-parser": "^7.18.2",
+        "@babel/eslint-plugin": "^7.17.7",
         "@babel/plugin-proposal-class-properties": "^7.5.5",
         "@babel/plugin-proposal-object-rest-spread": "^7.5.5",
         "@babel/plugin-transform-runtime": "^7.6.0",
         "@babel/preset-env": "^7.6.0",
         "@babel/preset-typescript": "^7.6.0",
         "@mparticle/data-planning-models": "^0.1.0",
-        "@mparticle/event-models": "^1.1.4",
+        "@mparticle/event-models": "^1.1.6",
         "@rollup/plugin-json": "^4.1.0",
+        "@rollup/plugin-typescript": "^8.3.3",
+        "@rollup/plugin-babel": "5.3.1",
+        "@rollup/plugin-commonjs": "22.0.1",
+        "@rollup/plugin-node-resolve": "13.3.0",
         "@semantic-release/changelog": "^5.0.1",
         "@semantic-release/exec": "^5.0.0",
         "@semantic-release/git": "^9.0.0",
         "@types/chai": "^4.2.3",
         "@types/mocha": "^9.0.0",
+        "@types/mparticle__web-sdk": "^2.16.1",
         "@types/node": "^16.0.0",
-        "babel-eslint": "^10.0.3",
         "babel-preset-minify": "^0.5.1",
         "browser-sync": "^2.26.3",
         "browserify": "^17.0.0",
         "chai": "^4.2.0",
         "cross-env": "^7.0.3",
-        "eslint": "^7.25.0",
+        "eslint": "^7.32.0",
         "eslint-config-prettier": "8.3.0",
         "eslint-plugin-prettier": "3.4.1",
         "fetch-mock": "^7.5.1",
@@ -100,11 +110,7 @@
         "mocha": "^9.0.0",
         "pre-commit": "^1.2.2",
         "prettier": "1.18.2",
-        "rollup": "^1.19.4",
-        "rollup-plugin-babel": "^4.3.3",
-        "rollup-plugin-commonjs": "^10.1.0",
-        "rollup-plugin-node-resolve": "^5.2.0",
-        "rollup-plugin-typescript": "^1.0.1",
+        "rollup": "^2.75.7",
         "shelljs": "^0.8.4",
         "should": "^7.1.0",
         "sinon": "^11.0.0",
@@ -112,8 +118,7 @@
         "typescript": "^4.2.4",
         "uglify-js": "^3.4.9",
         "webpack": "^5.36.2",
-        "webpack-cli": "^4.6.0",
-        "yuidocjs": "^0.10.2"
+        "webpack-cli": "^4.6.0"
     },
     "dependencies": {
         "@babel/runtime": "^7.6.0",

package/src/batchUploader.ts

@@ -136,7 +136,11 @@ export class BatchUploader {
 
                 if (onCreateBatchCallback) {
                     uploadBatchObject = onCreateBatchCallback(uploadBatchObject);
-                    uploadBatchObject.mutated = true;
+                    if (uploadBatchObject) {
+                        uploadBatchObject.modified = true;
+                    } else {
+                        mpInstance.Logger.warning('Skiping batch upload because no batch was returned from onCreateBatch callback');
+                    }
                 }
 
                 if (uploadBatchObject) {

package/src/constants.ts

@@ -59,8 +59,7 @@ const Constants = {
                 'identityRequests to modify require userIdentities to be present. Request not sent to server. Please fix and try again',
             IdentityRequesetInvalidKey:
                 'There is an invalid key on your identityRequest object. It can only contain a `userIdentities` object and a `onUserAlias` function. Request not sent to server. Please fix and try again.',
-            OnUserAliasType:
-                'The onUserAlias value must be a function. The onUserAlias provided is of type',
+            OnUserAliasType: 'The onUserAlias value must be a function.',
             UserIdentities:
                 'The userIdentities key must be an object with keys of identityTypes and values of strings. Request not sent to server. Please fix and try again.',
             UserIdentitiesInvalidKey:

package/src/helpers.js

@@ -1,9 +1,10 @@
 import Types from './types';
 import Constants from './constants';
 import Slugify from 'slugify';
+import * as utils from './utils';
+import Validators from './validators';
 
-var StorageNames = Constants.StorageNames,
-    pluses = /\+/g;
+var StorageNames = Constants.StorageNames;
 
 export default function Helpers(mpInstance) {
     var self = this;
@@ -19,14 +20,6 @@ export default function Helpers(mpInstance) {
         return false;
     };
 
-    this.returnConvertedBoolean = function(data) {
-        if (data === 'false' || data === '0') {
-            return false;
-        } else {
-            return Boolean(data);
-        }
-    };
-
     this.getFeatureFlag = function(feature) {
         if (mpInstance._Store.SDKConfig.flags.hasOwnProperty(feature)) {
             return mpInstance._Store.SDKConfig.flags[feature];
@@ -250,26 +243,6 @@ export default function Helpers(mpInstance) {
         return target;
     };
 
-    this.isObject = function(value) {
-        var objType = Object.prototype.toString.call(value);
-
-        return objType === '[object Object]' || objType === '[object Error]';
-    };
-
-    this.inArray = function(items, name) {
-        var i = 0;
-
-        if (Array.prototype.indexOf) {
-            return items.indexOf(name, 0) >= 0;
-        } else {
-            for (var n = items.length; i < n; i++) {
-                if (i in items && items[i] === name) {
-                    return true;
-                }
-            }
-        }
-    };
-
     this.createServiceUrl = function(secureServiceUrl, devToken) {
         var serviceScheme =
             window.mParticle && mpInstance._Store.SDKConfig.forceHttps
@@ -415,36 +388,6 @@ export default function Helpers(mpInstance) {
         return filteredUserAttributes;
     };
 
-    this.findKeyInObject = function(obj, key) {
-        if (key && obj) {
-            for (var prop in obj) {
-                if (
-                    obj.hasOwnProperty(prop) &&
-                    prop.toLowerCase() === key.toLowerCase()
-                ) {
-                    return prop;
-                }
-            }
-        }
-
-        return null;
-    };
-
-    this.decoded = function(s) {
-        return decodeURIComponent(s.replace(pluses, ' '));
-    };
-
-    this.converted = function(s) {
-        if (s.indexOf('"') === 0) {
-            s = s
-                .slice(1, -1)
-                .replace(/\\"/g, '"')
-                .replace(/\\\\/g, '\\');
-        }
-
-        return s;
-    };
-
     this.isEventType = function(type) {
         for (var prop in Types.EventType) {
             if (Types.EventType.hasOwnProperty(prop)) {
@@ -456,16 +399,8 @@ export default function Helpers(mpInstance) {
         return false;
     };
 
-    this.parseNumber = function(value) {
-        if (isNaN(value) || !isFinite(value)) {
-            return 0;
-        }
-        var floatValue = parseFloat(value);
-        return isNaN(floatValue) ? 0 : floatValue;
-    };
-
     this.parseStringOrNumber = function(value) {
-        if (self.Validators.isStringOrNumber(value)) {
+        if (Validators.isStringOrNumber(value)) {
             return value;
         } else {
             return null;
@@ -531,157 +466,6 @@ export default function Helpers(mpInstance) {
         return sanitizedAttrs;
     };
 
-    this.Validators = {
-        isValidAttributeValue: function(value) {
-            return (
-                value !== undefined &&
-                !self.isObject(value) &&
-                !Array.isArray(value)
-            );
-        },
-
-        // Neither null nor undefined can be a valid Key
-        isValidKeyValue: function(key) {
-            return Boolean(key && !self.isObject(key) && !Array.isArray(key));
-        },
-
-        isStringOrNumber: function(value) {
-            return typeof value === 'string' || typeof value === 'number';
-        },
-
-        isNumber: function(value) {
-            return typeof value === 'number';
-        },
-
-        isFunction: function(fn) {
-            return typeof fn === 'function';
-        },
-
-        validateIdentities: function(identityApiData, method) {
-            var validIdentityRequestKeys = {
-                userIdentities: 1,
-                onUserAlias: 1,
-                copyUserAttributes: 1,
-            };
-            if (identityApiData) {
-                if (method === 'modify') {
-                    if (
-                        (self.isObject(identityApiData.userIdentities) &&
-                            !Object.keys(identityApiData.userIdentities)
-                                .length) ||
-                        !self.isObject(identityApiData.userIdentities)
-                    ) {
-                        return {
-                            valid: false,
-                            error:
-                                Constants.Messages.ValidationMessages
-                                    .ModifyIdentityRequestUserIdentitiesPresent,
-                        };
-                    }
-                }
-                for (var key in identityApiData) {
-                    if (identityApiData.hasOwnProperty(key)) {
-                        if (!validIdentityRequestKeys[key]) {
-                            return {
-                                valid: false,
-                                error:
-                                    Constants.Messages.ValidationMessages
-                                        .IdentityRequesetInvalidKey,
-                            };
-                        }
-                        if (
-                            key === 'onUserAlias' &&
-                            !mpInstance._Helpers.Validators.isFunction(
-                                identityApiData[key]
-                            )
-                        ) {
-                            return {
-                                valid: false,
-                                error:
-                                    Constants.Messages.ValidationMessages
-                                        .OnUserAliasType +
-                                    typeof identityApiData[key],
-                            };
-                        }
-                    }
-                }
-                if (Object.keys(identityApiData).length === 0) {
-                    return {
-                        valid: true,
-                    };
-                } else {
-                    // identityApiData.userIdentities can't be undefined
-                    if (identityApiData.userIdentities === undefined) {
-                        return {
-                            valid: false,
-                            error:
-                                Constants.Messages.ValidationMessages
-                                    .UserIdentities,
-                        };
-                        // identityApiData.userIdentities can be null, but if it isn't null or undefined (above conditional), it must be an object
-                    } else if (
-                        identityApiData.userIdentities !== null &&
-                        !self.isObject(identityApiData.userIdentities)
-                    ) {
-                        return {
-                            valid: false,
-                            error:
-                                Constants.Messages.ValidationMessages
-                                    .UserIdentities,
-                        };
-                    }
-                    if (
-                        self.isObject(identityApiData.userIdentities) &&
-                        Object.keys(identityApiData.userIdentities).length
-                    ) {
-                        for (var identityType in identityApiData.userIdentities) {
-                            if (
-                                identityApiData.userIdentities.hasOwnProperty(
-                                    identityType
-                                )
-                            ) {
-                                if (
-                                    Types.IdentityType.getIdentityType(
-                                        identityType
-                                    ) === false
-                                ) {
-                                    return {
-                                        valid: false,
-                                        error:
-                                            Constants.Messages
-                                                .ValidationMessages
-                                                .UserIdentitiesInvalidKey,
-                                    };
-                                }
-                                if (
-                                    !(
-                                        typeof identityApiData.userIdentities[
-                                            identityType
-                                        ] === 'string' ||
-                                        identityApiData.userIdentities[
-                                            identityType
-                                        ] === null
-                                    )
-                                ) {
-                                    return {
-                                        valid: false,
-                                        error:
-                                            Constants.Messages
-                                                .ValidationMessages
-                                                .UserIdentitiesInvalidValues,
-                                    };
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            return {
-                valid: true,
-            };
-        },
-    };
-
     this.isDelayedByIntegration = function(
         delayedIntegrations,
         timeoutStart,
@@ -724,4 +508,16 @@ export default function Helpers(mpInstance) {
     this.isSlug = function(str) {
         return str === Slugify(str);
     };
+
+    // Utility Functions
+    this.converted = utils.converted;
+    this.findKeyInObject = utils.findKeyInObject;
+    this.parseNumber = utils.parseNumber;
+    this.inArray = utils.inArray;
+    this.isObject = utils.isObject;
+    this.decoded = utils.decoded;
+    this.returnConvertedBoolean = utils.returnConvertedBoolean;
+
+    // Imported Validators
+    this.Validators = Validators;
 }

package/src/sdkToEventsApiConverter.ts

@@ -327,8 +327,7 @@ export function convertPromotionAction(
         return null;
     }
     const promotionAction: EventsApi.PromotionAction = {
-        action: sdkEvent.PromotionAction
-            .PromotionActionType as EventsApi.PromotionActionActionEnum,
+        action: sdkEvent.PromotionAction.PromotionActionType as EventsApi.PromotionActionActionEnum,
         promotions: convertPromotions(sdkEvent.PromotionAction.PromotionList),
     };
     return promotionAction;

package/src/utils.ts

@@ -0,0 +1,82 @@
+type valueof<T> = T[keyof T];
+
+const inArray = (items: any[], name: string): boolean => {
+    let i = 0;
+
+    if (Array.prototype.indexOf) {
+        return items.indexOf(name, 0) >= 0;
+    } else {
+        for (var n = items.length; i < n; i++) {
+            if (i in items && items[i] === name) {
+                return true;
+            }
+        }
+    }
+
+    return false;
+};
+
+const findKeyInObject = (obj: any, key: string): string => {
+    if (key && obj) {
+        for (var prop in obj) {
+            if (
+                obj.hasOwnProperty(prop) &&
+                prop.toLowerCase() === key.toLowerCase()
+            ) {
+                return prop;
+            }
+        }
+    }
+
+    return null;
+};
+
+const isObject = (value: any): boolean => {
+    var objType = Object.prototype.toString.call(value);
+    return objType === '[object Object]' || objType === '[object Error]';
+};
+
+const parseNumber = (value: string | number): number => {
+    if (isNaN(value as number) || !isFinite(value as number)) {
+        return 0;
+    }
+    var floatValue = parseFloat(value as string);
+    return isNaN(floatValue) ? 0 : floatValue;
+};
+
+// FIXME: REFACTOR for V3
+// only used in store.js to sanitize server-side formatting of
+// booleans when checking for `isDevelopmentMode`
+// Should be removed in v3
+const returnConvertedBoolean = (data: string | boolean | number) => {
+    if (data === 'false' || data === '0') {
+        return false;
+    } else {
+        return Boolean(data);
+    }
+};
+
+const decoded = (s: string): string =>
+    decodeURIComponent(s.replace(/\+/g, ' '));
+
+const converted = (s: string): string => {
+    if (s.indexOf('"') === 0) {
+        s = s
+            .slice(1, -1)
+            .replace(/\\"/g, '"')
+            .replace(/\\\\/g, '\\');
+    }
+
+    return s;
+};
+
+export {
+    valueof,
+    converted,
+    decoded,
+    findKeyInObject,
+    inArray,
+    isObject,
+    parseNumber,
+    returnConvertedBoolean,
+};

package/src/validators.ts

@@ -0,0 +1,163 @@
+import Types from './types';
+import { isObject } from './utils';
+import Constants from './constants';
+import { IdentityApiData } from '@mparticle/web-sdk';
+import { valueof } from './utils';
+
+type IdentityAPIMethod = 'login' | 'logout' | 'identify' | 'modify';
+
+type ValidationIdentitiesReturn = {
+    valid: boolean;
+    error?: valueof<typeof Constants.Messages.ValidationMessages>;
+};
+
+const Validators = {
+    isValidAttributeValue: function(value: any): boolean {
+        return value !== undefined && !isObject(value) && !Array.isArray(value);
+    },
+
+    // Neither null nor undefined can be a valid Key
+    isValidKeyValue: function(key: any): boolean {
+        return Boolean(
+            key &&
+                !isObject(key) &&
+                !Array.isArray(key) &&
+                !this.isFunction(key)
+        );
+    },
+
+    isStringOrNumber: function(value: any): boolean {
+        return typeof value === 'string' || typeof value === 'number';
+    },
+
+    isNumber: function(value: any): boolean {
+        return typeof value === 'number';
+    },
+
+    isFunction: (fn: any): boolean => {
+        return typeof fn === 'function';
+    },
+
+    validateIdentities: function(
+        identityApiData: IdentityApiData,
+        method?: IdentityAPIMethod
+    ): ValidationIdentitiesReturn {
+        var validIdentityRequestKeys = {
+            userIdentities: 1,
+            onUserAlias: 1,
+            copyUserAttributes: 1,
+        };
+        if (identityApiData) {
+            if (method === 'modify') {
+                if (
+                    (isObject(identityApiData.userIdentities) &&
+                        !Object.keys(identityApiData.userIdentities).length) ||
+                    !isObject(identityApiData.userIdentities)
+                ) {
+                    return {
+                        valid: false,
+                        error:
+                            Constants.Messages.ValidationMessages
+                                .ModifyIdentityRequestUserIdentitiesPresent,
+                    };
+                }
+            }
+            for (var key in identityApiData) {
+                if (identityApiData.hasOwnProperty(key)) {
+                    if (!validIdentityRequestKeys[key]) {
+                        return {
+                            valid: false,
+                            error:
+                                Constants.Messages.ValidationMessages
+                                    .IdentityRequesetInvalidKey,
+                        };
+                    }
+                    if (
+                        key === 'onUserAlias' &&
+                        !Validators.isFunction(identityApiData[key])
+                    ) {
+                        return {
+                            valid: false,
+                            error:
+                                Constants.Messages.ValidationMessages
+                                    .OnUserAliasType,
+                        };
+                    }
+                }
+            }
+            if (Object.keys(identityApiData).length === 0) {
+                return {
+                    valid: true,
+                };
+            } else {
+                // identityApiData.userIdentities can't be undefined
+                if (identityApiData.userIdentities === undefined) {
+                    return {
+                        valid: false,
+                        error:
+                            Constants.Messages.ValidationMessages
+                                .UserIdentities,
+                    };
+                    // identityApiData.userIdentities can be null, but if it isn't null or undefined (above conditional), it must be an object
+                } else if (
+                    identityApiData.userIdentities !== null &&
+                    !isObject(identityApiData.userIdentities)
+                ) {
+                    return {
+                        valid: false,
+                        error:
+                            Constants.Messages.ValidationMessages
+                                .UserIdentities,
+                    };
+                }
+                if (
+                    isObject(identityApiData.userIdentities) &&
+                    Object.keys(identityApiData.userIdentities).length
+                ) {
+                    for (var identityType in identityApiData.userIdentities) {
+                        if (
+                            identityApiData.userIdentities.hasOwnProperty(
+                                identityType
+                            )
+                        ) {
+                            if (
+                                Types.IdentityType.getIdentityType(
+                                    identityType
+                                ) === false
+                            ) {
+                                return {
+                                    valid: false,
+                                    error:
+                                        Constants.Messages.ValidationMessages
+                                            .UserIdentitiesInvalidKey,
+                                };
+                            }
+                            if (
+                                !(
+                                    typeof identityApiData.userIdentities[
+                                        identityType
+                                    ] === 'string' ||
+                                    identityApiData.userIdentities[
+                                        identityType
+                                    ] === null
+                                )
+                            ) {
+                                return {
+                                    valid: false,
+                                    error:
+                                        Constants.Messages.ValidationMessages
+                                            .UserIdentitiesInvalidValues,
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            valid: true,
+        };
+    },
+};
+
+export default Validators;