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

package/src/JavaScriptSDK/ChannelController.ts

@@ -1,135 +1,274 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-"use strict";
+// // Licensed under the MIT License.
 
-import dynamicProto from "@microsoft/dynamicproto-js";
-import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore"
-import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
+import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
+import { TelemetryUnloadReason } from "../JavaScriptSDK.Enums/TelemetryUnloadReason";
+import { TelemetryUpdateReason } from "../JavaScriptSDK.Enums/TelemetryUpdateReason";
+import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IChannelControls } from "../JavaScriptSDK.Interfaces/IChannelControls";
-import { IPlugin, ITelemetryPlugin  } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
-import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
+import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
+import { IBaseProcessingContext, IProcessTelemetryContext, IProcessTelemetryUnloadContext, IProcessTelemetryUpdateContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
-import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
-import { _InternalLogMessage } from "./DiagnosticLogger";
-import { BaseTelemetryPlugin } from "./BaseTelemetryPlugin";
-import { ProcessTelemetryContext } from "./ProcessTelemetryContext";
+import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
+import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
+import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
+import { ITelemetryUpdateState } from "../JavaScriptSDK.Interfaces/ITelemetryUpdateState";
+import { arrForEach, isArray, objFreeze, throwError } from "./HelperFuncs";
+import { strPause, strProcessNext, strResume, strTeardown } from "./InternalConstants";
+import { createProcessTelemetryContext, createTelemetryProxyChain } from "./ProcessTelemetryContext";
 import { initializePlugins } from "./TelemetryHelpers";
-import { arrForEach, objDefineAccessors, throwError } from "./HelperFuncs";
 
-const ChannelControllerPriority = 500;
-const ChannelValidationMessage = "Channel has invalid priority";
+export const ChannelControllerPriority = 500;
+const ChannelValidationMessage = "Channel has invalid priority - ";
 
-export class ChannelController extends BaseTelemetryPlugin {
+export interface IChannelController extends IChannelControls {
+    flush(isAsync: boolean, callBack: (flushComplete?: boolean) => void, sendReason: SendRequestReason, cbTimeout?: number): void;
 
-    identifier: string = "ChannelControllerPlugin";
-    priority: number = ChannelControllerPriority; // in reserved range 100 to 200
+    getChannel<T extends IPlugin = IPlugin>(pluginIdentifier: string): T;
+}
 
-    public setNextPlugin: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
+export interface IInternalChannelController extends IChannelController {
+    _setQueue: (channels: _IInternalChannels[]) => void;
+}
 
-    constructor() {
-        super();
-        let _channelQueue: IChannelControls[][];
+export interface _IInternalChannels {
+    queue: IChannelControls[];
+    chain: ITelemetryPluginChain;
+}
 
-        dynamicProto(ChannelController, this, (_self, _base) => {
-            _self.setNextPlugin = (next: ITelemetryPlugin | ITelemetryPluginChain) => {
-                // The Channel controller is last in pipeline
-            };
+function _addChannelQueue(channelQueue: _IInternalChannels[], queue: IChannelControls[], config: IConfiguration, core: IAppInsightsCore) {
+    if (queue && isArray(queue) && queue.length > 0) {
+        queue = queue.sort((a, b) => { // sort based on priority within each queue
+            return a.priority - b.priority;
+        });
 
-            _self.processTelemetry = (item: ITelemetryItem, itemCtx: IProcessTelemetryContext) => {
-                if (_channelQueue) {
-                    arrForEach(_channelQueue, queues => {
-                        // pass on to first item in queue
-                        if (queues.length > 0) {
-                            // Copying the item context as we could have mutiple chains that are executing asynchronously
-                            // and calling _getDefTelCtx as it's possible that the caller doesn't pass any context
-                            let chainCtx = this._getTelCtx(itemCtx).createNew(queues);
-                            chainCtx.processNext(item);
-                        }
-                    });
-                }
-            };
-
-            _self.getChannelControls = (): IChannelControls[][] => {
-                return _channelQueue;
-            };
-                
-            _self.initialize = (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[]) => {
-                if (_self.isInitialized()) {
-                    // already initialized
-                    return;
-                }
+        arrForEach(queue, queueItem => {
+            if (queueItem.priority < ChannelControllerPriority) {
+                throwError(ChannelValidationMessage + queueItem.identifier);
+            }
+        });
+
+        channelQueue.push({
+            queue: objFreeze(queue),
+            chain: createTelemetryProxyChain(queue, config, core)
+        });
+    }
+}
+
+export function createChannelControllerPlugin(channelQueue: _IInternalChannels[], core: IAppInsightsCore): IChannelController {
+
+    function _getTelCtx() {
+        return createProcessTelemetryContext(null, core.config, core, null)
+    }
 
-                _base.initialize(config, core, extensions);
+    function _processChannelQueue<T extends IBaseProcessingContext>(theChannels: _IInternalChannels[], itemCtx: T, processFn: (chainCtx: T) => void, onComplete: (() => void) | null) {
+        let waiting = theChannels ? (theChannels.length + 1) : 1;
 
-                _createChannelQueues((config||{}).channels, extensions);
-        
-                // Initialize the Queues
-                arrForEach(_channelQueue, queue => initializePlugins(new ProcessTelemetryContext(queue, config, core), extensions));
+        function _runChainOnComplete() {
+            waiting --;
+
+            if (waiting === 0) {
+                onComplete && onComplete();
+                onComplete = null;
             }
+        }
+
+        if (waiting > 0) {
+            arrForEach(theChannels, (channels) => {
+                // pass on to first item in queue
+                if (channels && channels.queue.length > 0) {
+                    let channelChain = channels.chain;
+                    let chainCtx = itemCtx.createNew(channelChain) as T;
+                    chainCtx.onComplete(_runChainOnComplete);
+
+                    // Cause this chain to start processing
+                    processFn(chainCtx);
+                } else {
+                    waiting --;
+                }
+            });
+        }
+
+        _runChainOnComplete();
+    }
+
+    function _doUpdate(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState) {
+        let theUpdateState: ITelemetryUpdateState = updateState || {
+            reason: TelemetryUpdateReason.Unknown
+        };
+
+        _processChannelQueue(channelQueue, updateCtx, (chainCtx: IProcessTelemetryUpdateContext) => {
+            chainCtx[strProcessNext](theUpdateState);
+        }, () => {
+            updateCtx[strProcessNext](theUpdateState);
+        });
+
+        return true;
+    }
+
+    function _doTeardown(unloadCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) {
+        let theUnloadState: ITelemetryUnloadState = unloadState || {
+            reason: TelemetryUnloadReason.ManualTeardown,
+            isAsync: false
+        };
+
+        _processChannelQueue(channelQueue, unloadCtx, (chainCtx: IProcessTelemetryUnloadContext) => {
+            chainCtx[strProcessNext](theUnloadState);
+        }, () => {
+            unloadCtx[strProcessNext](theUnloadState);
+            isInitialized = false;
         });
 
-        function _checkQueuePriority(queue:IChannelControls[]) {
-            arrForEach(queue, queueItem => {
-                if (queueItem.priority < ChannelControllerPriority) {
-                    throwError(ChannelValidationMessage + queueItem.identifier);
+        return true;
+    }
+
+    function _getChannel<T extends IPlugin = IPlugin>(pluginIdentifier: string): T {
+        let thePlugin: T = null;
+
+        if (channelQueue && channelQueue.length > 0) {
+            arrForEach(channelQueue, (channels) => {
+                // pass on to first item in queue
+                if (channels && channels.queue.length > 0) {
+                    arrForEach(channels.queue, (ext: any) => {
+                        if (ext.identifier === pluginIdentifier) {
+                            thePlugin = ext;
+                            // Cause arrForEach to stop iterating
+                            return -1;
+                        }
+                    });
+
+                    if (thePlugin) {
+                        // Cause arrForEach to stop iterating
+                        return -1;
+                    }
                 }
             });
         }
-        
-        function _addChannelQueue(queue:IChannelControls[]) {
-            if (queue && queue.length > 0) {
-                queue = queue.sort((a, b) => { // sort based on priority within each queue
-                    return a.priority - b.priority;
+
+        return thePlugin;
+    }
+
+    let isInitialized = false;
+    let channelController: IInternalChannelController = {
+        identifier: "ChannelControllerPlugin",
+        priority: ChannelControllerPriority,
+        initialize: (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain) => {
+            isInitialized = true;
+            arrForEach(channelQueue, (channels) => {
+                if (channels && channels.queue.length > 0) {
+                    initializePlugins(createProcessTelemetryContext(channels.chain, config, core), extensions);
+                }
+            });
+        },
+        isInitialized: () => {
+            return isInitialized
+        },
+        processTelemetry: (item: ITelemetryItem, itemCtx: IProcessTelemetryContext) => {
+            _processChannelQueue(channelQueue, itemCtx || _getTelCtx(), (chainCtx: IProcessTelemetryContext) => {
+                chainCtx[strProcessNext](item);
+            }, () => {
+                itemCtx[strProcessNext](item);
+            });
+        },
+        update: _doUpdate,
+        [strPause]: () => {
+            _processChannelQueue(channelQueue, _getTelCtx(), (chainCtx: IProcessTelemetryContext) => {
+                chainCtx.iterate<IChannelControls>((plugin) => {
+                    plugin[strPause] && plugin[strPause]();
                 });
-        
-                _checkQueuePriority(queue);
-                _channelQueue.push(queue);
-            }
-        }
-        
-        function _createChannelQueues(channels:IChannelControls[][], extensions: IPlugin[]) {
-            _channelQueue = [];
-        
-            if (channels) {
-                // Add and sort the configuration channel queues
-                arrForEach(channels, queue => _addChannelQueue(queue));
+            }, null);
+        },
+        [strResume]: () => {
+            _processChannelQueue(channelQueue, _getTelCtx(), (chainCtx: IProcessTelemetryContext) => {
+                chainCtx.iterate<IChannelControls>((plugin) => {
+                    plugin[strResume] && plugin[strResume]();
+                });
+            }, null);
+        },
+        [strTeardown]: _doTeardown,
+        getChannel: _getChannel,
+        flush: (isAsync: boolean, callBack: (flushComplete?: boolean) => void, sendReason: SendRequestReason, cbTimeout?: number) => {
+            // Setting waiting to one so that we don't call the callBack until we finish iterating
+            let waiting = 1;
+            let doneIterating = false;
+            let cbTimer: any = null;
+
+            cbTimeout = cbTimeout || 5000;
+
+            function doCallback() {
+                waiting--;
+                if (doneIterating && waiting === 0) {
+                    if (cbTimer) {
+                        clearTimeout(cbTimer);
+                        cbTimer = null;
+                    }
+
+                    callBack && callBack(doneIterating);
+                    callBack = null;
+                }
             }
-        
-            if (extensions) {
-                // Create a new channel queue for any extensions with a priority > the ChannelControllerPriority
-                let extensionQueue:IChannelControls[] = [];
-                arrForEach(extensions as IChannelControls[], plugin => {
-                    if (plugin.priority > ChannelControllerPriority) {
-                        extensionQueue.push(plugin);
+
+            _processChannelQueue(channelQueue, _getTelCtx(), (chainCtx: IProcessTelemetryContext) => {
+                chainCtx.iterate<IChannelControls>((plugin) => {
+                    if (plugin.flush) {
+                        waiting ++;
+
+                        let handled = false;
+                        // Not all channels will call this callback for every scenario
+                        if (!plugin.flush(isAsync, () => {
+                            handled = true;
+                            doCallback();
+                        }, sendReason)) {
+                            if (!handled) {
+                                // If any channel doesn't return true and it didn't call the callback, then we should assume that the callback
+                                // will never be called, so use a timeout to allow the channel(s) some time to "finish" before triggering any
+                                // followup function (such as unloading)
+                                if (isAsync && cbTimer == null) {
+                                    cbTimer = setTimeout(() => {
+                                        cbTimer = null;
+                                        doCallback();
+                                    }, cbTimeout);
+                                } else {
+                                    doCallback();
+                                }
+                            }
+                        }
                     }
                 });
-            
-                _addChannelQueue(extensionQueue);
-            }
+            }, () => {
+                doneIterating = true;
+                doCallback();
+            });
+
+            return true;
+        },
+        _setQueue: (queue: _IInternalChannels[]) => {
+            channelQueue = queue;
         }
-    }
+    };
 
-    public processTelemetry(item: ITelemetryItem, itemCtx: IProcessTelemetryContext) {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-    }
+    return channelController;
+}
+
+export function createChannelQueues(channels: IChannelControls[][], extensions: IPlugin[], config: IConfiguration, core: IAppInsightsCore) {
+    let channelQueue: _IInternalChannels[] = [];
 
-    public getChannelControls(): IChannelControls[][] {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
-        return null;
+    if (channels) {
+        // Add and sort the configuration channel queues
+        arrForEach(channels, queue => _addChannelQueue(channelQueue, queue, config, core));
     }
 
-    public initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[]) {
-        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+    if (extensions) {
+        // Create a new channel queue for any extensions with a priority > the ChannelControllerPriority
+        let extensionQueue: IChannelControls[] = [];
+        arrForEach(extensions as IChannelControls[], plugin => {
+            if (plugin.priority > ChannelControllerPriority) {
+                extensionQueue.push(plugin);
+            }
+        });
+    
+        _addChannelQueue(channelQueue, extensionQueue, config, core);
     }
 
-    /**
-     * Static constructor, attempt to create accessors
-     */
-    // tslint:disable-next-line
-    private static _staticInit = (() => {
-        let proto = ChannelController.prototype;
-        // Dynamically create get/set property accessors
-        objDefineAccessors(proto, "ChannelControls", proto.getChannelControls);
-        objDefineAccessors(proto, "channelQueue", proto.getChannelControls);
-    })();
+    return channelQueue;
 }

package/src/JavaScriptSDK/CookieMgr.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { ICookieMgr, ICookieMgrConfig } from "../JavaScriptSDK.Interfaces/ICookieMgr";
-import { _InternalMessageId, LoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
+import { _eInternalMessageId, eLoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
 import { dumpObj, getDocument, getLocation, getNavigator, isIE } from "./EnvUtils";
 import {
     arrForEach, dateNow, getExceptionName, isFunction, isNotNullOrUndefined, isNullOrUndefined, isString, isTruthy, isUndefined,
@@ -10,6 +10,8 @@ import {
 } from "./HelperFuncs";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
+import { strEmpty } from "./InternalConstants";
+import { _throwInternal } from "./DiagnosticLogger";
 
 const strToGMTString = "toGMTString";
 const strToUTCString = "toUTCString";
@@ -19,7 +21,6 @@ const strEnabled = "enabled";
 const strIsCookieUseDisabled = "isCookieUseDisabled";
 const strDisableCookiesUsage = "disableCookiesUsage";
 const strConfigCookieMgr = "_ckMgr";
-const strEmpty = "";
 
 let _supportsCookies: boolean = null;
 let _allowUaSameSite: boolean = null;
@@ -252,9 +253,10 @@ export function areCookiesSupported(logger?: IDiagnosticLogger): any {
             let doc = _doc || {} as Document;
             _supportsCookies = doc[strCookie] !== undefined;
         } catch (e) {
-            logger && logger.throwInternal(
-                LoggingSeverity.WARNING,
-                _InternalMessageId.CannotAccessCookie,
+            _throwInternal(
+                logger,
+                eLoggingSeverity.WARNING,
+                _eInternalMessageId.CannotAccessCookie,
                 "Cannot access document.cookie - " + getExceptionName(e),
                 { exception: dumpObj(e) });
         }

package/src/JavaScriptSDK/CoreUtils.ts

@@ -6,158 +6,21 @@ import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { _gblCookieMgr } from "./CookieMgr";
-import { getWindow, getDocument, getPerformance, isIE }  from "./EnvUtils";
+import { getPerformance, isIE }  from "./EnvUtils";
 import {
-    arrForEach, arrIndexOf, arrMap, arrReduce, attachEvent, dateNow, detachEvent, hasOwnProperty,
+    arrForEach, arrIndexOf, arrMap, arrReduce, dateNow, hasOwnProperty,
     isArray, isBoolean, isDate, isError, isFunction, isNullOrUndefined, isNumber, isObject, isString, isTypeof,
     isUndefined, objDefineAccessors, objKeys, strTrim, toISOString
 } from "./HelperFuncs";
-import { randomValue, random32, mwcRandomSeed, mwcRandom32 } from "./RandomHelper";
-
-const strVisibilityChangeEvt: string = "visibilitychange";
-const strPageHide: string = "pagehide";
-const strPageShow: string = "pageshow";
+import { addEventHandler, attachEvent, detachEvent } from "./EventHelpers";
+import { randomValue, random32, mwcRandomSeed, mwcRandom32, newId } from "./RandomHelper";
+import { strEmpty } from "./InternalConstants";
 
 let _cookieMgrs: ICookieMgr[] = null;
 let _canUseCookies: boolean;    // legacy supported config
 
 // Added to help with minfication
 export const Undefined = strShimUndefined;
-
-/**
- * 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
- * @return {boolean} - true if the handler was successfully added
- */
-export function addEventHandler(eventName: string, callback: any): boolean {
-    let result = false;
-    let w = getWindow();
-    if (w) {
-        result = attachEvent(w, eventName, callback);
-        result = attachEvent(w["body"], eventName, callback) || result;
-    }
-
-    let doc = getDocument();
-    if (doc) {
-        result = attachEvent(doc, eventName, callback) || result;
-    }
-
-    return result;
-}
-
-/**
- * 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.
- * @returns true - when at least one of the events was registered otherwise false
- */
- export function addEventListeners(events: string[], listener: any, excludeEvents?: string[]): boolean {
-    let added = false;
-
-    if (listener && events && isArray(events)) {
-        let excluded: string[] = [];
-        arrForEach(events, (name) => {
-            if (isString(name)) {
-                if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {
-                    added = addEventHandler(name, listener) || added;
-                } else {
-                    excluded.push(name);
-                }
-            }
-        });
-
-        if (!added && excluded.length > 0) {
-            // Failed to add any listeners and we excluded some, so just attempt to add the excluded events
-            added = addEventListeners(excluded, listener);
-        }
-    }
-
-    return added;
-}
-
-/**
- * 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.
- * @returns true - when at least one of the events was registered otherwise false
- */
-export function addPageUnloadEventListener(listener: any, excludeEvents?: string[]): boolean {
-    // 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(["beforeunload", "unload", "pagehide"], listener, excludeEvents);
-}
-
-/**
- * Listen to the pagehide and visibility changing to 'hidden' events
- * @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.
- * 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[]): boolean {
-
-    function _handlePageVisibility(evt: any) {
-        let doc = getDocument();
-        if (listener && doc && doc.visibilityState === "hidden") {
-            listener(evt);
-        }
-    }
-
-    let pageUnloadAdded = false;
-    if (!excludeEvents || arrIndexOf(excludeEvents, strPageHide) === -1) {
-        pageUnloadAdded = addEventHandler(strPageHide, listener);
-    }
-
-    if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
-        pageUnloadAdded = addEventHandler(strVisibilityChangeEvt, _handlePageVisibility) || 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);
-    }
-
-    return pageUnloadAdded;
-}
-
-/**
- * Listen to the pageshow and visibility changing to 'visible' events
- * @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.
- * @returns true - when at least one of the events was registered otherwise false
- */
- export function addPageShowEventListener(listener: any, excludeEvents?: string[]): boolean {
-
-    function _handlePageVisibility(evt: any) {
-        let doc = getDocument();
-        if (listener && doc && doc.visibilityState === "visible") {
-            listener(evt);
-        }
-    }
-
-    let pageShowAdded = false;
-    if (!excludeEvents || arrIndexOf(excludeEvents, strPageShow) === -1) {
-        pageShowAdded = addEventHandler(strPageShow, listener);
-    }
-
-    if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
-        pageShowAdded = addEventHandler(strVisibilityChangeEvt, _handlePageVisibility) || 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);
-    }
-
-    return pageShowAdded;
-}
-
 export function newGuid(): string {
     function randomHexDigit() {
         return randomValue(15); // Get a random value from 0..15
@@ -182,33 +45,6 @@ export function perfNow(): number {
     return dateNow();
 }
 
-/**
- * Generate random base64 id string.
- * The default length is 22 which is 132-bits so almost the same as a GUID but as base64 (the previous default was 5)
- * @param maxLength - Optional value to specify the length of the id to be generated, defaults to 22
- */
-export function newId(maxLength = 22): string {
-    const base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-    // Start with an initial random number, consuming the value in reverse byte order
-    let number = random32() >>> 0;  // Make sure it's a +ve number
-    let chars = 0;
-    let result = "";
-    while (result.length < maxLength) {
-        chars ++;
-        result += base64chars.charAt(number & 0x3F);
-        number >>>= 6;              // Zero fill with right shift
-        if (chars === 5) {
-            // 5 base64 characters === 30 bits so we don't have enough bits for another base64 char
-            // So add on another 30 bits and make sure it's +ve
-            number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
-            chars = 0;      // We need to reset the number every 5 chars (30 bits)
-        }
-    }
-
-    return result;
-}
-
 /**
  * The strEndsWith() method determines whether a string ends with the characters of a specified string, returning true or false as appropriate.
  * @param value - The value to check whether it ends with the search value.
@@ -232,7 +68,7 @@ export function generateW3CId(): string {
     const hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
 
     // rfc4122 version 4 UUID without dashes and with lowercase letters
-    let oct = "", tmp;
+    let oct = strEmpty, tmp;
     for (let a = 0; a < 4; a++) {
         tmp = random32();
         oct +=
@@ -407,7 +243,7 @@ export interface ICoreUtils {
      * @param callback {any} - The callback function that needs to be executed for the given event
      * @return {boolean} - true if the handler was successfully added
      */
-    addEventHandler: (eventName: string, callback: any) => boolean;
+    addEventHandler: (eventName: string, callback: any, evtNamespace?: string | string[]) => boolean;
 
     /**
      * Return the current time via the Date now() function (if available) and falls back to (new Date()).getTime() if now() is unavailable (IE8 or less)
@@ -574,7 +410,7 @@ export const EventHelper: IEventHelper = {
  * @param logger
  * @returns
  */
- export function _legacyCookieMgr(config?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr {
+export function _legacyCookieMgr(config?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr {
     let cookieMgr = _gblCookieMgr(config, logger);
     let legacyCanUseCookies = (CoreUtils as any)._canUseCookies;