@microsoft/applicationinsights-core-js 2.7.5-nightly.2203-03 → 2.7.5

package/src/JavaScriptSDK/DiagnosticLogger.ts

@@ -2,14 +2,13 @@
 // Licensed under the MIT License.
 "use strict"
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration"
-import { _InternalMessageId, _eInternalMessageId, LoggingSeverity, eLoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
+import { _InternalMessageId, LoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
-import { hasJSON, getJSON, getConsole } from "./EnvUtils";
+import { hasJSON, getJSON, getConsole, dumpObj } from "./EnvUtils";
 import dynamicProto from "@microsoft/dynamicproto-js";
 import { isFunction, isNullOrUndefined, isUndefined } from "./HelperFuncs";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { getDebugExt } from "./DbgExtensionUtils";
-import { strEmpty } from "./InternalConstants";
 
 /**
  * For user non actionable traces use AI Internal prefix.
@@ -31,10 +30,10 @@ const strWarnToConsole = "warnToConsole";
 
 function _sanitizeDiagnosticText(text: string) {
     if (text) {
-        return "\"" + text.replace(/\"/g, strEmpty) + "\"";
+        return "\"" + text.replace(/\"/g, "") + "\"";
     }
 
-    return strEmpty;
+    return "";
 }
 
 function _logToConsole(func: string, message: string) {
@@ -65,14 +64,14 @@ export class _InternalLogMessage{
             (isUserAct ? AiUserActionablePrefix : AiNonUserActionablePrefix) +
             msgId;
 
-        let strProps:string = strEmpty;
+        let strProps:string = "";
         if (hasJSON()) {
             strProps = getJSON().stringify(properties);
         }
 
         const diagnosticText =
-            (msg ? " message:" + _sanitizeDiagnosticText(msg) : strEmpty) +
-            (properties ? " props:" + _sanitizeDiagnosticText(strProps) : strEmpty);
+            (msg ? " message:" + _sanitizeDiagnosticText(msg) : "") +
+            (properties ? " props:" + _sanitizeDiagnosticText(strProps) : "");
 
         _self.message += diagnosticText;
     }
@@ -123,10 +122,10 @@ export class DiagnosticLogger implements IDiagnosticLogger {
                 const message = new _InternalLogMessage(msgId, msg, isUserAct, properties);
 
                 if (_self.enableDebugExceptions()) {
-                    throw message;
+                    throw dumpObj(message);
                 } else {
                     // Get the logging function and fallback to warnToConsole of for some reason errorToConsole doesn't exist
-                    let logFunc = severity === eLoggingSeverity.CRITICAL ? strErrorToConsole : strWarnToConsole;
+                    let logFunc = severity === LoggingSeverity.CRITICAL ? strErrorToConsole : strWarnToConsole;
 
                     if (!isUndefined(message.message)) {
                         const logLevel = _self.consoleLoggingLevel();
@@ -147,7 +146,7 @@ export class DiagnosticLogger implements IDiagnosticLogger {
 
                         _self.logInternalMessage(severity, message);
                     } else {
-                        _debugExtMsg("throw" + (severity === eLoggingSeverity.CRITICAL ? "Critical" : "Warning"), message);
+                        _debugExtMsg("throw" + (severity === LoggingSeverity.CRITICAL ? "Critical" : "Warning"), message);
                     }
                 }
             }
@@ -165,7 +164,7 @@ export class DiagnosticLogger implements IDiagnosticLogger {
              * This will write an error to the console if possible
              * @param message {string} - The error message
              */
-            _self.errorToConsole = (message: string) => {
+             _self.errorToConsole = (message: string) => {
                 _logToConsole("error", message);
                 _debugExtMsg("error", message);
             }
@@ -204,15 +203,15 @@ export class DiagnosticLogger implements IDiagnosticLogger {
                     if (severity <= _self.telemetryLoggingLevel()) {
                         _self.queue.push(message);
                         _messageCount++;
-                        _debugExtMsg((severity === eLoggingSeverity.CRITICAL ? "error" : "warn"), message);
+                        _debugExtMsg((severity === LoggingSeverity.CRITICAL ? "error" : "warn"), message);
                     }
 
                     // When throttle limit reached, send a special event
                     if (_messageCount === _self.maxInternalMessageLimit()) {
                         const throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
-                        const throttleMessage = new _InternalLogMessage(_eInternalMessageId.MessageLimitPerPVExceeded, throttleLimitMessage, false);
+                        const throttleMessage = new _InternalLogMessage(_InternalMessageId.MessageLimitPerPVExceeded, throttleLimitMessage, false);
                         _self.queue.push(throttleMessage);
-                        if (severity === eLoggingSeverity.CRITICAL) {
+                        if (severity === LoggingSeverity.CRITICAL) {
                             _self.errorToConsole(throttleLimitMessage);
                         } else {
                             _self.warnToConsole(throttleLimitMessage);
@@ -320,17 +319,3 @@ export class DiagnosticLogger implements IDiagnosticLogger {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
     }
 }
-
-/**
- * This is a helper method which will call throwInternal on the passed logger, will throw exceptions in
- * debug mode or attempt to log the error as a console warning. This helper is provided mostly to better
- * support minification as logger.throwInternal() will not compress the publish "throwInternal" used throughout
- * the code.
- * @param logger - The Diagnostic Logger instance to use.
- * @param severity {LoggingSeverity} - The severity of the log message
- * @param message {_InternalLogMessage} - The log message.
- */
-export function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct = false) {
-    (logger || new DiagnosticLogger()).throwInternal(severity, msgId, msg, properties, isUserAct);
-}
-

package/src/JavaScriptSDK/EnvUtils.ts

@@ -5,7 +5,6 @@
 import {
     getGlobal, strShimUndefined, strShimObject, strShimPrototype
 } from "@microsoft/applicationinsights-shims";
-import { strEmpty } from "./InternalConstants";
 import { isString, isUndefined, strContains } from "./HelperFuncs";
 
 // TypeScript removed this interface so we need to declare the global so we can check for it's existence.
@@ -32,7 +31,6 @@ const strMsCrypto = "msCrypto";
 const strReactNative = "ReactNative";
 const strMsie = "msie";
 const strTrident = "trident/";
-const strXMLHttpRequest = "XMLHttpRequest";
 
 let _isTrident: boolean = null;
 let _navUserAgentCheck: string = null;
@@ -297,7 +295,7 @@ export function isIE() {
     if (nav && (nav.userAgent !== _navUserAgentCheck || _isTrident === null)) {
         // Added to support test mocking of the user agent
         _navUserAgentCheck = nav.userAgent;
-        let userAgent = (_navUserAgentCheck || strEmpty).toLowerCase();
+        let userAgent = (_navUserAgentCheck || "").toLowerCase();
         _isTrident = (strContains(userAgent, strMsie) || strContains(userAgent, strTrident));
     }
 
@@ -310,10 +308,10 @@ export function isIE() {
 export function getIEVersion(userAgentStr: string = null): number {
     if (!userAgentStr) {
         let navigator = getNavigator() || ({} as Navigator);
-        userAgentStr = navigator ? (navigator.userAgent || strEmpty).toLowerCase() : strEmpty;
+        userAgentStr = navigator ? (navigator.userAgent || "").toLowerCase() : "";
     }
 
-    var ua = (userAgentStr || strEmpty).toLowerCase();
+    var ua = (userAgentStr || "").toLowerCase();
     // Also check for documentMode in case X-UA-Compatible meta tag was included in HTML.
     if (strContains(ua, strMsie)) {
         let doc = getDocument() || {} as Document;
@@ -333,7 +331,7 @@ export function getIEVersion(userAgentStr: string = null): number {
  */
 export function dumpObj(object: any): string {
     const objectTypeDump: string = Object[strShimPrototype].toString.call(object);
-    let propertyValueDump: string = strEmpty;
+    let propertyValueDump: string = "";
     if (objectTypeDump === "[object Error]") {
         propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
     } else if (hasJSON()) {
@@ -346,10 +344,10 @@ export function dumpObj(object: any): string {
 export function isSafari(userAgentStr ?: string) {
     if (!userAgentStr || !isString(userAgentStr)) {
         let navigator = getNavigator() || ({} as Navigator);
-        userAgentStr = navigator ? (navigator.userAgent || strEmpty).toLowerCase() : strEmpty;
+        userAgentStr = navigator ? (navigator.userAgent || "").toLowerCase() : "";
     }
 
-    var ua = (userAgentStr || strEmpty).toLowerCase();
+    var ua = (userAgentStr || "").toLowerCase();
     return (ua.indexOf("safari") >= 0);
 }
 
@@ -357,7 +355,7 @@ export function isSafari(userAgentStr ?: string) {
  * Checks if HTML5 Beacons are supported in the current environment.
  * @returns True if supported, false otherwise.
  */
-export function isBeaconsSupported(): boolean {
+ export function isBeaconsSupported(): boolean {
     if (_beaconsSupported === null) {
         _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
     }
@@ -373,7 +371,8 @@ export function isBeaconsSupported(): boolean {
 export function isFetchSupported(withKeepAlive?: boolean): boolean {
     let isSupported = false;
     try {
-        isSupported = !!getGlobalInst("fetch");
+        const fetchApi = getGlobalInst("fetch");
+        isSupported = !!fetchApi;
         const request = getGlobalInst("Request");
         if (isSupported && withKeepAlive && request) {
             isSupported = _hasProperty(request, "keepalive");
@@ -387,9 +386,9 @@ export function isFetchSupported(withKeepAlive?: boolean): boolean {
 
 export function useXDomainRequest(): boolean | undefined {
     if (_useXDomainRequest === null) {
-        _useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);
+        _useXDomainRequest = (typeof XDomainRequest !== "undefined");
         if (_useXDomainRequest && isXhrSupported()) {
-            _useXDomainRequest = _useXDomainRequest && !_hasProperty(getGlobalInst(strXMLHttpRequest), "withCredentials");
+            _useXDomainRequest = _useXDomainRequest && !_hasProperty(getGlobalInst("XMLHttpRequest"), "withCredentials");
         }
     }
 
@@ -403,7 +402,7 @@ export function useXDomainRequest(): boolean | undefined {
 export function isXhrSupported(): boolean {
     let isSupported = false;
     try {
-        const xmlHttpRequest = getGlobalInst(strXMLHttpRequest);
+        const xmlHttpRequest = getGlobalInst("XMLHttpRequest");
         isSupported = !!xmlHttpRequest;
     } catch (e) {
         // Just Swallow any failure during availability checks

package/src/JavaScriptSDK/HelperFuncs.ts

@@ -4,11 +4,15 @@ import {
     strShimUndefined, strShimObject, strShimFunction, throwTypeError,
     ObjClass, ObjProto, ObjAssign, ObjHasOwnProperty, ObjDefineProperty, strShimPrototype
 } from "@microsoft/applicationinsights-shims";
-import { strEmpty } from "./InternalConstants";
 
 // 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
+const strOnPrefix = "on";
+const strAttachEvent = "attachEvent";
+const strAddEventHelper = "addEventListener";
+const strDetachEvent = "detachEvent";
+const strRemoveEventListener = "removeEventListener";
 const strToISOString = "toISOString";
 const cStrEndsWith = "endsWith";
 const cStrStartsWith = "startsWith";
@@ -22,9 +26,9 @@ const strToString = "toString";
  * Constant string defined to support minimization
  * @ignore
  */
-const str__Proto = "__proto__";
+ const str__Proto = "__proto__";
 
-/**
+ /**
   * Constant string defined to support minimization
   * @ignore
   */
@@ -58,27 +62,27 @@ const rLeadingNumeric = /^(\d+[\w\d_$])/;
  * Pre-lookup to check if we are running on a modern browser (i.e. not IE8)
  * @ignore
  */
-let _objGetPrototypeOf = Object["getPrototypeOf"];
+ let _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:any) {
-    if (target) {
-        // This method doesn't existing in older browsers (e.g. IE8)
-        if (_objGetPrototypeOf) {
-            return _objGetPrototypeOf(target);
-        }
+ export function _getObjProto(target:any) {
+     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
-        let newProto = target[str__Proto] || target[strShimPrototype] || target[strConstructor];
-        if(newProto) {
-            return newProto;
-        }
-    }
+         // target[Constructor] May break if the constructor has been changed or removed
+         let newProto = target[str__Proto] || target[strShimPrototype] || target[strConstructor];
+         if(newProto) {
+             return newProto;
+         }
+     }
  
-    return null;
+     return null;
 }
 
 export function objToString(obj: any) {
@@ -89,19 +93,19 @@ export function isTypeof(value: any, theType: string): boolean {
     return typeof value === theType;
 }
 
-export function isUndefined(value: any): value is undefined {
+export function isUndefined(value: any): boolean {
     return value === undefined || typeof value === strShimUndefined;
 }
 
-export function isNotUndefined<T>(value: T): value is T {
+export function isNotUndefined(value: any): boolean {
     return !isUndefined(value);
 }
 
-export function isNullOrUndefined(value: any): value is null | undefined {
+export function isNullOrUndefined(value: any): boolean {
     return (value === null || isUndefined(value));
 }
 
-export function isNotNullOrUndefined<T>(value: T): value is T {
+export function isNotNullOrUndefined(value: any): boolean {
     return !isNullOrUndefined(value);
 }
 
@@ -109,7 +113,7 @@ export function hasOwnProperty(obj: any, prop: string): boolean {
     return !!(obj && ObjHasOwnProperty.call(obj, prop));
 }
 
-export function isObject<T>(value: T): value is T {
+export function isObject(value: any): boolean {
     // Changing to inline for performance
     return !!(value && typeof value === strShimObject);
 }
@@ -119,8 +123,54 @@ export function isFunction(value: any): value is Function {
     return !!(value && typeof value === strShimFunction);
 }
 
-export function isPromiseLike<T>(value: any): value is PromiseLike<T> {
-    return value && isFunction(value.then);
+/**
+ * Binds the specified function to an event, so that the function gets called whenever the event fires on the object
+ * @param obj Object to add the event too.
+ * @param eventNameWithoutOn String that specifies any of the standard DHTML Events without "on" prefix
+ * @param handlerRef Pointer that specifies the function to call when event fires
+ * @param useCapture [Optional] Defaults to false
+ * @returns True if the function was bound successfully to the event, otherwise false
+ */
+export function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture: boolean = false) {
+    let result = false;
+    if (!isNullOrUndefined(obj)) {
+        try {
+            if (!isNullOrUndefined(obj[strAddEventHelper])) {
+                // all browsers except IE before version 9
+                obj[strAddEventHelper](eventNameWithoutOn, handlerRef, useCapture);
+                result = true;
+            } else if (!isNullOrUndefined(obj[strAttachEvent])) {
+                // IE before version 9
+                obj[strAttachEvent](strOnPrefix + eventNameWithoutOn, handlerRef);
+                result = true;
+            }
+        } catch (e) {
+            // Just Ignore any error so that we don't break any execution path
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Removes an event handler for the specified event
+ * @param Object to remove the event from
+ * @param eventNameWithoutOn {string} - The name of the event
+ * @param handlerRef {any} - The callback function that needs to be executed for the given event
+ * @param useCapture [Optional] Defaults to false
+ */
+export function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture: boolean = false) {
+    if (!isNullOrUndefined(obj)) {
+        try {
+            if (!isNullOrUndefined(obj[strRemoveEventListener])) {
+                obj[strRemoveEventListener](eventNameWithoutOn, handlerRef, useCapture);
+            } else if (!isNullOrUndefined(obj[strDetachEvent])) {
+                obj[strDetachEvent](strOnPrefix + eventNameWithoutOn, handlerRef);
+            }
+        } catch (e) {
+            // Just Ignore any error so that we don't break any execution path
+        }
+    }
 }
 
 /**
@@ -154,7 +204,7 @@ export function normalizeJsName(name: string): string {
  * @param target The target object to find and process the keys
  * @param callbackfn The function to call with the details
  */
-export function objForEachKey<T = any>(target: T, callbackfn: (name: string, value: T[keyof T]) => void) {
+export function objForEachKey(target: any, callbackfn: (name: string, value: any) => void) {
     if (target) {
         for (let prop in target) {
             if (ObjHasOwnProperty.call(target, prop)) {
@@ -186,7 +236,7 @@ export function strEndsWith(value: string, search: string) {
  * @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: string, search: string) {
+ export function _strEndsWithPoly(value: string, search: string) {
     let result = false;
     let searchLen = search ? search.length : 0;
     let valLen = value ? value.length : 0;
@@ -214,7 +264,7 @@ export function _strEndsWithPoly(value: string, search: string) {
 export function strStartsWith(value: string, checkValue: string) {
     let 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
+       // 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);
     }
 
@@ -227,7 +277,7 @@ export function strStartsWith(value: string, checkValue: string) {
  * @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: string, checkValue: string) {
+ export function _strStartsWithPoly(value: string, checkValue: string) {
     // Using helper for performance and because string startsWith() is not available on IE
     let result = false;
     let chkLen = checkValue ? checkValue.length : 0;
@@ -265,8 +315,7 @@ export function isDate(obj: any): obj is Date {
 }
 
 /**
- * Check if an object is of type Array with optional generic T, the generic type is not validated
- * and exists to help with TypeScript validation only.
+ * Check if an object is of type Array
  */
 export let isArray: <T = any>(obj: any) => obj is Array<T> = _isArray || _isArrayPoly;
 function _isArrayPoly<T = any>(obj: any): obj is Array<T> {
@@ -328,7 +377,7 @@ export function isPlainObject(value: any): boolean {
     let result: boolean = false;
 
     if (value && typeof value === "object") {
-        // Inlining _objGetPrototypeOf for performance to avoid an additional function call
+            // Inlining _objGetPrototypeOf for performance to avoid an additional function call
         let proto = _objGetPrototypeOf ? _objGetPrototypeOf(value) : _getObjProto(value);
         if (!proto) {
             // No prototype found so this is a plain Object eg. 'Object.create(null)'
@@ -389,7 +438,7 @@ export function _toISOStringPoly(date: Date) {
  * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. It can return -1 to break out of the loop
  * @param thisArg  [Optional] 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 arrForEach<T = any>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => undefined | void | number, thisArg?: any): void {
+export function arrForEach<T>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => void|number, thisArg?: any): void {
     let len = arr.length;
     try {
         for (let idx = 0; idx < len; idx++) {
@@ -615,18 +664,6 @@ function _doNothing<T>(value: T): T {
     return value;
 }
 
-export function deepFreeze<T>(obj: T): T {
-    if (_objFreeze) {
-        objForEachKey(obj, (name, value) => {
-            if (isArray(value) || isObject(value)) {
-                _objFreeze(value);
-            }
-        });
-    }
-
-    return objFreeze(obj);
-}
-
 export const objFreeze: <T>(value: T) => T = _objFreeze || _doNothing;
 export const objSeal: <T>(value: T) => T = _objSeal || _doNothing;
 
@@ -648,7 +685,7 @@ export function getExceptionName(object: any): string {
         return object.name;
     }
 
-    return strEmpty;
+    return "";
 }
 
 /**
@@ -661,7 +698,7 @@ export function getExceptionName(object: any): string {
  * @param srcChk - [Optional] Callback to check to original value that if supplied will be called if the new value should be set (if allowed)
  * @returns The existing or new value, depending what was set
  */
-export function setValue<T, K extends keyof T>(target: T, field: K, value: T[K], valChk?: ((value: T[K]) => boolean) | null, srcChk?: ((value: T[K]) => boolean) | null) {
+export function setValue<T, K extends keyof T>(target: T, field: K, value: T[K], valChk?: (value: T[K]) => boolean, srcChk?: (value: T[K]) => boolean) {
     let theValue = value;
     if (target) {
         theValue = target[field];
@@ -709,28 +746,6 @@ export function throwError(message: string): never {
     throw new Error(message);
 }
 
-function _createProxyFunction<S>(source: S | (() => S), funcName: (keyof S)) {
-    let srcFunc: () => S = null;
-    let src: S = null;
-    if (isFunction (source)) {
-        srcFunc = source;
-    } else {
-        src = source;
-    }
-
-    return function() {
-        // Capture the original arguments passed to the method
-        var originalArguments = arguments;
-        if (srcFunc) {
-            src = srcFunc();
-        }
-
-        if (src) {
-            return (src[funcName] as any).apply(src, originalArguments);
-        }
-    }
-}
-
 /**
  * Effectively assigns all enumerable properties (not just own properties) and functions (including inherited prototype) from
  * the source object to the target, it attempts to use proxy getters / setters (if possible) and proxy functions to avoid potential
@@ -745,9 +760,10 @@ function _createProxyFunction<S>(source: S | (() => S), funcName: (keyof S)) {
  * @param target - The target object to be assigned with the source properties and functions
  * @param source - The source object which will be assigned / called by setting / calling the targets proxies
  * @param chkSet - An optional callback to determine whether a specific property/function should be proxied
+ * @memberof Initialization
  */
-export function proxyAssign<T, S>(target: T, source: S, chkSet?: (name: string, isFunc?: boolean, source?: S, target?: T) => boolean) {
-    if (target && source && isObject(target) && isObject(source)) {
+export function proxyAssign(target: any, source: any, chkSet?: (name: string, isFunc?: boolean, source?: any, target?: any) => boolean) {
+    if (target && source && target !== source && isObject(target) && isObject(source)) {
         // effectively apply/proxy full source to the target instance
         for (const field in source) {
             if (isString(field)) {
@@ -755,12 +771,18 @@ export function proxyAssign<T, S>(target: T, source: S, chkSet?: (name: string,
                 if (isFunction(value)) {
                     if (!chkSet || chkSet(field, true, source, target)) {
                         // Create a proxy function rather than just copying the (possible) prototype to the new object as an instance function
-                        target[field as string] = _createProxyFunction(source, field);
+                        target[field as string] = (function(funcName: string) {
+                            return function() {
+                                // Capture the original arguments passed to the method
+                                var originalArguments = arguments;
+                                return source[funcName].apply(source, originalArguments);
+                            }
+                        })(field);
                     }
                 } else if (!chkSet || chkSet(field, false, source, target)) {
                     if (hasOwnProperty(target, field)) {
                         // Remove any previous instance property
-                        delete (target as any)[field];
+                        delete target[field];
                     }
 
                     if (!objDefineAccessors(target, field, () => {
@@ -781,33 +803,6 @@ export function proxyAssign<T, S>(target: T, source: S, chkSet?: (name: string,
     return target;
 }
 
-export function proxyFunctionAs<T, S>(target: T, name: string, source: S | (() => S), theFunc: (keyof S), overwriteTarget: boolean = true) {
-    if (target && name && source) {
-        if (overwriteTarget || isUndefined(target[name])) {
-            (target as any)[name] = _createProxyFunction(source, theFunc);
-        }
-    }
-}
-
-/**
- * Creates proxy functions on the target which internally will call the source version with all arguments passed to the target method.
- *
- * @param target - The target object to be assigned with the source properties and functions
- * @param source - The source object which will be assigned / called by setting / calling the targets proxies
- * @param functionsToProxy - An array of function names that will be proxied on the target
- */
-export function proxyFunctions<T, S>(target: T, source: S | (() => S), functionsToProxy: (keyof S)[], overwriteTarget: boolean = true) {
-    if (target && source && isObject(target) && isArray(functionsToProxy)) {
-        arrForEach(functionsToProxy, (theFuncName) => {
-            if (isString(theFuncName)) {
-                proxyFunctionAs(target, theFuncName, source, theFuncName, overwriteTarget);
-            }
-        });
-    }
-
-    return target;
-}
-
 /**
  * Simpler helper to create a dynamic class that implements the interface and populates the values with the defaults.
  * Only instance properties (hasOwnProperty) values are copied from the defaults to the new instance
@@ -825,25 +820,6 @@ export function createClassFromInterface<T>(defaults?: T) {
     } as new () => T;
 }
 
-/**
- * Create an enum style object which has both the key => value and value => key mappings
- * @param values - The values to populate on the new object
- * @returns
- */
-export function createEnumStyle<T>(values: T) {
-    let enumClass: any = {};
-    objForEachKey(values, (field, value) => {
-        enumClass[field] = value;
-        // Add Reverse lookup
-        if (!isUndefined(enumClass[value])) {
-            throwError("[" + value + "] exists for " + field);
-        }
-        enumClass[value] = field;
-    });
-
-    return objFreeze(enumClass as T);
-}
-
 /**
  * A helper function to assist with JIT performance for objects that have properties added / removed dynamically
  * this is primarily for chromium based browsers and has limited effects on Firefox and none of IE. Only call this
@@ -871,9 +847,7 @@ export function optimizeObject<T>(theObject: T): T {
  * @param obj5 - object to merge.
  * @returns The extended first object.
  */
-export function objExtend<T2, T3, T4, T5, T6>(deepExtend?: boolean, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T2 & T3 & T4 & T5 & T6
-export function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6
-export function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1 | any, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6 {
+ export function objExtend<T1, T2, T3, T4, T5, T6>(obj?: boolean | T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6 {
     // Variables
     let theArgs = arguments as any;
     let extended: T1 & T2 & T3 & T4 & T5 & T6 = theArgs[0] || {};
@@ -888,7 +862,7 @@ export function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1 | any, obj2?: T2, ob
         idx++;
     }
 
-    // Handle case when target is a string or something (possible in deep copy)
+	// Handle case when target is a string or something (possible in deep copy)
     if (!isObject(extended)) {
         extended = {} as T1 & T2 & T3 & T4 & T5 & T6;
     }

package/src/JavaScriptSDK/InstrumentHooks.ts

@@ -6,7 +6,6 @@ import {
 } from "../JavaScriptSDK.Interfaces/IInstrumentHooks";
 import { strShimFunction, strShimPrototype } from "@microsoft/applicationinsights-shims";
 import { hasOwnProperty, _getObjProto } from "./HelperFuncs";
-import { getGlobalInst } from "./EnvUtils";
 
 const aiInstrumentHooks = "_aiHooks";
 
@@ -73,13 +72,13 @@ function _doCallbacks(hooks:IInstrumentHook[], callDetails: IInstrumentCallDetai
 function _createFunctionHook(aiHook:IInstrumentHooks) {
 
     // Define a temporary method that queues-up a the real method call
-    return function (this: any) {
+    return function () {
         let funcThis = this;
         // Capture the original arguments passed to the method
         let orgArgs = arguments as any;
         let hooks = aiHook.h;
 
-        let funcArgs: IInstrumentCallDetails = {
+        let funcArgs:IInstrumentCallDetails = {
             name: aiHook.n,
             inst: funcThis,
             ctx: null,
@@ -88,7 +87,6 @@ function _createFunctionHook(aiHook:IInstrumentHooks) {
 
         let hookCtx: any[] = [];
         let cbArgs = _createArgs([funcArgs], orgArgs);
-        funcArgs.evt = getGlobalInst("event");
 
         function _createArgs(target:any[], theArgs:any[]): any[] {
             _arrLoop((theArgs as any), (arg) => {