EnvUtils.ts

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
"use strict";

import { getGlobal, strShimObject, strShimPrototype, strShimUndefined } from "@microsoft/applicationinsights-shims";
import {
    ICachedValue, arrForEach, createCachedValue, getDeferred, getDocument, getInst, getLazy, getNavigator, getPerformance, hasNavigator,
    isFunction, isNullOrUndefined, isString, isUndefined, mathMax, strIndexOf, strSubstring
} from "@nevware21/ts-utils";
import { DEFAULT_SENSITIVE_PARAMS, STR_EMPTY, STR_REDACTED } from "../constants/InternalConstants";
import { UrlRedactionOptions } from "../enums/ai/UrlRedactionOptions";
import { IConfiguration } from "../interfaces/ai/IConfiguration";
import { strContains } from "./HelperFuncs";

// TypeScript removed this interface so we need to declare the global so we can check for it's existence.
declare var XDomainRequest: any;

/**
 * This file exists to hold environment utilities that are required to check and
 * validate the current operating environment. Unless otherwise required, please
 * only use defined methods (functions) in this class so that users of these
 * functions/properties only need to include those that are used within their own modules.
 */

const strDocumentMode = "documentMode";
const strLocation = "location";
const strConsole = "console";
const strJSON = "JSON";
const strCrypto = "crypto";
const strMsCrypto = "msCrypto";
const strReactNative = "ReactNative";
const strMsie = "msie";
const strTrident = "trident/";
const strXMLHttpRequest = "XMLHttpRequest";

// Local cached properties which are used to avoid multiple checks within the module
let _isTrident: ICachedValue<boolean>;
let _navUserAgentCheck: string;
let _enableMocks = false;
let _useXDomainRequest: ICachedValue<boolean>;
let _beaconsSupported: ICachedValue<boolean>;
let _userAgent: ICachedValue<string>;

function _hasProperty(theClass: any, property: string) {
    let supported = false;
    if (theClass) {
        try {
            supported = property in theClass;
            if (!supported) {
                let proto = theClass[strShimPrototype];
                if (proto) {
                    supported = property in proto;
                }
            }
        } catch (e) {
            // Do Nothing
        }

        if (!supported) {
            try {
                let tmp = new theClass();
                supported = !isUndefined(tmp[property]);
            } catch (e) {
                // Do Nothing
            }
        }
    }

    return supported;
}

/*#__NO_SIDE_EFFECTS__*/
export function getUserAgentString(): string {
    if (!_userAgent) {
        // Use lazy to allow mocking
        _userAgent = getLazy(() => {
            let nav = getNavigator() || {} as Navigator;
            return nav.userAgent || STR_EMPTY;
        });
    }

    return _userAgent.v;
}

/**
 * Enable the lookup of test mock objects if requested
 * @param enabled - A flag to enable or disable the mock
 */
export function setEnableEnvMocks(enabled: boolean) {
    _enableMocks = enabled;
}

/**
 * Returns the global location object if it is present otherwise null.
 * This helper is used to access the location object without causing an exception
 * "Uncaught ReferenceError: location is not defined"
 */
/*#__NO_SIDE_EFFECTS__*/
export function getLocation(checkForMock?: boolean): Location | null {
    if (checkForMock && _enableMocks) {
        let mockLocation = getInst("__mockLocation") as Location;
        if (mockLocation) {
            return mockLocation;
        }
    }

    if (typeof location === strShimObject && location) {
        return location;
    }

    return getInst(strLocation);
}

/**
 * Returns the global console object
 */
/*#__NO_SIDE_EFFECTS__*/
export function getConsole(): Console | null {
    if (typeof console !== strShimUndefined) {
        return console;
    }

    return getInst(strConsole);
}

/**
 * Checks if JSON 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: JSON is not defined"
 * exception will be thrown.
 * Defined as a function to support lazy / late binding environments.
 */
/*#__NO_SIDE_EFFECTS__*/
export function hasJSON(): boolean {
    return Boolean((typeof JSON === strShimObject && JSON) || getInst(strJSON) !== null);
}

/**
 * Returns the global JSON object if it is present otherwise null.
 * This helper is used to access the JSON object without causing an exception
 * "Uncaught ReferenceError: JSON is not defined"
 */
/*#__NO_SIDE_EFFECTS__*/
export function getJSON(): JSON | null {
    if (hasJSON()) {
        return JSON || getInst(strJSON);
    }

    return null;
}

