@microsoft/applicationinsights-core-js 2.8.0-nightly.2202-06 → 2.8.0-nightly.2204-04

package/types/JavaScriptSDK/BaseCore.d.ts

@@ -1,13 +1,19 @@
-import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
+import { IAppInsightsCore, ILoadedPlugin } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
+import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { IChannelControls } from "../JavaScriptSDK.Interfaces/IChannelControls";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
 import { INotificationManager } from "../JavaScriptSDK.Interfaces/INotificationManager";
+import { INotificationListener } from "../JavaScriptSDK.Interfaces/INotificationListener";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
-import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { IProcessTelemetryContext, IProcessTelemetryUpdateContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { IPerfManager } from "../JavaScriptSDK.Interfaces/IPerfManager";
 import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
+import { ITelemetryInitializerHandler, TelemetryInitializerFunction } from "../JavaScriptSDK.Interfaces/ITelemetryInitializers";
+import { UnloadHandler } from "./UnloadHandlerContainer";
+import { ITelemetryUpdateState } from "../JavaScriptSDK.Interfaces/ITelemetryUpdateState";
+import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
+import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
 export declare class BaseCore implements IAppInsightsCore {
     static defaultConfig: IConfiguration;
     config: IConfiguration;
@@ -20,6 +26,18 @@ export declare class BaseCore implements IAppInsightsCore {
     track(telemetryItem: ITelemetryItem): void;
     getProcessTelContext(): IProcessTelemetryContext;
     getNotifyMgr(): INotificationManager;
+    /**
+     * Adds a notification listener. The SDK calls methods on the listener when an appropriate notification is raised.
+     * The added plugins must raise notifications. If the plugins do not implement the notifications, then no methods will be
+     * called.
+     * @param {INotificationListener} listener - An INotificationListener object.
+     */
+    addNotificationListener(listener: INotificationListener): void;
+    /**
+     * Removes all instances of the listener.
+     * @param {INotificationListener} listener - INotificationListener to remove.
+     */
+    removeNotificationListener(listener: INotificationListener): void;
     /**
      * Get the current cookie manager for this instance
      */
@@ -32,5 +50,65 @@ export declare class BaseCore implements IAppInsightsCore {
     getPerfMgr(): IPerfManager;
     setPerfMgr(perfMgr: IPerfManager): void;
     eventCnt(): number;
+    /**
+     * Periodically check logger.queue for
+     */
+    pollInternalLogs(eventName?: string): number;
+    /**
+     * Periodically check logger.queue for
+     */
+    stopPollingInternalLogs(): void;
+    /**
+     * Add a telemetry processor to decorate or drop telemetry events.
+     * @param telemetryInitializer - The Telemetry Initializer function
+     * @returns - A ITelemetryInitializerHandler to enable the initializer to be removed
+     */
+    addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
+    /**
+     * Unload and Tear down the SDK and any initialized plugins, after calling this the SDK will be considered
+     * to be un-initialized and non-operational, re-initializing the SDK should only be attempted if the previous
+     * unload call return `true` stating that all plugins reported that they also unloaded, the recommended
+     * approach is to create a new instance and initialize that instance.
+     * This is due to possible unexpected side effects caused by plugins not supporting unload / teardown, unable
+     * to successfully remove any global references or they may just be completing the unload process asynchronously.
+     * @param isAsync - Can the unload be performed asynchronously (default)
+     * @param unloadComplete - An optional callback that will be called once the unload has completed
+     * @param cbTimeout - An optional timeout to wait for any flush operations to complete before proceeding with the unload. Defaults to 5 seconds.
+     */
+    unload(isAsync?: boolean, unloadComplete?: (unloadState: ITelemetryUnloadState) => void, cbTimeout?: number): void;
+    getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
+    /**
+     * Add a new plugin to the installation
+     * @param plugin - The new plugin to add
+     * @param replaceExisting - should any existing plugin be replaced, default is false
+     * @param doAsync - Should the add be performed asynchronously
+     * @param addCb - [Optional] callback to call after the plugin has been added
+     */
+    addPlugin<T extends IPlugin = ITelemetryPlugin>(plugin: T, replaceExisting?: boolean, doAsync?: boolean, addCb?: (added?: boolean) => void): void;
+    /**
+     * Returns the unique event namespace that should be used
+     */
+    evtNamespace(): string;
+    /**
+     * Add an unload handler that will be called when the SDK is being unloaded
+     * @param handler - the handler
+     */
+    addUnloadCb(handler: UnloadHandler): void;
+    /**
+     * Flush and send any batched / cached data immediately
+     * @param async - send data asynchronously when true (defaults to true)
+     * @param callBack - if specified, notify caller when send is complete, the channel should return true to indicate to the caller that it will be called.
+     * If the caller doesn't return true the caller should assume that it may never be called.
+     * @param sendReason - specify the reason that you are calling "flush" defaults to ManualFlush (1) if not specified
+     * @returns - true if the callback will be return after the flush is complete otherwise the caller should assume that any provided callback will never be called
+     */
+    flush(isAsync?: boolean, callBack?: (flushComplete?: boolean) => void, sendReason?: SendRequestReason): void;
     protected releaseQueue(): void;
+    /**
+     * Hook for Core extensions to allow them to update their own configuration before updating all of the plugins.
+     * @param updateCtx - The plugin update context
+     * @param updateState - The Update State
+     * @returns boolean - True means the extension class will call updateState otherwise the Core will
+     */
+    protected _updateHook?(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
 }

package/types/JavaScriptSDK/BaseTelemetryPlugin.d.ts

@@ -3,14 +3,25 @@ import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
-import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { IProcessTelemetryContext, IProcessTelemetryUnloadContext, IProcessTelemetryUpdateContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
+import { UnloadHandler } from "./UnloadHandlerContainer";
+import { IInstrumentHook } from "../JavaScriptSDK.Interfaces/IInstrumentHooks";
+import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
+import { ITelemetryUpdateState } from "../JavaScriptSDK.Interfaces/ITelemetryUpdateState";
 /**
  * BaseTelemetryPlugin provides a basic implementation of the ITelemetryPlugin interface so that plugins
  * can avoid implementation the same set of boiler plate code as well as provide a base
  * implementation so that new default implementations can be added without breaking all plugins.
  */
 export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
+    identifier: string;
+    version?: string;
+    /**
+     * Holds the core instance that was used during initialization
+     */
+    core: IAppInsightsCore;
+    priority: number;
     /**
      * Call back for telemetry processing before it it is sent
      * @param env - This is the current event being reported
@@ -32,13 +43,6 @@ export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      * Returns whether the plugin has been initialized
      */
     isInitialized: () => boolean;
-    identifier: string;
-    version?: string;
-    /**
-     * Holds the core instance that was used during initialization
-     */
-    core: IAppInsightsCore;
-    priority: number;
     /**
      * Helper to return the current IProcessTelemetryContext, if the passed argument exists this just
      * returns that value (helps with minification for callers), otherwise it will return the configured
@@ -51,10 +55,49 @@ export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      */
     protected setInitialized: (isInitialized: boolean) => void;
     /**
-     * Internal helper to initialize the instance
+     * Teardown / Unload hook to allow implementations to perform some additional unload operations before the BaseTelemetryPlugin
+     * finishes it's removal.
+     * @param unloadCtx - This is the context that should be used during unloading.
+     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
+     * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async unload/teardown operations.
+     * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
+     */
+    protected _doTeardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void) => void | boolean;
+    /**
+     * Extension hook to allow implementations to perform some additional update operations before the BaseTelemetryPlugin finishes it's removal
+     * @param updateCtx - This is the context that should be used during updating.
+     * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
+     * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async update operations.
+     * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
      */
-    private _baseTelInit;
+    protected _doUpdate?: (updateCtx?: IProcessTelemetryUpdateContext, updateState?: ITelemetryUpdateState, asyncCallback?: () => void) => void | boolean;
     constructor();
     initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain): void;
+    /**
+     * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
+     * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
+     * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
+     * @param unloadCtx - This is the context that should be used during unloading.
+     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
+     * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
+     */
+    teardown(unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState): void | boolean;
     abstract processTelemetry(env: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
+    /**
+     * The the plugin should re-evaluate configuration and update any cached configuration settings.
+     * @param updateCtx - This is the context that should be used during updating.
+     * @param updateState - The details / state of the update process, it holds details like the current and previous configuration.
+     * @returns boolean - true if the plugin has or will call updateCtx.processNext(), this allows the plugin to perform any asynchronous operations.
+     */
+    update(updateCtx: IProcessTelemetryUpdateContext, updateState: ITelemetryUpdateState): void | boolean;
+    /**
+     * Add an unload handler that will be called when the SDK is being unloaded
+     * @param handler - the handler
+     */
+    protected _addUnloadCb(handler: UnloadHandler): void;
+    /**
+     * Add this hook so that it is automatically removed during unloading
+     * @param hooks - The single hook or an array of IInstrumentHook objects
+     */
+    protected _addHook(hooks: IInstrumentHook | IInstrumentHook[]): void;
 }

package/types/JavaScriptSDK/ChannelController.d.ts

@@ -1,21 +1,20 @@
+import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
-import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IChannelControls } from "../JavaScriptSDK.Interfaces/IChannelControls";
-import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
+import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
+import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
-import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
-import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
-import { BaseTelemetryPlugin } from "./BaseTelemetryPlugin";
-export declare class ChannelController extends BaseTelemetryPlugin {
-    identifier: string;
-    priority: number;
-    setNextPlugin: (next: ITelemetryPlugin | ITelemetryPluginChain) => void;
-    constructor();
-    processTelemetry(item: ITelemetryItem, itemCtx: IProcessTelemetryContext): void;
-    getChannelControls(): IChannelControls[][];
-    initialize(config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[]): void;
-    /**
-     * Static constructor, attempt to create accessors
-     */
-    private static _staticInit;
+export declare const ChannelControllerPriority = 500;
+export interface IChannelController extends IChannelControls {
+    flush(isAsync: boolean, callBack: (flushComplete?: boolean) => void, sendReason: SendRequestReason, cbTimeout?: number): void;
+    getChannel<T extends IPlugin = IPlugin>(pluginIdentifier: string): T;
+}
+export interface IInternalChannelController extends IChannelController {
+    _setQueue: (channels: _IInternalChannels[]) => void;
+}
+export interface _IInternalChannels {
+    queue: IChannelControls[];
+    chain: ITelemetryPluginChain;
 }
+export declare function createChannelControllerPlugin(channelQueue: _IInternalChannels[], core: IAppInsightsCore): IChannelController;
+export declare function createChannelQueues(channels: IChannelControls[][], extensions: IPlugin[], config: IConfiguration, core: IAppInsightsCore): _IInternalChannels[];

package/types/JavaScriptSDK/CoreUtils.d.ts

@@ -2,59 +2,12 @@ import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 export declare const Undefined = "undefined";
-/**
- * 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 declare function addEventHandler(eventName: string, callback: any): boolean;
-/**
- * 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 declare function addEventListeners(events: string[], listener: any, excludeEvents?: string[]): boolean;
-/**
- * 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 declare function addPageUnloadEventListener(listener: any, excludeEvents?: string[]): boolean;
-/**
- * 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 declare function addPageHideEventListener(listener: any, excludeEvents?: string[]): boolean;
-/**
- * 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 declare function addPageShowEventListener(listener: any, excludeEvents?: string[]): boolean;
 export declare function newGuid(): string;
 /**
  * Return the current value of the Performance Api now() function (if available) and fallback to dateNow() if it is unavailable (IE9 or less)
  * https://caniuse.com/#search=performance.now
  */
 export declare function perfNow(): number;
-/**
- * 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 declare function newId(maxLength?: number): string;
 /**
  * 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.
@@ -199,7 +152,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)
      * https://caniuse.com/#search=Date.now

package/types/JavaScriptSDK/DataCacheHelper.d.ts

@@ -0,0 +1,13 @@
+export interface IDataCache {
+    id: string;
+    accept: (target: any) => boolean;
+    get: <T>(target: any, name: string, defValue?: T, addDefault?: boolean) => T;
+    kill: (target: any, name: string) => void;
+}
+export declare function createUniqueNamespace(name: string, includeVersion?: boolean): string;
+export declare function createElmNodeData(name?: string): {
+    id: string;
+    accept: (target: any) => boolean;
+    get: <T>(target: any, name: string, defValue?: T, addDefault?: boolean) => T;
+    kill: (target: any, name: string) => void;
+};

package/types/JavaScriptSDK/DiagnosticLogger.d.ts

@@ -63,3 +63,13 @@ export declare class DiagnosticLogger implements IDiagnosticLogger {
      */
     logInternalMessage(severity: LoggingSeverity, message: _InternalLogMessage): void;
 }
+/**
+ * This is a helper method which will call throwInternal on the passed logger, will throw exceptions in
+ * debug mode or attempt to log the error as a console warning. This helper is provided mostly to better
+ * support minification as logger.throwInternal() will not compress the publish "throwInternal" used throughout
+ * the code.
+ * @param logger - The Diagnostic Logger instance to use.
+ * @param severity {LoggingSeverity} - The severity of the log message
+ * @param message {_InternalLogMessage} - The log message.
+ */
+export declare function _throwInternal(logger: IDiagnosticLogger, severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;

package/types/JavaScriptSDK/EventHelpers.d.ts

@@ -0,0 +1,154 @@
+export interface _IRegisteredEvents {
+    name: string;
+    handler: any;
+}
+/**
+ * Get all of the registered events on the target object, this is primarily used for testing cleanup but may also be used by
+ * applications to remove their own events
+ * @param target - The EventTarget that has registered events
+ * @param eventName - [Optional] The name of the event to return the registered handlers and full name (with namespaces)
+ * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,
+ * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
+ */
+export declare function __getRegisteredEvents(target: any, eventName?: string, evtNamespace?: string | string[]): _IRegisteredEvents[];
+export declare function mergeEvtNamespace(theNamespace: string, namespaces?: string | string[] | null): string | string[];
+/**
+ * Binds the specified function to an event, so that the function gets called whenever the event fires on the object
+ * @param obj Object to add the event too.
+ * @param eventName String that specifies any of the standard DHTML Events without "on" prefix, if may also include an optional (dot "." prefixed)
+ * namespaces "click" "click.mynamespace" in addition to specific namespaces.
+ * @param handlerRef Pointer that specifies the function to call when event fires
+ * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,
+ * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
+ * @param useCapture [Optional] Defaults to false
+ * @returns True if the function was bound successfully to the event, otherwise false
+ */
+export declare function eventOn<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[] | null, useCapture?: boolean): boolean;
+/**
+ * Removes an event handler for the specified event
+ * @param Object to remove the event from
+ * @param eventName {string} - The name of the event, with optional namespaces or just the namespaces,
+ * such as "click", "click.mynamespace" or ".mynamespace"
+ * @param handlerRef {any} - The callback function that needs to be removed from the given event, when using a
+ * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
+ * otherwise this will only remove events with this specific handler.
+ * @param evtNamespace - [Optional] Additional namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace,
+ * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
+ * @param useCapture [Optional] Defaults to false
+ */
+export declare function eventOff<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[] | null, useCapture?: boolean): void;
+/**
+ * Binds the specified function to an event, so that the function gets called whenever the event fires on the object
+ * @param obj Object to add the event too.
+ * @param eventNameWithoutOn String that specifies any of the standard DHTML Events without "on" prefix and optional (dot "." prefixed) namespaces "click" "click.mynamespace".
+ * @param handlerRef Pointer that specifies the function to call when event fires
+ * @param useCapture [Optional] Defaults to false
+ * @returns True if the function was bound successfully to the event, otherwise false
+ */
+export declare function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture?: boolean): boolean;
+/**
+ * Removes an event handler for the specified event
+ * @param Object to remove the event from
+ * @param eventNameWithoutOn {string} - The name of the event, with optional namespaces or just the namespaces,
+ * such as "click", "click.mynamespace" or ".mynamespace"
+ * @param handlerRef {any} - The callback function that needs to be removed from the given event, when using a
+ * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
+ * otherwise this will only remove events with this specific handler.
+ * @param useCapture [Optional] Defaults to false
+ */
+export declare function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture?: boolean): void;
+/**
+ * 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
+ * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
+ * @return {boolean} - true if the handler was successfully added
+ */
+export declare function addEventHandler(eventName: string, callback: any, evtNamespace?: string | string[] | null): boolean;
+/**
+ * Trys to remove event handler(s) for the specified event/namespace to the window, body and document
+ * @param eventName {string} - The name of the event, with optional namespaces or just the namespaces,
+ * such as "click", "click.mynamespace" or ".mynamespace"
+ * @param callback {any} - - The callback function that needs to be removed from the given event, when using a
+ * namespace (with or without a qualifying event) this may be null to remove all previously attached event handlers
+ * otherwise this will only remove events with this specific handler.
+ * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
+ */
+export declare function removeEventHandler(eventName: string, callback: any, evtNamespace?: string | string[] | null): void;
+/**
+ * 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.
+ * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+export declare function addEventListeners(events: string[], listener: any, excludeEvents?: string[], evtNamespace?: string | string[]): boolean;
+/**
+ * Remove the listener from 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 evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
+ */
+export declare function removeEventListeners(events: string[], listener: any, evtNamespace?: string | string[]): void;
+/**
+ * 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.
+ * @param evtNamespace - [Optional] Namespace(s) to append to the event listeners so they can be uniquely identified and removed based on this namespace.
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+export declare function addPageUnloadEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string | string[]): boolean;
+/**
+ * Remove any matching 'beforeunload', 'unload' and 'pagehide' events that may have been added via addEventListener,
+ * addEventListeners, addPageUnloadEventListener or addPageHideEventListener.
+ * @param listener - The specific event callback to to be removed
+ * @param evtNamespace - [Optional] Namespace(s) uniquely identified and removed based on this namespace.
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+export declare function removePageUnloadEventListener(listener: any, evtNamespace?: string | string[]): void;
+/**
+ * Listen to the pagehide and visibility changing to 'hidden' events, because the 'visibilitychange' uses
+ * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call
+ * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.
+ * @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.
+ * @param evtNamespace - [Optional] A Namespace to append to the event listeners so they can be uniquely identified and removed
+ * based on this namespace. This call also adds an additional unique "pageshow" namespace to the events
+ * so that only the matching "removePageHideEventListener" can remove these events.
+ * 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 declare function addPageHideEventListener(listener: any, excludeEvents?: string[] | null, evtNamespace?: string | string[] | null): boolean;
+/**
+ * Removes the pageHide event listeners added by addPageHideEventListener, because the 'visibilitychange' uses
+ * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageHideEventListener
+ * as the remove ignores the listener argument for the 'visibilitychange' event.
+ * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')
+ * @param evtNamespace - The unique namespace used when calling addPageShowEventListener
+ */
+export declare function removePageHideEventListener(listener: any, evtNamespace?: string | string[] | null): void;
+/**
+ * Listen to the pageshow and visibility changing to 'visible' events, because the 'visibilitychange' uses
+ * an internal proxy to detect the visibility state you SHOULD use a unique namespace when if you plan to call
+ * removePageShowEventListener as the remove ignores the listener argument for the 'visibilitychange' event.
+ * @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.
+ * @param evtNamespace - [Optional/Recommended] A Namespace to append to the event listeners so they can be uniquely
+ * identified and removed based on this namespace. This call also adds an additional unique "pageshow" namespace to the events
+ * so that only the matching "removePageShowEventListener" can remove these events.
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+export declare function addPageShowEventListener(listener: any, excludeEvents?: string[] | null, evtNamespace?: string | string[] | null): boolean;
+/**
+ * Removes the pageShow event listeners added by addPageShowEventListener, because the 'visibilitychange' uses
+ * an internal proxy to detect the visibility state you SHOULD use a unique namespace when calling addPageShowEventListener
+ * as the remove ignores the listener argument for the 'visibilitychange' event.
+ * @param listener - The specific listener to remove for the 'pageshow' event only (ignored for 'visibilitychange')
+ * @param evtNamespace - The unique namespace used when calling addPageShowEventListener
+ */
+export declare function removePageShowEventListener(listener: any, evtNamespace?: string | string[] | null): void;

