@microsoft/applicationinsights-core-js 2.7.4-nightly.2202-02 → 2.7.4-nightly.2202-08

package/dist-esm/JavaScriptSDK/HelperFuncs.js

@@ -1,10 +1,10 @@
 /*
- * Application Insights JavaScript SDK - Core, 2.7.4-nightly.2202-02
+ * Application Insights JavaScript SDK - Core, 2.7.4-nightly.2202-08
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 
 
-import { strShimUndefined, strShimObject, strShimFunction, throwTypeError, ObjClass, ObjProto, ObjAssign, ObjHasOwnProperty, ObjDefineProperty } from "@microsoft/applicationinsights-shims";
+import { strShimUndefined, strShimObject, strShimFunction, throwTypeError, ObjClass, ObjProto, ObjAssign, ObjHasOwnProperty, ObjDefineProperty, strShimPrototype } from "@microsoft/applicationinsights-shims";
 // RESTRICT and AVOID circular dependencies you should not import other contained modules or export the contents of this file directly
 // Added to help with minfication
 var strOnPrefix = "on";
@@ -13,11 +13,66 @@ var strAddEventHelper = "addEventListener";
 var strDetachEvent = "detachEvent";
 var strRemoveEventListener = "removeEventListener";
 var strToISOString = "toISOString";
+var cStrEndsWith = "endsWith";
+var cStrStartsWith = "startsWith";
+var strIndexOf = "indexOf";
+var strMap = "map";
+var strReduce = "reduce";
+var cStrTrim = "trim";
+var strToString = "toString";
+/**
+ * Constant string defined to support minimization
+ * @ignore
+ */
+var str__Proto = "__proto__";
+/**
+ * Constant string defined to support minimization
+ * @ignore
+ */
+var strConstructor = "constructor";
 var _objDefineProperty = ObjDefineProperty;
