@microsoft/applicationinsights-common 3.0.6-nightly3.2311-01 → 3.0.6-nightly3.2311-02

package/dist/es5/applicationinsights-common.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Common, 3.0.6-nightly3.2311-01
+ * Application Insights JavaScript SDK - Common, 3.0.6-nightly3.2311-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -689,7 +689,7 @@
     var _DYN_WATCH = "watch";
     var _DYN_LOGGER = "logger";
     var _DYN_APPLY = "apply";
-    var _DYN_PUSH = "push";
+    var _DYN_PUSH$1 = "push";
     var _DYN_SPLICE = "splice";
     var _DYN_HDLR = "hdlr";
     var _DYN_CANCEL = "cancel";
@@ -702,8 +702,11 @@
     var _DYN_DIAG_LOG = "diagLog";
     var _DYN_USER_AGENT = "userAgent";
     var _DYN_SPLIT$1 = "split";
+    var _DYN_NODE_TYPE = "nodeType";
     var _DYN_REPLACE = "replace";
     var _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
+    var _DYN_TYPE = "type";
+    var _DYN_HANDLER = "handler";
     var _DYN_TRACE_ID = "traceId";
     var _DYN_SPAN_ID = "spanId";
     var _DYN_TRACE_FLAGS = "traceFlags";
@@ -1220,13 +1223,62 @@
         return result;
     }
 
-    var version = '3.0.6-nightly3.2311-01';
+    var version = '3.0.6-nightly3.2311-02';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
+    function _canAcceptData(target) {
+        return target[_DYN_NODE_TYPE ] === 1 || target[_DYN_NODE_TYPE ] === 9 || !(+target[_DYN_NODE_TYPE ]);
+    }
+    function _getCache(data, target) {
+        var theCache = target[data.id];
+        if (!theCache) {
+            theCache = {};
+            try {
+                if (_canAcceptData(target)) {
+                    objDefine(target, data.id, {
+                        e: false,
+                        v: theCache
+                    });
+                }
+            }
+            catch (e) {
+            }
+        }
+        return theCache;
+    }
     function createUniqueNamespace(name, includeVersion) {
         if (includeVersion === void 0) { includeVersion = false; }
         return normalizeJsName(name + (_dataUid++) + (includeVersion ? "." + version : STR_EMPTY) + instanceName);
     }
+    function createElmNodeData(name) {
+        var data = {
+            id: createUniqueNamespace("_aiData-" + (name || STR_EMPTY) + "." + version),
+            accept: function (target) {
+                return _canAcceptData(target);
+            },
+            get: function (target, name, defValue, addDefault) {
+                var theCache = target[data.id];
+                if (!theCache) {
+                    if (addDefault) {
+                        theCache = _getCache(data, target);
+                        theCache[normalizeJsName(name)] = defValue;
+                    }
+                    return defValue;
+                }
+                return theCache[normalizeJsName(name)];
+            },
+            kill: function (target, name) {
+                if (target && target[name]) {
+                    try {
+                        delete target[name];
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+        };
+        return data;
+    }
 
     function _isConfigDefaults(value) {
         return (value && isObject(value) && (value.isVal || value.fb || objHasOwn(value, "v") || objHasOwn(value, "mrg") || objHasOwn(value, "ref") || value.set));
@@ -1449,7 +1501,7 @@
             trk: function (handler) {
                 if (handler && handler.fn) {
                     if (arrIndexOf(detail.h, handler) === -1) {
-                        detail.h[_DYN_PUSH ](handler);
+                        detail.h[_DYN_PUSH$1 ](handler);
                     }
                     state.trk(handler, detail);
                 }
@@ -1661,7 +1713,7 @@
                                 _useHandler(handler, handler.fn);
                             }
                             catch (e) {
-                                watcherFailures_1[_DYN_PUSH ](e);
+                                watcherFailures_1[_DYN_PUSH$1 ](e);
                             }
                         }
                     }
@@ -1671,7 +1723,7 @@
                         _notifyWatchers();
                     }
                     catch (e) {
-                        watcherFailures_1[_DYN_PUSH ](e);
+                        watcherFailures_1[_DYN_PUSH$1 ](e);
                     }
                 }
                 if (watcherFailures_1[_DYN_LENGTH$1 ] > 0) {
@@ -1693,7 +1745,7 @@
                 for (var idx = 0; idx < detail.h[_DYN_LENGTH$1 ]; idx++) {
                     var handler = detail.h[idx];
                     if (handler && arrIndexOf(_waitingHandlers, handler) === -1) {
-                        _waitingHandlers[_DYN_PUSH ](handler);
+                        _waitingHandlers[_DYN_PUSH$1 ](handler);
                     }
                 }
             }