/**
 * Returns the crypto object if it is present otherwise null.
 * This helper is used to access the crypto object from the current
 * global instance which could be window or globalThis for a web worker
 */
/*#__NO_SIDE_EFFECTS__*/
export function getCrypto(): Crypto | null {
    return getInst(strCrypto);
}

/**
 * Returns the crypto object if it is present otherwise null.
 * This helper is used to access the crypto object from the current
 * global instance which could be window or globalThis for a web worker
 */
/*#__NO_SIDE_EFFECTS__*/
export function getMsCrypto(): Crypto | null {
    return getInst(strMsCrypto);
}

/**
 * Returns whether the environment is reporting that we are running in a React Native Environment
 */
/*#__NO_SIDE_EFFECTS__*/
export function isReactNative(): boolean {
    // If running in React Native, navigator.product will be populated
    var nav = getNavigator();
    if (nav && nav.product) {
        return nav.product === strReactNative;
    }

    return false;
}

/**
 * Identifies whether the current environment appears to be IE
 */
/*#__NO_SIDE_EFFECTS__*/
export function isIE() {
    let userAgent = getUserAgentString();
    if (!_isTrident || userAgent !== _navUserAgentCheck) {
        // Added to support test mocking of the user agent
        _navUserAgentCheck = userAgent;
        let lwrUserAgent = _navUserAgentCheck.toLowerCase();
        _isTrident = createCachedValue( strContains(lwrUserAgent, strMsie) || strContains(lwrUserAgent, strTrident));
    }

    return _isTrident.v;
}

/**
 * Gets IE version returning the document emulation mode if we are running on IE, or null otherwise
 */
/*#__NO_SIDE_EFFECTS__*/
export function getIEVersion(userAgentStr: string = null): number {
    if (!userAgentStr) {
        userAgentStr = getUserAgentString();
    }

    var ua = (userAgentStr || STR_EMPTY).toLowerCase();
    // Also check for documentMode in case X-UA-Compatible meta tag was included in HTML.
    if (strContains(ua, strMsie)) {
        let doc = getDocument() || {} as Document;
        return mathMax(parseInt(ua.split(strMsie)[1]), (doc[strDocumentMode] || 0));
    } else if (strContains(ua, strTrident)) {
        let tridentVer = parseInt(ua.split(strTrident)[1]);
        if (tridentVer) {
            return tridentVer + 4;
        }
    }

    return null;
}

/*#__NO_SIDE_EFFECTS__*/
export function isSafari(userAgentStr ?: string) {
    if (!userAgentStr || !isString(userAgentStr)) {
        userAgentStr = getUserAgentString().toLowerCase();
    }

    var ua = (userAgentStr || STR_EMPTY).toLowerCase();
    return (strIndexOf(ua, "safari") >= 0);
}

/**
 * Checks if HTML5 Beacons are supported in the current environment. There is a side effect (for testing)
 * when `useCached` is set to `false`, it will reset the cached value causing all future calls to
 * use the new re-evaluated value for all future calls.
 * @param useCached - [Optional] used for testing to bypass the cached lookup, when `true` this will
 * cause the cached global to be reset.
 * @returns True if supported, false otherwise.
 */
export function isBeaconsSupported(useCached?: boolean): boolean {
    if (!_beaconsSupported || useCached === false) {
        _beaconsSupported = createCachedValue(hasNavigator() && !!(getNavigator().sendBeacon));
    }

    return _beaconsSupported.v;
}

/**
 * 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
 */
/*#__NO_SIDE_EFFECTS__*/
export function isFetchSupported(withKeepAlive?: boolean): boolean {
    let isSupported = false;
    try {
        isSupported = !!getInst("fetch");
        const request = getInst("Request");
        if (isSupported && withKeepAlive && request) {
            isSupported = _hasProperty(request, "keepalive");
        }
    } catch (e) {
        // Just Swallow any failure during availability checks
    }

    return isSupported;
}

/*#__NO_SIDE_EFFECTS__*/
export function useXDomainRequest(): boolean | undefined {
    if (!_useXDomainRequest) {
        _useXDomainRequest = getDeferred(() => {
            let useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);
            if (useXDomainRequest && isXhrSupported()) {
                useXDomainRequest = useXDomainRequest && !_hasProperty(getInst(strXMLHttpRequest), "withCredentials");
            }

            return !!useXDomainRequest;
        });
    }

    return _useXDomainRequest.v;
}

