@microsoft/1ds-core-js 3.1.3 → 3.1.7

package/src/Utils.ts

@@ -4,22 +4,25 @@
  * @copyright Microsoft 2018
  * File containing utility functions.
  */
-import { getGlobal, objCreateFn, ObjHasOwnProperty, strShimObject } from "@microsoft/applicationinsights-shims";
+import { objCreateFn, strShimObject } from "@microsoft/applicationinsights-shims";
 import { IEventProperty, IExtendedTelemetryItem } from "./DataModels";
 import { EventPropertyType, _ExtendedInternalMessageId, GuidStyle, ValueKind, FieldValueSanitizerType, EventLatency } from "./Enums";
 import {
-    ITelemetryItem, getDocument, hasNavigator, getNavigator, getWindow, getGlobalInst,
+    ITelemetryItem, getDocument, getNavigator, getWindow, getGlobalInst,
     objForEachKey, isUndefined, isNullOrUndefined, isNumber, isReactNative, isString, isBoolean, isArray,
     newGuid, isObject, perfNow, hasOwnProperty, addEventHandler, uaDisallowsSameSiteNone, strPrototype, objDefineAccessors,
     toISOString, strTrim, isFunction, objKeys, arrReduce, arrMap, arrIndexOf, arrForEach, strUndefined, strObject,
-    areCookiesSupported, IDiagnosticLogger, ICookieMgr,  safeGetCookieMgr, IConfiguration, IAppInsightsCore, generateW3CId,
-    mwcRandom32, mwcRandomSeed, random32, randomValue, newId, isIE, dateNow, isError, isDate, isTypeof, ICoreUtils, strEndsWith,
-    objFreeze,
+    areCookiesSupported, ICookieMgr,  safeGetCookieMgr, generateW3CId,
+    mwcRandom32, mwcRandomSeed, random32, randomValue, newId, isIE, dateNow, isError, isDate, isTypeof, ICoreUtils, strEndsWith, useXDomainRequest, isBeaconsSupported,
 } from "@microsoft/applicationinsights-core-js";
 
 export const Version = "#version#";
 export const FullVersionString = "1DS-Web-JS-" + Version;
 
