@microsoft/applicationinsights-core-js 2.8.0-beta.2203-01 → 2.8.0-beta.2203-02

package/src/JavaScriptSDK.Interfaces/ITelemetryPlugin.ts

@@ -5,13 +5,11 @@
 import { ITelemetryItem } from "./ITelemetryItem";
 import { IConfiguration } from "./IConfiguration";
 import { IAppInsightsCore } from "./IAppInsightsCore";
-import { IProcessTelemetryContext } from "./IProcessTelemetryContext";
+import { IProcessTelemetryContext, IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
 import { ITelemetryPluginChain } from "./ITelemetryPluginChain";
+import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
 
-/**
- * Configuration provided to SDK core
- */
-export interface ITelemetryPlugin extends IPlugin {
+export interface ITelemetryProcessor {
     /**
      * Call back for telemetry processing before it it is sent
      * @param env - This is the current event being reported
@@ -20,7 +18,12 @@ export interface ITelemetryPlugin extends IPlugin {
      * to later plugins (vs appending items to the telemetry item)
      */
     processTelemetry: (env: ITelemetryItem, itemCtx?: IProcessTelemetryContext) => void;
-    
+}
+
+/**
+ * Configuration provided to SDK core
+ */
+export interface ITelemetryPlugin extends ITelemetryProcessor, IPlugin {
     /**
      * Set next extension for telemetry processing, this is not optional as plugins should use the
      * processNext() function of the passed IProcessTelemetryContext instead. It is being kept for
@@ -52,10 +55,14 @@ export interface IPlugin {
     isInitialized?: () => boolean;
 
     /**
-     * Tear down the plugin and remove any hooked value, the plugin should remove that it is no longer initialized and
-     * therefore can be re-initialized after being torn down.
+     * 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?: () => void;
+    teardown?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => void | boolean;
 
     /**
      * Extension name

package/src/JavaScriptSDK.Interfaces/ITelemetryPluginChain.ts

@@ -1,15 +1,14 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
-"use strict";
 
-import { ITelemetryItem } from "./ITelemetryItem";
-import { IProcessTelemetryContext } from "./IProcessTelemetryContext";
-import { ITelemetryPlugin } from "./ITelemetryPlugin";
+import { IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
+import { ITelemetryPlugin, ITelemetryProcessor } from "./ITelemetryPlugin";
+import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
 
 /**
  * Configuration provided to SDK core
  */
-export interface ITelemetryPluginChain {
+export interface ITelemetryPluginChain extends ITelemetryProcessor {
 
     /**
      * Returns the underlying plugin that is being proxied for the processTelemetry call
@@ -22,11 +21,10 @@ export interface ITelemetryPluginChain {
     getNext: () => ITelemetryPluginChain;
 
     /**
-     * Call back for telemetry processing before it it is sent
-     * @param env - This is the current event being reported
-     * @param itemCtx - This is the context for the current request, ITelemetryPlugin instances
-     * can optionally use this to access the current core instance or define / pass additional information
-     * to later plugins (vs appending items to the telemetry item)
+     * This plugin is being unloaded and should remove any hooked events and cleanup any global/scoped values, after this
+     * call the plugin will be removed from the telemetry processing chain and will no longer receive any events..
+     * @param unloadCtx - The unload context to use for this call.
+     * @param unloadState - The details of the unload operation
      */
-    processTelemetry: (env: ITelemetryItem, itemCtx:IProcessTelemetryContext) => void;
+    unload?: (unloadCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) => void;
 }

package/src/JavaScriptSDK.Interfaces/ITelemetryUnloadState.ts

@@ -0,0 +1,10 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { TelemetryUnloadReason } from "../JavaScriptSDK.Enums/TelemetryUnloadReason";
+
+export interface ITelemetryUnloadState {
+    reason: TelemetryUnloadReason;
+    isAsync: boolean;
+    flushComplete?: boolean;
+}

package/types/JavaScriptSDK/BaseCore.d.ts

@@ -61,5 +61,9 @@ export declare class BaseCore implements IAppInsightsCore {
      */
     addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler | void;
     getPlugin<T extends IPlugin = IPlugin>(pluginIdentifier: string): ILoadedPlugin<T>;
+    /**
+     * Returns the unique event namespace that should be used
+     */
+    evtNamespace(): string;
     protected releaseQueue(): void;
 }

package/types/JavaScriptSDK/BaseTelemetryPlugin.d.ts

@@ -3,9 +3,10 @@ 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 } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
 import { IInstrumentHook } from "../JavaScriptSDK.Interfaces/IInstrumentHooks";
+import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
 /**
  * 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
@@ -51,8 +52,26 @@ export declare abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      * Internal helper to allow setting of the internal initialized setting for inherited instances and unit testing
      */
     protected setInitialized: (isInitialized: boolean) => void;
+    /**
+     * 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;
     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;
     /**
      * Add this hook so that it is automatically removed during unloading

package/types/JavaScriptSDK/ChannelController.d.ts

@@ -7,6 +7,10 @@ import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPlu
 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[];

package/types/JavaScriptSDK/CoreUtils.d.ts

@@ -2,47 +2,6 @@ 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)
@@ -193,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/EventHelpers.d.ts

@@ -0,0 +1,152 @@
+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 evtName - [Optional] The name of the event to return the registered handlers and full name (with namespaces)
+ */
+export declare function __getRegisteredEvents(target: any, evtName?: string): _IRegisteredEvents[];
+export declare function mergeEvtNamespace(theNamespace: string, namespaces: string | string[]): 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[], 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[], 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[]): 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[]): 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[], evtNamespace?: string | string[]): 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[]): 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[], evtNamespace?: string | string[]): 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[]): void;

