@microsoft/applicationinsights-core-js 3.0.0-beta.2210-04 → 3.0.0-beta.2210-07

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@microsoft/applicationinsights-core-js",
     "author": "Microsoft Application Insights Team",
-    "version": "3.0.0-beta.2210-04",
+    "version": "3.0.0-beta.2210-07",
     "description": "Microsoft Application Insights Core Javascript SDK",
     "homepage": "https://github.com/microsoft/ApplicationInsights-JS#readme",
     "keywords": [
@@ -65,8 +65,8 @@
     },
     "dependencies": {
         "@microsoft/applicationinsights-shims": "2.0.1",
-        "@microsoft/dynamicproto-js": "^1.1.6",
-        "@nevware21/ts-utils": "^0.4.3"
+        "@microsoft/dynamicproto-js": "^1.1.7",
+        "@nevware21/ts-utils": "^0.4.4"
     },
     "publishConfig": {
         "tag": "beta"

package/src/JavaScriptSDK/AppInsightsCore.ts

@@ -7,7 +7,6 @@ import {
     arrAppend, arrForEach, arrIndexOf, deepExtend, dumpObj, isFunction, isNullOrUndefined, objDeepFreeze, objDefineProp, objFreeze,
     objHasOwn, throwError
 } from "@nevware21/ts-utils";
-import { applyDefaults } from "../Config/ConfigDefaults";
 import { createDynamicConfig, onConfigChange } from "../Config/DynamicConfig";
 import { IConfigDefaults } from "../Config/IConfigDefaults";
 import { IDynamicConfigHandler, _IInternalDynamicConfigHandler } from "../Config/IDynamicConfigHandler";
@@ -154,7 +153,7 @@ function _deepMergeConfig(details: IWatchDetails<IConfiguration>, target: any, n
                 _deepMergeConfig(details, target[key], value, merge);
             } else {
                 // Just Assign (replace) and/or make the property dynamic
-                details.hdlr.set(target, key, value);
+                details.set(target, key, value);
             }
         });
     }
@@ -612,13 +611,13 @@ export class AppInsightsCore implements IAppInsightsCore {
                         objForEachKey(theConfig, (key) => {
                             if (!objHasOwn(newConfig, key)) {
                                 // Set the value to undefined
-                                details.hdlr.set(theConfig, key, UNDEFINED_VALUE);
+                                details.set(theConfig, key, UNDEFINED_VALUE);
                             }
                         });
                     }
 
                     // Apply defaults to the new config
-                    applyDefaults(theConfig, defaultConfig as any);
+                    details.setDf(theConfig, defaultConfig as any);
 
                     // Reapply the notification manager
                     _initExtConfig();

package/src/JavaScriptSDK/CookieMgr.ts

@@ -4,7 +4,6 @@ import {
     arrForEach, dumpObj, getDocument, getNavigator, isArray, isFunction, isNullOrUndefined, isString, isTruthy, isUndefined, objDeepFreeze,
     objForEachKey, strEndsWith, strTrim
 } from "@nevware21/ts-utils";
