@microsoft/applicationinsights-core-js 2.8.0-beta.2202-06 → 2.8.0-beta.2203-02

package/dist-esm/JavaScriptSDK/EventHelpers.js

@@ -0,0 +1,472 @@
+/*
+ * Application Insights JavaScript SDK - Core, 2.8.0-beta.2203-02
+ * Copyright (c) Microsoft and contributors. All rights reserved.
+ */
+
+
+import { createElmNodeData, createUniqueNamespace } from "./DataCacheHelper";
+import { getDocument, getWindow } from "./EnvUtils";
+import { arrForEach, arrIndexOf, isArray, objForEachKey, objKeys } from "./HelperFuncs";
+// Added to help with minfication
+var strOnPrefix = "on";
+var strAttachEvent = "attachEvent";
+var strAddEventHelper = "addEventListener";
+var strDetachEvent = "detachEvent";
+var strRemoveEventListener = "removeEventListener";
+var strEvents = "events";
+var strVisibilityChangeEvt = "visibilitychange";
+var strPageHide = "pagehide";
+var strPageShow = "pageshow";
+var strUnload = "unload";
+var strBeforeUnload = "beforeunload";
+var strPageHideNamespace = createUniqueNamespace("aiEvtPageHide");
+var strPageShowNamespace = createUniqueNamespace("aiEvtPageShow");
+var _guid = 1;
+var elmNodeData = createElmNodeData("events");
+var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
+function _normalizeNamespace(name) {
+    if (name && name.replace) {
+        return name.replace(/^\s*\.*|\.*\s*$/g, "");
+    }
+    return name;
+}
+function _getEvtNamespace(eventName, namespaces) {
+    if (namespaces) {
+        var theNamespace_1 = "";
+        if (isArray(namespaces)) {
+            theNamespace_1 = "";
+            arrForEach(namespaces, function (name) {
+                name = _normalizeNamespace(name);
+                if (name) {
+                    if (name[0] !== ".") {
+                        name = "." + name;
+                    }
+                    theNamespace_1 += name;
+                }
+            });
+        }
+        else {
+            theNamespace_1 = _normalizeNamespace(namespaces);
+        }
+        if (theNamespace_1) {
+            if (theNamespace_1[0] !== ".") {
+                theNamespace_1 = "." + theNamespace_1;
+            }
+            // We may only have the namespace and not an eventName
+            eventName = (eventName || "") + theNamespace_1;
+        }
+    }
+    var parsedEvent = (eventNamespace.exec(eventName) || []);
+    return {
+        type: parsedEvent[1],
+        ns: ((parsedEvent[2] || "").split(".").sort()).join(".")
+    };
+}
+/**
+ * Get all of the registered events on the target object, this is primarily used for testing cleanup but may also be used by
+ * applications to remove their own events
+ * @param target - The EventTarget that has registered events
+ * @param evtName - [Optional] The name of the event to return the registered handlers and full name (with namespaces)
+ */
+export function __getRegisteredEvents(target, evtName) {
+    var theEvents = [];
+    var eventCache = elmNodeData.get(target, strEvents, {}, false);
+    objForEachKey(eventCache, function (evtType, registeredEvents) {
+        arrForEach(registeredEvents, function (value) {
+            if (!evtName || evtName === value.evtName.type) {
+                theEvents.push({
+                    name: value.evtName.type + (value.evtName.ns ? "." + value.evtName.ns : ""),
+                    handler: value.handler
+                });
+            }
+        });
+    });
+    return theEvents;
+}
+// Exported for internal unit testing only
+function _getRegisteredEvents(target, evtName, addDefault) {
+    if (addDefault === void 0) { addDefault = true; }
+    var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);
+    var registeredEvents = aiEvts[evtName];
+    if (!registeredEvents) {
+        registeredEvents = aiEvts[evtName] = [];
+    }
+    return registeredEvents;
+}
+function _doDetach(obj, evtName, handlerRef, useCapture) {
+    if (obj && evtName && evtName.type) {
+        if (obj[strRemoveEventListener]) {
+            obj[strRemoveEventListener](evtName.type, handlerRef, useCapture);
+        }
+        else if (obj[strDetachEvent]) {
+            obj[strDetachEvent](strOnPrefix + evtName.type, handlerRef);
+        }
+    }
+}
+function _doAttach(obj, evtName, handlerRef, useCapture) {
+    var result = false;
+    if (obj && evtName && evtName.type && handlerRef) {
+        if (obj[strAddEventHelper]) {
+            // all browsers except IE before version 9
+            obj[strAddEventHelper](evtName.type, handlerRef, useCapture);
+            result = true;
+        }
+        else if (obj[strAttachEvent]) {
+            // IE before version 9
+            obj[strAttachEvent](strOnPrefix + evtName.type, handlerRef);
+            result = true;
+        }
+    }
+    return result;
+}
+function _doUnregister(target, events, evtName, unRegFn) {
+    var idx = events.length;
+    while (idx--) {
+        var theEvent = events[idx];
+        if (theEvent) {
+            if (!evtName.ns || evtName.ns === theEvent.evtName.ns) {
+                if (!unRegFn || unRegFn(theEvent)) {
+                    _doDetach(target, theEvent.evtName, theEvent.handler, theEvent.capture);
+                    // Remove the registered event
+                    events.splice(idx, 1);
+                }
+            }
+        }
+    }
+}
+function _unregisterEvents(target, evtName, unRegFn) {
+    if (evtName.type) {
+        _doUnregister(target, _getRegisteredEvents(target, evtName.type), evtName, unRegFn);
+    }
+    else {
+        var eventCache = elmNodeData.get(target, strEvents, {});
+        objForEachKey(eventCache, function (evtType, events) {
+            _doUnregister(target, events, evtName, unRegFn);
+        });
+        // Cleanup
+        if (objKeys(eventCache).length === 0) {
+            elmNodeData.kill(target, strEvents);
+        }
+    }
+}
+export function mergeEvtNamespace(theNamespace, namespaces) {
+    var newNamespaces;
+    if (namespaces) {
+        if (isArray(namespaces)) {
+            newNamespaces = [theNamespace].concat(namespaces);
+        }
+        else {
+            newNamespaces = [theNamespace, namespaces];
+        }
+    }
+    else {
+        newNamespaces = theNamespace;
+    }
+    return newNamespaces;
+}
+/**
+ * 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 eventName String that specifies any of the standard DHTML Events without "on" prefix, if may also include an optional (dot "." prefixed)
+ * namespaces "click" "click.mynamespace" in addition to specific namespaces.
+ * @param handlerRef Pointer that specifies the function to call when event fires
+ * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,
+ * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
+ * @param useCapture [Optional] Defaults to false
+ * @returns True if the function was bound successfully to the event, otherwise false
+ */
+export function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
+    if (useCapture === void 0) { useCapture = false; }
+    var result = false;
+    if (target) {
+        try {
+            var evtName = _getEvtNamespace(eventName, evtNamespace);
+            result = _doAttach(target, evtName, handlerRef, useCapture);
+            if (result && elmNodeData.accept(target)) {
+                var registeredEvent = {
+                    guid: _guid++,
+                    evtName: evtName,
+                    handler: handlerRef,
+                    capture: useCapture
+                };
+                _getRegisteredEvents(target, evtName.type).push(registeredEvent);
+            }
+        }
+        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 eventName {string} - The name of the event, with optional namespaces or just the namespaces,
+ * such as "click", "click.mynamespace" or ".mynamespace"
+ * @param handlerRef {any} - The callback function that needs to be removed from the given event, when using a
+ * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
+ * otherwise this will only remove events with this specific handler.
+ * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,
+ * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
+ * @param useCapture [Optional] Defaults to false
+ */
+export function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {
+    if (useCapture === void 0) { useCapture = false; }
+    if (target) {
+        try {
+            var evtName_1 = _getEvtNamespace(eventName, evtNamespace);
+            var found_1 = false;
+            _unregisterEvents(target, evtName_1, function (regEvent) {
+                if ((evtName_1.ns && !handlerRef) || regEvent.handler === handlerRef) {
+                    found_1 = true;
+                    return true;
+                }
+                return false;
+            });
+            if (!found_1) {
+                // fallback to try and remove as requested
+                _doDetach(target, evtName_1, handlerRef, useCapture);
+            }
+        }
+        catch (e) {
+            // Just Ignore any error so that we don't break any execution path
+        }
+    }
+}
+/**
+ * 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 and optional (dot "." prefixed) namespaces "click" "click.mynamespace".
+ * @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, eventNameWithoutOn, handlerRef, useCapture) {
+    if (useCapture === void 0) { useCapture = false; }
+    return eventOn(obj, eventNameWithoutOn, handlerRef, null, useCapture);
+}
+/**
+ * Removes an event handler for the specified event
+ * @param Object to remove the event from
+ * @param eventNameWithoutOn {string} - The name of the event, with optional namespaces or just the namespaces,
+ * such as "click", "click.mynamespace" or ".mynamespace"
+ * @param handlerRef {any} - The callback function that needs to be removed from the given event, when using a
+ * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
+ * otherwise this will only remove events with this specific handler.
+ * @param useCapture [Optional] Defaults to false
+ */
+export function detachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {
+    if (useCapture === void 0) { useCapture = false; }
+    eventOff(obj, eventNameWithoutOn, handlerRef, null, useCapture);
+}
+/**
+ * Trys to add an event handler for the specified event to the window, body and document
+ * @param eventName {string} - The name of the event
+ * @param callback {any} - The callback function that needs to be executed for the given event
+ * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
+ * @return {boolean} - true if the handler was successfully added
+ */
+export function addEventHandler(eventName, callback, evtNamespace) {
+    var result = false;
+    var w = getWindow();
+    if (w) {
+        result = eventOn(w, eventName, callback, evtNamespace);
+        result = eventOn(w["body"], eventName, callback, evtNamespace) || result;
+    }
+    var doc = getDocument();
+    if (doc) {
+        result = eventOn(doc, eventName, callback, evtNamespace) || result;
+    }
+    return result;
+}
+/**
+ * Trys to remove event handler(s) for the specified event/namespace to the window, body and document
+ * @param eventName {string} - The name of the event, with optional namespaces or just the namespaces,
+ * such as "click", "click.mynamespace" or ".mynamespace"
+ * @param callback {any} - - The callback function that needs to be removed from the given event, when using a
+ * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
+ * otherwise this will only remove events with this specific handler.
+ * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
+ */
+export function removeEventHandler(eventName, callback, evtNamespace) {
+    var w = getWindow();
+    if (w) {
+        eventOff(w, eventName, callback, evtNamespace);
+        eventOff(w["body"], eventName, callback, evtNamespace);
+    }
+    var doc = getDocument();
+    if (doc) {
+        eventOff(doc, eventName, callback, evtNamespace);
+    }
+}
+/**
+ * Bind the listener to the array of events
+ * @param events An string array of event names to bind the listener to
+ * @param listener The event callback to call when the event is triggered
+ * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
+ * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+function _addEventListeners(events, listener, excludeEvents, evtNamespace) {
+    var added = false;
+    if (listener && events && events.length > 0) {
+        arrForEach(events, function (name) {
+            if (name) {
+                if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {
+                    added = addEventHandler(name, listener, evtNamespace) || added;
+                }
+            }
+        });
+    }
+    return added;
+}
+/**
+ * Bind the listener to the array of events
+ * @param events An string array of event names to bind the listener to
+ * @param listener The event callback to call when the event is triggered
+ * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
+ * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+// export function addEventListeners(events: string[], listener: any, excludeEvents?: string[], evtNamespace?: string): boolean {
+export function addEventListeners(events, listener, excludeEvents, evtNamespace) {
+    var added = false;
+    if (listener && events && isArray(events)) {
+        added = _addEventListeners(events, listener, excludeEvents, evtNamespace);
+        if (!added && excludeEvents && excludeEvents.length > 0) {
+            // Failed to add any listeners and we excluded some, so just attempt to add the excluded events
+            added = _addEventListeners(events, listener, null, evtNamespace);
+        }
+    }
+    return added;
+}
+/**
+ * Remove the listener from the array of events
+ * @param events An string array of event names to bind the listener to
+ * @param listener The event callback to call when the event is triggered
+ * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
+ */
+export function removeEventListeners(events, listener, evtNamespace) {
+    if (events && isArray(events)) {
+        arrForEach(events, function (name) {
+            if (name) {
+                removeEventHandler(name, listener, evtNamespace);
+            }
+        });
+    }
+}
+/**
+ * Listen to the 'beforeunload', 'unload' and 'pagehide' events which indicates a page unload is occurring,
+ * this does NOT listen to the 'visibilitychange' event as while it does indicate that the page is being hidden
+ * it does not *necessarily* mean that the page is being completely unloaded, it can mean that the user is
+ * just navigating to a different Tab and may come back (without unloading the page). As such you may also
+ * need to listen to the 'addPageHideEventListener' and 'addPageShowEventListener' events.
+ * @param listener - The event callback to call when a page unload event is triggered
+ * @param excludeEvents - [Optional] An array of events that should not be hooked, unless no other events can be.
+ * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+//export function addPageUnloadEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string): boolean {
+export function addPageUnloadEventListener(listener, excludeEvents, evtNamespace) {
+    // Hook the unload event for the document, window and body to ensure that the client events are flushed to the server
+    // As just hooking the window does not always fire (on chrome) for page navigation's.
+    return addEventListeners([strBeforeUnload, strUnload, strPageHide], listener, excludeEvents, evtNamespace);
+}
+/**
+ * Remove any matching 'beforeunload', 'unload' and 'pagehide' events that may have been added via addEventListener,
+ * addEventListeners, addPageUnloadEventListener or addPageHideEventListener.
+ * @param listener - The specific event callback to to be removed
+ * @param evtNamespace - [Optional] Namespace(s) uniquely identified and removed based on this namespace.
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+export function removePageUnloadEventListener(listener, evtNamespace) {
+    removeEventListeners([strBeforeUnload, strUnload, strPageHide], listener, evtNamespace);
+}
+/**
+ * Listen to the pagehide and visibility changing to 'hidden' events, because the 'visibilitychange' uses
+ * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call
+ * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.
+ * @param listener - The event callback to call when a page hide event is triggered
+ * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
+ * @param evtNamespace - [Optional] A Namespace to append to the event listeners so they can be uniquely identified and removed
+ * based on this namespace. This call also adds an additional unique "pageshow" namespace to the events
+ * so that only the matching "removePageHideEventListener" can remove these events.
+ * Suggestion: pass as true if you are also calling addPageUnloadEventListener as that also hooks pagehide
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+//export function addPageHideEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string): boolean {
+export function addPageHideEventListener(listener, excludeEvents, evtNamespace) {
+    function _handlePageVisibility(evt) {
+        var doc = getDocument();
+        if (listener && doc && doc.visibilityState === "hidden") {
+            listener(evt);
+        }
+    }
+    // add the unique page show namespace to any provided namespace so we can only remove the ones added by "pagehide"
+    var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
+    var pageUnloadAdded = _addEventListeners([strPageHide], listener, excludeEvents, newNamespaces);
+    if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
+        pageUnloadAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageUnloadAdded;
+    }
+    if (!pageUnloadAdded && excludeEvents) {
+        // Failed to add any listeners and we where requested to exclude some, so just call again without excluding anything
+        pageUnloadAdded = addPageHideEventListener(listener, null, evtNamespace);
+    }
+    return pageUnloadAdded;
+}
+/**
+ * Removes the pageHide event listeners added by addPageHideEventListener, because the 'visibilitychange' uses
+ * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageHideEventListener
+ * as the remove ignores the listener argument for the 'visibilitychange' event.
+ * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')
+ * @param evtNamespace - The unique namespace used when calling addPageShowEventListener
+ */
+export function removePageHideEventListener(listener, evtNamespace) {
+    // add the unique page show namespace to any provided namespace so we only remove the ones added by "pagehide"
+    var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
+    removeEventListeners([strPageHide], listener, newNamespaces);
+    removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
+}
+/**
+ * Listen to the pageshow and visibility changing to 'visible' events, because the 'visibilitychange' uses
+ * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call
+ * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.
+ * @param listener - The event callback to call when a page is show event is triggered
+ * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
+ * @param evtNamespace - [Optional/Recommended] A Namespace to append to the event listeners so they can be uniquely
+ * identified and removed based on this namespace. This call also adds an additional unique "pageshow" namespace to the events
+ * so that only the matching "removePageShowEventListener" can remove these events.
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+//export function addPageShowEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string): boolean {
+export function addPageShowEventListener(listener, excludeEvents, evtNamespace) {
+    function _handlePageVisibility(evt) {
+        var doc = getDocument();
+        if (listener && doc && doc.visibilityState === "visible") {
+            listener(evt);
+        }
+    }
+    // add the unique page show namespace to any provided namespace so we can only remove the ones added by "pageshow"
+    var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
+    var pageShowAdded = _addEventListeners([strPageShow], listener, excludeEvents, newNamespaces);
+    pageShowAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageShowAdded;
+    if (!pageShowAdded && excludeEvents) {
+        // Failed to add any listeners and we where requested to exclude some, so just call again without excluding anything
+        pageShowAdded = addPageShowEventListener(listener, null, evtNamespace);
+    }
+    return pageShowAdded;
+}
+/**
+ * Removes the pageShow event listeners added by addPageShowEventListener, because the 'visibilitychange' uses
+ * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageShowEventListener
+ * as the remove ignores the listener argument for the 'visibilitychange' event.
+ * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')
+ * @param evtNamespace - The unique namespace used when calling addPageShowEventListener
+ */
+export function removePageShowEventListener(listener, evtNamespace) {
+    // add the unique page show namespace to any provided namespace so we only remove the ones added by "pageshow"
+    var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
+    removeEventListeners([strPageShow], listener, newNamespaces);
+    removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);
+}
+//# sourceMappingURL=EventHelpers.js.map

