@microsoft/applicationinsights-core-js 3.0.0-beta.2303-09 → 3.0.0-beta.2303-11

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@microsoft/applicationinsights-core-js",
     "author": "Microsoft Application Insights Team",
-    "version": "3.0.0-beta.2303-09",
+    "version": "3.0.0-beta.2303-11",
     "description": "Microsoft Application Insights Core Javascript SDK",
     "homepage": "https://github.com/microsoft/ApplicationInsights-JS#readme",
     "keywords": [

package/types/Config/DynamicProperty.d.ts

@@ -1,3 +1,3 @@
 import { _IDynamicConfigHandlerState } from "./_IDynamicConfigHandlerState";
-export declare function _setDynamicProperty<T, C, V = any>(state: _IDynamicConfigHandlerState<T>, target: C, name: string, value: V, inPlace?: boolean, rdOnly?: boolean): V;
+export declare function _setDynamicProperty<T, C, V = any>(state: _IDynamicConfigHandlerState<T>, target: C, name: string, value: V, inPlace?: boolean, rdOnly?: boolean): C;
 export declare function _makeDynamicObject<T>(state: _IDynamicConfigHandlerState<T>, target: any): any;

package/types/Config/DynamicSupport.d.ts

@@ -8,6 +8,73 @@ export declare function _cfgDeepCopy<T>(source: T): T;
  * @returns
  */
 export declare function getDynamicConfigHandler<T>(value: T | IDynamicConfigHandler<T>): IDynamicConfigHandler<T> | null;
+/**
+ * Mark the provided value so that if it's included into the configuration it will NOT have
+ * its properties converted into a dynamic (reactive) object. If the object is not a plain object
+ * or an array (ie. a class) this function has not affect as only Objects and Arrays are converted
+ * into dynamic objects in the dynamic configuration.
+ *
+ * When you have tagged a value as both {@link forceDynamicConversion} and blocked force will take precedence.
+ *
+ * You should only need to use this function, if you are creating dynamic "classes" from objects
+ * which confirm to the require interface. A common case for this is during unit testing where it's
+ * easier to create mock extensions.
+ *
+ * If `value` is falsy (null / undefined / 0 / empty string etc) it will not be tagged and
+ * if there is an exception adding the property to the value (because its frozen etc) the
+ * exception will be swallowed
+ *
+ * @example
+ * ```ts
+ * // This is a valid "extension", but it is technically an object
+ * // So when included in the config.extensions it WILL be cloned and then
+ * // converted into a dynamic object, where all of its properties will become
+ * // get/set object properties and will be tracked. While this WILL still
+ * // function, when attempt to use a mocking framework on top of this the
+ * // functions are now technically get accessors which return a function
+ * // and this can cause some mocking frameworks to fail.
+ * let mockChannel = {
+ *      pause: () => { },
+*      resume: () => { },
+*      teardown: () => { },
+*      flush: (async: any, callBack: any) => { },
+*      processTelemetry: (env: any) => { },
+*      setNextPlugin: (next: any) => { },
+*      initialize: (config: any, core: any, extensions: any) => { },
+*      identifier: "testChannel",
+*      priority: 1003
+* };
+ * ```
+ * @param value - The object that you want to block from being converted into a
+ * trackable dynamic object
+ * @returns The original value
+ */
+export declare function blockDynamicConversion<T>(value: T): T;
+/**
+ * This is the reverse case of {@link blockDynamicConversion} in that this will tag an
+ * object to indicate that it should always be converted into a dynamic trackable object
+ * even when not an object or array. So all properties of this object will become
+ * get / set accessor functions.
+ *
+ * When you have tagged a value as both {@link forceDynamicConversion} and blocked force will take precedence.
+ *
+ * If `value` is falsy (null / undefined / 0 / empty string etc) it will not be tagged and
+ * if there is an exception adding the property to the value (because its frozen etc) the
+ * exception will be swallowed.
+ * @param value - The object that should be tagged and converted if included into a dynamic
+ * configuration.
+ * @returns The original value
+ */
+export declare function forceDynamicConversion<T>(value: T): T;
+/**
+ * @internal
+ * @ignore
+ * Helper function to check whether an object can or should be converted into a dynamic
+ * object.
+ * @param value - The object to check whether it should be converted
+ * @returns `true` if the value should be converted otherwise `false`.
+ */
+export declare function _canMakeDynamic<T>(value: any): boolean;
 /**
  * Throws an invalid access exception
  * @param message - The message to include in the exception

package/types/Config/IDynamicConfigHandler.d.ts

@@ -62,6 +62,8 @@ export interface _IInternalDynamicConfigHandler<T extends IConfiguration> extend
     /**
      * @ignore
      * Internal function to explicitly block watching for any config updates
+     * @param configHandler - The Callback function to call after blocking update listening
+     * @param allowUpdate - An optional flag to enable updating config properties marked as readonly
      */
-    _block: (configHandler: WatcherFunction<T>) => void;
+    _block: (configHandler: WatcherFunction<T>, allowUpdate?: boolean) => void;
 }