@@ -1702,7 +1754,7 @@
             if (handler) {
                 var details = handler[dynamicPropertyDetail] = handler[dynamicPropertyDetail] || [];
                 if (arrIndexOf(details, detail) === -1) {
-                    details[_DYN_PUSH ](detail);
+                    details[_DYN_PUSH$1 ](detail);
                 }
             }
         }
@@ -1990,14 +2042,14 @@
                     }
                     if (logMessage) {
                         if (severity <= _loggingLevelTelemetry) {
-                            _self.queue[_DYN_PUSH ](message);
+                            _self.queue[_DYN_PUSH$1 ](message);
                             _messageCount++;
                             _debugExtMsg((severity === 1  ? "error" : "warn"), message);
                         }
                         if (_messageCount === _maxInternalMessageLimit) {
                             var throttleLimitMessage = "Internal events throttle limit per PageView reached for this app.";
                             var throttleMessage = new _InternalLogMessage(23 , throttleLimitMessage, false);
-                            _self.queue[_DYN_PUSH ](throttleMessage);
+                            _self.queue[_DYN_PUSH$1 ](throttleMessage);
                             if (severity === 1 ) {
                                 _self.errorToConsole(throttleLimitMessage);
                             }
@@ -2169,6 +2221,180 @@
         return traceParent;
     }
 
+    var strOnPrefix = "on";
+    var strAttachEvent = "attachEvent";
+    var strAddEventHelper = "addEventListener";
+    var strDetachEvent = "detachEvent";
+    var strRemoveEventListener = "removeEventListener";
+    var strEvents = "events";
+    createUniqueNamespace("aiEvtPageHide");
+    createUniqueNamespace("aiEvtPageShow");
+    var rRemoveEmptyNs = /\.[\.]+/g;
+    var rRemoveTrailingEmptyNs = /[\.]+$/;
+    var _guid = 1;
+    var elmNodeData = createElmNodeData("events");
+    var eventNamespace = /^([^.]*)(?:\.(.+)|)/;
+    function _normalizeNamespace(name) {
+        if (name && name[_DYN_REPLACE ]) {
+            return name[_DYN_REPLACE ](/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY);
+        }
+        return name;
+    }
+    function _getEvtNamespace(eventName, evtNamespace) {
+        var _a;
+        if (evtNamespace) {
+            var theNamespace_1 = STR_EMPTY;
+            if (isArray(evtNamespace)) {
+                theNamespace_1 = STR_EMPTY;
+                arrForEach(evtNamespace, function (name) {
+                    name = _normalizeNamespace(name);
+                    if (name) {
+                        if (name[0] !== ".") {
+                            name = "." + name;
+                        }
+                        theNamespace_1 += name;
+                    }
+                });
+            }
+            else {
+                theNamespace_1 = _normalizeNamespace(evtNamespace);
+            }
+            if (theNamespace_1) {
+                if (theNamespace_1[0] !== ".") {
+                    theNamespace_1 = "." + theNamespace_1;
+                }
+                eventName = (eventName || STR_EMPTY) + theNamespace_1;
+            }
+        }
+        var parsedEvent = (eventNamespace.exec(eventName || STR_EMPTY) || []);
+        return _a = {},
+            _a[_DYN_TYPE ] = parsedEvent[1],
+            _a.ns = ((parsedEvent[2] || STR_EMPTY).replace(rRemoveEmptyNs, ".").replace(rRemoveTrailingEmptyNs, STR_EMPTY)[_DYN_SPLIT$1 ](".").sort()).join("."),
+            _a;
+    }
+    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[_DYN_TYPE ]) {
+            if (obj[strRemoveEventListener]) {
+                obj[strRemoveEventListener](evtName[_DYN_TYPE ], handlerRef, useCapture);
+            }
+            else if (obj[strDetachEvent]) {
+                obj[strDetachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
+            }
+        }
+    }
+    function _doAttach(obj, evtName, handlerRef, useCapture) {
+        var result = false;
+        if (obj && evtName && evtName[_DYN_TYPE ] && handlerRef) {
+            if (obj[strAddEventHelper]) {
+                obj[strAddEventHelper](evtName[_DYN_TYPE ], handlerRef, useCapture);
+                result = true;
+            }
+            else if (obj[strAttachEvent]) {
+                obj[strAttachEvent](strOnPrefix + evtName[_DYN_TYPE ], handlerRef);
+                result = true;
+            }
+        }
+        return result;
+    }
+    function _doUnregister(target, events, evtName, unRegFn) {
+        var idx = events[_DYN_LENGTH$1 ];
+        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[_DYN_HANDLER ], theEvent.capture);
+                        events[_DYN_SPLICE ](idx, 1);
+                    }
+                }
+            }
+        }
+    }
+    function _unregisterEvents(target, evtName, unRegFn) {
+        if (evtName[_DYN_TYPE ]) {
+            _doUnregister(target, _getRegisteredEvents(target, evtName[_DYN_TYPE ]), evtName, unRegFn);
+        }
+        else {
+            var eventCache = elmNodeData.get(target, strEvents, {});
+            objForEachKey(eventCache, function (evtType, events) {
+                _doUnregister(target, events, evtName, unRegFn);
+            });
+            if (objKeys(eventCache)[_DYN_LENGTH$1 ] === 0) {
+                elmNodeData.kill(target, strEvents);
+            }
+        }
+    }
+    function mergeEvtNamespace(theNamespace, namespaces) {
+        var newNamespaces;
+        if (namespaces) {
+            if (isArray(namespaces)) {
+                newNamespaces = [theNamespace].concat(namespaces);
+            }
+            else {
+                newNamespaces = [theNamespace, namespaces];
+            }
+            newNamespaces = (_getEvtNamespace("xx", newNamespaces).ns)[_DYN_SPLIT$1 ](".");
+        }
+        else {
+            newNamespaces = theNamespace;
+        }
+        return newNamespaces;
+    }
+    function eventOn(target, eventName, handlerRef, evtNamespace, useCapture) {
+        var _a;
+        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 = (_a = {
+                            guid: _guid++,
+                            evtName: evtName
+                        },
+                        _a[_DYN_HANDLER ] = handlerRef,
+                        _a.capture = useCapture,
+                        _a);
+                    _getRegisteredEvents(target, evtName.type)[_DYN_PUSH$1 ](registeredEvent);
+                }
+            }
+            catch (e) {
+            }
+        }
+        return result;
+    }
+    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[_DYN_HANDLER ] === handlerRef) {
+                        found_1 = true;
+                        return true;
+                    }
+                    return false;
+                });
+                if (!found_1) {
+                    _doDetach(target, evtName_1, handlerRef, useCapture);
+                }
+            }
+            catch (e) {
+            }
+        }
+    }
+
     var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
     var SampleRate = "sampleRate";
     var ProcessLegacy = "ProcessLegacy";