/**
 * Checks if XMLHttpRequest is supported
 * @returns True if supported, otherwise false
 */
/*#__NO_SIDE_EFFECTS__*/
export function isXhrSupported(): boolean {
    let isSupported = false;
    try {
        const xmlHttpRequest = getInst(strXMLHttpRequest);
        isSupported = !!xmlHttpRequest;
    } catch (e) {
        // Just Swallow any failure during availability checks
    }

    return isSupported;
}

/*#__NO_SIDE_EFFECTS__*/
function _getNamedValue<T>(values: any, name: string): T[] {
    let items: T[]  = [];
    if (values) {
        arrForEach(values, (value) => {
            if (value.name) {
                if(value.name === name) {
                    items.push(value);
                }
            }
        });
    }

    return items;
}

/**
 * Helper function to fetch the named meta-tag from the page.
 * @param name - The name of the meta-tag to find.
 */
/*#__NO_SIDE_EFFECTS__*/
export function findMetaTag(name: string): any {
    let tags = findMetaTags(name);
    if (tags.length > 0) {
        return tags[0];
    }

    return null;
}

/**
 * Helper function to fetch all named meta-tag from the page.
 * @since 3.4.0
 * @param name - The name of the meta-tag to find.
 * @returns - An array of meta-tag values.
 */
/*#__NO_SIDE_EFFECTS__*/
export function findMetaTags(name: string): string[] {
    let tags: string[] = [];
    let doc = getDocument();
    if (doc && name) {
        // Look for a meta-tag
        arrForEach(_getNamedValue<any>(doc.querySelectorAll("meta"), name), (item) => {
            tags.push(item.content);
        });
    }

    return tags;
}

/**
 * Helper function to fetch the named server timing value from the page response (first navigation event).
 * @param name - The name of the server timing value to find.
 */
/*#__NO_SIDE_EFFECTS__*/
export function findNamedServerTiming(name: string): any {
    let value: any;
    let serverTimings = findNamedServerTimings(name);
    if (serverTimings.length > 0) {
        value = serverTimings[0];
    }

    return value;
}

/**
 * Helper function to fetch the named server timing value from the page response (first navigation event).
 * @since 3.4.0
 * @param name - The name of the server timing value to find.
 * @returns - An array of server timing values.
 */
/*#__NO_SIDE_EFFECTS__*/
export function findNamedServerTimings(name: string): string[] {
    let values: string[] = [];
    let perf = getPerformance();
    if (perf && perf.getEntriesByType) {
        // Try looking for a server-timing header
        arrForEach(perf.getEntriesByType("navigation") || [], (navPerf: any) => {
            arrForEach(_getNamedValue(navPerf.serverTiming, name), (value: any) => {
                let desc = value.description;
                if (!isNullOrUndefined(desc)) {
                    values.push(desc);
                }
            });
        });
    }

    return values;
}

// TODO: should reuse this method for analytics plugin
export function dispatchEvent(target:EventTarget, evnt: Event | CustomEvent): boolean {
    if (target && target.dispatchEvent && evnt) {
        target.dispatchEvent(evnt);
        return true;
    }
    return false;
}


/*#__NO_SIDE_EFFECTS__*/
export function createCustomDomEvent(eventName: string, details?: any): CustomEvent {
    let event: CustomEvent = null;
    let detail = {detail: details || null } as CustomEventInit;
    if (isFunction(CustomEvent)) { // Use CustomEvent constructor when available
        event = new CustomEvent(eventName, detail);
    } else { // CustomEvent has no constructor in IE
        let doc = getDocument();
        if (doc && doc.createEvent) {
            event = doc.createEvent("CustomEvent");
            event.initCustomEvent(eventName, true, true, detail);
        }
    }

    return event;
}

export function sendCustomEvent(evtName: string, cfg?: any, customDetails?: any): boolean {
    let global = getGlobal();
    if (global && (global as any).CustomEvent) {
        try {
            let details = {cfg: cfg || null,  customDetails: customDetails || null} as any;
            return dispatchEvent(global, createCustomDomEvent(evtName, details));
        } catch(e) {
            // eslint-disable-next-line no-empty
        }
    }
    return false;
}

/**
 * Redacts user information from a URL
 * @param url - The URL string to redact
 * @returns The URL with user information redacted
 */
/*#__NO_SIDE_EFFECTS__*/
function redactUserInfo(url: string): string {
    return url.replace(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^:@]{1,200}):([^@]{1,200})@(.*)$/, "$1REDACTED:REDACTED@$4");
}