package/types/JavaScriptSDK/HelperFuncs.d.ts

@@ -12,23 +12,7 @@ export declare function isNotNullOrUndefined(value: any): boolean;
 export declare function hasOwnProperty(obj: any, prop: string): boolean;
 export declare function isObject(value: any): boolean;
 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
@@ -187,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;
 /**
@@ -250,6 +235,12 @@ export declare function proxyFunctions<T, S>(target: T, source: S | (() => S), f
  * @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

package/types/JavaScriptSDK/InternalConstants.d.ts

@@ -0,0 +1,20 @@
+export declare const strEmpty = "";
+export declare const strProcessTelemetry = "processTelemetry";
+export declare const strPriority = "priority";
+export declare const strSetNextPlugin = "setNextPlugin";
+export declare const strIsInitialized = "isInitialized";
+export declare const strTeardown = "teardown";
+export declare const strCore = "core";
+export declare const strUpdate = "update";
+export declare const strDisabled = "disabled";
+export declare const strDoTeardown = "_doTeardown";
+export declare const strProcessNext = "processNext";
+export declare const strResume = "resume";
+export declare const strPause = "pause";
+export declare const strNotificationListener = "NotificationListener";
+export declare const strAddNotificationListener: string;
+export declare const strRemoveNotificationListener: string;
+export declare const strEventsSent = "eventsSent";
+export declare const strEventsDiscarded = "eventsDiscarded";
+export declare const strEventsSendRequest = "eventsSendRequest";
+export declare const strPerfEvent = "perfEvent";

package/types/JavaScriptSDK/ProcessTelemetryContext.d.ts

@@ -2,7 +2,7 @@ import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
 import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
-import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { IProcessTelemetryContext, IProcessTelemetryUnloadContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 /**
@@ -12,6 +12,13 @@ import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger
  * @param core - The current core instance
  */
 export declare function createProcessTelemetryContext(telemetryChain: ITelemetryPluginChain, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryContext;
+/**
+ * Creates a new Telemetry Item context with the current config, core and plugin execution chain for handling the unloading of the chain
+ * @param plugins - The plugin instances that will be executed
+ * @param config - The current config
+ * @param core - The current core instance
+ */
+export declare function createProcessTelemetryUnloadContext(telemetryChain: ITelemetryPluginChain, config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryUnloadContext;
 /**
  * Creates an execution chain from the array of plugins
  * @param plugins - The array of plugins that will be executed in this order
@@ -70,15 +77,15 @@ export declare class ProcessTelemetryContext implements IProcessTelemetryContext
      * @param itemCtx - This is the context for the current request, ITelemetryPlugin instances
      * can optionally use this to access the current core instance or define / pass additional information
      * to later plugins (vs appending items to the telemetry item)
+     * @returns boolean (true) if there is no more plugins to process otherwise false or undefined (void)
      */
-    processNext: (env: ITelemetryItem) => void;
+    processNext: (env: ITelemetryItem) => boolean | void;
     /**
      * Synchronously iterate over the context chain running the callback for each plugin, once
      * every plugin has been executed via the callback, any associated onComplete will be called.
      * @param callback - The function call for each plugin in the context chain
      */
     iterate: <T extends ITelemetryPlugin = ITelemetryPlugin>(callback: (plugin: T) => void) => void;
-    /**
     /**
      * Create a new context using the core and config from the current instance
      * @param plugins - The execution order to process the plugins, if null or not supplied

package/types/JavaScriptSDK/TelemetryHelpers.d.ts

@@ -1,5 +1,13 @@
 import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
+export interface IPluginState {
+    core?: IAppInsightsCore;
+    isInitialized?: boolean;
+    tearDown?: boolean;
+    disabled?: boolean;
+}
+export declare function _getPluginState(plugin: IPlugin): IPluginState;
 /**
  * Initialize the queue of plugins
  * @param plugins - The array of plugins to initialize and setting of the next plugin

package/types/JavaScriptSDK/TelemetryInitializerPlugin.d.ts

@@ -13,11 +13,4 @@ export declare class TelemetryInitializerPlugin extends BaseTelemetryPlugin impl
      */
     addTelemetryInitializer(telemetryInitializer: TelemetryInitializerFunction): ITelemetryInitializerHandler;
     processTelemetry(env: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
-    /**
-     * This plugin is being unloaded and should remove any hooked events and cleanup any global/scoped values, after this
-     * call the plugin will be removed from the telemetry processing chain and will no longer receive any events..
-     * @param itemCtx - This is the context that should be used during unloading if required to flush any cached events.
-     * @param isAsync - Should the plugin attempt to unload synchronously or can it complete asynchronously
-     */
-    unload(itemCtx: IProcessTelemetryContext, isAsync: boolean): void;
 }

package/types/JavaScriptSDK.Enums/LoggingEnums.d.ts

@@ -1,4 +1,4 @@
-export declare enum LoggingSeverity {
+export declare const enum eLoggingSeverity {
     /**
      * Error will be sent as internal telemetry
      */
@@ -8,6 +8,95 @@ export declare enum LoggingSeverity {
      */
     WARNING = 2
 }
+export declare const LoggingSeverity: {
+    CRITICAL: number;
+    WARNING: number;
+};
+export declare type LoggingSeverity = number | eLoggingSeverity;
+export declare const enum _eInternalMessageId {
+    BrowserDoesNotSupportLocalStorage = 0,
+    BrowserCannotReadLocalStorage = 1,
+    BrowserCannotReadSessionStorage = 2,
+    BrowserCannotWriteLocalStorage = 3,
+    BrowserCannotWriteSessionStorage = 4,
+    BrowserFailedRemovalFromLocalStorage = 5,
+    BrowserFailedRemovalFromSessionStorage = 6,
+    CannotSendEmptyTelemetry = 7,
+    ClientPerformanceMathError = 8,
+    ErrorParsingAISessionCookie = 9,
+    ErrorPVCalc = 10,
+    ExceptionWhileLoggingError = 11,
+    FailedAddingTelemetryToBuffer = 12,
+    FailedMonitorAjaxAbort = 13,
+    FailedMonitorAjaxDur = 14,
+    FailedMonitorAjaxOpen = 15,
+    FailedMonitorAjaxRSC = 16,
+    FailedMonitorAjaxSend = 17,
+    FailedMonitorAjaxGetCorrelationHeader = 18,
+    FailedToAddHandlerForOnBeforeUnload = 19,
+    FailedToSendQueuedTelemetry = 20,
+    FailedToReportDataLoss = 21,
+    FlushFailed = 22,
+    MessageLimitPerPVExceeded = 23,
+    MissingRequiredFieldSpecification = 24,
+    NavigationTimingNotSupported = 25,
+    OnError = 26,
+    SessionRenewalDateIsZero = 27,
+    SenderNotInitialized = 28,
+    StartTrackEventFailed = 29,
+    StopTrackEventFailed = 30,
+    StartTrackFailed = 31,
+    StopTrackFailed = 32,
+    TelemetrySampledAndNotSent = 33,
+    TrackEventFailed = 34,
+    TrackExceptionFailed = 35,
+    TrackMetricFailed = 36,
+    TrackPVFailed = 37,
+    TrackPVFailedCalc = 38,
+    TrackTraceFailed = 39,
+    TransmissionFailed = 40,
+    FailedToSetStorageBuffer = 41,
+    FailedToRestoreStorageBuffer = 42,
+    InvalidBackendResponse = 43,
+    FailedToFixDepricatedValues = 44,
+    InvalidDurationValue = 45,
+    TelemetryEnvelopeInvalid = 46,
+    CreateEnvelopeError = 47,
+    CannotSerializeObject = 48,
+    CannotSerializeObjectNonSerializable = 49,
+    CircularReferenceDetected = 50,
+    ClearAuthContextFailed = 51,
+    ExceptionTruncated = 52,
+    IllegalCharsInName = 53,
+    ItemNotInArray = 54,
+    MaxAjaxPerPVExceeded = 55,
+    MessageTruncated = 56,
+    NameTooLong = 57,
+    SampleRateOutOfRange = 58,
+    SetAuthContextFailed = 59,
+    SetAuthContextFailedAccountName = 60,
+    StringValueTooLong = 61,
+    StartCalledMoreThanOnce = 62,
+    StopCalledWithoutStart = 63,
+    TelemetryInitializerFailed = 64,
+    TrackArgumentsNotSpecified = 65,
+    UrlTooLong = 66,
+    SessionStorageBufferFull = 67,
+    CannotAccessCookie = 68,
+    IdTooLong = 69,
+    InvalidEvent = 70,
+    FailedMonitorAjaxSetRequestHeader = 71,
+    SendBrowserInfoOnUserInit = 72,
+    PluginException = 73,
+    NotificationException = 74,
+    SnippetScriptLoadFailure = 99,
+    InvalidInstrumentationKey = 100,
+    CannotParseAiBlobValue = 101,
+    InvalidContentBlob = 102,
+    TrackPageActionEventFailed = 103,
+    FailedAddingCustomDefinedRequestContext = 104,
+    InMemoryStorageBufferFull = 105
+}
 /**
  * Internal message ID. Please create a new one for every conceptually different message. Please keep alphabetically ordered
  */
@@ -95,4 +184,4 @@ export declare const _InternalMessageId: {
     FailedAddingCustomDefinedRequestContext: number;
     InMemoryStorageBufferFull: number;
 };
-export declare type _InternalMessageId = number | typeof _InternalMessageId;
+export declare type _InternalMessageId = number | _eInternalMessageId;

package/types/JavaScriptSDK.Enums/TelemetryUnloadReason.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The TelemetryUnloadReason enumeration contains the possible reasons for why a plugin is being unloaded / torndown().
+ */
+export declare const enum TelemetryUnloadReason {
+    /**
+     * Teardown has been called without any context.
+     */
+    ManualTeardown = 0
+}