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

package/browser/es5/{applicationinsights-teechannel-js.3.0.1-nightly3.2304-41.cjs.js → applicationinsights-teechannel-js.3.0.1-nightly3.2304-44.cjs.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.
  */
 'use strict';
@@ -35,7 +35,7 @@ var StrProto = StrCls[PROTOTYPE];
 var ArrCls = Array;
 var ArrProto = ArrCls[PROTOTYPE];
 
-function _safeGet(cb, defValue) {
+function safeGet(cb, defValue) {
     var result = defValue;
     try {
         result = cb();
@@ -83,6 +83,9 @@ var isArray = ArrCls.isArray;
 var isNumber = _createIs(NUMBER);
 var isBoolean = _createIs(BOOLEAN);
 var isError = _createObjIs("Error");
+function isPromiseLike(value) {
+    return !!value && isFunction(value.then);
+}
 
 var objGetOwnPropertyDescriptor = ObjClass.getOwnPropertyDescriptor;
 
@@ -309,19 +312,21 @@ function getLazy(cb) {
     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) {
@@ -334,29 +339,40 @@ function getInst(name, useCached) {
     }
     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;
@@ -928,6 +944,7 @@ var _DYN_NAME = "name";
 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";
@@ -964,6 +981,278 @@ function throwAggregationError(message, sourceErrors) {
     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";
@@ -1147,7 +1436,7 @@ function newId(maxLength) {
     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) {
@@ -1742,7 +2031,7 @@ function onConfigChange(config, configHandler, logger) {
         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) {
@@ -1837,8 +2126,9 @@ var DiagnosticLogger = /** @class */ (function () {
         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; }
@@ -1881,6 +2171,10 @@ var DiagnosticLogger = /** @class */ (function () {
                 _messageLogged = {};
             };
             _self[_DYN_LOG_INTERNAL_MESSAGE ] = _logInternalMessage;
+            _self[_DYN_UNLOAD ] = function (isAsync) {
+                _unloadHandler && _unloadHandler.rm();
+                _unloadHandler = null;
+            };
             function _logInternalMessage(severity, message) {
                 if (_areInternalMessagesThrottled()) {
                     return;
@@ -1913,8 +2207,7 @@ var DiagnosticLogger = /** @class */ (function () {
                 }
             }
             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;
@@ -2264,7 +2557,7 @@ function createProcessTelemetryUnloadContext(telemetryChain, core, startAt) {
     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) {
@@ -2763,7 +3056,13 @@ function createChannelControllerPlugin() {
             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) {
@@ -2800,7 +3099,7 @@ function createChannelControllerPlugin() {
                 doneIterating = true;
                 doCallback();
             });
-            return true;
+            return result;
         }
     };
     return channelController;
@@ -2915,4 +3214,4 @@ var TeeChannel = /** @class */ (function (_super) {
 }(BaseTelemetryPlugin));
 
 exports.TeeChannel = TeeChannel;
-//# sourceMappingURL=applicationinsights-teechannel-js.3.0.1-nightly3.2304-41.cjs.js.map
+//# sourceMappingURL=applicationinsights-teechannel-js.3.0.1-nightly3.2304-44.cjs.js.map