+// Defining here so we don't need to take (import) the ApplicationInsights Common module
+const strDisabledPropertyName: string = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
+const strWithCredentials: string = "withCredentials";
+
 // If value is array just get the type for the first element
 const _fieldTypeEventPropMap = {
     [FieldValueSanitizerType.NotSet]: EventPropertyType.Unspecified,
@@ -36,35 +39,9 @@ const _fieldTypeEventPropMap = {
  */
 // let _uaDisallowsSameSiteNone = null;
 
-let _useXDomainRequest: boolean | null = null;
-var beaconsSupported: boolean | null = null;
 var uInt8ArraySupported: boolean | null = null;
 // var _areCookiesAvailable: boolean | undefined;
 
-function _hasProperty(theClass: any, property: string) {
-    let supported = false;
-    if (theClass) {
-        supported = property in theClass;
-        if (!supported) {
-            let proto = theClass.prototype;
-            if (proto) {
-                supported = property in proto;
-            }
-        }
-
-        if (!supported) {
-            try {
-                let tmp = new theClass();
-                supported = !isUndefined(tmp[property]);
-            } catch (e) {
-                // Do Nothing
-            }
-        }
-    }
-
-    return supported;
-}
-
 /**
  * Checks if document object is available
  */
@@ -102,46 +79,6 @@ export function getTenantId(apiKey: string | undefined): string {
     return "";
 }
 
-/**
- * Checks if HTML5 Beacons are supported in the current environment.
- * @returns True if supported, false otherwise.
- */
-export function isBeaconsSupported(): boolean {
-    if (beaconsSupported === null) {
-        beaconsSupported = hasNavigator() && Boolean(getNavigator().sendBeacon);
-    }
-    return beaconsSupported;
-}
-
-/**
- * Checks if the Fetch API is supported in the current environment.
- * @param withKeepAlive - [Optional] If True, check if fetch is available and it supports the keepalive feature, otherwise only check if fetch is supported
- * @returns True if supported, otherwise false
- */
-export function isFetchSupported(withKeepAlive?: boolean): boolean {
-    let isSupported = false;
-    try {
-        const fetchApi = getGlobalInst("fetch");
-        isSupported = !!fetchApi;
-        const request = getGlobalInst("Request");
-        if (isSupported && withKeepAlive && request) {
-            isSupported = _hasProperty(request, "keepalive");
-        }
-    } catch (e) {
-        // Just Swallow any failure during availability checks
-    }
-
-    return isSupported;
-}
-
-/**
- * Checks if XMLHttpRequest is supported
- * @returns True if supported, otherwise false
- */
-export function isXhrSupported(): boolean {
-    return typeof XMLHttpRequest !== undefined;
-}
-
 /**
  * Checks if Uint8Array are available in the current environment. Safari and Firefox along with
  * ReactNative are known to not support Uint8Array properly.
@@ -218,17 +155,6 @@ export function sanitizeProperty(name: string,
     return (property as IEventProperty);
 }
 
-export function useXDomainRequest(): boolean | undefined {
-    if (_useXDomainRequest === null) {
-        _useXDomainRequest = (typeof XDomainRequest !== undefined);
-        if (_useXDomainRequest && isXhrSupported()) {
-            _useXDomainRequest = _useXDomainRequest && !_hasProperty(XMLHttpRequest, "withCredentials");
-        }
-    }
-
-    return _useXDomainRequest;
-}
-
 export function getCommonSchemaMetaData(value: string | boolean | number | string[] | number[] | boolean[] | undefined, kind: number | undefined, type?: number | undefined): number {
     let encodedTypeValue = -1;
 
@@ -443,13 +369,58 @@ export function isArrayValid(value: any[]): boolean {
     return value.length > 0;
 }
 
+/**
+ * Listen to the pagehide and visibility changing to 'hidden' events
+ * @param listener The event callback to call when a page hide event is triggered
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+export function addPageHideEventListener(listener: any): boolean {
+
+    function _handlePageVisibility(evt) {
+        let doc = getDocument();
+        if (listener && doc && doc.visibilityState === 'hidden') {
+            listener(evt);
+        }
+    }
+
+    let pageUnloadAdded = addEventHandler("pagehide", listener);
+    return addEventHandler("visibilitychange", _handlePageVisibility) || pageUnloadAdded;
+}
+
+/**
+ * Listen to the pageshow and visibility changing to 'visible' events
+ * @param listener The event callback to call when a page is show event is triggered
+ * @returns true - when at least one of the events was registered otherwise false
+ */
+ export function addPageShowEventListener(listener: any): boolean {
+    
+    function _handlePageVisibility(evt) {
+        let doc = getDocument();
+        if (listener && doc && doc.visibilityState === 'visible') {
+            listener(evt);
+        }
+    }
+
+    let pageUnloadAdded = addEventHandler("pageshow", listener);
+    return addEventHandler("visibilitychange", _handlePageVisibility) || pageUnloadAdded;
+}
+
+/**
+ * Listen to the 'beforeunload', 'unload' and 'pagehide' events which indicates a page unload is occurring,
+ * this does NOT listen to the 'visibilitychange' event as while it does indicate that the page is being hidden
+ * it does not *necessarily* mean that the page is being completely unloaded, it can mean that the user is
+ * just navigating to a different Tab and may come back (without unloading the page). As such you may also 
+ * need to listen to the 'addPageHideEventListener' and 'addPageShowEventListener' events.
+ * @param listener The event callback to call when a page unload event is triggered
+ * @returns true - when at least one of the events was registered otherwise false
+ */
 export function addPageUnloadEventListener(listener: any): 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 navigations.
     let pageUnloadAdded = addEventHandler("beforeunload", listener);
     pageUnloadAdded = addEventHandler("unload", listener) || pageUnloadAdded;
-    pageUnloadAdded = addEventHandler("pagehide", listener) || pageUnloadAdded;
-    return pageUnloadAdded;
+    return addEventHandler("pagehide", listener) || pageUnloadAdded;
 }
 
 export function setProcessTelemetryTimings(event: ITelemetryItem, identifier: string): void {
@@ -592,3 +563,48 @@ export const CoreUtils: ICoreUtils = {
 export function isChromium() {
     return !!getGlobalInst("chrome");
 }
+
+/**
+ * Create and open an XMLHttpRequest object
+ * @param method - The request method
+ * @param urlString - The url
+ * @param withCredentials - Option flag indicating that credentials should be sent
+ * @param disabled - Optional flag indicating that the XHR object should be marked as disabled and not tracked (default is false)
+ * @param isSync - Optional flag indicating if the instance should be a synchronous request (defaults to false)
+ * @returns A new opened XHR request
+ */
+export function openXhr(method: string, urlString: string, withCredentials?: boolean, disabled: boolean = false, isSync: boolean = false) {
+
+    function _wrapSetXhrProp(xhr: XMLHttpRequest, prop: string, value: boolean) {
+        try {
+            xhr[prop] = value;
+        } catch (e) {
+            // - Wrapping as depending on the environment setting the property may fail (non-terminally)
+        }
+    }
+
+    let xhr = new XMLHttpRequest();
+
+    if (disabled) {
+        // Tag the instance so it's not tracked (trackDependency)
+        // If the environment has locked down the XMLHttpRequest (preventExtensions and/or freeze), this would
+        // cause the request to fail and we no telemetry would be sent
+        _wrapSetXhrProp(xhr, strDisabledPropertyName, disabled);
+    }
+
+    if (withCredentials) {
+        // Some libraries require that the withCredentials flag is set "before" open and
+        // - Wrapping as IE 10 has started throwing when setting before open
+        _wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
+    }
+
+    xhr.open(method, urlString, !isSync);
+
+    if (withCredentials) {
+        // withCredentials should be set AFTER open (https://xhr.spec.whatwg.org/#the-withcredentials-attribute)
+        // And older firefox instances from 11+ will throw for sync events (current versions don't) which happens during unload processing
+        _wrapSetXhrProp(xhr, strWithCredentials, withCredentials);
+    }
+
+    return xhr;
+}

package/tsconfig.json

@@ -13,12 +13,10 @@
         "noEmitHelpers": true,
         "forceConsistentCasingInFileNames": true,
         "declaration": true,
-        "rootDir": "shared/core",
-        "outDir": "dist-esm/"
+        "outDir": "dist-esm/src/"
     },
     "include": [
-        "./src/**/*.ts",
-        "./test/**/*.ts"
+        "./src/**/*.ts"
     ],
     "exclude": [
         "node_modules/"