-import { applyDefaults } from "../Config/ConfigDefaults";
 import { createDynamicConfig, onConfigChange } from "../Config/DynamicConfig";
 import { IConfigDefaults } from "../Config/IConfigDefaults";
 import { _eInternalMessageId, eLoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
@@ -150,10 +149,10 @@ export function createCookieMgr(rootConfig?: IConfiguration, logger?: IDiagnosti
     onConfigChange(rootConfig, (details) => {
 
         // Make sure the root config has all of the the defaults to the root config to ensure they are dynamic
-        applyDefaults(details.cfg, rootDefaultConfig);
+        details.setDf(details.cfg, rootDefaultConfig);
 
         // Create and apply the defaults to the cookieCfg element
-        cookieMgrConfig = applyDefaults(details.cfg.cookieCfg, defaultConfig);
+        cookieMgrConfig =  details.setDf(details.cfg.cookieCfg, defaultConfig);
         let isEnabled = cookieMgrConfig.enabled;
         if (isNullOrUndefined(isEnabled)) {
             // Set the enabled from the provided setting or the legacy root values

package/src/JavaScriptSDK/ProcessTelemetryContext.ts

@@ -3,7 +3,7 @@
 "use strict";
 
 import { arrForEach, dumpObj, isArray, isFunction, isNullOrUndefined, isUndefined, objFreeze, objKeys } from "@nevware21/ts-utils";
-import { _applyDefaultValue, applyDefaults } from "../Config/ConfigDefaults";
+import { _applyDefaultValue } from "../Config/ConfigDefaults";
 import { createDynamicConfig } from "../Config/DynamicConfig";
 import { IConfigDefaults } from "../Config/IConfigDefaults";
 import { IDynamicConfigHandler } from "../Config/IDynamicConfigHandler";
@@ -65,19 +65,19 @@ function _getNextProxyStart(proxy: ITelemetryPluginChain, core: IAppInsightsCore
 /**
  * @ignore
  * @param telemetryChain
- * @param dynamicConfig
+ * @param dynamicHandler
  * @param core
  * @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
  * @returns
  */
-function _createInternalContext<T extends IBaseProcessingContext>(telemetryChain: ITelemetryPluginChain, dynamicConfig: IDynamicConfigHandler<IConfiguration>, core: IAppInsightsCore, startAt?: IPlugin): IInternalContext<T> {
+function _createInternalContext<T extends IBaseProcessingContext>(telemetryChain: ITelemetryPluginChain, dynamicHandler: IDynamicConfigHandler<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 = null;  // By Default set as no next plugin
     let _onComplete: OnCompleteCallback[] = [];
 
-    if (!dynamicConfig) {
-        dynamicConfig = createDynamicConfig({}, null, core.logger);
+    if (!dynamicHandler) {
+        dynamicHandler = createDynamicConfig({}, null, core.logger);
     }
 
     if (startAt !== null) {
@@ -92,10 +92,10 @@ function _createInternalContext<T extends IBaseProcessingContext>(telemetryChain
                 return core
             },
             diagLog: () => {
-                return safeGetLogger(core, dynamicConfig.cfg);
+                return safeGetLogger(core, dynamicHandler.cfg);
             },
             getCfg: () => {
-                return dynamicConfig.cfg;
+                return dynamicHandler.cfg;
             },
             getExtCfg: _resolveExtCfg,
             getConfig: _getConfig,
@@ -153,19 +153,26 @@ function _createInternalContext<T extends IBaseProcessingContext>(telemetryChain
 
     function _getExtCfg<T>(identifier: string, createIfMissing: boolean) {
         let idCfg: T = null;
-        if (dynamicConfig.cfg && identifier) {
-            let extCfg = dynamicConfig.cfg.extensionConfig;
+        let cfg = dynamicHandler.cfg;
+        if (cfg && identifier) {
+            let extCfg = cfg.extensionConfig;
             if (!extCfg && createIfMissing) {
-                dynamicConfig.set(dynamicConfig.cfg, "extensionConfig", {});
-                extCfg = dynamicConfig.cfg.extensionConfig;
+                extCfg = {};
             }
-            
+
+            // Always set the value so that it's created as a dynamic config element (if not already)
+            dynamicHandler.set(cfg, "extensionConfig", extCfg);  // Note: it is valid for the "value" to be undefined
+            extCfg = cfg.extensionConfig;
+        
             if (extCfg) {
                 idCfg = extCfg[identifier];
                 if (!idCfg && createIfMissing) {
-                    dynamicConfig.set(extCfg, identifier, {});
-                    idCfg = extCfg[identifier];
+                    idCfg = {} as T;
                 }
+
+                // Always set the value so that it's created as a dynamic config element (if not already)
+                dynamicHandler.set(extCfg, identifier, idCfg);
+                idCfg = extCfg[identifier];
             }
         }
 
@@ -181,23 +188,23 @@ function _createInternalContext<T extends IBaseProcessingContext>(telemetryChain
             objForEachKey(defaultValues, (field, defaultValue) => {
                 // for each unspecified field, set the default value
                 if (isNullOrUndefined(newConfig[field])) {
-                    let cfgValue = dynamicConfig.cfg[field];
+                    let cfgValue = dynamicHandler.cfg[field];
                     if (cfgValue || !isNullOrUndefined(cfgValue)) {
                         newConfig[field] = cfgValue;
                     }
                 }
 
-                _applyDefaultValue(newConfig, field, defaultValue);
+                _applyDefaultValue(dynamicHandler, newConfig, field, defaultValue);
             });
         }
 
-        return applyDefaults(newConfig, defaultValues);
+        return dynamicHandler.setDf(newConfig, defaultValues);
     }
 
     function _getConfig(identifier:string, field: string, defaultValue: number | string | boolean | string[] | RegExp[] | Function = false) {
         let theValue;
         let extConfig: T = _getExtCfg(identifier, false);
-        let rootConfig = dynamicConfig.cfg;
+        let rootConfig = dynamicHandler.cfg;
 
         if (extConfig && (extConfig[field] || !isNullOrUndefined(extConfig[field]))) {
             theValue = extConfig[field];

package/src/JavaScriptSDK.Interfaces/IDiagnosticLogger.ts

@@ -4,8 +4,6 @@ import { LoggingSeverity, _InternalMessageId } from "../JavaScriptSDK.Enums/Logg
 import { _InternalLogMessage } from "../JavaScriptSDK/DiagnosticLogger";
 import { ITelemetryUpdateState } from "./ITelemetryUpdateState";
 
-"use strict"
-
 export interface IDiagnosticLogger {
     /**
      * When this is true the SDK will throw exceptions to aid in debugging.
@@ -38,14 +36,14 @@ export interface IDiagnosticLogger {
 
     /**
      * This method will throw exceptions in debug mode or attempt to log the error as a console warning.
-     * @param severity - {LoggingSeverity} - The severity of the log message
-     * @param message - {_InternalLogMessage} - The log message.
+     * @param severity - The severity of the log message
+     * @param message - The log message.
      */
     throwInternal(severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
 
     /**
      * This will write a warning to the console if possible
-     * @param message - {string} - The warning message
+     * @param message - The warning message
      */
     warnToConsole(message: string): void;
 
@@ -53,7 +51,7 @@ export interface IDiagnosticLogger {
      * This will write an error to the console if possible.
      * Provided by the default DiagnosticLogger instance, and internally the SDK will fall back to warnToConsole, however,
      * direct callers MUST check for its existence on the logger as you can provide your own IDiagnosticLogger instance.
-     * @param message - {string} - The error message
+     * @param message - The error message
      */
     errorToConsole?(message: string): void;
 
@@ -64,8 +62,8 @@ export interface IDiagnosticLogger {
 
     /**
      * Logs a message to the internal queue.
-     * @param severity - {LoggingSeverity} - The severity of the log message
-     * @param message - {_InternalLogMessage} - The message to log.
+     * @param severity - The severity of the log message
+     * @param message - The message to log.
      */
     logInternalMessage?(severity: LoggingSeverity, message: _InternalLogMessage): void;
 

package/types/Config/ConfigDefaults.d.ts

@@ -1,10 +1,10 @@
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { IConfigDefaultCheck, IConfigDefaults } from "./IConfigDefaults";
+import { IConfigDefaultCheck } from "./IConfigDefaults";
+import { IDynamicConfigHandler } from "./IDynamicConfigHandler";
 /**
  * Applies the default value on the config property and makes sure that it's dynamic
  * @param theConfig
  * @param name
  * @param defaultValue
  */
-export declare function _applyDefaultValue<T extends IConfiguration, C>(theConfig: C, name: string, defaultValue: C[keyof C] | IConfigDefaultCheck<C, C[keyof C], T>): void;
-export declare function applyDefaults<C>(theConfig: C, defaultValues: IConfigDefaults<C>): C;
+export declare function _applyDefaultValue<T extends IConfiguration, C>(dynamicHandler: IDynamicConfigHandler<T>, theConfig: C, name: string, defaultValue: C[keyof C] | IConfigDefaultCheck<C, C[keyof C], T>): void;

package/types/Config/IDynamicConfigHandler.d.ts

@@ -1,5 +1,6 @@
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
+import { IConfigDefaults } from "./IConfigDefaults";
 import { IWatcherHandler, WatcherFunction } from "./IDynamicWatcher";
 /**
  * This interface identifies the config which can track changes
@@ -32,6 +33,12 @@ export interface IDynamicConfigHandler<T extends IConfiguration> {
      * @throws TypeError if the provided config is not a monitored dynamic config
      */
     set: <C, V>(theConfig: C, name: string, value: V) => V;
+    /**
+     * Set default values for the config if not present.
+     * @param theConfig - The configuration object to set default on (if missing)
+     * @param defaultValues - The default values to apply to the config
+     */
+    setDf: <C>(theConfig: C, defaultValues: IConfigDefaults<C, T>) => C;
 }
 /**
  * @internal

package/types/Config/IDynamicWatcher.d.ts

@@ -1,10 +1,25 @@
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IUnloadHook } from "../JavaScriptSDK.Interfaces/IUnloadHook";
-import { IDynamicConfigHandler } from "./IDynamicConfigHandler";
+import { IConfigDefaults } from "./IConfigDefaults";
 import { IDynamicPropertyHandler } from "./IDynamicPropertyHandler";
 export interface IWatchDetails<T extends IConfiguration> {
+    /**
+     * The current config object
+     */
     cfg: T;
-    hdlr: IDynamicConfigHandler<T>;
+    /**
+     * Set the value against the provided config/name with the value, the property
+     * will be converted to be dynamic (if not already) as long as the provided config
+     * is already a tracked dynamic object.
+     * @throws TypeError if the provided config is not a monitored dynamic config
+     */
+    set: <C, V>(theConfig: C, name: string, value: V) => V;
+    /**
+     * Set default values for the config if not present.
+     * @param theConfig - The configuration object to set default on (if missing)
+     * @param defaultValues - The default values to apply to the config
+     */
+    setDf: <C>(theConfig: C, defaultValues: IConfigDefaults<C>) => C;
 }
 export declare type WatcherFunction<T extends IConfiguration> = (details: IWatchDetails<T>) => void;
 /**

package/types/JavaScriptSDK.Interfaces/IDiagnosticLogger.d.ts

@@ -28,20 +28,20 @@ export interface IDiagnosticLogger {
     queue: _InternalLogMessage[];
     /**
      * This method will throw exceptions in debug mode or attempt to log the error as a console warning.
-     * @param severity - {LoggingSeverity} - The severity of the log message
-     * @param message - {_InternalLogMessage} - The log message.
+     * @param severity - The severity of the log message
+     * @param message - The log message.
      */
     throwInternal(severity: LoggingSeverity, msgId: _InternalMessageId, msg: string, properties?: Object, isUserAct?: boolean): void;
     /**
      * This will write a warning to the console if possible
-     * @param message - {string} - The warning message
+     * @param message - The warning message
      */
     warnToConsole(message: string): void;
     /**
      * This will write an error to the console if possible.
      * Provided by the default DiagnosticLogger instance, and internally the SDK will fall back to warnToConsole, however,
      * direct callers MUST check for its existence on the logger as you can provide your own IDiagnosticLogger instance.
-     * @param message - {string} - The error message
+     * @param message - The error message
      */
     errorToConsole?(message: string): void;
     /**
@@ -50,8 +50,8 @@ export interface IDiagnosticLogger {
     resetInternalMessageCount(): void;
     /**
      * Logs a message to the internal queue.
-     * @param severity - {LoggingSeverity} - The severity of the log message
-     * @param message - {_InternalLogMessage} - The message to log.
+     * @param severity - The severity of the log message
+     * @param message - The message to log.
      */
     logInternalMessage?(severity: LoggingSeverity, message: _InternalLogMessage): void;
     /**

package/types/__DynamicConstants.d.ts

@@ -1,6 +1,7 @@
 export declare const _DYN_LENGTH = "length";
 export declare const _DYN_NOTIFY = "notify";
 export declare const _DYN_THROW_INTERNAL = "throwInternal";
+export declare const _DYN_SET_DF = "setDf";
 export declare const _DYN_WATCH = "watch";
 export declare const _DYN_LOGGER = "logger";
 export declare const _DYN_CONFIGURABLE = "configurable";

package/types/applicationinsights-core-js.d.ts

@@ -50,6 +50,5 @@ export { IConfigCheckFn, IConfigDefaultCheck, IConfigDefaults, IConfigSetFn } fr
 export { IDynamicConfigHandler } from "./Config/IDynamicConfigHandler";
 export { IDynamicPropertyHandler } from "./Config/IDynamicPropertyHandler";
 export { IWatchDetails, IWatcherHandler, WatcherFunction } from "./Config/IDynamicWatcher";
-export { applyDefaults } from "./Config/ConfigDefaults";
 export { createDynamicConfig, onConfigChange } from "./Config/DynamicConfig";
 export { getDynamicConfigHandler } from "./Config/DynamicSupport";

package/types/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.32.0"
+      "packageVersion": "7.32.1"
     }
   ]
 }