package/types/JavaScriptSDK/HelperFuncs.d.ts

@@ -1,34 +1,18 @@
 /**
- * Helper used to get the prototype of the target object as getPrototypeOf is not available in an ES3 environment.
- * @ignore
- */
+  * Helper used to get the prototype of the target object as getPrototypeOf is not available in an ES3 environment.
+  * @ignore
+  */
 export declare function _getObjProto(target: any): any;
 export declare function objToString(obj: any): any;
 export declare function isTypeof(value: any, theType: string): boolean;
-export declare function isUndefined(value: any): boolean;
-export declare function isNotUndefined(value: any): boolean;
-export declare function isNullOrUndefined(value: any): boolean;
-export declare function isNotNullOrUndefined(value: any): boolean;
+export declare function isUndefined(value: any): value is undefined;
+export declare function isNotUndefined<T>(value: T): value is T;
+export declare function isNullOrUndefined(value: any): value is null | undefined;
+export declare function isNotNullOrUndefined<T>(value: T): value is T;
 export declare function hasOwnProperty(obj: any, prop: string): boolean;
-export declare function isObject(value: any): boolean;
+export declare function isObject<T>(value: T): value is T;
 export declare function isFunction(value: any): value is Function;
-/**
- * Binds the specified function to an event, so that the function gets called whenever the event fires on the object
- * @param obj Object to add the event too.
- * @param eventNameWithoutOn String that specifies any of the standard DHTML Events without "on" prefix
- * @param handlerRef Pointer that specifies the function to call when event fires
- * @param useCapture [Optional] Defaults to false
- * @returns True if the function was bound successfully to the event, otherwise false
- */
-export declare function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture?: boolean): boolean;
-/**
- * Removes an event handler for the specified event
- * @param Object to remove the event from
- * @param eventNameWithoutOn {string} - The name of the event
- * @param handlerRef {any} - The callback function that needs to be executed for the given event
- * @param useCapture [Optional] Defaults to false
- */
-export declare function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture?: boolean): void;
+export declare function isPromiseLike<T>(value: any): value is PromiseLike<T>;
 /**
  * Validates that the string name conforms to the JS IdentifierName specification and if not
  * normalizes the name so that it would. This method does not identify or change any keywords
@@ -43,7 +27,7 @@ export declare function normalizeJsName(name: string): string;
  * @param target The target object to find and process the keys
  * @param callbackfn The function to call with the details
  */
-export declare function objForEachKey(target: any, callbackfn: (name: string, value: any) => void): void;
+export declare function objForEachKey<T = any>(target: T, callbackfn: (name: string, value: T[keyof T]) => void): void;
 /**
  * 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.
@@ -83,7 +67,8 @@ export declare function strContains(value: string, search: string): boolean;
  */
 export declare function isDate(obj: any): obj is Date;
 /**
- * Check if an object is of type Array
+ * Check if an object is of type Array with optional generic T, the generic type is not validated
+ * and exists to help with TypeScript validation only.
  */
 export declare let isArray: <T = any>(obj: any) => obj is Array<T>;
 /**
@@ -136,7 +121,7 @@ export declare function _toISOStringPoly(date: Date): string;
  * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. It can return -1 to break out of the loop
  * @param thisArg  [Optional] An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
  */
-export declare function arrForEach<T>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => void | number, thisArg?: any): void;
+export declare function arrForEach<T = any>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => undefined | void | number, thisArg?: any): void;
 /**
  * Returns the index of the first occurrence of a value in an array. This helper exists to avoid adding a polyfil for older browsers
  * that do not define Array.prototype.xxxx (eg. ES3 only, IE8) just in case any page checks for presence/absence of the prototype
@@ -186,6 +171,7 @@ export declare function objKeys(obj: {}): string[];
  * @returns True if it was able to create the accessors otherwise false
  */
 export declare function objDefineAccessors<T>(target: any, prop: string, getProp?: () => T, setProp?: (v: T) => void): boolean;