package/dist-esm/JavaScriptSDK/EventHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventHelpers.js.map","sources":["EventHelpers.js"],"sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved.\r\n// Licensed under the MIT License.\r\nimport { createElmNodeData, createUniqueNamespace } from \"./DataCacheHelper\";\r\nimport { getDocument, getWindow } from \"./EnvUtils\";\r\nimport { arrForEach, arrIndexOf, isArray, objForEachKey, objKeys } from \"./HelperFuncs\";\r\n// Added to help with minfication\r\nvar strOnPrefix = \"on\";\r\nvar strAttachEvent = \"attachEvent\";\r\nvar strAddEventHelper = \"addEventListener\";\r\nvar strDetachEvent = \"detachEvent\";\r\nvar strRemoveEventListener = \"removeEventListener\";\r\nvar strEvents = \"events\";\r\nvar strVisibilityChangeEvt = \"visibilitychange\";\r\nvar strPageHide = \"pagehide\";\r\nvar strPageShow = \"pageshow\";\r\nvar strUnload = \"unload\";\r\nvar strBeforeUnload = \"beforeunload\";\r\nvar strPageHideNamespace = createUniqueNamespace(\"aiEvtPageHide\");\r\nvar strPageShowNamespace = createUniqueNamespace(\"aiEvtPageShow\");\r\nvar _guid = 1;\r\nvar elmNodeData = createElmNodeData(\"events\");\r\nvar eventNamespace = /^([^.]*)(?:\\.(.+)|)/;\r\nfunction _normalizeNamespace(name) {\r\n    if (name && name.replace) {\r\n        return name.replace(/^\\s*\\.*|\\.*\\s*$/g, \"\");\r\n    }\r\n    return name;\r\n}\r\nfunction _getEvtNamespace(eventName, namespaces) {\r\n    if (namespaces) {\r\n        var theNamespace_1 = \"\";\r\n        if (isArray(namespaces)) {\r\n            theNamespace_1 = \"\";\r\n            arrForEach(namespaces, function (name) {\r\n                name = _normalizeNamespace(name);\r\n                if (name) {\r\n                    if (name[0] !== \".\") {\r\n                        name = \".\" + name;\r\n                    }\r\n                    theNamespace_1 += name;\r\n                }\r\n            });\r\n        }\r\n        else {\r\n            theNamespace_1 = _normalizeNamespace(namespaces);\r\n        }\r\n        if (theNamespace_1) {\r\n            if (theNamespace_1[0] !== \".\") {\r\n                theNamespace_1 = \".\" + theNamespace_1;\r\n            }\r\n            // We may only have the namespace and not an eventName\r\n            eventName = (eventName || \"\") + theNamespace_1;\r\n        }\r\n    }\r\n    var parsedEvent = (eventNamespace.exec(eventName) || []);\r\n    return {\r\n        type: parsedEvent[1],\r\n        ns: ((parsedEvent[2] || \"\").split(\".\").sort()).join(\".\")\r\n    };\r\n}\r\n/**\r\n * Get all of the registered events on the target object, this is primarily used for testing cleanup but may also be used by\r\n * applications to remove their own events\r\n * @param target - The EventTarget that has registered events\r\n * @param evtName - [Optional] The name of the event to return the registered handlers and full name (with namespaces)\r\n */\r\nexport function __getRegisteredEvents(target, evtName) {\r\n    var theEvents = [];\r\n    var eventCache = elmNodeData.get(target, strEvents, {}, false);\r\n    objForEachKey(eventCache, function (evtType, registeredEvents) {\r\n        arrForEach(registeredEvents, function (value) {\r\n            if (!evtName || evtName === value.evtName.type) {\r\n                theEvents.push({\r\n                    name: value.evtName.type + (value.evtName.ns ? \".\" + value.evtName.ns : \"\"),\r\n                    handler: value.handler\r\n                });\r\n            }\r\n        });\r\n    });\r\n    return theEvents;\r\n}\r\n// Exported for internal unit testing only\r\nfunction _getRegisteredEvents(target, evtName, addDefault) {\r\n    if (addDefault === void 0) { addDefault = true; }\r\n    var aiEvts = elmNodeData.get(target, strEvents, {}, addDefault);\r\n    var registeredEvents = aiEvts[evtName];\r\n    if (!registeredEvents) {\r\n        registeredEvents = aiEvts[evtName] = [];\r\n    }\r\n    return registeredEvents;\r\n}\r\nfunction _doDetach(obj, evtName, handlerRef, useCapture) {\r\n    if (obj && evtName && evtName.type) {\r\n        if (obj[strRemoveEventListener]) {\r\n            obj[strRemoveEventListener](evtName.type, handlerRef, useCapture);\r\n        }\r\n        else if (obj[strDetachEvent]) {\r\n            obj[strDetachEvent](strOnPrefix + evtName.type, handlerRef);\r\n        }\r\n    }\r\n}\r\nfunction _doAttach(obj, evtName, handlerRef, useCapture) {\r\n    var result = false;\r\n    if (obj && evtName && evtName.type && handlerRef) {\r\n        if (obj[strAddEventHelper]) {\r\n            // all browsers except IE before version 9\r\n            obj[strAddEventHelper](evtName.type, handlerRef, useCapture);\r\n            result = true;\r\n        }\r\n        else if (obj[strAttachEvent]) {\r\n            // IE before version 9\r\n            obj[strAttachEvent](strOnPrefix + evtName.type, handlerRef);\r\n            result = true;\r\n        }\r\n    }\r\n    return result;\r\n}\r\nfunction _doUnregister(target, events, evtName, unRegFn) {\r\n    var idx = events.length;\r\n    while (idx--) {\r\n        var theEvent = events[idx];\r\n        if (theEvent) {\r\n            if (!evtName.ns || evtName.ns === theEvent.evtName.ns) {\r\n                if (!unRegFn || unRegFn(theEvent)) {\r\n                    _doDetach(target, theEvent.evtName, theEvent.handler, theEvent.capture);\r\n                    // Remove the registered event\r\n                    events.splice(idx, 1);\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\nfunction _unregisterEvents(target, evtName, unRegFn) {\r\n    if (evtName.type) {\r\n        _doUnregister(target, _getRegisteredEvents(target, evtName.type), evtName, unRegFn);\r\n    }\r\n    else {\r\n        var eventCache = elmNodeData.get(target, strEvents, {});\r\n        objForEachKey(eventCache, function (evtType, events) {\r\n            _doUnregister(target, events, evtName, unRegFn);\r\n        });\r\n        // Cleanup\r\n        if (objKeys(eventCache).length === 0) {\r\n            elmNodeData.kill(target, strEvents);\r\n        }\r\n    }\r\n}\r\nexport function mergeEvtNamespace(theNamespace, namespaces) {\r\n    var newNamespaces;\r\n    if (namespaces) {\r\n        if (isArray(namespaces)) {\r\n            newNamespaces = [theNamespace].concat(namespaces);\r\n        }\r\n        else {\r\n            newNamespaces = [theNamespace, namespaces];\r\n        }\r\n    }\r\n    else {\r\n        newNamespaces = theNamespace;\r\n    }\r\n    return newNamespaces;\r\n}\r\n/**\r\n * Binds the specified function to an event, so that the function gets called whenever the event fires on the object\r\n * @param obj Object to add the event too.\r\n * @param eventName String that specifies any of the standard DHTML Events without \"on\" prefix, if may also include an optional (dot \".\" prefixed)\r\n * namespaces \"click\" \"click.mynamespace\" in addition to specific namespaces.\r\n * @param handlerRef Pointer that specifies the function to call when event fires\r\n * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,\r\n * if the eventName also includes a namespace the namespace(s) are merged into a single namespace\r\n * @param useCapture [Optional] Defaults to false\r\n * @returns True if the function was bound successfully to the event, otherwise false\r\n */\r\nexport function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {\r\n    if (useCapture === void 0) { useCapture = false; }\r\n    var result = false;\r\n    if (target) {\r\n        try {\r\n            var evtName = _getEvtNamespace(eventName, evtNamespace);\r\n            result = _doAttach(target, evtName, handlerRef, useCapture);\r\n            if (result && elmNodeData.accept(target)) {\r\n                var registeredEvent = {\r\n                    guid: _guid++,\r\n                    evtName: evtName,\r\n                    handler: handlerRef,\r\n                    capture: useCapture\r\n                };\r\n                _getRegisteredEvents(target, evtName.type).push(registeredEvent);\r\n            }\r\n        }\r\n        catch (e) {\r\n            // Just Ignore any error so that we don't break any execution path\r\n        }\r\n    }\r\n    return result;\r\n}\r\n/**\r\n * Removes an event handler for the specified event\r\n * @param Object to remove the event from\r\n * @param eventName {string} - The name of the event, with optional namespaces or just the namespaces,\r\n * such as \"click\", \"click.mynamespace\" or \".mynamespace\"\r\n * @param handlerRef {any} - The callback function that needs to be removed from the given event, when using a\r\n * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers\r\n * otherwise this will only remove events with this specific handler.\r\n * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,\r\n * if the eventName also includes a namespace the namespace(s) are merged into a single namespace\r\n * @param useCapture [Optional] Defaults to false\r\n */\r\nexport function eventOff(target, eventName, handlerRef, evtNamespace, useCapture) {\r\n    if (useCapture === void 0) { useCapture = false; }\r\n    if (target) {\r\n        try {\r\n            var evtName_1 = _getEvtNamespace(eventName, evtNamespace);\r\n            var found_1 = false;\r\n            _unregisterEvents(target, evtName_1, function (regEvent) {\r\n                if ((evtName_1.ns && !handlerRef) || regEvent.handler === handlerRef) {\r\n                    found_1 = true;\r\n                    return true;\r\n                }\r\n                return false;\r\n            });\r\n            if (!found_1) {\r\n                // fallback to try and remove as requested\r\n                _doDetach(target, evtName_1, handlerRef, useCapture);\r\n            }\r\n        }\r\n        catch (e) {\r\n            // Just Ignore any error so that we don't break any execution path\r\n        }\r\n    }\r\n}\r\n/**\r\n * Binds the specified function to an event, so that the function gets called whenever the event fires on the object\r\n * @param obj Object to add the event too.\r\n * @param eventNameWithoutOn String that specifies any of the standard DHTML Events without \"on\" prefix and optional (dot \".\" prefixed) namespaces \"click\" \"click.mynamespace\".\r\n * @param handlerRef Pointer that specifies the function to call when event fires\r\n * @param useCapture [Optional] Defaults to false\r\n * @returns True if the function was bound successfully to the event, otherwise false\r\n */\r\nexport function attachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {\r\n    if (useCapture === void 0) { useCapture = false; }\r\n    return eventOn(obj, eventNameWithoutOn, handlerRef, null, useCapture);\r\n}\r\n/**\r\n * Removes an event handler for the specified event\r\n * @param Object to remove the event from\r\n * @param eventNameWithoutOn {string} - The name of the event, with optional namespaces or just the namespaces,\r\n * such as \"click\", \"click.mynamespace\" or \".mynamespace\"\r\n * @param handlerRef {any} - The callback function that needs to be removed from the given event, when using a\r\n * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers\r\n * otherwise this will only remove events with this specific handler.\r\n * @param useCapture [Optional] Defaults to false\r\n */\r\nexport function detachEvent(obj, eventNameWithoutOn, handlerRef, useCapture) {\r\n    if (useCapture === void 0) { useCapture = false; }\r\n    eventOff(obj, eventNameWithoutOn, handlerRef, null, useCapture);\r\n}\r\n/**\r\n * Trys to add an event handler for the specified event to the window, body and document\r\n * @param eventName {string} - The name of the event\r\n * @param callback {any} - The callback function that needs to be executed for the given event\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n * @return {boolean} - true if the handler was successfully added\r\n */\r\nexport function addEventHandler(eventName, callback, evtNamespace) {\r\n    var result = false;\r\n    var w = getWindow();\r\n    if (w) {\r\n        result = eventOn(w, eventName, callback, evtNamespace);\r\n        result = eventOn(w[\"body\"], eventName, callback, evtNamespace) || result;\r\n    }\r\n    var doc = getDocument();\r\n    if (doc) {\r\n        result = eventOn(doc, eventName, callback, evtNamespace) || result;\r\n    }\r\n    return result;\r\n}\r\n/**\r\n * Trys to remove event handler(s) for the specified event/namespace to the window, body and document\r\n * @param eventName {string} - The name of the event, with optional namespaces or just the namespaces,\r\n * such as \"click\", \"click.mynamespace\" or \".mynamespace\"\r\n * @param callback {any} - - The callback function that needs to be removed from the given event, when using a\r\n * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers\r\n * otherwise this will only remove events with this specific handler.\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n */\r\nexport function removeEventHandler(eventName, callback, evtNamespace) {\r\n    var w = getWindow();\r\n    if (w) {\r\n        eventOff(w, eventName, callback, evtNamespace);\r\n        eventOff(w[\"body\"], eventName, callback, evtNamespace);\r\n    }\r\n    var doc = getDocument();\r\n    if (doc) {\r\n        eventOff(doc, eventName, callback, evtNamespace);\r\n    }\r\n}\r\n/**\r\n * Bind the listener to the array of events\r\n * @param events An string array of event names to bind the listener to\r\n * @param listener The event callback to call when the event is triggered\r\n * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\nfunction _addEventListeners(events, listener, excludeEvents, evtNamespace) {\r\n    var added = false;\r\n    if (listener && events && events.length > 0) {\r\n        arrForEach(events, function (name) {\r\n            if (name) {\r\n                if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {\r\n                    added = addEventHandler(name, listener, evtNamespace) || added;\r\n                }\r\n            }\r\n        });\r\n    }\r\n    return added;\r\n}\r\n/**\r\n * Bind the listener to the array of events\r\n * @param events An string array of event names to bind the listener to\r\n * @param listener The event callback to call when the event is triggered\r\n * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\n// export function addEventListeners(events: string[], listener: any, excludeEvents?: string[], evtNamespace?: string): boolean {\r\nexport function addEventListeners(events, listener, excludeEvents, evtNamespace) {\r\n    var added = false;\r\n    if (listener && events && isArray(events)) {\r\n        added = _addEventListeners(events, listener, excludeEvents, evtNamespace);\r\n        if (!added && excludeEvents && excludeEvents.length > 0) {\r\n            // Failed to add any listeners and we excluded some, so just attempt to add the excluded events\r\n            added = _addEventListeners(events, listener, null, evtNamespace);\r\n        }\r\n    }\r\n    return added;\r\n}\r\n/**\r\n * Remove the listener from the array of events\r\n * @param events An string array of event names to bind the listener to\r\n * @param listener The event callback to call when the event is triggered\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n */\r\nexport function removeEventListeners(events, listener, evtNamespace) {\r\n    if (events && isArray(events)) {\r\n        arrForEach(events, function (name) {\r\n            if (name) {\r\n                removeEventHandler(name, listener, evtNamespace);\r\n            }\r\n        });\r\n    }\r\n}\r\n/**\r\n * Listen to the 'beforeunload', 'unload' and 'pagehide' events which indicates a page unload is occurring,\r\n * this does NOT listen to the 'visibilitychange' event as while it does indicate that the page is being hidden\r\n * it does not *necessarily* mean that the page is being completely unloaded, it can mean that the user is\r\n * just navigating to a different Tab and may come back (without unloading the page). As such you may also\r\n * need to listen to the 'addPageHideEventListener' and 'addPageShowEventListener' events.\r\n * @param listener - The event callback to call when a page unload event is triggered\r\n * @param excludeEvents - [Optional] An array of events that should not be hooked, unless no other events can be.\r\n * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\n//export function addPageUnloadEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string): boolean {\r\nexport function addPageUnloadEventListener(listener, excludeEvents, evtNamespace) {\r\n    // Hook the unload event for the document, window and body to ensure that the client events are flushed to the server\r\n    // As just hooking the window does not always fire (on chrome) for page navigation's.\r\n    return addEventListeners([strBeforeUnload, strUnload, strPageHide], listener, excludeEvents, evtNamespace);\r\n}\r\n/**\r\n * Remove any matching 'beforeunload', 'unload' and 'pagehide' events that may have been added via addEventListener,\r\n * addEventListeners, addPageUnloadEventListener or addPageHideEventListener.\r\n * @param listener - The specific event callback to to be removed\r\n * @param evtNamespace - [Optional] Namespace(s) uniquely identified and removed based on this namespace.\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\nexport function removePageUnloadEventListener(listener, evtNamespace) {\r\n    removeEventListeners([strBeforeUnload, strUnload, strPageHide], listener, evtNamespace);\r\n}\r\n/**\r\n * Listen to the pagehide and visibility changing to 'hidden' events, because the 'visibilitychange' uses\r\n * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call\r\n * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.\r\n * @param listener - The event callback to call when a page hide event is triggered\r\n * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.\r\n * @param evtNamespace - [Optional] A Namespace to append to the event listeners so they can be uniquely identified and removed\r\n * based on this namespace. This call also adds an additional unique \"pageshow\" namespace to the events\r\n * so that only the matching \"removePageHideEventListener\" can remove these events.\r\n * Suggestion: pass as true if you are also calling addPageUnloadEventListener as that also hooks pagehide\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\n//export function addPageHideEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string): boolean {\r\nexport function addPageHideEventListener(listener, excludeEvents, evtNamespace) {\r\n    function _handlePageVisibility(evt) {\r\n        var doc = getDocument();\r\n        if (listener && doc && doc.visibilityState === \"hidden\") {\r\n            listener(evt);\r\n        }\r\n    }\r\n    // add the unique page show namespace to any provided namespace so we can only remove the ones added by \"pagehide\"\r\n    var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);\r\n    var pageUnloadAdded = _addEventListeners([strPageHide], listener, excludeEvents, newNamespaces);\r\n    if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {\r\n        pageUnloadAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageUnloadAdded;\r\n    }\r\n    if (!pageUnloadAdded && excludeEvents) {\r\n        // Failed to add any listeners and we where requested to exclude some, so just call again without excluding anything\r\n        pageUnloadAdded = addPageHideEventListener(listener, null, evtNamespace);\r\n    }\r\n    return pageUnloadAdded;\r\n}\r\n/**\r\n * Removes the pageHide event listeners added by addPageHideEventListener, because the 'visibilitychange' uses\r\n * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageHideEventListener\r\n * as the remove ignores the listener argument for the 'visibilitychange' event.\r\n * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')\r\n * @param evtNamespace - The unique namespace used when calling addPageShowEventListener\r\n */\r\nexport function removePageHideEventListener(listener, evtNamespace) {\r\n    // add the unique page show namespace to any provided namespace so we only remove the ones added by \"pagehide\"\r\n    var newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);\r\n    removeEventListeners([strPageHide], listener, newNamespaces);\r\n    removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);\r\n}\r\n/**\r\n * Listen to the pageshow and visibility changing to 'visible' events, because the 'visibilitychange' uses\r\n * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call\r\n * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.\r\n * @param listener - The event callback to call when a page is show event is triggered\r\n * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.\r\n * @param evtNamespace - [Optional/Recommended] A Namespace to append to the event listeners so they can be uniquely\r\n * identified and removed based on this namespace. This call also adds an additional unique \"pageshow\" namespace to the events\r\n * so that only the matching \"removePageShowEventListener\" can remove these events.\r\n * @returns true - when at least one of the events was registered otherwise false\r\n */\r\n//export function addPageShowEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string): boolean {\r\nexport function addPageShowEventListener(listener, excludeEvents, evtNamespace) {\r\n    function _handlePageVisibility(evt) {\r\n        var doc = getDocument();\r\n        if (listener && doc && doc.visibilityState === \"visible\") {\r\n            listener(evt);\r\n        }\r\n    }\r\n    // add the unique page show namespace to any provided namespace so we can only remove the ones added by \"pageshow\"\r\n    var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);\r\n    var pageShowAdded = _addEventListeners([strPageShow], listener, excludeEvents, newNamespaces);\r\n    pageShowAdded = _addEventListeners([strVisibilityChangeEvt], _handlePageVisibility, excludeEvents, newNamespaces) || pageShowAdded;\r\n    if (!pageShowAdded && excludeEvents) {\r\n        // Failed to add any listeners and we where requested to exclude some, so just call again without excluding anything\r\n        pageShowAdded = addPageShowEventListener(listener, null, evtNamespace);\r\n    }\r\n    return pageShowAdded;\r\n}\r\n/**\r\n * Removes the pageShow event listeners added by addPageShowEventListener, because the 'visibilitychange' uses\r\n * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageShowEventListener\r\n * as the remove ignores the listener argument for the 'visibilitychange' event.\r\n * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')\r\n * @param evtNamespace - The unique namespace used when calling addPageShowEventListener\r\n */\r\nexport function removePageShowEventListener(listener, evtNamespace) {\r\n    // add the unique page show namespace to any provided namespace so we only remove the ones added by \"pageshow\"\r\n    var newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);\r\n    removeEventListeners([strPageShow], listener, newNamespaces);\r\n    removeEventListeners([strVisibilityChangeEvt], null, newNamespaces);\r\n}\r\n//# sourceMappingURL=EventHelpers.js.map"],"names":[],"mappings":";;;;AAA4D;AAC1B;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA"}