package/types/JavaScriptSDK/DiagnosticLogger.d.ts

@@ -17,26 +17,12 @@ export declare class DiagnosticLogger implements IDiagnosticLogger {
      */
     queue: _InternalLogMessage[];
     constructor(config?: IConfiguration);
-    /**
-     * When this is true the SDK will throw exceptions to aid in debugging.
-     */
-    enableDebugExceptions(): boolean;
     /**
      * 0: OFF (default)
      * 1: CRITICAL
      * 2: >= WARNING
      */
     consoleLoggingLevel(): number;
-    /**
-     * 0: OFF
-     * 1: CRITICAL (default)
-     * 2: >= WARNING
-     */
-    telemetryLoggingLevel(): number;
-    /**
-     * The maximum number of internal messages allowed to be sent per page view
-     */
-    maxInternalMessageLimit(): number;
     /**
      * 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

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

@@ -51,7 +51,7 @@ export interface IConfiguration {
     /**
      * If enabled, uncaught exceptions will be thrown to help with debugging
      */
-    enableDebugExceptions?: boolean;
+    enableDebug?: boolean;
     /**
      * Endpoint where telemetry data is sent
      */

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

@@ -2,26 +2,12 @@ import { LoggingSeverity, _InternalMessageId } from "../JavaScriptSDK.Enums/Logg
 import { _InternalLogMessage } from "../JavaScriptSDK/DiagnosticLogger";
 import { ITelemetryUpdateState } from "./ITelemetryUpdateState";
 export interface IDiagnosticLogger {
-    /**
-     * When this is true the SDK will throw exceptions to aid in debugging.
-     */
-    enableDebugExceptions: () => boolean;
     /**
      * 0: OFF
      * 1: only critical (default)
      * 2: critical + info
      */
     consoleLoggingLevel: () => number;
-    /**
-     * 0: OFF (default)
-     * 1: CRITICAL
-     * 2: WARNING
-     */
-    telemetryLoggingLevel: () => number;
-    /**
-     * The maximum number of internal messages allowed to be sent per page view
-     */
-    maxInternalMessageLimit: () => number;
     /**
      * The internal logging queue
      */

package/types/__DynamicConstants.d.ts

@@ -40,7 +40,6 @@ export declare const _DYN_USER_AGENT = "userAgent";
 export declare const _DYN_SPLIT = "split";
 export declare const _DYN_NODE_TYPE = "nodeType";
 export declare const _DYN_REPLACE = "replace";
-export declare const _DYN_ENABLE_DEBUG_EXCEPTI5 = "enableDebugExceptions";
 export declare const _DYN_LOG_INTERNAL_MESSAGE = "logInternalMessage";
 export declare const _DYN_TYPE = "type";
 export declare const _DYN_HANDLER = "handler";

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

@@ -54,5 +54,5 @@ export { IDynamicConfigHandler } from "./Config/IDynamicConfigHandler";
 export { IDynamicPropertyHandler } from "./Config/IDynamicPropertyHandler";
 export { IWatchDetails, IWatcherHandler, WatcherFunction } from "./Config/IDynamicWatcher";
 export { createDynamicConfig, onConfigChange } from "./Config/DynamicConfig";
-export { getDynamicConfigHandler } from "./Config/DynamicSupport";
+export { getDynamicConfigHandler, blockDynamicConversion, forceDynamicConversion } from "./Config/DynamicSupport";
 export { cfgDfValidate, cfgDfMerge, cfgDfBoolean, cfgDfFunc, cfgDfString, cfgDfSet } from "./Config/ConfigDefaultHelpers";