@microsoft/applicationinsights-core-js 3.0.0-beta.2210-01 → 3.0.0-beta.2210-02

package/src/JavaScriptSDK/EnvUtils.ts

@@ -35,7 +35,6 @@ let _enableMocks = false;
 let _useXDomainRequest: boolean | null = null;
 let _beaconsSupported: boolean | null = null;
 
-
 function _hasProperty(theClass: any, property: string) {
     let supported = false;
     if (theClass) {
@@ -72,123 +71,6 @@ export function setEnableEnvMocks(enabled: boolean) {
     _enableMocks = enabled;
 }
 
-// /**
-//  * Return the named global object if available, will return null if the object is not available.
-//  * @param name The globally named object
-//  */
-// export function getinst<T>(name:string): T {
-//     let gbl = getGlobal();
-//     if (gbl && gbl[name]) {
-//         return gbl[name] as T;
-//     }
-
-//     // Test workaround, for environments where <global>.window (when global == window) doesn't return the base window
-//     if (name === strWindow && hasWindow()) {
-//         // tslint:disable-next-line: no-angle-bracket-type-assertion
-//         return <any>window as T;
-//     }
-
-//     return null;
-// }
-
-// /**
-//  * Checks if window object is available, this is required as we support the API running without a
-//  * window /document (eg. Node server, electron webworkers) and if we attempt to assign a window
-//  * object to a local variable or pass as an argument an "Uncaught ReferenceError: window is not defined"
-//  * exception will be thrown.
-//  * Defined as a function to support lazy / late binding environments.
-//  */
-// export const hasWindow = () => boolean = hasWindow;
-//     return Boolean(typeof window === strShimObject && window);
-// }
-
-// /**
-//  * Returns the global window object if it is present otherwise null.
-//  * This helper is used to access the window object without causing an exception
-//  * "Uncaught ReferenceError: window is not defined"
-//  */
-// export function getWindow(): Window | null {
-//     if (hasWindow()) {
-//         return window;
-//     }
-
-//     // Return the global instance or null
-//     return getInst(strWindow);
-// }
-
-// /**
-//  * Checks if document object is available, this is required as we support the API running without a
-//  * window /document (eg. Node server, electron webworkers) and if we attempt to assign a document
-//  * object to a local variable or pass as an argument an "Uncaught ReferenceError: document is not defined"
-//  * exception will be thrown.
-//  * Defined as a function to support lazy / late binding environments.
-//  */
-// export function hasDocument(): boolean {
-//     return Boolean(typeof document === strShimObject && document);
-// }
-
-// /**
-//  * Returns the global document object if it is present otherwise null.
-//  * This helper is used to access the document object without causing an exception
-//  * "Uncaught ReferenceError: document is not defined"
-//  */
-// export function getDocument(): Document | null {
-//     if (hasDocument()) {
-//         return document;
-//     }
-
-//     return getInst(strDocument);
-// }
-
-
-// /**
-//  * Checks if navigator object is available, this is required as we support the API running without a
-//  * window /document (eg. Node server, electron webworkers) and if we attempt to assign a navigator
-//  * object to a local variable or pass as an argument an "Uncaught ReferenceError: navigator is not defined"
-//  * exception will be thrown.
-//  * Defined as a function to support lazy / late binding environments.
-//  */
-// export function hasNavigator(): boolean {
-//     return Boolean(typeof navigator === strShimObject && navigator);
-// }
-
-// /**
-//  * Returns the global navigator object if it is present otherwise null.
-//  * This helper is used to access the navigator object without causing an exception
-//  * "Uncaught ReferenceError: navigator is not defined"
-//  */
-// export function getNavigator(): Navigator | null {
-//     if (hasNavigator()) {
-//         return navigator;
-//     }
-
-//     return getInst(strNavigator);
-// }
-
-// /**
-//  * Checks if history object is available, this is required as we support the API running without a
-//  * window /document (eg. Node server, electron webworkers) and if we attempt to assign a history
-//  * object to a local variable or pass as an argument an "Uncaught ReferenceError: history is not defined"
-//  * exception will be thrown.
-//  * Defined as a function to support lazy / late binding environments.
-//  */
-// export function hasHistory(): boolean {
-//     return Boolean(typeof history === strShimObject && history);
-// }
-
-// /**
-//  * Returns the global history object if it is present otherwise null.
-//  * This helper is used to access the history object without causing an exception
-//  * "Uncaught ReferenceError: history is not defined"
-//  */
-// export function getHistory(): History | null {
-//     if (hasHistory()) {
-//         return history;
-//     }
-
-//     return getInst(strHistory);
-// }
-
 /**
  * Returns the global location object if it is present otherwise null.
  * This helper is used to access the location object without causing an exception
@@ -323,21 +205,6 @@ export function getIEVersion(userAgentStr: string = null): number {
     return null;
 }
 
-// /**
-//  * Returns string representation of an object suitable for diagnostics logging.
-//  */
-// export function dumpObj(object: any): string {
-//     const objectTypeDump: string = Object[strShimPrototype].toString.call(object);
-//     let propertyValueDump: string = STR_EMPTY;
-//     if (objectTypeDump === "[object Error]") {
-//         propertyValueDump = "{ stack: '" + object.stack + "', message: '" + object.message + "', name: '" + object.name + "'";
-//     } else if (hasJSON()) {
-//         propertyValueDump = getJSON().stringify(object);
-//     }
-
-//     return objectTypeDump + propertyValueDump;
-// }
-
 export function isSafari(userAgentStr ?: string) {
     if (!userAgentStr || !isString(userAgentStr)) {
         let navigator = getNavigator() || ({} as Navigator);

package/src/JavaScriptSDK/EventHelpers.ts

@@ -1,7 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
-import { arrForEach, arrIndexOf, getDocument, getWindow, isArray, objForEachKey, objKeys } from "@nevware21/ts-utils";
+import { arrForEach, arrIndexOf, getDocument, getWindow, isArray, objKeys } from "@nevware21/ts-utils";
 import { createElmNodeData, createUniqueNamespace } from "./DataCacheHelper";
+import { objForEachKey } from "./HelperFuncs";
 import { STR_EMPTY } from "./InternalConstants";
 
 // Added to help with minfication
@@ -46,7 +47,7 @@ const eventNamespace = /^([^.]*)(?:\.(.+)|)/
 
 function _normalizeNamespace(name: string) {
     if (name && name.replace) {
-        return name.replace(/^\s*\.*|\.*\s*$/g, STR_EMPTY);
+        return name.replace(/^[\s\.]+|(?=[\s\.])[\.\s]+$/g, STR_EMPTY);
     }
 
     return name;
@@ -216,13 +217,13 @@ export function mergeEvtNamespace(theNamespace: string, namespaces?: string | st
 
 /**
  * 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)
+ * @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 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
+ * @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[] | null, useCapture: boolean = false) {
@@ -253,15 +254,15 @@ export function eventOn<T>(target: T, eventName: string, handlerRef: any, evtNam
 
 /**
  * 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,
+ * @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
+ * @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
+ * @param useCapture - [Optional] Defaults to false
  */
 export function eventOff<T>(target: T, eventName: string, handlerRef: any, evtNamespace?: string | string[] | null, useCapture: boolean = false) {
     if (target) {
@@ -290,10 +291,10 @@ export function eventOff<T>(target: T, eventName: string, handlerRef: any, evtNa
 
 /**
  * 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
+ * @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 function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture: boolean = false) {
@@ -302,13 +303,13 @@ export function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: an
 
 /**
  * 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,
+ * @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
+ * @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
+ * @param useCapture - [Optional] Defaults to false
  */
 export function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture: boolean = false) {
     eventOff(obj, eventNameWithoutOn, handlerRef, null, useCapture);
@@ -316,8 +317,8 @@ export function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: an
 
 /**
  * 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 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
  */
@@ -339,9 +340,9 @@ export function addEventHandler(eventName: string, callback: any, evtNamespace?:
 
 /**
  * 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,
+ * @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
+ * @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.
@@ -361,8 +362,8 @@ export function removeEventHandler(eventName: string, callback: any, evtNamespac
 
 /**
  * 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 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
@@ -385,8 +386,8 @@ function _addEventListeners(events: string[], listener: any, excludeEvents?: str
 
 /**
  * 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 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
@@ -408,8 +409,8 @@ export function addEventListeners(events: string[], listener: any, excludeEvents
 
 /**
  * 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 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 function removeEventListeners(events: string[], listener: any, evtNamespace?: string | string[]) {

package/src/JavaScriptSDK/HelperFuncs.ts

@@ -1,19 +1,15 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
-import { ObjAssign, ObjClass, ObjHasOwnProperty, ObjProto, strShimFunction, strShimPrototype } from "@microsoft/applicationinsights-shims";
+import { ObjAssign, ObjClass, strShimFunction } from "@microsoft/applicationinsights-shims";
 import {
-    arrForEach, isArray, isBoolean, isError, isFunction, isNullOrUndefined, isObject, isString, isUndefined, objDeepFreeze,
-    objDefineAccessors, objForEachKey, objHasOwnProperty, strIndexOf, throwUnsupported
+    arrForEach, asString as asString21, isArray, isBoolean, isError, isFunction, isNullOrUndefined, isObject, isString, isUndefined,
+    objDeepFreeze, objDefineAccessors, objForEachKey as objForEachKey21, objHasOwn, objHasOwnProperty, strIndexOf
 } from "@nevware21/ts-utils";
 import { STR_EMPTY } from "./InternalConstants";
 
 // RESTRICT and AVOID circular dependencies you should not import other contained modules or export the contents of this file directly
 
 // Added to help with minification
-const cString = "String";
-const cObject = "Object";
-const strToISOString = "toISOString";
-const strMap = "map";
 const strToString = "toString";
 const strGetPrototypeOf = "getPrototypeOf";
 
@@ -23,11 +19,7 @@ const strGetPrototypeOf = "getPrototypeOf";
   */
 const strConstructor = "constructor";
 
-const DateProto = Date[strShimPrototype];
-const _dateToISOString = DateProto[strToISOString] || _polyfillRequired("Date", strToISOString);
-const _objToString = ObjProto[strToString] || _polyfillRequired(cObject, strToString);
-
-const _fnToString = ObjHasOwnProperty[strToString] || _polyfillRequired(cString, strToString);
+const _fnToString = ObjClass[strToString];
 // Cache what this browser reports as the object function constructor (as a string)
 const _objFunctionString = _fnToString.call(ObjClass);
 
@@ -35,17 +27,7 @@ const rCamelCase = /-([a-z])/g;
 const rNormalizeInvalid = /([^\w\d_$])/g;
 const rLeadingNumeric = /^(\d+[\w\d_$])/;
 
-function _polyfillRequired(object:string, name: string): any {
-    return function() {
-        throwUnsupported("Polyfill required for [" + name + "]");
-    }
-}
-
-export let _getObjProto = Object[strGetPrototypeOf] || _polyfillRequired(cObject, strGetPrototypeOf);
-
-export function objToString(obj: any) {
-    return _objToString.call(obj);
-}
+export let _getObjProto = Object[strGetPrototypeOf];
 
 export function isNotUndefined<T>(value: T): value is T {
     return !isUndefined(value);
@@ -60,7 +42,7 @@ export function isNotNullOrUndefined<T>(value: T): value is T {
  * normalizes the name so that it would. This method does not identify or change any keywords
  * meaning that if you pass in a known keyword the same value will be returned.
  * This is a simplified version
- * @param name The name to validate
+ * @param name - The name to validate
  */
 export function normalizeJsName(name: string): string {
     let value = name;
@@ -80,6 +62,14 @@ export function normalizeJsName(name: string): string {
     return value;
 }
 
+/**
+ * This is a helper function for the equivalent of arForEach(objKeys(target), callbackFn), this is a
+ * performance optimization to avoid the creation of a new array for large objects
+ * @param target - The target object to find and process the keys
+ * @param callbackfn - The function to call with the details
+ */
+export const objForEachKey = objForEachKey21;
+
 /**
  * A simple wrapper (for minification support) to check if the value contains the search string.
  * @param value - The string value to check for the existence of the search value
@@ -108,7 +98,7 @@ export function isPlainObject(value: any): boolean {
             result = true;
         } else {
             // Objects that have a prototype are plain only if they were created using the Object global (native) function
-            if (proto[strConstructor] && ObjHasOwnProperty.call(proto, strConstructor)) {
+            if (proto[strConstructor] && objHasOwnProperty(proto, strConstructor)) {
                 proto = proto[strConstructor];
             }
 
@@ -123,7 +113,7 @@ export function isPlainObject(value: any): boolean {
  * Convert a date to I.S.O. format in IE8
  */
 export function toISOString(date: Date) {
-    return _dateToISOString.call(date);
+    return date && date.toISOString() || "";
 }
 
 export const deepFreeze: <T>(obj: T) => T = objDeepFreeze;
@@ -195,15 +185,6 @@ export function getSetValue<T, K extends keyof T>(target: T, field: K, defValue?
     return theValue;
 }
 
-/**
- * Get the mapped config value, if null or undefined any supplied defaultValue will be returned.
- * @param field - The name of the field as the named enum value (number) or the string name.
- * @param defaultValue - The default value to return if the config field is not present, null or undefined.
- */
-export function getCfgValue<V>(theValue: V, defaultValue?: V): V {
-    return !isNullOrUndefined(theValue) ? theValue : defaultValue;
-}
-
 function _createProxyFunction<S>(source: S | (() => S), funcName: (keyof S)) {
     let srcFunc: () => S = null;
     let src: S = null;
@@ -253,7 +234,7 @@ export function proxyAssign<T, S>(target: T, source: S, chkSet?: (name: string,
                         target[field as string] = _createProxyFunction(source, field);
                     }
                 } else if (!chkSet || chkSet(field, false, source, target)) {
-                    if (objHasOwnProperty(target, field)) {
+                    if (objHasOwn(target, field)) {
                         // Remove any previous instance property
                         delete (target as any)[field];
                     }
@@ -316,7 +297,7 @@ export function proxyFunctions<T, S>(target: T, source: S | (() => S), functions
 /**
  * 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
+ * @param defaults - Simple helper
  */
 export function createClassFromInterface<T>(defaults?: T) {
     return class {
@@ -385,7 +366,7 @@ export function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1 | any, obj2?: T2, ob
         let isArgArray = isArray(arg);
         let isArgObj = isObject(arg);
         for (let prop in arg) {
-            let propOk = (isArgArray && (prop in arg)) || (isArgObj && (ObjHasOwnProperty.call(arg, prop)));
+            let propOk = (isArgArray && (prop in arg)) || (isArgObj && objHasOwn(arg, prop));
             if (!propOk) {
                 continue;
             }
@@ -420,4 +401,6 @@ export function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1 | any, obj2?: T2, ob
     }
 
     return extended;
-}
+}
+
+export const asString = asString21;

package/src/JavaScriptSDK/InternalConstants.ts

@@ -5,6 +5,7 @@
 // Note: DON'T Export these const from the package as we are still targeting IE/ES5 this will export a mutable variables that someone could change ###
 // ###################################################################################################################################################
 
+export const UNDEFINED_VALUE: any = undefined;
 export const STR_EMPTY = "";
 export const STR_CHANNELS = "channels";
 export const STR_CORE = "core";
@@ -24,3 +25,7 @@ export const STR_ERROR_TO_CONSOLE = "errorToConsole";
 export const STR_WARN_TO_CONSOLE = "warnToConsole";
 
 export const STR_GET_PERF_MGR = "getPerfMgr";
+export const STR_DOMAIN = "domain";
+export const STR_PATH = "path";
+
+export const STR_NOT_DYNAMIC_ERROR = "Not dynamic - ";

package/src/JavaScriptSDK/NotificationManager.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 import dynamicProto from "@microsoft/dynamicproto-js";
 import { arrForEach, arrIndexOf } from "@nevware21/ts-utils";
+import { createDynamicConfig } from "../Config/DynamicConfig";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { INotificationListener } from "../JavaScriptSDK.Interfaces/INotificationListener";
 import { INotificationManager } from "../JavaScriptSDK.Interfaces/INotificationManager";
@@ -9,6 +10,10 @@ import { IPerfEvent } from "../JavaScriptSDK.Interfaces/IPerfEvent";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
 import { STR_EVENTS_DISCARDED, STR_EVENTS_SEND_REQUEST, STR_EVENTS_SENT, STR_PERF_EVENT } from "./InternalConstants";
 
+const defaultValues = {
+    perfEvtsSendAll: false
+};
+
 function _runListeners(listeners: INotificationListener[], name: string, isAsync: boolean, callback: (listener: INotificationListener) => void) {
     arrForEach(listeners, (listener) => {
         if (listener && listener[name]) {
@@ -32,7 +37,13 @@ export class NotificationManager implements INotificationManager {
     listeners: INotificationListener[] = [];
 
     constructor(config?: IConfiguration) {
-        let perfEvtsSendAll = !!(config ||{}).perfEvtsSendAll;
+        let perfEvtsSendAll: boolean;
+        
+        let cfgHandler = createDynamicConfig(config, defaultValues);
+
+        cfgHandler.watch((details) => {
+            perfEvtsSendAll = !!details.cfg.perfEvtsSendAll;
+        });
 
         dynamicProto(NotificationManager, this, (_self) => {
             _self.addNotificationListener = (listener: INotificationListener): void => {
@@ -41,7 +52,7 @@ export class NotificationManager implements INotificationManager {
 
             /**
              * Removes all instances of the listener.
-             * @param {INotificationListener} listener - AWTNotificationListener to remove.
+             * @param listener - AWTNotificationListener to remove.
              */
             _self.removeNotificationListener = (listener: INotificationListener): void => {
                 let index: number = arrIndexOf(_self.listeners, listener);
@@ -53,7 +64,7 @@ export class NotificationManager implements INotificationManager {
 
             /**
              * Notification for events sent.
-             * @param {ITelemetryItem[]} events - The array of events that have been sent.
+             * @param events - The array of events that have been sent.
              */
             _self.eventsSent = (events: ITelemetryItem[]): void => {
                 _runListeners(_self.listeners, STR_EVENTS_SENT, true, (listener) => {
@@ -63,8 +74,8 @@ export class NotificationManager implements INotificationManager {
 
             /**
              * Notification for events being discarded.
-             * @param {ITelemetryItem[]} events - The array of events that have been discarded by the SDK.
-             * @param {number} reason           - The reason for which the SDK discarded the events. The EventsDiscardedReason
+             * @param events - The array of events that have been discarded by the SDK.
+             * @param reason - The reason for which the SDK discarded the events. The EventsDiscardedReason
              * constant should be used to check the different values.
              */
             _self.eventsDiscarded = (events: ITelemetryItem[], reason: number): void => {
@@ -75,8 +86,8 @@ export class NotificationManager implements INotificationManager {
 
             /**
              * [Optional] A function called when the events have been requested to be sent to the sever.
-             * @param {number} sendReason - The reason why the event batch is being sent.
-             * @param {boolean} isAsync   - A flag which identifies whether the requests are being sent in an async or sync manner.
+             * @param sendReason - The reason why the event batch is being sent.
+             * @param isAsync - A flag which identifies whether the requests are being sent in an async or sync manner.
              */
             _self.eventsSendRequest = (sendReason: number, isAsync: boolean): void => {
                 _runListeners(_self.listeners, STR_EVENTS_SEND_REQUEST, isAsync, (listener) => {
@@ -104,7 +115,7 @@ export class NotificationManager implements INotificationManager {
     
     /**
      * Adds a notification listener.
-     * @param {INotificationListener} listener - The notification listener to be added.
+     * @param listener - The notification listener to be added.
      */
     addNotificationListener(listener: INotificationListener): void {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
@@ -112,7 +123,7 @@ export class NotificationManager implements INotificationManager {
 
     /**
      * Removes all instances of the listener.
-     * @param {INotificationListener} listener - AWTNotificationListener to remove.
+     * @param listener - AWTNotificationListener to remove.
      */
     removeNotificationListener(listener: INotificationListener): void {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
@@ -120,7 +131,7 @@ export class NotificationManager implements INotificationManager {
 
     /**
      * Notification for events sent.
-     * @param {ITelemetryItem[]} events - The array of events that have been sent.
+     * @param events - The array of events that have been sent.
      */
     eventsSent(events: ITelemetryItem[]): void {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
@@ -128,8 +139,8 @@ export class NotificationManager implements INotificationManager {
 
     /**
      * Notification for events being discarded.
-     * @param {ITelemetryItem[]} events - The array of events that have been discarded by the SDK.
-     * @param {number} reason           - The reason for which the SDK discarded the events. The EventsDiscardedReason
+     * @param events - The array of events that have been discarded by the SDK.
+     * @param reason - The reason for which the SDK discarded the events. The EventsDiscardedReason
      * constant should be used to check the different values.
      */
     eventsDiscarded(events: ITelemetryItem[], reason: number): void {
@@ -138,8 +149,8 @@ export class NotificationManager implements INotificationManager {
 
     /**
      * [Optional] A function called when the events have been requested to be sent to the sever.
-     * @param {number} sendReason - The reason why the event batch is being sent.
-     * @param {boolean} isAsync   - A flag which identifies whether the requests are being sent in an async or sync manner.
+     * @param sendReason - The reason why the event batch is being sent.
+     * @param isAsync - A flag which identifies whether the requests are being sent in an async or sync manner.
      */
     eventsSendRequest?(sendReason: number, isAsync: boolean): void {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging

package/src/JavaScriptSDK/PerfManager.ts

@@ -177,7 +177,7 @@ export class PerfManager implements IPerfManager  {
     /**
      * Create a new event and start timing, the manager may return null/undefined to indicate that it does not
      * want to monitor this source event.
-     * @param src The source name of the event
+     * @param src - The source name of the event
      * @param payloadDetails - An optional callback function to fetch the payload details for the event.
      * @param isAsync - Is the event occurring from a async event
      */
@@ -188,7 +188,7 @@ export class PerfManager implements IPerfManager  {
 
     /**
      * Complete the perfEvent and fire any notifications.
-     * @param perfEvent Fire the event which will also complete the passed event
+     * @param perfEvent - Fire the event which will also complete the passed event
      */
     public fire(perfEvent: IPerfEvent): void {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging