@microsoft/applicationinsights-teechannel-js 3.0.1-nightly3.2304-41 → 3.0.1-nightly3.2304-44

package/dist/es5/applicationinsights-teechannel-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Tee Channel, 3.0.1-nightly3.2304-41
+ * Application Insights JavaScript SDK - Tee Channel, 3.0.1-nightly3.2304-44
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -39,7 +39,7 @@
     var ArrCls = Array;
     var ArrProto = ArrCls[PROTOTYPE];
 
-    function _safeGet(cb, defValue) {
+    function safeGet(cb, defValue) {
         var result = defValue;
         try {
             result = cb();
@@ -87,6 +87,9 @@
     var isNumber = _createIs(NUMBER);
     var isBoolean = _createIs(BOOLEAN);
     var isError = _createObjIs("Error");
+    function isPromiseLike(value) {
+        return !!value && isFunction(value.then);
+    }
 
     var objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
 
@@ -313,19 +316,21 @@
         return lazyValue;
     }
 
-    function _lazySafeGet(cb, defValue) {
-        return getLazy(function () { return _safeGet(cb, defValue); });
+    function safeGetLazy(cb, defValue) {
+        return getLazy(function () { return safeGet(cb, defValue); });
     }
 
     var WINDOW = "window";
     var _cachedGlobal;
     var _cachedWindow;
+    var _cachedDocument;
     var _cachedNavigator;
-    function _lazySafeGetInst(name) {
-        return _lazySafeGet(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
+    var _isNode;
+    function lazySafeGetInst(name) {
+        return safeGetLazy(function () { return getInst(name) || UNDEF_VALUE; }, UNDEF_VALUE);
     }
     function getGlobal(useCached) {
-        (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = _lazySafeGet(_getGlobalValue, null));
+        (!_cachedGlobal || useCached === false || (_globalLazyTestHooks.lzy && !_cachedGlobal.b)) && (_cachedGlobal = safeGetLazy(_getGlobalValue, null));
         return _cachedGlobal.v;
     }
     function getInst(name, useCached) {
@@ -338,29 +343,40 @@
         }
         return null;
     }
+    function getDocument() {
+        (!_cachedDocument || (_globalLazyTestHooks.lzy && !_cachedDocument.b)) && (_cachedDocument = lazySafeGetInst("document"));
+        return _cachedDocument.v;
+    }
     function hasWindow() {
         return !!getWindow();
     }
     function getWindow() {
-        (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = _lazySafeGetInst(WINDOW));
+        (!_cachedWindow || (_globalLazyTestHooks.lzy && !_cachedWindow.b)) && (_cachedWindow = lazySafeGetInst(WINDOW));
         return _cachedWindow.v;
     }
     function getNavigator() {
-        (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = _lazySafeGetInst("navigator"));
+        (!_cachedNavigator || (_globalLazyTestHooks.lzy && !_cachedNavigator.b)) && (_cachedNavigator = lazySafeGetInst("navigator"));
         return _cachedNavigator.v;
     }
+    function isNode() {
+        !_isNode && (_isNode = safeGetLazy(function () { return !!(process && (process.versions || {}).node); }, false));
+        return _isNode.v;
+    }
 
     var _symbol;
     var _symbolFor;
     var _symbolKeyFor;
     function _getSymbolValue(name) {
-        return _lazySafeGet(function () {
+        return safeGetLazy(function () {
             return (_symbol.v ? _symbol[name] : UNDEF_VALUE);
         }, UNDEF_VALUE);
     }
+    function hasSymbol() {
+        return !!getSymbol();
+    }
     function getSymbol() {
         var resetCache = !_symbol || (_globalLazyTestHooks && _globalLazyTestHooks.lzy && !_symbol.b);
-        resetCache && (_symbol = _lazySafeGetInst(SYMBOL));
+        resetCache && (_symbol = lazySafeGetInst(SYMBOL));
         (!_symbolFor || resetCache) && (_symbolFor = _getSymbolValue("for"));
         (!_symbolKeyFor || resetCache) && (_symbolKeyFor = _getSymbolValue("keyFor"));
         return _symbol.v;
@@ -932,6 +948,7 @@
     var _DYN_TIME = "time";
     var _DYN_PROCESS_NEXT$1 = "processNext";
     var _DYN_GET_PROCESS_TEL_CONT0 = "getProcessTelContext";
+    var _DYN_UNLOAD = "unload";
     var _DYN_LOGGING_LEVEL_CONSOL4 = "loggingLevelConsole";
     var _DYN_CREATE_NEW = "createNew";
     var _DYN_TEARDOWN$1 = "teardown";
@@ -968,6 +985,278 @@
         throw new aggregationErrorType(theMessage, sourceErrors || []);
     }
 
+    var _theLogger = null;
+    function _debugLog(id, message) {
+        if (_theLogger) {
+            _theLogger(id, message);
+        }
+    }
+
+    var STRING_STATES = [
+        "pending", "resolving", "resolved", "rejected"
+    ];
+
+    var DISPATCH_EVENT = "dispatchEvent";
+    var _hasInitEvent;
+    function emitEvent(target, evtName, populateEvent, useNewEvent) {
+        var doc = getDocument();
+        !_hasInitEvent && (_hasInitEvent = safeGetLazy(function () {
+            var evt;
+            if (doc && doc.createEvent) {
+                evt = doc.createEvent("Event");
+            }
+            return (!!evt && evt.initEvent);
+        }, null));
+        var theEvt = _hasInitEvent.v ? doc.createEvent("Event") : (useNewEvent ? new Event(evtName) : {});
+        populateEvent && populateEvent(theEvt);
+        if (_hasInitEvent.v) {
+            theEvt.initEvent(evtName, false, true);
+        }
+        if (theEvt && target[DISPATCH_EVENT]) {
+            target[DISPATCH_EVENT](theEvt);
+        }
+        else {
+            var handler = target["on" + evtName];
+            if (handler) {
+                handler(theEvt);
+            }
+            else {
+                var theConsole = getInst("console");
+                theConsole && (theConsole["error"] || theConsole["log"])(evtName, dumpObj(theEvt));
+            }
+        }
+    }
+
+    var STR_PROMISE = "Promise";
+
+    var NODE_UNHANDLED_REJECTION = "unhandledRejection";
+    var UNHANDLED_REJECTION = NODE_UNHANDLED_REJECTION.toLowerCase();
+    var _unhandledRejectionTimeout = 10;
+    var _hasPromiseRejectionEvent;
+    function dumpFnObj(value) {
+        if (isFunction(value)) {
+            return value.toString();
+        }
+        return dumpObj(value);
+    }
+    function _createPromise(newPromise, processor, executor) {
+        var additionalArgs = arrSlice(arguments, 3);
+        var _state = 0 ;
+        var _hasResolved = false;
+        var _settledValue;
+        var _queue = [];
+        var _handled = false;
+        var _unHandledRejectionHandler = null;
+        var _thePromise;
+        !_hasPromiseRejectionEvent && (_hasPromiseRejectionEvent = lazySafeGetInst(STR_PROMISE + "RejectionEvent"));
+        var _then = function (onResolved, onRejected) {
+            try {
+                _handled = true;
+                _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
+                _unHandledRejectionHandler = null;
+                _debugLog(_toString(), "then(" + dumpFnObj(onResolved) + ", " + dumpFnObj(onResolved) + ")");
+                var thenPromise = newPromise(function (resolve, reject) {
+                    _queue.push(function () {
+                        try {
+                            _debugLog(_toString(), "Handling settled value " + dumpFnObj(_settledValue));
+                            var handler = _state === 2  ? onResolved : onRejected;
+                            var value = isUndefined(handler) ? _settledValue : (isFunction(handler) ? handler(_settledValue) : handler);
+                            _debugLog(_toString(), "Handling Result " + dumpFnObj(value));
+                            if (isPromiseLike(value)) {
+                                value.then(resolve, reject);
+                            }
+                            else if (handler) {
+                                resolve(value);
+                            }
+                            else if (_state === 3 ) {
+                                reject(value);
+                            }
+                            else {
+                                resolve(value);
+                            }
+                        }
+                        catch (e) {
+                            reject(e);
+                        }
+                    });
+                    _debugLog(_toString(), "Added to Queue " + _queue.length);
+                    if (_hasResolved) {
+                        _processQueue();
+                    }
+                }, additionalArgs);
+                _debugLog(_toString(), "Created -> " + thenPromise.toString());
+                return thenPromise;
+            }
+            finally {
+            }
+        };
+        var _catch = function (onRejected) {
+            return _then(undefined, onRejected);
+        };
+        var _finally = function (onFinally) {
+            var thenFinally = onFinally;
+            var catchFinally = onFinally;
+            if (isFunction(onFinally)) {
+                thenFinally = function (value) {
+                    onFinally && onFinally();
+                    return value;
+                };
+                catchFinally = function (reason) {
+                    onFinally && onFinally();
+                    throw reason;
+                };
+            }
+            return _then(thenFinally, catchFinally);
+        };
+        var _strState = function () {
+            return STRING_STATES[_state];
+        };
+        var _processQueue = function () {
+            if (_queue.length > 0) {
+                var pending = _queue.slice();
+                _queue = [];
+                _debugLog(_toString(), "Processing queue " + pending.length);
+                _handled = true;
+                processor(pending);
+                _debugLog(_toString(), "Processing done");
+                _unHandledRejectionHandler && _unHandledRejectionHandler.cancel();
+                _unHandledRejectionHandler = null;
+            }
+            else {
+                _debugLog(_toString(), "Empty Processing queue ");
+            }
+        };
+        var _createSettleIfFn = function (newState, allowState) {
+            return function (theValue) {
+                if (_state === allowState) {
+                    if (newState === 2  && isPromiseLike(theValue)) {
+                        _state = 1 ;
+                        _debugLog(_toString(), "Resolving");
+                        theValue.then(_createSettleIfFn(2 , 1 ), _createSettleIfFn(3 , 1 ));
+                        return;
+                    }
+                    _state = newState;
+                    _hasResolved = true;
+                    _settledValue = theValue;
+                    _debugLog(_toString(), _strState());
+                    _processQueue();
+                    if (!_handled && newState === 3  && !_unHandledRejectionHandler) {
+                        _unHandledRejectionHandler = scheduleTimeout(_notifyUnhandledRejection, _unhandledRejectionTimeout);
+                    }
+                }
+                else {
+                    _debugLog(_toString(), "Already " + _strState());
+                }
+            };
+        };
+        var _notifyUnhandledRejection = function () {
+            if (!_handled) {
+                if (isNode()) {
+                    _debugLog(_toString(), "Emitting " + NODE_UNHANDLED_REJECTION);
+                    process.emit(NODE_UNHANDLED_REJECTION, _settledValue, _thePromise);
+                }
+                else {
+                    var gbl = getWindow() || getGlobal();
+                    _debugLog(_toString(), "Emitting " + UNHANDLED_REJECTION);
+                    emitEvent(gbl, UNHANDLED_REJECTION, function (theEvt) {
+                        objDefine(theEvt, "promise", { g: function () { return _thePromise; } });
+                        theEvt.reason = _settledValue;
+                        return theEvt;
+                    }, !!_hasPromiseRejectionEvent.v);
+                }
+            }
+        };
+        _thePromise = {
+            then: _then,
+            "catch": _catch,
+            finally: _finally
+        };
+        objDefineProp(_thePromise, "state", {
+            get: _strState
+        });
+        if (hasSymbol()) {
+            _thePromise[getKnownSymbol(11 )] = "IPromise";
+        }
+        var _toString = function () {
+            return "IPromise" + ("") + " " + _strState() + (_hasResolved ? (" - " + dumpFnObj(_settledValue)) : "");
+        };
+        _thePromise.toString = _toString;
+        (function _initialize() {
+            if (!isFunction(executor)) {
+                throwTypeError(STR_PROMISE + ": executor is not a function - " + dumpFnObj(executor));
+            }
+            var _rejectFn = _createSettleIfFn(3 , 0 );
+            try {
+                _debugLog(_toString(), "Executing");
+                executor.call(_thePromise, _createSettleIfFn(2 , 0 ), _rejectFn);
+            }
+            catch (e) {
+                _rejectFn(e);
+            }
+        })();
+        _debugLog(_toString(), "Returning");
+        return _thePromise;
+    }
+
+    var _processPendingItems = function (pending) {
+        arrForEach(pending, function (fn) {
+            try {
+                fn();
+            }
+            catch (e) {
+            }
+        });
+    };
+    function timeoutItemProcessor(timeout) {
+        var callbackTimeout = isNumber(timeout) ? timeout : 0;
+        return function (pending) {
+            scheduleTimeout(function () {
+                _processPendingItems(pending);
+            }, callbackTimeout);
+        };
+    }
+
+    function createAsyncPromise(executor, timeout) {
+        return _createPromise(createAsyncPromise, timeoutItemProcessor(timeout), executor, timeout);
+    }
+
+    var _isPromiseSupported;
+    function createNativePromise(executor, timeout) {
+        !_isPromiseSupported && (_isPromiseSupported = lazySafeGetInst(STR_PROMISE));
+        var PrmCls = _isPromiseSupported.v;
+        if (!PrmCls) {
+            return createAsyncPromise(executor);
+        }
+        if (!isFunction(executor)) {
+            throwTypeError(STR_PROMISE + ": executor is not a function - " + dumpObj(executor));
+        }
+        var _state = 0 ;
+        function _strState() {
+            return STRING_STATES[_state];
+        }
+        var thePromise = new PrmCls(function (resolve, reject) {
+            function _resolve(value) {
+                _state = 2 ;
+                resolve(value);
+            }
+            function _reject(reason) {
+                _state = 3 ;
+                reject(reason);
+            }
+            executor(_resolve, _reject);
+        });
+        objDefineProp(thePromise, "state", {
+            get: _strState
+        });
+        return thePromise;
+    }
+
+    var _promiseCreator;
+    function createPromise(executor, timeout) {
+        !_promiseCreator && (_promiseCreator = getLazy(function () { return createNativePromise; }));
+        return _promiseCreator.v.call(this, executor, timeout);
+    }
+
     var UNDEFINED_VALUE = undefined;
     var STR_EMPTY = "";
     var STR_CORE = "core";
@@ -1151,7 +1440,7 @@
         return result;
     }
 
-    var version = "3.0.1-nightly3.2304-41";
+    var version = "3.0.1-nightly3.2304-44";
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -1746,7 +2035,7 @@
             return handler[_DYN_WATCH ](configHandler);
         }
         _logInvalidAccess(logger, STR_NOT_DYNAMIC_ERROR + dumpObj(config));
-        createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
+        return createDynamicConfig(config, null, logger)[_DYN_WATCH ](configHandler);
     }
 
     function _stringToBoolOrDefault(theValue, defaultValue, theConfig) {
@@ -1841,8 +2130,9 @@
             var _loggingLevelTelemetry;
             var _maxInternalMessageLimit;
             var _enableDebug;
+            var _unloadHandler;
             dynamicProto(DiagnosticLogger, this, function (_self) {
-                _setDefaultsFromConfig(config || {});
+                _unloadHandler = _setDefaultsFromConfig(config || {});
                 _self.consoleLoggingLevel = function () { return _loggingLevelConsole; };
                 _self[_DYN_THROW_INTERNAL ] = function (severity, msgId, msg, properties, isUserAct) {
                     if (isUserAct === void 0) { isUserAct = false; }
@@ -1885,6 +2175,10 @@
                     _messageLogged = {};
                 };
                 _self[_DYN_LOG_INTERNAL_MESSAGE ] = _logInternalMessage;
+                _self[_DYN_UNLOAD ] = function (isAsync) {
+                    _unloadHandler && _unloadHandler.rm();
+                    _unloadHandler = null;
+                };
                 function _logInternalMessage(severity, message) {
                     if (_areInternalMessagesThrottled()) {
                         return;
@@ -1917,8 +2211,7 @@
                     }
                 }
                 function _setDefaultsFromConfig(config) {
-                    var handler = createDynamicConfig(config, defaultValues$1, _self);
-                    handler[_DYN_WATCH ](function (details) {
+                    return onConfigChange(createDynamicConfig(config, defaultValues$1, _self).cfg, function (details) {
                         var config = details.cfg;
                         _loggingLevelConsole = config[_DYN_LOGGING_LEVEL_CONSOL4 ];
                         _loggingLevelTelemetry = config.loggingLevelTelemetry;
@@ -2268,7 +2561,7 @@
         var context = internalContext.ctx;
         function _processNext(unloadState) {
             var nextPlugin = internalContext._next();
-            nextPlugin && nextPlugin.unload(context, unloadState);
+            nextPlugin && nextPlugin[_DYN_UNLOAD ](context, unloadState);
             return !nextPlugin;
         }
         function _createNew(plugins, startAt) {
@@ -2767,7 +3060,13 @@
                 var waiting = 1;
                 var doneIterating = false;
                 var cbTimer = null;
+                var result = true;
                 cbTimeout = cbTimeout || 5000;
+                if (isAsync && !callBack) {
+                    result = createPromise(function (resolve) {
+                        callBack = resolve;
+                    });
+                }
                 function doCallback() {
                     waiting--;
                     if (doneIterating && waiting === 0) {
@@ -2804,7 +3103,7 @@
                     doneIterating = true;
                     doCallback();
                 });
-                return true;
+                return result;
             }
         };
         return channelController;