+export declare function deepFreeze<T>(obj: T): T;
 export declare const objFreeze: <T>(value: T) => T;
 export declare const objSeal: <T>(value: T) => T;
 /**
@@ -207,7 +193,7 @@ export declare function getExceptionName(object: any): string;
  * @param srcChk - [Optional] Callback to check to original value that if supplied will be called if the new value should be set (if allowed)
  * @returns The existing or new value, depending what was set
  */
-export declare function setValue<T, K extends keyof T>(target: T, field: K, value: T[K], valChk?: (value: T[K]) => boolean, srcChk?: (value: T[K]) => boolean): T[K];
+export declare function setValue<T, K extends keyof T>(target: T, field: K, value: T[K], valChk?: ((value: T[K]) => boolean) | null, srcChk?: ((value: T[K]) => boolean) | null): T[K];
 /**
  * Returns the current value from the target object if not null or undefined otherwise sets the new value and returns it
  * @param target - The target object to return or set the default value
@@ -232,15 +218,29 @@ export declare function throwError(message: string): never;
  * @param target - The target object to be assigned with the source properties and functions
  * @param source - The source object which will be assigned / called by setting / calling the targets proxies
  * @param chkSet - An optional callback to determine whether a specific property/function should be proxied
- * @memberof Initialization
  */