package/dist-esm/JavaScriptSDK/HelperFuncs.js

@@ -1,17 +1,13 @@
 /*
- * Application Insights JavaScript SDK - Core, 2.8.0-beta.2202-06
+ * Application Insights JavaScript SDK - Core, 2.8.0-beta.2203-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 
 
 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
-var strOnPrefix = "on";
-var strAttachEvent = "attachEvent";
-var strAddEventHelper = "addEventListener";
-var strDetachEvent = "detachEvent";
-var strRemoveEventListener = "removeEventListener";
 var strToISOString = "toISOString";
 var cStrEndsWith = "endsWith";
 var cStrStartsWith = "startsWith";
@@ -100,58 +96,8 @@ export function isFunction(value) {
     // Changing to inline for performance
     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
- * @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, eventNameWithoutOn, handlerRef, useCapture) {
-    if (useCapture === void 0) { useCapture = false; }
-    var 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, eventNameWithoutOn, handlerRef, useCapture) {
-    if (useCapture === void 0) { useCapture = 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
-        }
-    }
+export function isPromiseLike(value) {
+    return value && isFunction(value.then);
 }
 /**
  * Validates that the string name conforms to the JS IdentifierName specification and if not
@@ -586,6 +532,16 @@ export function objDefineAccessors(target, prop, getProp, setProp) {
 function _doNothing(value) {
     return value;
 }
+export function deepFreeze(obj) {
+    if (_objFreeze) {
+        objForEachKey(obj, function (name, value) {
+            if (isArray(value) || isObject(value)) {
+                _objFreeze(value);
+            }
+        });
+    }
+    return objFreeze(obj);
+}
 export var objFreeze = _objFreeze || _doNothing;
 export var objSeal = _objSeal || _doNothing;
 /**
@@ -603,7 +559,7 @@ export function getExceptionName(object) {
     if (isError(object)) {
         return object.name;
     }
-    return "";
+    return strEmpty;
 }
 /**
  * Sets the provided value on the target instance using the field name when the provided chk function returns true, the chk
@@ -772,6 +728,23 @@ export function createClassFromInterface(defaults) {
         return class_1;
     }());
 }
+/**
+ * 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(values) {
+    var enumClass = {};
+    objForEachKey(values, function (field, value) {
+        enumClass[field] = value;
+        // Add Reverse lookup
+        if (!isUndefined(enumClass[value])) {
+            throwError("Value: [" + value + "] already exists for " + field);
+        }
+        enumClass[value] = field;
+    });
+    return objFreeze(enumClass);
+}
 /**
  * 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