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

package/src/JavaScriptSDK/ChannelController.ts

@@ -1,274 +1,135 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
-// // Licensed under the MIT License.
+// Licensed under the MIT License.
+"use strict";
 
-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 dynamicProto from "@microsoft/dynamicproto-js";
+import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore"
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { IBaseProcessingContext, IProcessTelemetryContext, IProcessTelemetryUnloadContext, IProcessTelemetryUpdateContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
-import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
-import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
+import { IChannelControls } from "../JavaScriptSDK.Interfaces/IChannelControls";
+import { IPlugin, ITelemetryPlugin  } 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 { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
+import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { _InternalLogMessage } from "./DiagnosticLogger";
+import { BaseTelemetryPlugin } from "./BaseTelemetryPlugin";
+import { ProcessTelemetryContext } from "./ProcessTelemetryContext";
 import { initializePlugins } from "./TelemetryHelpers";
+import { arrForEach, objDefineAccessors, throwError } from "./HelperFuncs";
 
-export const ChannelControllerPriority = 500;
-const ChannelValidationMessage = "Channel has invalid priority - ";
+const ChannelControllerPriority = 500;
+const ChannelValidationMessage = "Channel has invalid priority";
 
-export interface IChannelController extends IChannelControls {
-    flush(isAsync: boolean, callBack: (flushComplete?: boolean) => void, sendReason: SendRequestReason, cbTimeout?: number): void;
+export class ChannelController extends BaseTelemetryPlugin {
 
-    getChannel<T extends IPlugin = IPlugin>(pluginIdentifier: string): T;
-}
+    identifier: string = "ChannelControllerPlugin";
+    priority: number = ChannelControllerPriority; // in reserved range 100 to 200
 
-export interface IInternalChannelController extends IChannelController {
-    _setQueue: (channels: _IInternalChannels[]) => void;
-}
+    public setNextPlugin: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
 
-export interface _IInternalChannels {
-    queue: IChannelControls[];
-    chain: ITelemetryPluginChain;
-}
+    constructor() {
+        super();
+        let _channelQueue: IChannelControls[][];
 
-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;
-        });
+        dynamicProto(ChannelController, this, (_self, _base) => {
+            _self.setNextPlugin = (next: ITelemetryPlugin | ITelemetryPluginChain) => {
+                // The Channel controller is last in pipeline
+            };
 
-        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)
-    }
-
-    function _processChannelQueue<T extends IBaseProcessingContext>(theChannels: _IInternalChannels[], itemCtx: T, processFn: (chainCtx: T) => void, onComplete: (() => void) | null) {
-        let waiting = theChannels ? (theChannels.length + 1) : 1;
-
-        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 --;
+            _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;
                 }
-            });
-        }
-
-        _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
-        };
+                _base.initialize(config, core, extensions);
 
-        _processChannelQueue(channelQueue, unloadCtx, (chainCtx: IProcessTelemetryUnloadContext) => {
-            chainCtx[strProcessNext](theUnloadState);
-        }, () => {
-            unloadCtx[strProcessNext](theUnloadState);
-            isInitialized = false;
+                _createChannelQueues((config||{}).channels, extensions);
+        
+                // Initialize the Queues
+                arrForEach(_channelQueue, queue => initializePlugins(new ProcessTelemetryContext(queue, config, core), extensions));
+            }
         });
 
-        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 _checkQueuePriority(queue:IChannelControls[]) {
+            arrForEach(queue, queueItem => {
+                if (queueItem.priority < ChannelControllerPriority) {
+                    throwError(ChannelValidationMessage + queueItem.identifier);
                 }
             });
         }
-
-        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]();
-                });
-            }, null);
-        },
-        [strResume]: () => {
-            _processChannelQueue(channelQueue, _getTelCtx(), (chainCtx: IProcessTelemetryContext) => {
-                chainCtx.iterate<IChannelControls>((plugin) => {
-                    plugin[strResume] && plugin[strResume]();
+        
+        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;
                 });
-            }, 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;
-                }
+        
+                _checkQueuePriority(queue);
+                _channelQueue.push(queue);
             }
-
-            _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();
-                                }
-                            }
-                        }
+        }
+        
+        function _createChannelQueues(channels:IChannelControls[][], extensions: IPlugin[]) {
+            _channelQueue = [];
+        
+            if (channels) {
+                // Add and sort the configuration channel queues
+                arrForEach(channels, queue => _addChannelQueue(queue));
+            }
+        
+            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);
                     }
                 });
