@microsoft/applicationinsights-core-js 2.8.0-beta.2203-09 → 2.8.0-beta.2203-12

package/src/JavaScriptSDK/BaseTelemetryPlugin.ts

@@ -303,7 +303,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      * @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.
      */
-     public teardown(unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState): void | boolean {
+    public teardown(unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState): void | boolean {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
         return false;
     }

package/src/JavaScriptSDK/ChannelController.ts

@@ -61,7 +61,7 @@ export function createChannelControllerPlugin(channelQueue: _IInternalChannels[]
         return createProcessTelemetryContext(null, core.config, core, null)
     }
 
-    function _processChannelQueue<T extends IBaseProcessingContext>(theChannels: _IInternalChannels[], itemCtx: T, processFn: (chainCtx: T) => void, onComplete: () => void) {
+    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() {
@@ -160,7 +160,9 @@ export function createChannelControllerPlugin(channelQueue: _IInternalChannels[]
                 }
             });
         },
-        isInitialized: () => { return isInitialized },
+        isInitialized: () => {
+            return isInitialized
+        },
         processTelemetry: (item: ITelemetryItem, itemCtx: IProcessTelemetryContext) => {
             _processChannelQueue(channelQueue, itemCtx || _getTelCtx(), (chainCtx: IProcessTelemetryContext) => {
                 chainCtx[strProcessNext](item);

package/src/JavaScriptSDK/CoreUtils.ts

@@ -410,7 +410,7 @@ export const EventHelper: IEventHelper = {
  * @param logger
  * @returns
  */
- export function _legacyCookieMgr(config?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr {
+export function _legacyCookieMgr(config?: IConfiguration, logger?: IDiagnosticLogger): ICookieMgr {
     let cookieMgr = _gblCookieMgr(config, logger);
     let legacyCanUseCookies = (CoreUtils as any)._canUseCookies;
 

package/src/JavaScriptSDK/DataCacheHelper.ts

@@ -7,7 +7,7 @@ import { newId } from "./RandomHelper";
 
 const _objDefineProperty = ObjDefineProperty;
 
-const version = "2.7.3";
+const version = "2.8.0-beta.2203-12";
 let instanceName = "." + newId(6);
 let _dataUid = 0;
 

package/src/JavaScriptSDK/DiagnosticLogger.ts

@@ -165,7 +165,7 @@ export class DiagnosticLogger implements IDiagnosticLogger {
              * This will write an error to the console if possible
              * @param message {string} - The error message
              */
-             _self.errorToConsole = (message: string) => {
+            _self.errorToConsole = (message: string) => {
                 _logToConsole("error", message);
                 _debugExtMsg("error", message);
             }

package/src/JavaScriptSDK/EnvUtils.ts

@@ -357,7 +357,7 @@ export function isSafari(userAgentStr ?: string) {
  * Checks if HTML5 Beacons are supported in the current environment.
  * @returns True if supported, false otherwise.
  */
- export function isBeaconsSupported(): boolean {
+export function isBeaconsSupported(): boolean {
     if (_beaconsSupported === null) {
         _beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
     }

package/src/JavaScriptSDK/EventHelpers.ts

@@ -52,7 +52,7 @@ function _normalizeNamespace(name: string) {
     return name;
 }
 
-function _getEvtNamespace(eventName: string, evtNamespace?: string | string[]): IEventDetails {
+function _getEvtNamespace(eventName: string | undefined, evtNamespace?: string | string[] | null): IEventDetails {
     if (evtNamespace) {
         let theNamespace: string = "";
         if (isArray(evtNamespace)) {
@@ -81,7 +81,7 @@ function _getEvtNamespace(eventName: string, evtNamespace?: string | string[]):
         }
     }
 
-    let parsedEvent: any[] = (eventNamespace.exec(eventName) || []);
+    let parsedEvent: any[] = (eventNamespace.exec(eventName || "") || []);
 
     return {
         type: parsedEvent[1],
@@ -195,7 +195,7 @@ function _unregisterEvents(target: any, evtName: IEventDetails, unRegFn: (regEve
     }
 }
 
-export function mergeEvtNamespace(theNamespace: string, namespaces: string | string[]): string | string[] {
+export function mergeEvtNamespace(theNamespace: string, namespaces?: string | string[] | null): string | string[] {
     let newNamespaces: string | string[];
 
     if (namespaces) {
@@ -225,7 +225,7 @@ export function mergeEvtNamespace(theNamespace: string, namespaces: string | str
  * @param useCapture [Optional] Defaults to false
  * @returns True if the function was bound successfully to the event, otherwise false
  */
-export function eventOn<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[], useCapture: boolean = false) {
+export function eventOn<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[] | null, useCapture: boolean = false) {
     let result = false;
 
     if (target) {
@@ -263,7 +263,7 @@ export function eventOn<T>(target: T, eventName: string, handlerRef: any, evtNam
  * if the eventName also includes a namespace the namespace(s) are merged into a single namespace
  * @param useCapture [Optional] Defaults to false
  */
- export function eventOff<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[], useCapture: boolean = false) {
+export function eventOff<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[] | null, useCapture: boolean = false) {
     if (target) {
         try {
             let evtName = _getEvtNamespace(eventName, evtNamespace);
@@ -296,7 +296,7 @@ export function eventOn<T>(target: T, eventName: string, handlerRef: any, evtNam
  * @param useCapture [Optional] Defaults to false
  * @returns True if the function was bound successfully to the event, otherwise false
  */
- export function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture: boolean = false) {
+export function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture: boolean = false) {
     return eventOn(obj, eventNameWithoutOn, handlerRef, null, useCapture);
 }
 
@@ -321,7 +321,7 @@ export function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: an
  * @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 function addEventHandler(eventName: string, callback: any, evtNamespace?: string | string[]): boolean {
+export function addEventHandler(eventName: string, callback: any, evtNamespace?: string | string[] | null): boolean {
     let result = false;
     let w = getWindow();
     if (w) {
@@ -346,7 +346,7 @@ export function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: an
  * 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 function removeEventHandler(eventName: string, callback: any, evtNamespace?: string | string[]) {
+export function removeEventHandler(eventName: string, callback: any, evtNamespace?: string | string[] | null) {
     let w = getWindow();
     if (w) {
         eventOff(w, eventName, callback, evtNamespace);
@@ -367,7 +367,7 @@ export function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: an
  * @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
  */
-function _addEventListeners(events: string[], listener: any, excludeEvents: string[], evtNamespace: string | string[]): boolean {
+function _addEventListeners(events: string[], listener: any, excludeEvents?: string[] | null, evtNamespace?: string | string[] | null): boolean {
     let added = false;
 
     if (listener && events && events.length > 0) {
@@ -391,7 +391,6 @@ function _addEventListeners(events: string[], listener: any, excludeEvents: stri
  * @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 function addEventListeners(events: string[], listener: any, excludeEvents?: string[], evtNamespace?: string): boolean {
 export function addEventListeners(events: string[], listener: any, excludeEvents?: string[], evtNamespace?: string | string[]): boolean {
     let added = false;
 
@@ -434,8 +433,7 @@ export function removeEventListeners(events: string[], listener: any, evtNamespa
  * @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 function addPageUnloadEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string): boolean {
-export function addPageUnloadEventListener(listener: any, excludeEvents: string[], evtNamespace?: string | string[]): boolean {
+export function addPageUnloadEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string | 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([strBeforeUnload, strUnload, strPageHide], listener, excludeEvents, evtNamespace);
@@ -464,8 +462,7 @@ export function removePageUnloadEventListener(listener: any, evtNamespace?: stri
  * 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[], evtNamespace?: string): boolean {
-export function addPageHideEventListener(listener: any, excludeEvents: string[], evtNamespace?: string | string[]): boolean {
+export function addPageHideEventListener(listener: any, excludeEvents?: string[] | null, evtNamespace?: string | string[] | null): boolean {
 
     function _handlePageVisibility(evt: any) {
         let doc = getDocument();
@@ -498,7 +495,7 @@ export function addPageHideEventListener(listener: any, excludeEvents: string[],
  * @param evtNamespace - The unique namespace used when calling addPageShowEventListener
  */
 
-export function removePageHideEventListener(listener: any, evtNamespace?: string | string[]) {
+export function removePageHideEventListener(listener: any, evtNamespace?: string | string[] | null) {
     // add the unique page show namespace to any provided namespace so we only remove the ones added by "pagehide"
     let newNamespaces = mergeEvtNamespace(strPageHideNamespace, evtNamespace);
     removeEventListeners([strPageHide], listener, newNamespaces);
@@ -516,8 +513,7 @@ export function removePageHideEventListener(listener: any, evtNamespace?: string
  * so that only the matching "removePageShowEventListener" can remove these events.
  * @returns true - when at least one of the events was registered otherwise false
  */
-//export function addPageShowEventListener(listener: any, excludeEvents?: string[], evtNamespace?: string): boolean {
-export function addPageShowEventListener(listener: any, excludeEvents: string[], evtNamespace?: string | string[]): boolean {
+export function addPageShowEventListener(listener: any, excludeEvents?: string[] | null, evtNamespace?: string | string[] | null): boolean {
 
     function _handlePageVisibility(evt: any) {
         let doc = getDocument();
@@ -546,7 +542,7 @@ export function addPageShowEventListener(listener: any, excludeEvents: string[],
  * @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 function removePageShowEventListener(listener: any, evtNamespace?: string | string[]) {
+export function removePageShowEventListener(listener: any, evtNamespace?: string | string[] | null) {
     // add the unique page show namespace to any provided namespace so we only remove the ones added by "pageshow"
     let newNamespaces = mergeEvtNamespace(strPageShowNamespace, evtNamespace);
     removeEventListeners([strPageShow], listener, newNamespaces);

package/src/JavaScriptSDK/HelperFuncs.ts

@@ -22,9 +22,9 @@ const strToString = "toString";
  * Constant string defined to support minimization
  * @ignore
  */
- const str__Proto = "__proto__";
+const str__Proto = "__proto__";
 
- /**
+/**
   * Constant string defined to support minimization
   * @ignore
   */
@@ -58,27 +58,27 @@ const rLeadingNumeric = /^(\d+[\w\d_$])/;
  * Pre-lookup to check if we are running on a modern browser (i.e. not IE8)
  * @ignore
  */
- let _objGetPrototypeOf = Object["getPrototypeOf"];
+let _objGetPrototypeOf = Object["getPrototypeOf"];
 
- /**
+/**
   * Helper used to get the prototype of the target object as getPrototypeOf is not available in an ES3 environment.
   * @ignore
   */
- export function _getObjProto(target:any) {
-     if (target) {
-         // This method doesn't existing in older browsers (e.g. IE8)
-         if (_objGetPrototypeOf) {
-             return _objGetPrototypeOf(target);
-         }
+export function _getObjProto(target:any) {
+    if (target) {
+        // This method doesn't existing in older browsers (e.g. IE8)
+        if (_objGetPrototypeOf) {
+            return _objGetPrototypeOf(target);
+        }
  
-         // target[Constructor] May break if the constructor has been changed or removed
-         let newProto = target[str__Proto] || target[strShimPrototype] || target[strConstructor];
-         if(newProto) {
-             return newProto;
-         }
-     }
+        // target[Constructor] May break if the constructor has been changed or removed
+        let newProto = target[str__Proto] || target[strShimPrototype] || target[strConstructor];
+        if(newProto) {
+            return newProto;
+        }
+    }
  
-     return null;
+    return null;
 }
 
 export function objToString(obj: any) {
@@ -89,19 +89,19 @@ export function isTypeof(value: any, theType: string): boolean {
     return typeof value === theType;
 }
 
-export function isUndefined(value: any): boolean {
+export function isUndefined(value: any): value is undefined {
     return value === undefined || typeof value === strShimUndefined;
 }
 
-export function isNotUndefined(value: any): boolean {
+export function isNotUndefined<T>(value: T): value is T {
     return !isUndefined(value);
 }
 
-export function isNullOrUndefined(value: any): boolean {
+export function isNullOrUndefined(value: any): value is null | undefined {
     return (value === null || isUndefined(value));
 }
 
-export function isNotNullOrUndefined(value: any): boolean {
+export function isNotNullOrUndefined<T>(value: T): value is T {
     return !isNullOrUndefined(value);
 }
 
@@ -109,7 +109,7 @@ export function hasOwnProperty(obj: any, prop: string): boolean {
     return !!(obj && ObjHasOwnProperty.call(obj, prop));
 }
 
-export function isObject(value: any): boolean {
+export function isObject<T>(value: T): value is T {
     // Changing to inline for performance
     return !!(value && typeof value === strShimObject);
 }
@@ -186,7 +186,7 @@ export function strEndsWith(value: string, search: string) {
  * @param search - The characters to be searched for at the end of the value.
  * @returns true if the given search value is found at the end of the string, otherwise false.
  */
- export function _strEndsWithPoly(value: string, search: string) {
+export function _strEndsWithPoly(value: string, search: string) {
     let result = false;
     let searchLen = search ? search.length : 0;
     let valLen = value ? value.length : 0;
@@ -214,7 +214,7 @@ export function strEndsWith(value: string, search: string) {
 export function strStartsWith(value: string, checkValue: string) {
     let result = false;
     if (value && checkValue && !(result = value === checkValue)) {
-       // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
+        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
         result = _strStartsWith ? value[cStrStartsWith](checkValue) : _strStartsWithPoly(value, checkValue);
     }
 
@@ -227,7 +227,7 @@ export function strStartsWith(value: string, checkValue: string) {
  * @param checkValue - The characters to be searched for at the start of the value.
  * @returns true if the given search value is found at the start of the string, otherwise false.
  */
- export function _strStartsWithPoly(value: string, checkValue: string) {
+export function _strStartsWithPoly(value: string, checkValue: string) {
     // Using helper for performance and because string startsWith() is not available on IE
     let result = false;
     let chkLen = checkValue ? checkValue.length : 0;
@@ -328,7 +328,7 @@ export function isPlainObject(value: any): boolean {
     let result: boolean = false;
 
     if (value && typeof value === "object") {
-            // Inlining _objGetPrototypeOf for performance to avoid an additional function call
+        // Inlining _objGetPrototypeOf for performance to avoid an additional function call
         let proto = _objGetPrototypeOf ? _objGetPrototypeOf(value) : _getObjProto(value);
         if (!proto) {
             // No prototype found so this is a plain Object eg. 'Object.create(null)'
@@ -389,7 +389,7 @@ export function _toISOStringPoly(date: Date) {
  * @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 function arrForEach<T = any>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => void|number, thisArg?: any): void {
+export function arrForEach<T = any>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => undefined | void | number, thisArg?: any): void {
     let len = arr.length;
     try {
         for (let idx = 0; idx < len; idx++) {
@@ -661,7 +661,7 @@ export 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 function setValue<T, K extends keyof T>(target: T, field: K, value: T[K], valChk?: (value: T[K]) => boolean, srcChk?: (value: T[K]) => boolean) {
+export 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) {
     let theValue = value;
     if (target) {
         theValue = target[field];
@@ -796,7 +796,7 @@ export function proxyFunctionAs<T, S>(target: T, name: string, source: S | (() =
  * @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 function proxyFunctions<T, S>(target: T, source: S | (() => S), functionsToProxy: (keyof S)[], overwriteTarget: boolean = true) {
+export function proxyFunctions<T, S>(target: T, source: S | (() => S), functionsToProxy: (keyof S)[], overwriteTarget: boolean = true) {
     if (target && source && isObject(target) && isArray(functionsToProxy)) {
         arrForEach(functionsToProxy, (theFuncName) => {
             if (isString(theFuncName)) {
@@ -888,7 +888,7 @@ export function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1 | any, obj2?: T2, ob
         idx++;
     }
 
-	// Handle case when target is a string or something (possible in deep copy)
+    // Handle case when target is a string or something (possible in deep copy)
     if (!isObject(extended)) {
         extended = {} as T1 & T2 & T3 & T4 & T5 & T6;
     }

package/src/JavaScriptSDK/InstrumentHooks.ts

@@ -73,7 +73,7 @@ function _doCallbacks(hooks:IInstrumentHook[], callDetails: IInstrumentCallDetai
 function _createFunctionHook(aiHook:IInstrumentHooks) {
 
     // Define a temporary method that queues-up a the real method call
-    return function () {
+    return function (this: any) {
         let funcThis = this;
         // Capture the original arguments passed to the method
         let orgArgs = arguments as any;

package/src/JavaScriptSDK/PerfManager.ts

@@ -104,12 +104,9 @@ export class PerfEvent implements IPerfEvent {
                         _self.isChildEvt = (): boolean => true;
                     }
                     _self[key] = value;
-                }
-                else if (key === PerfEvent.ChildrenContextKey) {
+                } else if (key === PerfEvent.ChildrenContextKey) {
                     _self[key] = value;
-                }
-                else
-                {
+                } else {
                     let ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
                     ctx[key] = value;
                 }
@@ -146,7 +143,7 @@ export class PerfManager implements IPerfManager  {
      */
     private ctx: { [key: string] : any } = {};
 
-    constructor(manager: INotificationManager) {
+    constructor(manager?: INotificationManager) {
 
         dynamicProto(PerfManager, this, (_self) => {
 

package/src/JavaScriptSDK/ProcessTelemetryContext.ts

@@ -26,7 +26,7 @@ const strGetTelCtx = "_getTelCtx";
 let _chainId = 0;
 
 interface OnCompleteCallback {
-    func: Function;
+    func: () => void;
     self: any;      // This for the function
     args: any[];    // Additional arguments for the function
 }
@@ -67,7 +67,7 @@ function _getNextProxyStart(proxy: ITelemetryPluginChain, config: IConfiguration
 function _createInternalContext<T extends IBaseProcessingContext>(telemetryChain: ITelemetryPluginChain, config: IConfiguration, core:IAppInsightsCore, startAt?: IPlugin): IInternalContext<T> {
     // We have a special case where we want to start execution from this specific plugin
     // or we simply reuse the existing telemetry plugin chain (normal execution case)
-    let _nextProxy: ITelemetryPluginChain = null;  // By Default set as no next plugin
+    let _nextProxy: ITelemetryPluginChain | null = null;  // By Default set as no next plugin
     let _onComplete: OnCompleteCallback[] = [];
 
     if (startAt !== null) {
@@ -78,7 +78,9 @@ function _createInternalContext<T extends IBaseProcessingContext>(telemetryChain
     let context: IInternalContext<T> = {
         _next: _moveNext,
         ctx: {
-            core: () => { return core },
+            core: () => {
+                return core
+            },
             diagLog: () => {
                 return safeGetLogger(core, config);
             },
@@ -101,7 +103,7 @@ function _createInternalContext<T extends IBaseProcessingContext>(telemetryChain
         } as T
     };
 
-    function _addOnComplete(onComplete: Function, that?: any, ...args: any[]) {
+    function _addOnComplete(onComplete: () => void, that?: any, ...args: any[]) {
         if (onComplete) {
             _onComplete.push({
                 func: onComplete,
@@ -209,7 +211,7 @@ function _createInternalContext<T extends IBaseProcessingContext>(telemetryChain
  * @param core - The current core instance
  * @param startAt - Identifies the next plugin to execute, if null there is no "next" plugin and if undefined it should assume the start of the chain
  */
-export function createProcessTelemetryContext(telemetryChain: ITelemetryPluginChain, config: IConfiguration, core:IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryContext {
+export function createProcessTelemetryContext(telemetryChain: ITelemetryPluginChain | null, config: IConfiguration, core:IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryContext {
     let internalContext: IInternalContext<IProcessTelemetryContext> = _createInternalContext<IProcessTelemetryContext>(telemetryChain, config, core, startAt);
     let context = internalContext.ctx;
 
@@ -221,7 +223,7 @@ export function createProcessTelemetryContext(telemetryChain: ITelemetryPluginCh
         return !nextPlugin;
     }
 
-    function _createNew(plugins: IPlugin[] | ITelemetryPluginChain = null, startAt?: IPlugin) {
+    function _createNew(plugins: IPlugin[] | ITelemetryPluginChain | null = null, startAt?: IPlugin) {
         if (isArray(plugins)) {
             plugins = createTelemetryProxyChain(plugins, config, core, startAt);
         }
@@ -274,7 +276,7 @@ export function createProcessTelemetryUnloadContext(telemetryChain: ITelemetryPl
  * @param core - The current core instance
  * @param startAt - Identifies the next plugin to execute, if null there is no "next" plugin and if undefined it should assume the start of the chain
  */
- export function createProcessTelemetryUpdateContext(telemetryChain: ITelemetryPluginChain, config: IConfiguration, core:IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryUpdateContext {
+export function createProcessTelemetryUpdateContext(telemetryChain: ITelemetryPluginChain, config: IConfiguration, core:IAppInsightsCore, startAt?: IPlugin): IProcessTelemetryUpdateContext {
     let internalContext: IInternalContext<IProcessTelemetryUpdateContext> = _createInternalContext<IProcessTelemetryUpdateContext>(telemetryChain, config, core, startAt);
     let context = internalContext.ctx;
 
@@ -307,7 +309,7 @@ export function createProcessTelemetryUnloadContext(telemetryChain: ITelemetryPl
  * should be for legacy plugins only. Currently, only used for passing the current core instance and to provide better error
  * reporting (hasRun) when errors occur.
  */
- export function createTelemetryProxyChain(plugins: IPlugin[], config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): ITelemetryPluginChain {
+export function createTelemetryProxyChain(plugins: IPlugin[], config: IConfiguration, core: IAppInsightsCore, startAt?: IPlugin): ITelemetryPluginChain {
     let firstProxy: ITelemetryPluginChain = null;
     let add = startAt ? false : true;
 
@@ -399,11 +401,11 @@ export function createTelemetryPluginProxy(plugin: ITelemetryPlugin, config: ICo
     }
 
     function _processChain<T extends IBaseProcessingContext>(
-                itemCtx: T,
-                processPluginFn: (itemCtx: T) => boolean,
-                name: string,
-                details: () => any,
-                isAsync: boolean) {
+        itemCtx: T,
+        processPluginFn: (itemCtx: T) => boolean,
+        name: string,
+        details: () => any,
+        isAsync: boolean) {
 
         let hasRun = false;
         let identifier = plugin ? plugin.identifier : strTelemetryPluginChain;
@@ -560,7 +562,7 @@ export class ProcessTelemetryContext implements IProcessTelemetryContext {
 
     public getExtCfg: <T>(identifier:string, defaultValue?:T|any) => T;
                         
-    public getConfig: (identifier:string, field: string, defaultValue?: number | string | boolean) => number | string | boolean;
+    public getConfig: (identifier:string, field: string, defaultValue?: number | string | boolean | string[] | RegExp[] | Function) => number | string | boolean | string[] | RegExp[] | Function;
 
     /**
      * Returns the IAppInsightsCore instance for the current request

package/src/JavaScriptSDK/RandomHelper.ts

@@ -122,7 +122,7 @@ export function mwcRandom32(signed?: boolean) {
  * 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 {
+export function newId(maxLength = 22): string {
     const base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
     // Start with an initial random number, consuming the value in reverse byte order

package/src/JavaScriptSDK/TelemetryHelpers.ts

@@ -3,13 +3,16 @@
 "use strict";
 
 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 { arrForEach, isFunction } from "./HelperFuncs";
-import { strCore, strIsInitialized, strPriority, strProcessTelemetry, strSetNextPlugin, strTeardown } from "./InternalConstants";
+import { strCore, strDoTeardown, strIsInitialized, strPriority, strProcessTelemetry, strSetNextPlugin, strTeardown } from "./InternalConstants";
 import { createElmNodeData } from "./DataCacheHelper";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
+import { IUnloadableComponent } from "../JavaScriptSDK.Interfaces/IUnloadableComponent";
+import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
 
+const strDoUnload = "_doUnload";
 export interface IPluginState {
     core?: IAppInsightsCore;
     isInitialized?: boolean;
@@ -100,4 +103,33 @@ export function sortPlugins<T = IPlugin>(plugins:T[]) {
         return result;
     });
     // sort complete
+}
+
+/**
+ * Teardown / Unload helper to perform teardown/unloading operations for the provided components synchronously or asynchronously, this will call any
+ * _doTeardown() or _doUnload() functions on the provided components to allow them to finish removal.
+ * @param components - The components you want to unload
+ * @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.
+ */
+export function unloadComponents(components: any | IUnloadableComponent[], unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void): void | boolean {
+    let idx = 0;
+
+    function _doUnload(): void | boolean {
+        while (idx < components.length) {
+            let component = components[idx++];
+            if (component) {
+                let func = component[strDoUnload] || component[strDoTeardown];
+                if (isFunction(func)) {
+                    if (func.call(component, unloadCtx, unloadState, _doUnload) === true) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+
+    return _doUnload();
 }

package/src/JavaScriptSDK.Enums/TelemetryUnloadReason.ts

@@ -4,7 +4,7 @@
 /**
  * The TelemetryUnloadReason enumeration contains the possible reasons for why a plugin is being unloaded / torndown().
  */
- export const enum TelemetryUnloadReason {
+export const enum TelemetryUnloadReason {
     /**
      * Teardown has been called without any context.
      */

package/src/JavaScriptSDK.Enums/TelemetryUpdateReason.ts

@@ -4,7 +4,7 @@
 /**
  * The TelemetryUpdateReason enumeration contains a set of bit-wise values that specify the reason for update request.
  */
- export const enum TelemetryUpdateReason {
+export const enum TelemetryUpdateReason {
     /**
      * Unknown.
      */

package/src/JavaScriptSDK.Interfaces/IProcessTelemetryContext.ts

@@ -76,7 +76,7 @@ export interface IBaseProcessingContext {
      * @param that - The "this" value to use for the onComplete call, if not provided or undefined defaults to the current context
      * @param args - Any additional arguments to pass to the onComplete function
      */
-    onComplete: (onComplete: Function, that?: any, ...args: any[]) => void;
+    onComplete: (onComplete: () => void, that?: any, ...args: any[]) => void;
 
     /**
      * Create a new context using the core and config from the current instance, returns a new instance of the same type

package/src/JavaScriptSDK.Interfaces/ITelemetryUpdateState.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 import { TelemetryUpdateReason } from "../JavaScriptSDK.Enums/TelemetryUpdateReason";
-import { IConfiguration } from "./IConfiguration";
+//import { IConfiguration } from "./IConfiguration";
 import { IPlugin } from "./ITelemetryPlugin";
 
 export interface ITelemetryUpdateState {

package/src/JavaScriptSDK.Interfaces/IUnloadableComponent.ts

@@ -0,0 +1,17 @@
+import { IProcessTelemetryUnloadContext } from "./IProcessTelemetryContext";
+import { ITelemetryUnloadState } from "./ITelemetryUnloadState";
+
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+export interface IUnloadableComponent {
+    /**
+    * 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.
+    */
+    _doUnload?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void) => void | boolean;
+}