@@ -2195,6 +2421,7 @@
     var _DYN_TO_LOWER_CASE = "toLowerCase";
     var _DYN_INGESTIONENDPOINT = "ingestionendpoint";
     var _DYN_TO_STRING = "toString";
+    var _DYN_PUSH = "push";
     var _DYN_REMOVE_ITEM = "removeItem";
     var _DYN_NAME = "name";
     var _DYN_MESSAGE = "message";
@@ -2686,7 +2913,7 @@
         var keys = [];
         if (utlCanUseSessionStorage()) {
             objForEachKey(getInst("sessionStorage"), function (key) {
-                keys.push(key);
+                keys[_DYN_PUSH ](key);
             });
         }
         return keys;
@@ -2846,7 +3073,7 @@
                 else {
                     if (!!saveUnsentMsg) {
                         var queue = _getQueueByKey(msgID);
-                        queue.push({
+                        queue[_DYN_PUSH ]({
                             msgID: msgID,
                             message: message,
                             severity: severity
@@ -3225,7 +3452,7 @@
                 entry += "@" + lines[lp + 1];
                 lp++;
             }
-            stack.push(entry);
+            stack[_DYN_PUSH ](entry);
         }
         return {
             src: errorMessage,
@@ -3308,7 +3535,7 @@
                 if (_StackFrame.regex.test(theFrame)) {
                     var parsedFrame = new _StackFrame(theFrame, level_1++);
                     totalSizeInBytes_1 += parsedFrame[_DYN_SIZE_IN_BYTES ];
-                    parsedStack.push(parsedFrame);
+                    parsedStack[_DYN_PUSH ](parsedFrame);
                 }
             });
             var exceptionParsedStackThreshold = 32 * 1024;
@@ -3996,6 +4223,122 @@
         return event;
     }
 
+    function _disableEvents(target, evtNamespace) {
+        eventOff(target, null, null, evtNamespace);
+    }
+    function createOfflineListener(parentEvtNamespace) {
+        var _document = getDocument();
+        var _navigator = getNavigator();
+        var _isListening = false;
+        var listenerList = [];
+        var rState = 1 ;
+        if (_navigator && !isNullOrUndefined(_navigator.onLine) && !_navigator.onLine) {
+            rState = 2 ;
+        }
+        var uState = 0 ;
+        var _currentState = calCurrentState();
+        var _evtNamespace = mergeEvtNamespace(createUniqueNamespace("OfflineListener"), parentEvtNamespace);
+        try {
+            if (_enableEvents(getWindow())) {
+                _isListening = true;
+            }
+            if (_document) {
+                var target = _document.body || _document;
+                if (target.ononline) {
+                    if (_enableEvents(target)) {
+                        _isListening = true;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            _isListening = false;
+        }
+        function _enableEvents(target) {
+            var enabled = false;
+            if (target) {
+                enabled = eventOn(target, "online", _setOnline, _evtNamespace);
+                if (enabled) {
+                    eventOn(target, "offline", _setOffline, _evtNamespace);
+                }
+            }
+            return enabled;
+        }
+        function _isOnline() {
+            return _currentState;
+        }
+        function calCurrentState() {
+            if (uState === 2  || rState === 2 ) {
+                return false;
+            }
+            return true;
+        }
+        function listnerNoticeCheck() {
+            var newState = calCurrentState();
+            if (_currentState !== newState) {
+                _currentState = newState;
+                arrForEach(listenerList, function (callback) {
+                    var offlineState = {
+                        isOnline: _currentState,
+                        rState: rState,
+                        uState: uState
+                    };
+                    try {
+                        callback(offlineState);
+                    }
+                    catch (e) {
+                    }
+                });
+            }
+        }
+        function setOnlineState(newState) {
+            uState = newState;
+            listnerNoticeCheck();
+        }
+        function _setOnline() {
+            rState = 1 ;
+            listnerNoticeCheck();
+        }
+        function _setOffline() {
+            rState = 2 ;
+            listnerNoticeCheck();
+        }
+        function _unload() {
+            var win = getWindow();
+            if (win && _isListening) {
+                _disableEvents(win, _evtNamespace);
+                if (_document) {
+                    var target = _document.body || _document;
+                    if (!isUndefined(target.ononline)) {
+                        _disableEvents(target, _evtNamespace);
+                    }
+                }
+                _isListening = false;
+            }
+        }
+        function addListener(callback) {
+            listenerList[_DYN_PUSH ](callback);
+            return {
+                rm: function () {
+                    var index = listenerList.indexOf(callback);
+                    if (index > -1) {
+                        return listenerList.splice(index, 1);
+                    }
+                    else {
+                        return;
+                    }
+                }
+            };
+        }
+        return {
+            isOnline: _isOnline,
+            isListening: function () { return _isListening; },
+            unload: _unload,
+            addListener: addListener,
+            setOnlineState: setOnlineState
+        };
+    }
+
     var PropertiesPluginIdentifier = "AppInsightsPropertiesPlugin";
     var BreezeChannelIdentifier = "AppInsightsChannelPlugin";
     var AnalyticsPluginIdentifier = "ApplicationInsightsAnalytics";
@@ -4035,6 +4378,7 @@
     exports.correlationIdSetPrefix = correlationIdSetPrefix;
     exports.createDistributedTraceContextFromTrace = createDistributedTraceContextFromTrace;
     exports.createDomEvent = createDomEvent;
+    exports.createOfflineListener = createOfflineListener;
     exports.createTelemetryItem = createTelemetryItem;
     exports.createTraceParent = createTraceParent;
     exports.dataSanitizeException = dataSanitizeException;