-var _objFreeze = ObjClass["freeze"];
-var _objSeal = ObjClass["seal"];
+var _objFreeze = ObjClass.freeze;
+var _objSeal = ObjClass.seal;
+var _objKeys = ObjClass.keys;
+var StringProto = String[strShimPrototype];
+var _strTrim = StringProto[cStrTrim];
+var _strEndsWith = StringProto[cStrEndsWith];
+var _strStartsWith = StringProto[cStrStartsWith];
+var DateProto = Date[strShimPrototype];
+var _dataToISOString = DateProto[strToISOString];
+var _isArray = Array.isArray;
+var _objToString = ObjProto[strToString];
+var _fnToString = ObjHasOwnProperty[strToString];
+// Cache what this browser reports as the object function constructor (as a string)
+var _objFunctionString = _fnToString.call(ObjClass);
+var rCamelCase = /-([a-z])/g;
+var rNormalizeInvalid = /([^\w\d_$])/g;
+var rLeadingNumeric = /^(\d+[\w\d_$])/;
+/**
+ * Pre-lookup to check if we are running on a modern browser (i.e. not IE8)
+ * @ignore
+ */
+var _objGetPrototypeOf = Object["getPrototypeOf"];
+/**
+ * Helper used to get the prototype of the target object as getPrototypeOf is not available in an ES3 environment.
+ * @ignore
+ */
+export function _getObjProto(target) {
+    if (target) {
+        // This method doesn't existing in older browsers (e.g. IE8)
+        if (_objGetPrototypeOf) {
+            return _objGetPrototypeOf(target);
+        }
+        // target[Constructor] May break if the constructor has been changed or removed
+        var newProto = target[str__Proto] || target[strShimPrototype] || target[strConstructor];
+        if (newProto) {
+            return newProto;
+        }
+    }
+    return null;
+}
 export function objToString(obj) {
-    return ObjProto.toString.call(obj);
+    return _objToString.call(obj);
 }
 export function isTypeof(value, theType) {
     return typeof value === theType;
@@ -35,15 +90,15 @@ export function isNotNullOrUndefined(value) {
     return !isNullOrUndefined(value);
 }
 export function hasOwnProperty(obj, prop) {
-    return obj && ObjHasOwnProperty.call(obj, prop);
+    return !!(obj && ObjHasOwnProperty.call(obj, prop));
 }
 export function isObject(value) {
     // Changing to inline for performance
-    return typeof value === strShimObject;
+    return !!(value && typeof value === strShimObject);
 }
 export function isFunction(value) {
     // Changing to inline for performance
-    return typeof value === strShimFunction;
+    return !!(value && typeof value === strShimFunction);
 }
 /**
  * Binds the specified function to an event, so that the function gets called whenever the event fires on the object
@@ -107,9 +162,15 @@ export function detachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {
  */
 export function normalizeJsName(name) {
     var value = name;
-    var match = /([^\w\d_$])/g;
-    if (match.test(name)) {
-        value = name.replace(match, "_");
+    if (value && isString(value)) {
+        // CamelCase everything after the "-" and remove the dash
+        value = value.replace(rCamelCase, function (_all, letter) {
+            return letter.toUpperCase();
+        });
+        value = value.replace(rNormalizeInvalid, "_");
+        value = value.replace(rLeadingNumeric, function (_all, match) {
+            return "_" + match;
+        });
     }
     return value;
 }
@@ -135,24 +196,34 @@ export function objForEachKey(target, callbackfn) {
  * @returns true if the given search value is found at the end of the string, otherwise false.
  */
 export function strEndsWith(value, search) {
-    if (value && search) {
-        var searchLen = search.length;
-        var valLen = value.length;
-        if (value === search) {
-            return true;
-        }
-        else if (valLen >= searchLen) {
-            var pos = valLen - 1;
-            for (var lp = searchLen - 1; lp >= 0; lp--) {
-                if (value[pos] != search[lp]) {
-                    return false;
-                }
-                pos--;
+    var result = false;
+    if (value && search && !(result = value === search)) {
+        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
+        result = _strEndsWith ? value[cStrEndsWith](search) : _strEndsWithPoly(value, search);
+    }
+    return result;
+}
+/**
+ * The _strEndsWith() method determines whether a string ends with the characters of a specified string, returning true or false as appropriate.
+ * @param value - The value to check whether it ends with the search value.
+ * @param search - The characters to be searched for at the end of the value.
+ * @returns true if the given search value is found at the end of the string, otherwise false.
+ */
+export function _strEndsWithPoly(value, search) {
+    var result = false;
+    var searchLen = search ? search.length : 0;
+    var valLen = value ? value.length : 0;
+    if (searchLen && valLen && valLen >= searchLen && !(result = value === search)) {
+        var pos = valLen - 1;
+        for (var lp = searchLen - 1; lp >= 0; lp--) {
+            if (value[pos] != search[lp]) {
+                return false;
             }
-            return true;
+            pos--;
         }
+        result = true;
     }
-    return false;
+    return result;
 }
 /**
  * The strStartsWith() method determines whether a string starts with the characters of the specified string, returning true or false as appropriate.
@@ -161,21 +232,30 @@ export function strEndsWith(value, search) {
  * @returns true if the given search value is found at the start of the string, otherwise false.
  */
 export function strStartsWith(value, checkValue) {
+    var result = false;
+    if (value && checkValue && !(result = value === checkValue)) {
+        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
+        result = _strStartsWith ? value[cStrStartsWith](checkValue) : _strStartsWithPoly(value, checkValue);
+    }
+    return result;
+}
+/**
+ * The strStartsWith() method determines whether a string starts with the characters of the specified string, returning true or false as appropriate.
+ * @param value - The value to check whether it ends with the search value.
+ * @param checkValue - The characters to be searched for at the start of the value.
+ * @returns true if the given search value is found at the start of the string, otherwise false.
+ */
+export function _strStartsWithPoly(value, checkValue) {
     // Using helper for performance and because string startsWith() is not available on IE
     var result = false;
-    if (value && checkValue) {
-        var chkLen = checkValue.length;
-        if (value === checkValue) {
-            return true;
-        }
-        else if (value.length >= chkLen) {
-            for (var lp = 0; lp < chkLen; lp++) {
-                if (value[lp] !== checkValue[lp]) {
-                    return false;
-                }
+    var chkLen = checkValue ? checkValue.length : 0;
+    if (value && chkLen && value.length >= chkLen && !(result = value === checkValue)) {
+        for (var lp = 0; lp < chkLen; lp++) {
+            if (value[lp] !== checkValue[lp]) {
+                return false;
             }
-            result = true;
         }
+        result = true;
     }
     return result;
 }
@@ -194,19 +274,20 @@ export function strContains(value, search) {
  * Check if an object is of type Date
  */
 export function isDate(obj) {
-    return objToString(obj) === "[object Date]";
+    return !!(obj && _objToString.call(obj) === "[object Date]");
 }
 /**
  * Check if an object is of type Array
  */
-export function isArray(obj) {
-    return objToString(obj) === "[object Array]";
+export var isArray = _isArray || _isArrayPoly;
+function _isArrayPoly(obj) {
+    return !!(obj && _objToString.call(obj) === "[object Array]");
 }
 /**
  * Check if an object is of type Error
  */
 export function isError(obj) {
-    return objToString(obj) === "[object Error]";
+    return !!(obj && _objToString.call(obj) === "[object Error]");
 }
 /**
  * Checks if the type of value is a string.
@@ -244,32 +325,58 @@ export function isBoolean(value) {
 export function isSymbol(value) {
     return typeof value === "symbol";
 }
+/**
+ * Checks if the type of the value is a normal plain object (not a null or data)
+ * @param value
+ */
+export function isPlainObject(value) {
+    var result = false;
+    if (value && typeof value === "object") {
+        // Inlining _objGetPrototypeOf for performance to avoid an additional function call
+        var proto = _objGetPrototypeOf ? _objGetPrototypeOf(value) : _getObjProto(value);
+        if (!proto) {
+            // No prototype found so this is a plain Object eg. 'Object.create(null)'
+            result = true;
+        }
+        else {
+            // Objects that have a prototype are plain only if they were created using the Object global (native) function
+            if (proto[strConstructor] && ObjHasOwnProperty.call(proto, strConstructor)) {
+                proto = proto[strConstructor];
+            }
+            result = typeof proto === strShimFunction && _fnToString.call(proto) === _objFunctionString;
+        }
+    }
+    return result;
+}
 /**
  * Convert a date to I.S.O. format in IE8
  */
 export function toISOString(date) {
     if (date) {
-        if (date[strToISOString]) {
-            // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
-            return date[strToISOString]();
-        }
-        if (isDate(date)) {
-            var pad = function (num) {
-                var r = String(num);
-                if (r.length === 1) {
-                    r = "0" + r;
-                }
-                return r;
-            };
-            return date.getUTCFullYear()
-                + "-" + pad(date.getUTCMonth() + 1)
-                + "-" + pad(date.getUTCDate())
-                + "T" + pad(date.getUTCHours())
-                + ":" + pad(date.getUTCMinutes())
-                + ":" + pad(date.getUTCSeconds())
-                + "." + String((date.getUTCMilliseconds() / 1000).toFixed(3)).slice(2, 5)
-                + "Z";
-        }
+        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
+        return _dataToISOString ? date[strToISOString]() : _toISOStringPoly(date);
+    }
+}
+/**
+ * Convert a date to I.S.O. format in IE8
+ */
+export function _toISOStringPoly(date) {
+    if (date && date.getUTCFullYear) {
+        var pad = function (num) {
+            var r = String(num);
+            if (r.length === 1) {
+                r = "0" + r;
+            }
+            return r;
+        };
+        return date.getUTCFullYear()
+            + "-" + pad(date.getUTCMonth() + 1)
+            + "-" + pad(date.getUTCDate())
+            + "T" + pad(date.getUTCHours())
+            + ":" + pad(date.getUTCMinutes())
+            + ":" + pad(date.getUTCSeconds())
+            + "." + String((date.getUTCMilliseconds() / 1000).toFixed(3)).slice(2, 5)
+            + "Z";
     }
 }
 /**
@@ -304,17 +411,23 @@ export function arrForEach(arr, callbackfn, thisArg) {
  * @param fromIndex The array index at which to begin the search. If fromIndex is omitted, the search starts at index 0.
  */
 export function arrIndexOf(arr, searchElement, fromIndex) {
-    var len = arr.length;
-    var from = fromIndex || 0;
-    try {
-        for (var lp = Math.max(from >= 0 ? from : len - Math.abs(from), 0); lp < len; lp++) {
-            if (lp in arr && arr[lp] === searchElement) {
-                return lp;
+    if (arr) {
+        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
+        if (arr[strIndexOf]) {
+            return arr[strIndexOf](searchElement, fromIndex);
+        }
+        var len = arr.length;
+        var from = fromIndex || 0;
+        try {
+            for (var lp = Math.max(from >= 0 ? from : len - Math.abs(from), 0); lp < len; lp++) {
+                if (lp in arr && arr[lp] === searchElement) {
+                    return lp;
+                }
             }
         }
-    }
-    catch (e) {
-        // This can happen with some native browser objects, but should not happen for the type we are checking for
+        catch (e) {
+            // This can happen with some native browser objects, but should not happen for the type we are checking for
+        }
     }
     return -1;
 }
@@ -327,18 +440,25 @@ export function arrIndexOf(arr, searchElement, fromIndex) {
  * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
  */
 export function arrMap(arr, callbackfn, thisArg) {
-    var len = arr.length;
-    var _this = thisArg || arr;
-    var results = new Array(len);
-    try {
-        for (var lp = 0; lp < len; lp++) {
-            if (lp in arr) {
-                results[lp] = callbackfn.call(_this, arr[lp], arr);
+    var results;
+    if (arr) {
+        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
+        if (arr[strMap]) {
+            return arr[strMap](callbackfn, thisArg);
+        }
+        var len = arr.length;
+        var _this = thisArg || arr;
+        results = new Array(len);
+        try {
+            for (var lp = 0; lp < len; lp++) {
+                if (lp in arr) {
+                    results[lp] = callbackfn.call(_this, arr[lp], arr);
+                }
             }
         }
-    }
-    catch (e) {
-        // This can happen with some native browser objects, but should not happen for the type we are checking for
+        catch (e) {
+            // This can happen with some native browser objects, but should not happen for the type we are checking for
+        }
     }
     return results;
 }
@@ -351,24 +471,30 @@ export function arrMap(arr, callbackfn, thisArg) {
  * @param initialValue If initialValue is specified, it is used as the initial value to start the accumulation. The first call to the callbackfn function provides this value as an argument instead of an array value.
  */
 export function arrReduce(arr, callbackfn, initialValue) {
-    var len = arr.length;
-    var lp = 0;
     var value;
-    // Specifically checking the number of passed arguments as the value could be anything
-    if (arguments.length >= 3) {
-        value = arguments[2];
-    }
-    else {
-        while (lp < len && !(lp in arr)) {
-            lp++;
+    if (arr) {
+        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
+        if (arr[strReduce]) {
+            return arr[strReduce](callbackfn, initialValue);
         }
-        value = arr[lp++];
-    }
-    while (lp < len) {
-        if (lp in arr) {
-            value = callbackfn(value, arr[lp], lp, arr);
+        var len = arr.length;
+        var lp = 0;
+        // Specifically checking the number of passed arguments as the value could be anything
+        if (arguments.length >= 3) {
+            value = arguments[2];
+        }
+        else {
+            while (lp < len && !(lp in arr)) {
+                lp++;
+            }
+            value = arr[lp++];
+        }
+        while (lp < len) {
+            if (lp in arr) {
+                value = callbackfn(value, arr[lp], lp, arr);
+            }
+            lp++;
         }
-        lp++;
     }
     return value;
 }
@@ -376,10 +502,11 @@ export function arrReduce(arr, callbackfn, initialValue) {
  * helper method to trim strings (IE8 does not implement String.prototype.trim)
  */
 export function strTrim(str) {
-    if (typeof str !== "string") {
-        return str;
+    if (str) {
+        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
+        str = (_strTrim && str[cStrTrim]) ? str[cStrTrim]() : (str.replace ? str.replace(/^\s+|\s+$/g, "") : str);
     }
-    return str.replace(/^\s+|\s+$/g, "");
+    return str;
 }
 var _objKeysHasDontEnumBug = !({ toString: null }).propertyIsEnumerable("toString");
 var _objKeysDontEnums = [
@@ -402,6 +529,10 @@ export function objKeys(obj) {
     if (objType !== strShimFunction && (objType !== strShimObject || obj === null)) {
         throwTypeError("objKeys called on non-object");
     }
+    // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
+    if (!_objKeysHasDontEnumBug && _objKeys) {
+        return _objKeys(obj);
+    }
     var result = [];
     for (var prop in obj) {
         if (obj && ObjHasOwnProperty.call(obj, prop)) {
@@ -451,28 +582,18 @@ export function objDefineAccessors(target, prop, getProp, setProp) {
     }
     return false;
 }
-export function objFreeze(value) {
-    if (_objFreeze) {
-        value = _objFreeze(value);
-    }
-    return value;
-}
-export function objSeal(value) {
-    if (_objSeal) {
-        value = _objSeal(value);
-    }
+function _doNothing(value) {
     return value;
 }
+export var objFreeze = _objFreeze || _doNothing;
+export var objSeal = _objSeal || _doNothing;
 /**
  * Return the current time via the Date now() function (if available) and falls back to (new Date()).getTime() if now() is unavailable (IE8 or less)
  * https://caniuse.com/#search=Date.now
  */
 export function dateNow() {
     var dt = Date;
-    if (dt.now) {
-        return dt.now();
-    }
-    return new dt().getTime();
+    return dt.now ? dt.now() : new dt().getTime();
 }
 /**
  * Returns the name of object if it's an Error. Otherwise, returns empty string.
@@ -621,9 +742,73 @@ export function createClassFromInterface(defaults) {
 export function optimizeObject(theObject) {
     // V8 Optimization to cause the JIT compiler to create a new optimized object for looking up the own properties
     // primarily for object with <= 19 properties for >= 20 the effect is reduced or non-existent
-    if (theObject) {
-        theObject = ObjClass(ObjAssign ? ObjAssign({}, theObject) : theObject);
+    if (theObject && ObjAssign) {
+        theObject = ObjClass(ObjAssign({}, theObject));
     }
     return theObject;
 }
+/**
+ * Pass in the objects to merge as arguments, this will only "merge" (extend) properties that are owned by the object.
+ * It will NOT merge inherited or non-enumerable properties.
+ * @param obj1 - object to merge.  Set this argument to 'true' for a deep extend.
+ * @param obj2 - object to merge.
+ * @param obj3 - object to merge.
+ * @param obj4 - object to merge.
+ * @param obj5 - object to merge.
+ * @returns The extended first object.
+ */
+export function objExtend(obj, obj2, obj3, obj4, obj5, obj6) {
+    // Variables
+    var theArgs = arguments;
+    var extended = theArgs[0] || {};
+    var argLen = theArgs.length;
+    var deep = false;
+    var idx = 1;
+    // Check for "Deep" flag
+    if (argLen > 0 && isBoolean(extended)) {
+        deep = extended;
+        extended = theArgs[idx] || {};
+        idx++;
+    }
+    // Handle case when target is a string or something (possible in deep copy)
+    if (!isObject(extended)) {
+        extended = {};
+    }
+    // Loop through each remaining object and conduct a merge
+    for (; idx < argLen; idx++) {
+        var arg = theArgs[idx];
+        var isArgArray = isArray(arg);
+        var isArgObj = isObject(arg);
+        for (var prop in arg) {
+            var propOk = (isArgArray && (prop in arg)) || (isArgObj && (ObjHasOwnProperty.call(arg, prop)));
+            if (!propOk) {
+                continue;
+            }
+            var newValue = arg[prop];
+            var isNewArray = void 0;
+            // If deep merge and property is an object, merge properties
+            if (deep && newValue && ((isNewArray = isArray(newValue)) || isPlainObject(newValue))) {
+                // Grab the current value of the extended object
+                var clone = extended[prop];
+                if (isNewArray) {
+                    if (!isArray(clone)) {
+                        // We can't "merge" an array with a non-array so overwrite the original
+                        clone = [];
+                    }
+                }
+                else if (!isPlainObject(clone)) {
+                    // We can't "merge" an object with a non-object
+                    clone = {};
+                }
+                // Never move the original objects always clone them
+                newValue = objExtend(deep, clone, newValue);
+            }
+            // Assign the new (or previous) value (unless undefined)
+            if (newValue !== undefined) {
+                extended[prop] = newValue;
+            }
+        }
+    }
+    return extended;
+}
 //# sourceMappingURL=HelperFuncs.js.map