-export declare function proxyAssign(target: any, source: any, chkSet?: (name: string, isFunc?: boolean, source?: any, target?: any) => boolean): any;
+export declare function proxyAssign<T, S>(target: T, source: S, chkSet?: (name: string, isFunc?: boolean, source?: S, target?: T) => boolean): T;
+export declare function proxyFunctionAs<T, S>(target: T, name: string, source: S | (() => S), theFunc: (keyof S), overwriteTarget?: boolean): void;
+/**
+ * Creates proxy functions on the target which internally will call the source version with all arguments passed to the target method.
+ *
+ * @param target - The target object to be assigned with the source properties and functions
+ * @param source - The source object which will be assigned / called by setting / calling the targets proxies
+ * @param functionsToProxy - An array of function names that will be proxied on the target
+ */
+export declare function proxyFunctions<T, S>(target: T, source: S | (() => S), functionsToProxy: (keyof S)[], overwriteTarget?: boolean): T;
 /**
  * Simpler helper to create a dynamic class that implements the interface and populates the values with the defaults.
  * Only instance properties (hasOwnProperty) values are copied from the defaults to the new instance
  * @param defaults Simple helper
  */
 export declare function createClassFromInterface<T>(defaults?: T): new () => T;
+/**
+ * Create an enum style object which has both the key => value and value => key mappings
+ * @param values - The values to populate on the new object
+ * @returns
+ */
+export declare function createEnumStyle<T>(values: T): T;
 /**
  * A helper function to assist with JIT performance for objects that have properties added / removed dynamically
  * this is primarily for chromium based browsers and has limited effects on Firefox and none of IE. Only call this
@@ -259,4 +259,5 @@ export declare function optimizeObject<T>(theObject: T): T;
  * @param obj5 - object to merge.
  * @returns The extended first object.
  */
-export declare function objExtend<T1, T2, T3, T4, T5, T6>(obj?: boolean | T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6;
+export declare function objExtend<T2, T3, T4, T5, T6>(deepExtend?: boolean, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T2 & T3 & T4 & T5 & T6;
+export declare function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6;