-            }, () => {
-                doneIterating = true;
-                doCallback();
-            });
-
-            return true;
-        },
-        _setQueue: (queue: _IInternalChannels[]) => {
-            channelQueue = queue;
+            
+                _addChannelQueue(extensionQueue);
+            }
         }
-    };
-
-    return channelController;
-}
+    }
 
-export function createChannelQueues(channels: IChannelControls[][], extensions: IPlugin[], config: IConfiguration, core: IAppInsightsCore) {
-    let channelQueue: _IInternalChannels[] = [];
+    public processTelemetry(item: ITelemetryItem, itemCtx: IProcessTelemetryContext) {
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+    }
 
-    if (channels) {
-        // Add and sort the configuration channel queues
-        arrForEach(channels, queue => _addChannelQueue(channelQueue, queue, config, core));
+    public getChannelControls(): IChannelControls[][] {
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+        return 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);
-            }
-        });
-    
-        _addChannelQueue(channelQueue, extensionQueue, config, core);
+    public initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[]) {
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
     }
 
-    return channelQueue;
+    /**
+     * 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);
+    })();
 }

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 { _eInternalMessageId, eLoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
+import { _InternalMessageId, LoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
 import { dumpObj, getDocument, getLocation, getNavigator, isIE } from "./EnvUtils";
 import {
     arrForEach, dateNow, getExceptionName, isFunction, isNotNullOrUndefined, isNullOrUndefined, isString, isTruthy, isUndefined,
@@ -10,8 +10,6 @@ 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";
@@ -21,6 +19,7 @@ const strEnabled = "enabled";
 const strIsCookieUseDisabled = "isCookieUseDisabled";
 const strDisableCookiesUsage = "disableCookiesUsage";
 const strConfigCookieMgr = "_ckMgr";
+const strEmpty = "";
 
 let _supportsCookies: boolean = null;
 let _allowUaSameSite: boolean = null;
@@ -253,10 +252,9 @@ export function areCookiesSupported(logger?: IDiagnosticLogger): any {
             let doc = _doc || {} as Document;
             _supportsCookies = doc[strCookie] !== undefined;
         } catch (e) {
-            _throwInternal(
-                logger,
-                eLoggingSeverity.WARNING,
-                _eInternalMessageId.CannotAccessCookie,
+            logger && logger.throwInternal(
+                LoggingSeverity.WARNING,
+                _InternalMessageId.CannotAccessCookie,
                 "Cannot access document.cookie - " + getExceptionName(e),
                 { exception: dumpObj(e) });
         }

package/src/JavaScriptSDK/CoreUtils.ts

@@ -6,21 +6,158 @@ import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { _gblCookieMgr } from "./CookieMgr";
-import { getPerformance, isIE }  from "./EnvUtils";
+import { getWindow, getDocument, getPerformance, isIE }  from "./EnvUtils";
 import {
-    arrForEach, arrIndexOf, arrMap, arrReduce, dateNow, hasOwnProperty,
+    arrForEach, arrIndexOf, arrMap, arrReduce, attachEvent, dateNow, detachEvent, hasOwnProperty,
     isArray, isBoolean, isDate, isError, isFunction, isNullOrUndefined, isNumber, isObject, isString, isTypeof,
     isUndefined, objDefineAccessors, objKeys, strTrim, toISOString
 } from "./HelperFuncs";
-import { addEventHandler, attachEvent, detachEvent } from "./EventHelpers";
-import { randomValue, random32, mwcRandomSeed, mwcRandom32, newId } from "./RandomHelper";
-import { strEmpty } from "./InternalConstants";
+import { randomValue, random32, mwcRandomSeed, mwcRandom32 } from "./RandomHelper";
+
+const strVisibilityChangeEvt: string = "visibilitychange";
+const strPageHide: string = "pagehide";
+const strPageShow: string = "pageshow";
 
 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
@@ -45,6 +182,33 @@ 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.
@@ -68,7 +232,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 = strEmpty, tmp;
+    let oct = "", tmp;
     for (let a = 0; a < 4; a++) {
         tmp = random32();
         oct +=
@@ -243,7 +407,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, evtNamespace?: string | string[]) => boolean;
+    addEventHandler: (eventName: string, callback: any) => 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)
@@ -410,7 +574,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;