/**
 * Redacts sensitive query parameters from a URL
 * @param url - The URL string to redact
 * @returns The URL with sensitive query parameters redacted
 */
/*#__NO_SIDE_EFFECTS__*/
function redactQueryParameters(url: string, config?: IConfiguration): string {
    let sensitiveParams: string[];
    const questionMarkIndex = strIndexOf(url, "?");
    if (questionMarkIndex === -1) {
        return url;
    }

    if (config && config.redactUrls === UrlRedactionOptions.append) {
        sensitiveParams = DEFAULT_SENSITIVE_PARAMS.concat(config.redactQueryParams);
    } else if (config && config.redactUrls === UrlRedactionOptions.replace) {
        sensitiveParams = config.redactQueryParams;
    } else {
        sensitiveParams = DEFAULT_SENSITIVE_PARAMS;
    }

    const baseUrl = strSubstring(url, 0, questionMarkIndex + 1);
    let queryString = strSubstring(url, questionMarkIndex + 1);

    let fragment = STR_EMPTY;
    const hashIndex = strIndexOf(queryString, "#");
    if (hashIndex !== -1) {
        fragment = strSubstring(queryString, hashIndex);
        queryString = strSubstring(queryString, 0, hashIndex);
    }

    let hasPotentialSensitiveParam = false;
    for (let i = 0; i < sensitiveParams.length; i++) {
        const paramCheck = sensitiveParams[i] + "=";
        if (strIndexOf(queryString, paramCheck) !== -1) {
            hasPotentialSensitiveParam = true;
            break;
        }
    }

    if (!hasPotentialSensitiveParam) {
        return url;
    }

    const resultParts: string[] = [];
    let anyParamRedacted = false;

    if (queryString && queryString.length) {
        const pairs = queryString.split("&");
        for (let i = 0; i < pairs.length; i++) {
            const pair = pairs[i];
            if (!pair) {
                continue;
            }
            
            const equalsIndex = strIndexOf(pair, "=");
            if (equalsIndex === -1) {
                // Parameter without value
                resultParts.push(pair);
            } else {
                const paramName = pair.substring(0, equalsIndex);
                const paramValue = pair.substring(equalsIndex + 1);
                if (paramValue === STR_EMPTY) {
                    resultParts.push(pair);
                } else {
                    let shouldRedact = false;
                    for (let j = 0; j < sensitiveParams.length; j++) {
                        if (paramName === sensitiveParams[j]) {
                            shouldRedact = true;
                            anyParamRedacted = true;
                            break;
                        }
                    }
                    
                    if (shouldRedact) {
                        resultParts.push(paramName + "=" + STR_REDACTED);
                    } else {
                        resultParts.push(pair);
                    }
                }
            }
        }
    }
    
    // If no parameters were redacted, return the original URL
    if (!anyParamRedacted) {
        return url;
    }

    return baseUrl + resultParts.join("&") + fragment;
}

/**
 * Redacts sensitive information from a URL string, including credentials and specific query parameters.
 * @param input - The URL string to be redacted.
 * @param config - Configuration object that contain redactUrls setting.
 * @returns The redacted URL string or the original string if no redaction was needed or possible.
 */
/*#__NO_SIDE_EFFECTS__*/
export function fieldRedaction(input: string, config: IConfiguration): string {
    if (!input || !isString(input) || strIndexOf(input, " ") !== -1) {
        return input;
    }
    const isRedactionDisabled = config && (config.redactUrls === false || config.redactUrls === UrlRedactionOptions.false);
    if (isRedactionDisabled) {
        return input;
    }

    let hasCredentials = strIndexOf(input, "@") !== -1;
    let hasQueryParams = strIndexOf(input, "?") !== -1;
    
    // If no credentials and no query params, return original
    if (!hasCredentials && !hasQueryParams) {
        return input;
    }

    if (config.redactUrls === UrlRedactionOptions.usernamePasswordOnly) {
        hasQueryParams = false;
    }

    if (config.redactUrls === UrlRedactionOptions.queryParamsOnly) {
        hasCredentials = false;
    }

    try {
        let result = input;
        if (hasCredentials) {
            result = redactUserInfo(input);
        }
        if (hasQueryParams) {
            result = redactQueryParameters(result, config);
        }
        return result;
    } catch (e) {
        return input;
    }
}