oxygen-cli 1.32.0 → 1.33.0

package/build/ox_modules/module-http.js

@@ -9,6 +9,8 @@ require("source-map-support/register");
 
 var _got = _interopRequireDefault(require("got"));
 
+var _formData = _interopRequireDefault(require("form-data"));
+
 var _OxygenModule = _interopRequireDefault(require("../core/OxygenModule"));
 
 var _OxygenError = _interopRequireDefault(require("../errors/OxygenError"));
@@ -54,6 +56,7 @@ const DEFAULT_HTTP_OPTIONS = {
   dnsLookupIpVersion: 'ipv4'
 };
 const CONTENT_TYPE_HEADER = 'content-type';
+const HTTP_METHODS = ['get', 'post', 'patch'];
 
 class HttpModule extends _OxygenModule.default {
   constructor(options, context, rs, logger, modules, services) {
@@ -75,6 +78,16 @@ class HttpModule extends _OxygenModule.default {
   get name() {
     return MODULE_NAME;
   }
+  /*
+   * @summary Returns a new FormData object
+   * @function newFormData
+   * @return {FormData} new FormData object.
+   */
+
+
+  newFormData() {
+    return new _formData.default();
+  }
   /**
    * @summary Sets user defined HTTP options (such as proxy, decompress and etc.)
    * @function setOptions
@@ -167,12 +180,13 @@ class HttpModule extends _OxygenModule.default {
    * @param {String} url - URL.
    * @param {Object} data - Data.
    * @param {Object=} headers - HTTP headers.
+   * @param {Boolean=} isFormData - Indicates if "data" parameter is of URL-encoded form type.
    * @return {Object} Response object.
    */
 
 
-  async post(url, data, headers) {
-    const resolvedData = this._resolveData(data);
+  async post(url, data, headers, isFormData = false) {
+    const resolvedData = this._resolveData(data, headers, isFormData);
 
     const httpOpts = { ...DEFAULT_HTTP_OPTIONS,
       ...(this._userHttpOptions || {}),
@@ -420,10 +434,117 @@ class HttpModule extends _OxygenModule.default {
     global._lastTransactionName = name;
   }
 
-  _resolveData(data) {
+  getStepDisplayName(methodName, methodArgs, retval, error) {
+    if (!HTTP_METHODS.includes(methodName)) {
+      return undefined;
+    }
+
+    if (!this._extra || !this._extra.http || !this._extra.http.request) {
+      return undefined;
+    }
+
+    return `${methodName.toUpperCase()} ${this._extra.http.request.path}`;
+  }
+
+  _addRequestExtra(request, updatedOptions) {
+    const url = new URL(request.url);
+    const reqExtra = {
+      url: request.url,
+      path: `${url.pathname}${url.search}${url.hash}`,
+      queryParams: this._getQueryParams(url.searchParams),
+      method: request.method,
+      headers: updatedOptions.headers,
+      contentType: this._getContentType(updatedOptions.headers),
+      contentLength: this._getContentLength(updatedOptions.headers)
+    };
+
+    if (request.form) {
+      reqExtra.formData = request.form;
+    } else if (request.json) {
+      reqExtra.contentType = 'application/json';
+
+      if (request.json instanceof Object) {
+        reqExtra.content = JSON.stringify(request.json);
+      } else {
+        reqExtra.content = request.json;
+      }
+    } else if (request.body) {
+      reqExtra.content = request.body;
+    }
+
+    if (!this._extra.http) {
+      this._extra.http = {};
+    }
+
+    this._extra.http.request = reqExtra;
+  }
+
+  _getContentType(headers = {}) {
+    const contentType = headers['content-type'];
+
+    if (!contentType) {
+      return undefined;
+    }
+
+    const match = contentType.match(/^(.+?)(;|$)/);
+
+    if (!match || match.length < 2) {
+      return undefined;
+    }
+
+    return match[1];
+  }
+
+  _getContentLength(headers = {}) {
+    if (!headers['content-length']) {
+      return undefined;
+    }
+
+    const lengthAsStr = headers['content-length'];
+    return parseInt(lengthAsStr);
+  }
+
+  _getQueryParams(searchParams) {
+    return Array.from(searchParams.keys()).reduce((record, key) => {
+      const values = searchParams.getAll(key);
+      return { ...record,
+        [key]: values.length > 1 ? values.join(',') : values[0]
+      };
+    }, {});
+  }
+
+  _addResponseExtra(response) {
+    const resExtra = {
+      url: response.redirectUrls && response.redirectUrls.length && response.redirectUrls[0],
+      statusText: response.statusMessage,
+      statusCode: response.statusCode,
+      contentType: this._getContentType(response.headers),
+      contentLength: this._getContentLength(response.headers),
+      headers: response.headers,
+      version: response.httpVersion,
+      content: response.body
+    };
+
+    if (!this._extra.http) {
+      this._extra.http = {};
+    }
+
+    this._extra.http.response = resExtra;
+
+    if (response.timings && response.timings.phases) {
+      this._extra.http.timings = { ...response.timings.phases
+      };
+    }
+  }
+
+  _resolveData(data, headers, isFormData = false) {
     const dataResolver = {};
 
-    if (data instanceof Object) {
+    if (isFormData) {
+      dataResolver.form = data;
+    } else if (data instanceof _formData.default) {
+      dataResolver.body = data;
+    } else if (data instanceof Object) {
       _utils.default.assertCircular(data);
 
       dataResolver.json = data;
@@ -435,10 +556,21 @@ class HttpModule extends _OxygenModule.default {
   }
 
   async _httpRequestSync(httpOpts) {
+    if (this._extra.http) {
+      delete this._extra.http;
+    } //this._addRequestExtra(httpOpts);
+
+
     let result;
 
     try {
-      result = await (0, _got.default)(httpOpts);
+      result = await (0, _got.default)({ ...httpOpts,
+        hooks: {
+          beforeRequest: [options => {
+            this._addRequestExtra(httpOpts, options);
+          }]
+        }
+      });
 
       if (httpOpts.deflateRaw && result.headers['content-encoding'] === 'deflate') {
         const zlib = require('zlib');
@@ -513,7 +645,9 @@ class HttpModule extends _OxygenModule.default {
         retryCount: result.retryCount,
         body: result.body
       };
-    } // store last response to allow further assertions and validations
+    }
+
+    this._addResponseExtra(result); // store last response to allow further assertions and validations
 
 
     this._lastResponse = result;
@@ -523,4 +657,4 @@ class HttpModule extends _OxygenModule.default {
 }
 
 exports.default = HttpModule;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ox_modules/module-http.js"],"names":["MODULE_NAME","RESPONSE_TIMEOUT","DAFAULT_HTTP2","DEFAULT_HTTP_OPTIONS","decompress","responseType","timeout","lookup","connect","secureConnect","socket","send","response","http2","https","rejectUnauthorized","dnsLookupIpVersion","CONTENT_TYPE_HEADER","HttpModule","OxygenModule","constructor","options","context","rs","logger","modules","services","_alwaysInitialized","_lastResponse","_baseUrl","_userHttpOptions","_isInitialized","name","setOptions","opts","deflateRaw","setProxy","url","bootstrap","require","parse","parsedUrl","hostname","OxError","errHelper","errorCode","HTTP_ERROR","port","protocol","global","GLOBAL_AGENT","HTTP_PROXY","get","headers","httpOpts","method","_httpRequestSync","post","data","resolvedData","_resolveData","put","patch","delete","getResponse","getResponseBody","body","getResponseHeaders","getResponseUrl","assertText","pattern","ASSERT_ERROR","respContent","JSON","stringify","modUtils","matchPattern","assertResponseTime","maxTime","Error","assertHeader","headerName","headerValuePattern","length","toLowerCase","actualHeaderValue","assertCookie","cookieName","cookieValuePattern","assertStatus","codeList","Array","isArray","statusCode","includes","assertStatusOk","transaction","toString","_lastTransactionName","dataResolver","Object","assertCircular","json","result","zlib","decomp","createInflateRaw","write","Promise","resolve","reject","on","e","errorMessage","message","statusMessage","rawBody","httpVersion","upgrade","timings","requestUrl","redirectUrls","isFromCache","ip","retryCount"],"mappings":"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","sourcesContent":["/*\r\n * Copyright (C) 2015-present CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\n\r\n/**\r\n * @name http\r\n * @description Provides methods for working with HTTP(S)\r\n */\r\nimport got from 'got';\r\nimport OxygenModule from '../core/OxygenModule';\r\nimport OxError from '../errors/OxygenError';\r\nimport errHelper from '../errors/helper';\r\nimport modUtils from './utils';\r\n\r\nconst MODULE_NAME = 'http';\r\nconst RESPONSE_TIMEOUT = 1000 * 60;   // in ms\r\nconst DAFAULT_HTTP2 = false;\r\nconst DEFAULT_HTTP_OPTIONS = {\r\n    decompress: true,\r\n    responseType: 'text',\r\n    timeout: {\r\n        lookup: 1000,\r\n        connect: 500,\r\n        secureConnect: 500,\r\n        socket: 100000,\r\n        send: 100000,\r\n        response: RESPONSE_TIMEOUT\r\n    },\r\n    http2: DAFAULT_HTTP2,\r\n    https: {\r\n        rejectUnauthorized: false\r\n    },\r\n    dnsLookupIpVersion: 'ipv4'\r\n};\r\nconst CONTENT_TYPE_HEADER = 'content-type';\r\n\r\nexport default class HttpModule extends OxygenModule {\r\n    constructor(options, context, rs, logger, modules, services) {\r\n        super(options, context, rs, logger, modules, services);\r\n        this._alwaysInitialized = true;\r\n        this._lastResponse = null;\r\n        this._baseUrl = null;\r\n        this._userHttpOptions = {};\r\n        // pre-initialize the module\r\n        this._isInitialized = true;\r\n    }\r\n\r\n    /*\r\n     * @summary Gets module name\r\n     * @function name\r\n     * @return {String} Constant value \"http\".\r\n     */\r\n    get name() {\r\n        return MODULE_NAME;\r\n    }\r\n\r\n    /**\r\n     * @summary Sets user defined HTTP options (such as proxy, decompress and etc.)\r\n     * @function setOptions\r\n     * @param {Object} opts - HTTP request options object, see [Request Options](https://github.com/sindresorhus/got/blob/main/documentation/2-options.md). \r\n     * In addition to the options listed in the linked document, 'deflateRaw' option can be used when server returns Deflate-compressed stream without headers.\r\n     */\r\n    setOptions(opts) {\r\n        this._userHttpOptions = opts;\r\n        if (opts.deflateRaw) {\r\n            this._userHttpOptions.decompress = false;     // decompress=true in default options so we override it\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Sets proxy url to be used for connections with the service.\r\n     * @function setProxy\r\n     * @param {String} url - Proxy server URL. Not passing this argument will reset the proxy settings.\r\n     */\r\n    setProxy(url) {\r\n        if (url) {\r\n            const {\r\n                bootstrap\r\n            } = require('global-agent');\r\n\r\n            const { parse } = require('url');\r\n            const parsedUrl = parse(url);\r\n\r\n            if (!parsedUrl.hostname) {\r\n                throw new OxError(errHelper.errorCode.HTTP_ERROR, 'Hostname in undefined');\r\n            }\r\n            if (!parsedUrl.port) {\r\n                throw new OxError(errHelper.errorCode.HTTP_ERROR, 'Port in undefined');\r\n            }\r\n            if (!parsedUrl.protocol) {\r\n                throw new OxError(errHelper.errorCode.HTTP_ERROR, 'Protocol in undefined');\r\n            }\r\n\r\n            bootstrap();\r\n            global.GLOBAL_AGENT.HTTP_PROXY = url;\r\n        } else {\r\n            global.GLOBAL_AGENT.HTTP_PROXY = false;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Performs HTTP GET\r\n     * @function get\r\n     * @param {String} url - URL.\r\n     * @param {Object=} headers - HTTP headers.\r\n     * @return {Object} Response object.\r\n     * @example <caption>[javascript] Usage example</caption>\r\n     * // Basic usage example:\r\n     * var response = http.get(\r\n     * 'https://api.github.com/repos/oxygenhq/oxygen-ide/releases', \r\n     * {\r\n     *   'Accept-Encoding': 'gzip, deflate',\r\n     *   'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:86.0) Gecko/20100101 Firefox/86.0'\r\n     * });\r\n     * log.info(response.body);\r\n     *\r\n     * // If server returns Deflate-compressed stream without headers, `deflateRaw` can be used to decompress the content.\r\n     * http.setOptions({\r\n     *   deflateRaw: true\r\n     * });\r\n     * var response = http.get('https://FOO.BAR');\r\n     * log.info(response.body);\r\n     */\r\n    async get(url, headers) {\r\n        const httpOpts = {\r\n            ...DEFAULT_HTTP_OPTIONS,\r\n            ...this._userHttpOptions || {},\r\n            url: url,\r\n            method: 'GET',\r\n            headers: headers || {}\r\n        };\r\n        return await this._httpRequestSync(httpOpts);\r\n    }\r\n\r\n    /**\r\n     * @summary Performs HTTP POST\r\n     * @function post\r\n     * @param {String} url - URL.\r\n     * @param {Object} data - Data.\r\n     * @param {Object=} headers - HTTP headers.\r\n     * @return {Object} Response object.\r\n     */\r\n    async post(url, data, headers) {\r\n        const resolvedData = this._resolveData(data);\r\n\r\n        const httpOpts = {\r\n            ...DEFAULT_HTTP_OPTIONS,\r\n            ...this._userHttpOptions || {},\r\n            url: url,\r\n            method: 'POST',\r\n            headers: headers || {},\r\n            ...resolvedData\r\n        };\r\n        return await this._httpRequestSync(httpOpts);\r\n    }\r\n\r\n    /**\r\n     * @summary Performs HTTP PUT\r\n     * @function put\r\n     * @param {String} url - URL.\r\n     * @param {Object} data - Data.\r\n     * @param {Object=} headers - HTTP headers.\r\n     * @return {Object} Response object.\r\n     */\r\n    async put(url, data, headers) {\r\n        const resolvedData = this._resolveData(data);\r\n\r\n        const httpOpts = {\r\n            ...DEFAULT_HTTP_OPTIONS,\r\n            ...this._userHttpOptions || {},\r\n            url: url,\r\n            method: 'PUT',\r\n            headers: headers || {},\r\n            ...resolvedData\r\n        };\r\n        return await this._httpRequestSync(httpOpts);\r\n    }\r\n\r\n    /**\r\n     * @summary Performs HTTP PATCH\r\n     * @function patch\r\n     * @param {String} url - URL.\r\n     * @param {Object} data - Data.\r\n     * @param {Object=} headers - HTTP headers.\r\n     * @return {Object} Response object.\r\n     */\r\n    async patch(url, data, headers) {\r\n        const resolvedData = this._resolveData(data);\r\n\r\n        const httpOpts = {\r\n            ...DEFAULT_HTTP_OPTIONS,\r\n            ...this._userHttpOptions || {},\r\n            url: url,\r\n            method: 'PATCH',\r\n            headers: headers || {},\r\n            ...resolvedData\r\n        };\r\n        return await this._httpRequestSync(httpOpts);\r\n    }\r\n\r\n    /**\r\n     * @summary Performs HTTP DELETE\r\n     * @function delete\r\n     * @param {String} url - URL.\r\n     * @param {Object=} headers - HTTP headers.\r\n     * @param {Object} data - Data.\r\n     * @return {Object} Response object.\r\n     */\r\n    async delete(url, headers, data) {\r\n        const resolvedData = this._resolveData(data);\r\n        const httpOpts = {\r\n            ...DEFAULT_HTTP_OPTIONS,\r\n            ...this._userHttpOptions || {},\r\n            url: url,\r\n            method: 'DELETE',\r\n            headers: headers || {},\r\n            ...resolvedData\r\n        };\r\n        return await this._httpRequestSync(httpOpts);\r\n    }\r\n\r\n    /**\r\n     * @summary Returns last response object\r\n     * @function getResponse\r\n     * @return {Object} Response object.\r\n     */\r\n    getResponse() {\r\n        return this._lastResponse;\r\n    }\r\n\r\n    /**\r\n     * @summary Returns last response body\r\n     * @function getResponseBody\r\n     * @return {String} Response body.\r\n     */\r\n    getResponseBody() {\r\n        return this._lastResponse && this._lastResponse.body ? this._lastResponse.body : null;\r\n    }\r\n\r\n    /**\r\n     * @summary Returns response headers\r\n     * @function getResponseHeaders\r\n     * @return {Object} Response headers.\r\n     */\r\n    getResponseHeaders() {\r\n        if (!this._lastResponse) {\r\n            return null;\r\n        }\r\n        return this._lastResponse.headers;\r\n    }\r\n\r\n    /**\r\n     * @summary Returns response URL\r\n     * @function getResponseUrl\r\n     * @return {String} Response URL.\r\n     */\r\n    getResponseUrl() {\r\n        if (!this._lastResponse) {\r\n            return null;\r\n        }\r\n        return this._lastResponse.url;\r\n    }\r\n\r\n    /**\r\n     * @summary Assert whether the specified pattern is present in the response body.\r\n     * @function assertText\r\n     * @param {String} pattern - Pattern to assert.\r\n     */\r\n    assertText(pattern) {\r\n        if (!this._lastResponse) {\r\n            return false;\r\n        }\r\n        if (!this._lastResponse.body) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, 'Response body is empty');\r\n        }\r\n        const respContent = typeof this._lastResponse.body === 'string' ? this._lastResponse.body : JSON.stringify(this._lastResponse.body);\r\n        if (!modUtils.matchPattern(respContent, pattern)) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, `Expected HTTP response content to match: \"${pattern}\" but got: \"${respContent}\"`);\r\n        }\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @summary Assert response time\r\n     * @function assertResponseTime\r\n     * @param {Number} maxTime - Maximum response time in milliseconds.\r\n     */\r\n    assertResponseTime(maxTime) {\r\n        throw new Error('Not implemented');\r\n    }\r\n\r\n    /**\r\n     * @summary Assert if HTTP header is presented in the response\r\n     * @function assertHeader\r\n     * @param {String} headerName - A HTTP header name.\r\n     * @param {String=} headerValuePattern - An optional HTTP header value pattern.\r\n     */\r\n    assertHeader(headerName, headerValuePattern = null) {\r\n        if (!headerName || typeof headerName !== 'string' || headerName.length == 0) {\r\n            return false;\r\n        }\r\n        headerName = headerName.toLowerCase();\r\n        const headers = this._lastResponse.headers;\r\n        if (!headers[headerName]) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, 'Expected HTTP header \"${headerName}\" to be present');\r\n        }\r\n        else if (headerValuePattern && typeof headerValuePattern === 'string') {\r\n            const actualHeaderValue = headers[headerName];\r\n            if (!modUtils.matchPattern(actualHeaderValue, headerValuePattern)) {\r\n                throw new OxError(errHelper.errorCode.ASSERT_ERROR, `Expected HTTP header \"${headerName}\" value to match: \"${headerValuePattern}\" but got: \"${actualHeaderValue}\"`);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Assert if HTTP cookie is presented in the response\r\n     * @function assertCookie\r\n     * @param {String} cookieName - A HTTP cookie name.\r\n     * @param {String=} cookieValuePattern - An optional HTTP cookie value pattern.\r\n     */\r\n    assertCookie(cookieName, cookieValuePattern) {\r\n        throw new Error('Not implemented');\r\n    }\r\n\r\n    /**\r\n     * @summary Assert the last HTTP response's status code\r\n     * @function assertStatus\r\n     * @param {Number|Array} codeList - A single status code or a list of codes.\r\n     */\r\n    assertStatus(codeList) {\r\n        if (!this._lastResponse || !codeList) {\r\n            return false;\r\n        }\r\n        // if we got a single value, then convert it to an array\r\n        if (!Array.isArray(codeList)) {\r\n            codeList = [codeList];\r\n        }\r\n        const statusCode = this._lastResponse.statusCode;\r\n        if (!codeList.includes(statusCode)) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, `Expected HTTP status to be: \"${codeList}\" but got: \"${statusCode}\"`);\r\n        }\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @summary Assert HTTP 200 OK status\r\n     * @function assertStatusOk\r\n     */\r\n    assertStatusOk() {\r\n        return this.assertStatus(200);\r\n    }\r\n\r\n    /**\r\n     * @summary Opens new transaction.\r\n     * @description The transaction will persist till a new one is opened. Transaction names must be unique.\r\n     * @function transaction\r\n     * @param {String} name - The transaction name.\r\n     */\r\n    async transaction(name) {\r\n        if (!name) {\r\n            return;\r\n        }\r\n        // just in case user passed a complex object by mistake\r\n        name = name.toString();\r\n        global._lastTransactionName = name;\r\n    }\r\n\r\n    _resolveData(data) {\r\n        const dataResolver = {};\r\n\r\n        if (data instanceof Object) {\r\n            modUtils.assertCircular(data);\r\n            dataResolver.json = data;\r\n        } else {\r\n            dataResolver.body = data;\r\n        }\r\n\r\n        return dataResolver;\r\n    }\r\n\r\n    async _httpRequestSync(httpOpts) {\r\n        let result;\r\n\r\n        try {\r\n            result = await got(httpOpts);\r\n            if (httpOpts.deflateRaw && result.headers['content-encoding'] === 'deflate') {\r\n                const zlib = require('zlib');\r\n                const decomp = zlib.createInflateRaw();\r\n                decomp.write(result.body);\r\n                await (() => {\r\n                    return new Promise((resolve, reject) => {\r\n                        decomp.on('data', (data) => {\r\n                            result.body = data.toString();\r\n                            if (result.headers[CONTENT_TYPE_HEADER] && result.headers[CONTENT_TYPE_HEADER].includes('application/json')) {\r\n                                try {\r\n                                    result.body = JSON.parse(result.body);\r\n                                } catch (e) {\r\n                                    // if parsing fails just return the original string\r\n                                }\r\n                            }\r\n                            resolve();\r\n                        });\r\n                    });\r\n                })();\r\n            } else {\r\n                if (result.headers[CONTENT_TYPE_HEADER] && result.headers[CONTENT_TYPE_HEADER].includes('application/json')) {\r\n                    try {\r\n                        result.body = JSON.parse(result.body);\r\n                    } catch (e) {\r\n                        // if parsing fails just return the original string\r\n                    }\r\n                }\r\n            }\r\n        } catch (e) {\r\n            result = e;\r\n        }\r\n\r\n        if (result instanceof Error) {\r\n            let body = null;\r\n            if (\r\n                result.response &&\r\n                result.response.body\r\n            ) {\r\n                body = result.response.body;\r\n                if (typeof body === 'string') {\r\n                    try {\r\n                        body = JSON.parse(body);\r\n                    } catch (e) {\r\n                        body = result.response.body;\r\n                    }\r\n                }\r\n            }\r\n\r\n            result = {\r\n                errorMessage: result.message,\r\n                headers: result.response ? result.response.headers : null,\r\n                statusCode: result.response ? result.response.statusCode : null,\r\n                statusMessage: result.response ? result.response.statusMessage : null,\r\n                rawBody: result.response ? result.response.rawBody : null,\r\n                body: body\r\n            };\r\n        } else {\r\n            result = {\r\n                httpVersion: result.httpVersion,\r\n                headers: result.headers,\r\n                upgrade: result.upgrade,\r\n                url: result.url,\r\n                method: result.method,\r\n                statusCode: result.statusCode,\r\n                statusMessage: result.statusMessage,\r\n                timings: result.timings,\r\n                requestUrl: result.requestUrl,\r\n                redirectUrls: result.redirectUrls,\r\n                isFromCache: result.isFromCache,\r\n                ip: result.ip,\r\n                retryCount: result.retryCount,\r\n                body: result.body\r\n            };\r\n        }\r\n\r\n        // store last response to allow further assertions and validations\r\n        this._lastResponse = result;\r\n\r\n        return result;\r\n    }\r\n}"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/ox_modules/module-http.js"],"names":["MODULE_NAME","RESPONSE_TIMEOUT","DAFAULT_HTTP2","DEFAULT_HTTP_OPTIONS","decompress","responseType","timeout","lookup","connect","secureConnect","socket","send","response","http2","https","rejectUnauthorized","dnsLookupIpVersion","CONTENT_TYPE_HEADER","HTTP_METHODS","HttpModule","OxygenModule","constructor","options","context","rs","logger","modules","services","_alwaysInitialized","_lastResponse","_baseUrl","_userHttpOptions","_isInitialized","name","newFormData","FormData","setOptions","opts","deflateRaw","setProxy","url","bootstrap","require","parse","parsedUrl","hostname","OxError","errHelper","errorCode","HTTP_ERROR","port","protocol","global","GLOBAL_AGENT","HTTP_PROXY","get","headers","httpOpts","method","_httpRequestSync","post","data","isFormData","resolvedData","_resolveData","put","patch","delete","getResponse","getResponseBody","body","getResponseHeaders","getResponseUrl","assertText","pattern","ASSERT_ERROR","respContent","JSON","stringify","modUtils","matchPattern","assertResponseTime","maxTime","Error","assertHeader","headerName","headerValuePattern","length","toLowerCase","actualHeaderValue","assertCookie","cookieName","cookieValuePattern","assertStatus","codeList","Array","isArray","statusCode","includes","assertStatusOk","transaction","toString","_lastTransactionName","getStepDisplayName","methodName","methodArgs","retval","error","undefined","_extra","http","request","toUpperCase","path","_addRequestExtra","updatedOptions","URL","reqExtra","pathname","search","hash","queryParams","_getQueryParams","searchParams","contentType","_getContentType","contentLength","_getContentLength","form","formData","json","Object","content","match","lengthAsStr","parseInt","from","keys","reduce","record","key","values","getAll","join","_addResponseExtra","resExtra","redirectUrls","statusText","statusMessage","version","httpVersion","timings","phases","dataResolver","assertCircular","result","hooks","beforeRequest","zlib","decomp","createInflateRaw","write","Promise","resolve","reject","on","e","errorMessage","message","rawBody","upgrade","requestUrl","isFromCache","ip","retryCount"],"mappings":"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","sourcesContent":["/*\r\n * Copyright (C) 2015-present CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\n\r\n/**\r\n * @name http\r\n * @description Provides methods for working with HTTP(S)\r\n */\r\nimport got from 'got';\r\nimport FormData from 'form-data';\r\nimport OxygenModule from '../core/OxygenModule';\r\nimport OxError from '../errors/OxygenError';\r\nimport errHelper from '../errors/helper';\r\nimport modUtils from './utils';\r\n\r\nconst MODULE_NAME = 'http';\r\nconst RESPONSE_TIMEOUT = 1000 * 60;   // in ms\r\nconst DAFAULT_HTTP2 = false;\r\nconst DEFAULT_HTTP_OPTIONS = {\r\n    decompress: true,\r\n    responseType: 'text',\r\n    timeout: {\r\n        lookup: 1000,\r\n        connect: 500,\r\n        secureConnect: 500,\r\n        socket: 100000,\r\n        send: 100000,\r\n        response: RESPONSE_TIMEOUT\r\n    },\r\n    http2: DAFAULT_HTTP2,\r\n    https: {\r\n        rejectUnauthorized: false\r\n    },\r\n    dnsLookupIpVersion: 'ipv4'\r\n};\r\nconst CONTENT_TYPE_HEADER = 'content-type';\r\nconst HTTP_METHODS = [\r\n    'get',\r\n    'post',\r\n    'patch'\r\n];\r\n\r\nexport default class HttpModule extends OxygenModule {\r\n    constructor(options, context, rs, logger, modules, services) {\r\n        super(options, context, rs, logger, modules, services);\r\n        this._alwaysInitialized = true;\r\n        this._lastResponse = null;\r\n        this._baseUrl = null;\r\n        this._userHttpOptions = {};\r\n        // pre-initialize the module\r\n        this._isInitialized = true;\r\n    }\r\n\r\n    /*\r\n     * @summary Gets module name\r\n     * @function name\r\n     * @return {String} Constant value \"http\".\r\n     */\r\n    get name() {\r\n        return MODULE_NAME;\r\n    }\r\n\r\n    /*\r\n     * @summary Returns a new FormData object\r\n     * @function newFormData\r\n     * @return {FormData} new FormData object.\r\n     */\r\n    newFormData() {\r\n        return new FormData();\r\n    }\r\n\r\n    /**\r\n     * @summary Sets user defined HTTP options (such as proxy, decompress and etc.)\r\n     * @function setOptions\r\n     * @param {Object} opts - HTTP request options object, see [Request Options](https://github.com/sindresorhus/got/blob/main/documentation/2-options.md). \r\n     * In addition to the options listed in the linked document, 'deflateRaw' option can be used when server returns Deflate-compressed stream without headers.\r\n     */\r\n    setOptions(opts) {\r\n        this._userHttpOptions = opts;\r\n        if (opts.deflateRaw) {\r\n            this._userHttpOptions.decompress = false;     // decompress=true in default options so we override it\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Sets proxy url to be used for connections with the service.\r\n     * @function setProxy\r\n     * @param {String} url - Proxy server URL. Not passing this argument will reset the proxy settings.\r\n     */\r\n    setProxy(url) {\r\n        if (url) {\r\n            const {\r\n                bootstrap\r\n            } = require('global-agent');\r\n\r\n            const { parse } = require('url');\r\n            const parsedUrl = parse(url);\r\n\r\n            if (!parsedUrl.hostname) {\r\n                throw new OxError(errHelper.errorCode.HTTP_ERROR, 'Hostname in undefined');\r\n            }\r\n            if (!parsedUrl.port) {\r\n                throw new OxError(errHelper.errorCode.HTTP_ERROR, 'Port in undefined');\r\n            }\r\n            if (!parsedUrl.protocol) {\r\n                throw new OxError(errHelper.errorCode.HTTP_ERROR, 'Protocol in undefined');\r\n            }\r\n\r\n            bootstrap();\r\n            global.GLOBAL_AGENT.HTTP_PROXY = url;\r\n        } else {\r\n            global.GLOBAL_AGENT.HTTP_PROXY = false;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Performs HTTP GET\r\n     * @function get\r\n     * @param {String} url - URL.\r\n     * @param {Object=} headers - HTTP headers.\r\n     * @return {Object} Response object.\r\n     * @example <caption>[javascript] Usage example</caption>\r\n     * // Basic usage example:\r\n     * var response = http.get(\r\n     * 'https://api.github.com/repos/oxygenhq/oxygen-ide/releases', \r\n     * {\r\n     *   'Accept-Encoding': 'gzip, deflate',\r\n     *   'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:86.0) Gecko/20100101 Firefox/86.0'\r\n     * });\r\n     * log.info(response.body);\r\n     *\r\n     * // If server returns Deflate-compressed stream without headers, `deflateRaw` can be used to decompress the content.\r\n     * http.setOptions({\r\n     *   deflateRaw: true\r\n     * });\r\n     * var response = http.get('https://FOO.BAR');\r\n     * log.info(response.body);\r\n     */\r\n    async get(url, headers) {\r\n        const httpOpts = {\r\n            ...DEFAULT_HTTP_OPTIONS,\r\n            ...this._userHttpOptions || {},\r\n            url: url,\r\n            method: 'GET',\r\n            headers: headers || {}\r\n        };\r\n        return await this._httpRequestSync(httpOpts);\r\n    }\r\n\r\n    /**\r\n     * @summary Performs HTTP POST\r\n     * @function post\r\n     * @param {String} url - URL.\r\n     * @param {Object} data - Data.\r\n     * @param {Object=} headers - HTTP headers.\r\n     * @param {Boolean=} isFormData - Indicates if \"data\" parameter is of URL-encoded form type.\r\n     * @return {Object} Response object.\r\n     */\r\n    async post(url, data, headers, isFormData = false) {\r\n        const resolvedData = this._resolveData(data, headers, isFormData);\r\n        const httpOpts = {\r\n            ...DEFAULT_HTTP_OPTIONS,\r\n            ...this._userHttpOptions || {},\r\n            url: url,\r\n            method: 'POST',\r\n            headers: headers || {},\r\n            ...resolvedData\r\n        };\r\n        return await this._httpRequestSync(httpOpts);\r\n    }\r\n\r\n    /**\r\n     * @summary Performs HTTP PUT\r\n     * @function put\r\n     * @param {String} url - URL.\r\n     * @param {Object} data - Data.\r\n     * @param {Object=} headers - HTTP headers.\r\n     * @return {Object} Response object.\r\n     */\r\n    async put(url, data, headers) {\r\n        const resolvedData = this._resolveData(data);\r\n\r\n        const httpOpts = {\r\n            ...DEFAULT_HTTP_OPTIONS,\r\n            ...this._userHttpOptions || {},\r\n            url: url,\r\n            method: 'PUT',\r\n            headers: headers || {},\r\n            ...resolvedData\r\n        };\r\n        return await this._httpRequestSync(httpOpts);\r\n    }\r\n\r\n    /**\r\n     * @summary Performs HTTP PATCH\r\n     * @function patch\r\n     * @param {String} url - URL.\r\n     * @param {Object} data - Data.\r\n     * @param {Object=} headers - HTTP headers.\r\n     * @return {Object} Response object.\r\n     */\r\n    async patch(url, data, headers) {\r\n        const resolvedData = this._resolveData(data);\r\n\r\n        const httpOpts = {\r\n            ...DEFAULT_HTTP_OPTIONS,\r\n            ...this._userHttpOptions || {},\r\n            url: url,\r\n            method: 'PATCH',\r\n            headers: headers || {},\r\n            ...resolvedData\r\n        };\r\n        return await this._httpRequestSync(httpOpts);\r\n    }\r\n\r\n    /**\r\n     * @summary Performs HTTP DELETE\r\n     * @function delete\r\n     * @param {String} url - URL.\r\n     * @param {Object=} headers - HTTP headers.\r\n     * @param {Object} data - Data.\r\n     * @return {Object} Response object.\r\n     */\r\n    async delete(url, headers, data) {\r\n        const resolvedData = this._resolveData(data);\r\n        const httpOpts = {\r\n            ...DEFAULT_HTTP_OPTIONS,\r\n            ...this._userHttpOptions || {},\r\n            url: url,\r\n            method: 'DELETE',\r\n            headers: headers || {},\r\n            ...resolvedData\r\n        };\r\n        return await this._httpRequestSync(httpOpts);\r\n    }\r\n\r\n    /**\r\n     * @summary Returns last response object\r\n     * @function getResponse\r\n     * @return {Object} Response object.\r\n     */\r\n    getResponse() {\r\n        return this._lastResponse;\r\n    }\r\n\r\n    /**\r\n     * @summary Returns last response body\r\n     * @function getResponseBody\r\n     * @return {String} Response body.\r\n     */\r\n    getResponseBody() {\r\n        return this._lastResponse && this._lastResponse.body ? this._lastResponse.body : null;\r\n    }\r\n\r\n    /**\r\n     * @summary Returns response headers\r\n     * @function getResponseHeaders\r\n     * @return {Object} Response headers.\r\n     */\r\n    getResponseHeaders() {\r\n        if (!this._lastResponse) {\r\n            return null;\r\n        }\r\n        return this._lastResponse.headers;\r\n    }\r\n\r\n    /**\r\n     * @summary Returns response URL\r\n     * @function getResponseUrl\r\n     * @return {String} Response URL.\r\n     */\r\n    getResponseUrl() {\r\n        if (!this._lastResponse) {\r\n            return null;\r\n        }\r\n        return this._lastResponse.url;\r\n    }\r\n\r\n    /**\r\n     * @summary Assert whether the specified pattern is present in the response body.\r\n     * @function assertText\r\n     * @param {String} pattern - Pattern to assert.\r\n     */\r\n    assertText(pattern) {\r\n        if (!this._lastResponse) {\r\n            return false;\r\n        }\r\n        if (!this._lastResponse.body) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, 'Response body is empty');\r\n        }\r\n        const respContent = typeof this._lastResponse.body === 'string' ? this._lastResponse.body : JSON.stringify(this._lastResponse.body);\r\n        if (!modUtils.matchPattern(respContent, pattern)) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, `Expected HTTP response content to match: \"${pattern}\" but got: \"${respContent}\"`);\r\n        }\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @summary Assert response time\r\n     * @function assertResponseTime\r\n     * @param {Number} maxTime - Maximum response time in milliseconds.\r\n     */\r\n    assertResponseTime(maxTime) {\r\n        throw new Error('Not implemented');\r\n    }\r\n\r\n    /**\r\n     * @summary Assert if HTTP header is presented in the response\r\n     * @function assertHeader\r\n     * @param {String} headerName - A HTTP header name.\r\n     * @param {String=} headerValuePattern - An optional HTTP header value pattern.\r\n     */\r\n    assertHeader(headerName, headerValuePattern = null) {\r\n        if (!headerName || typeof headerName !== 'string' || headerName.length == 0) {\r\n            return false;\r\n        }\r\n        headerName = headerName.toLowerCase();\r\n        const headers = this._lastResponse.headers;\r\n        if (!headers[headerName]) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, 'Expected HTTP header \"${headerName}\" to be present');\r\n        }\r\n        else if (headerValuePattern && typeof headerValuePattern === 'string') {\r\n            const actualHeaderValue = headers[headerName];\r\n            if (!modUtils.matchPattern(actualHeaderValue, headerValuePattern)) {\r\n                throw new OxError(errHelper.errorCode.ASSERT_ERROR, `Expected HTTP header \"${headerName}\" value to match: \"${headerValuePattern}\" but got: \"${actualHeaderValue}\"`);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @summary Assert if HTTP cookie is presented in the response\r\n     * @function assertCookie\r\n     * @param {String} cookieName - A HTTP cookie name.\r\n     * @param {String=} cookieValuePattern - An optional HTTP cookie value pattern.\r\n     */\r\n    assertCookie(cookieName, cookieValuePattern) {\r\n        throw new Error('Not implemented');\r\n    }\r\n\r\n    /**\r\n     * @summary Assert the last HTTP response's status code\r\n     * @function assertStatus\r\n     * @param {Number|Array} codeList - A single status code or a list of codes.\r\n     */\r\n    assertStatus(codeList) {\r\n        if (!this._lastResponse || !codeList) {\r\n            return false;\r\n        }\r\n        // if we got a single value, then convert it to an array\r\n        if (!Array.isArray(codeList)) {\r\n            codeList = [codeList];\r\n        }\r\n        const statusCode = this._lastResponse.statusCode;\r\n        if (!codeList.includes(statusCode)) {\r\n            throw new OxError(errHelper.errorCode.ASSERT_ERROR, `Expected HTTP status to be: \"${codeList}\" but got: \"${statusCode}\"`);\r\n        }\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * @summary Assert HTTP 200 OK status\r\n     * @function assertStatusOk\r\n     */\r\n    assertStatusOk() {\r\n        return this.assertStatus(200);\r\n    }\r\n\r\n    /**\r\n     * @summary Opens new transaction.\r\n     * @description The transaction will persist till a new one is opened. Transaction names must be unique.\r\n     * @function transaction\r\n     * @param {String} name - The transaction name.\r\n     */\r\n    async transaction(name) {\r\n        if (!name) {\r\n            return;\r\n        }\r\n        // just in case user passed a complex object by mistake\r\n        name = name.toString();\r\n        global._lastTransactionName = name;\r\n    }\r\n\r\n    getStepDisplayName(methodName, methodArgs, retval, error) {\r\n        if (!HTTP_METHODS.includes(methodName)) {\r\n            return undefined;\r\n        }\r\n        if (!this._extra || !this._extra.http || !this._extra.http.request) {\r\n            return undefined;\r\n        }\r\n        return `${methodName.toUpperCase()} ${this._extra.http.request.path}`;\r\n    }\r\n\r\n    _addRequestExtra(request, updatedOptions) {\r\n        const url = new URL(request.url);\r\n        const reqExtra = {\r\n            url: request.url,\r\n            path: `${url.pathname}${url.search}${url.hash}`,\r\n            queryParams: this._getQueryParams(url.searchParams),\r\n            method: request.method,\r\n            headers: updatedOptions.headers,\r\n            contentType: this._getContentType(updatedOptions.headers),\r\n            contentLength: this._getContentLength(updatedOptions.headers),\r\n        };\r\n        if (request.form) {\r\n            reqExtra.formData = request.form;\r\n        }\r\n        else if (request.json) {\r\n            reqExtra.contentType = 'application/json';\r\n            if (request.json instanceof Object) {\r\n                reqExtra.content = JSON.stringify(request.json);\r\n            }\r\n            else {\r\n                reqExtra.content = request.json;\r\n            }\r\n        }\r\n        else if (request.body) {\r\n            reqExtra.content = request.body;\r\n        }\r\n\r\n        if (!this._extra.http) {\r\n            this._extra.http = {};\r\n        }\r\n        this._extra.http.request = reqExtra;\r\n    }\r\n\r\n    _getContentType(headers = {}) {\r\n        const contentType = headers['content-type'];\r\n        if (!contentType) {\r\n            return undefined;\r\n        }\r\n        const match = contentType.match(/^(.+?)(;|$)/);\r\n        if (!match || match.length < 2) {\r\n            return undefined;\r\n        }\r\n        return match[1];\r\n    }\r\n\r\n    _getContentLength(headers = {}) {\r\n        if (!headers['content-length']) {\r\n            return undefined;\r\n        }\r\n        const lengthAsStr = headers['content-length'];\r\n        return parseInt(lengthAsStr);\r\n    }\r\n\r\n    _getQueryParams(searchParams) {\r\n        return Array.from( searchParams.keys() ).reduce( ( record, key ) => {\r\n            const values = searchParams.getAll(key);\r\n            return { ...record, [ key ]: values.length > 1 ? values.join(',') : values[0] };\r\n        }, {});\r\n    }\r\n\r\n    _addResponseExtra(response) {\r\n        const resExtra = {\r\n            url: response.redirectUrls && response.redirectUrls.length && response.redirectUrls[0],\r\n            statusText: response.statusMessage,\r\n            statusCode: response.statusCode,\r\n            contentType: this._getContentType(response.headers),\r\n            contentLength: this._getContentLength(response.headers),\r\n            headers: response.headers,\r\n            version: response.httpVersion,\r\n            content: response.body,\r\n        };\r\n        if (!this._extra.http) {\r\n            this._extra.http = {};\r\n        }\r\n        this._extra.http.response = resExtra;\r\n        if (response.timings && response.timings.phases) {\r\n            this._extra.http.timings = { ...response.timings.phases };\r\n        }\r\n\r\n    }\r\n\r\n    _resolveData(data, headers, isFormData = false) {\r\n        const dataResolver = {};\r\n\r\n        if (isFormData) {\r\n            dataResolver.form = data;\r\n        }\r\n        else if (data instanceof FormData) {\r\n            dataResolver.body = data;\r\n        }\r\n        else if (data instanceof Object) {\r\n            modUtils.assertCircular(data);\r\n            dataResolver.json = data;\r\n        } else {\r\n            dataResolver.body = data;\r\n        }\r\n\r\n        return dataResolver;\r\n    }\r\n\r\n    async _httpRequestSync(httpOpts) {\r\n        if (this._extra.http) {\r\n            delete this._extra.http;\r\n        }\r\n        //this._addRequestExtra(httpOpts);\r\n        let result;\r\n\r\n        try {\r\n            result = await got({ ...httpOpts, hooks: {\r\n                beforeRequest: [\r\n                    options => { this._addRequestExtra(httpOpts, options); }\r\n                ],\r\n            }});\r\n            if (httpOpts.deflateRaw && result.headers['content-encoding'] === 'deflate') {\r\n                const zlib = require('zlib');\r\n                const decomp = zlib.createInflateRaw();\r\n                decomp.write(result.body);\r\n                await (() => {\r\n                    return new Promise((resolve, reject) => {\r\n                        decomp.on('data', (data) => {\r\n                            result.body = data.toString();\r\n                            if (result.headers[CONTENT_TYPE_HEADER] && result.headers[CONTENT_TYPE_HEADER].includes('application/json')) {\r\n                                try {\r\n                                    result.body = JSON.parse(result.body);\r\n                                } catch (e) {\r\n                                    // if parsing fails just return the original string\r\n                                }\r\n                            }\r\n                            resolve();\r\n                        });\r\n                    });\r\n                })();\r\n            } else {\r\n                if (result.headers[CONTENT_TYPE_HEADER] && result.headers[CONTENT_TYPE_HEADER].includes('application/json')) {\r\n                    try {\r\n                        result.body = JSON.parse(result.body);\r\n                    } catch (e) {\r\n                        // if parsing fails just return the original string\r\n                    }\r\n                }\r\n            }\r\n        } catch (e) {\r\n            result = e;\r\n        }\r\n\r\n        if (result instanceof Error) {\r\n            let body = null;\r\n            if (\r\n                result.response &&\r\n                result.response.body\r\n            ) {\r\n                body = result.response.body;\r\n                if (typeof body === 'string') {\r\n                    try {\r\n                        body = JSON.parse(body);\r\n                    } catch (e) {\r\n                        body = result.response.body;\r\n                    }\r\n                }\r\n            }\r\n\r\n            result = {\r\n                errorMessage: result.message,\r\n                headers: result.response ? result.response.headers : null,\r\n                statusCode: result.response ? result.response.statusCode : null,\r\n                statusMessage: result.response ? result.response.statusMessage : null,\r\n                rawBody: result.response ? result.response.rawBody : null,\r\n                body: body\r\n            };\r\n        } else {\r\n            result = {\r\n                httpVersion: result.httpVersion,\r\n                headers: result.headers,\r\n                upgrade: result.upgrade,\r\n                url: result.url,\r\n                method: result.method,\r\n                statusCode: result.statusCode,\r\n                statusMessage: result.statusMessage,\r\n                timings: result.timings,\r\n                requestUrl: result.requestUrl,\r\n                redirectUrls: result.redirectUrls,\r\n                isFromCache: result.isFromCache,\r\n                ip: result.ip,\r\n                retryCount: result.retryCount,\r\n                body: result.body\r\n            };\r\n        }\r\n        this._addResponseExtra(result);\r\n        // store last response to allow further assertions and validations\r\n        this._lastResponse = result;\r\n\r\n        return result;\r\n    }\r\n}"]}

package/build/ox_modules/module-web/commands/setAutoWaitForAngular.js

@@ -19,20 +19,23 @@ require("source-map-support/register");
 /**
  * @summary Wait for Angular based app will be loaded
  * @function setAutoWaitForAngular
- * @param {Boolean} autoWaitForAngular - new autoWait value. Dafault is false;
- * @param {String=} rootSelector - Selector for root element, need only for Angular 1
+ * @param {Boolean} autoWaitForAngular - true to enable auto-wait. false to disable.
+ * @param {String=} rootSelector - Selector for root element, needed only for AngularJS (v1). 
+ *                                 In Angular (v2) first available root node will be selected automatically.
+ * @param {Boolean=} softWait - If true then do not produce error if stability cannot be attained. Default is false.
  * @param {Number=} timeout - Timeout in milliseconds. Default is 60 seconds.
  * @example <caption>[javascript] Usage example</caption>
  * web.init();
  * web.open("www.yourwebsite.com");
  * web.setAutoWaitForAngular(true);
  */
-function setAutoWaitForAngular(autoWaitForAngular = false, rootSelector = '', timeout = 60 * 1000) {
+function setAutoWaitForAngular(autoWaitForAngular, rootSelector = null, softWait = false, timeout = 60 * 1000) {
   this.helpers.assertArgumentBool(autoWaitForAngular, 'autoWaitForAngular');
+  this.helpers.assertArgumentBool(softWait, 'softWait');
   this.helpers.assertArgumentTimeout(timeout, 'timeout');
-  this.helpers.assertArgumentString(rootSelector, 'rootSelector');
   this.autoWaitForAngular = autoWaitForAngular;
+  this.autoWaitForAngularSoftWait = softWait;
   this.autoWaitForAngularRootSelector = rootSelector;
   this.autoWaitForAngularTimeout = timeout;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9veF9tb2R1bGVzL21vZHVsZS13ZWIvY29tbWFuZHMvc2V0QXV0b1dhaXRGb3JBbmd1bGFyLmpzIl0sIm5hbWVzIjpbInNldEF1dG9XYWl0Rm9yQW5ndWxhciIsImF1dG9XYWl0Rm9yQW5ndWxhciIsInJvb3RTZWxlY3RvciIsInRpbWVvdXQiLCJoZWxwZXJzIiwiYXNzZXJ0QXJndW1lbnRCb29sIiwiYXNzZXJ0QXJndW1lbnRUaW1lb3V0IiwiYXNzZXJ0QXJndW1lbnRTdHJpbmciLCJhdXRvV2FpdEZvckFuZ3VsYXJSb290U2VsZWN0b3IiLCJhdXRvV2FpdEZvckFuZ3VsYXJUaW1lb3V0Il0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBOztBQUVBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFFTyxTQUFTQSxxQkFBVCxDQUErQkMsa0JBQWtCLEdBQUcsS0FBcEQsRUFBMkRDLFlBQVksR0FBRyxFQUExRSxFQUE4RUMsT0FBTyxHQUFHLEtBQUcsSUFBM0YsRUFBaUc7QUFDcEcsT0FBS0MsT0FBTCxDQUFhQyxrQkFBYixDQUFnQ0osa0JBQWhDLEVBQW9ELG9CQUFwRDtBQUNBLE9BQUtHLE9BQUwsQ0FBYUUscUJBQWIsQ0FBbUNILE9BQW5DLEVBQTRDLFNBQTVDO0FBQ0EsT0FBS0MsT0FBTCxDQUFhRyxvQkFBYixDQUFrQ0wsWUFBbEMsRUFBZ0QsY0FBaEQ7QUFFQSxPQUFLRCxrQkFBTCxHQUEwQkEsa0JBQTFCO0FBQ0EsT0FBS08sOEJBQUwsR0FBc0NOLFlBQXRDO0FBQ0EsT0FBS08seUJBQUwsR0FBaUNOLE9BQWpDO0FBQ0giLCJzb3VyY2VzQ29udGVudCI6WyIvKlxyXG4gKiBDb3B5cmlnaHQgKEMpIDIwMTUtcHJlc2VudCBDbG91ZEJlYXQgTGltaXRlZFxyXG4gKlxyXG4gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeVxyXG4gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieVxyXG4gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvclxyXG4gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLlxyXG4gKi9cclxuXHJcbi8qKlxyXG4gKiBAc3VtbWFyeSBXYWl0IGZvciBBbmd1bGFyIGJhc2VkIGFwcCB3aWxsIGJlIGxvYWRlZFxyXG4gKiBAZnVuY3Rpb24gc2V0QXV0b1dhaXRGb3JBbmd1bGFyXHJcbiAqIEBwYXJhbSB7Qm9vbGVhbn0gYXV0b1dhaXRGb3JBbmd1bGFyIC0gbmV3IGF1dG9XYWl0IHZhbHVlLiBEYWZhdWx0IGlzIGZhbHNlO1xyXG4gKiBAcGFyYW0ge1N0cmluZz19IHJvb3RTZWxlY3RvciAtIFNlbGVjdG9yIGZvciByb290IGVsZW1lbnQsIG5lZWQgb25seSBmb3IgQW5ndWxhciAxXHJcbiAqIEBwYXJhbSB7TnVtYmVyPX0gdGltZW91dCAtIFRpbWVvdXQgaW4gbWlsbGlzZWNvbmRzLiBEZWZhdWx0IGlzIDYwIHNlY29uZHMuXHJcbiAqIEBleGFtcGxlIDxjYXB0aW9uPltqYXZhc2NyaXB0XSBVc2FnZSBleGFtcGxlPC9jYXB0aW9uPlxyXG4gKiB3ZWIuaW5pdCgpO1xyXG4gKiB3ZWIub3BlbihcInd3dy55b3Vyd2Vic2l0ZS5jb21cIik7XHJcbiAqIHdlYi5zZXRBdXRvV2FpdEZvckFuZ3VsYXIodHJ1ZSk7XHJcbiAqL1xyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIHNldEF1dG9XYWl0Rm9yQW5ndWxhcihhdXRvV2FpdEZvckFuZ3VsYXIgPSBmYWxzZSwgcm9vdFNlbGVjdG9yID0gJycsIHRpbWVvdXQgPSA2MCoxMDAwKSB7XHJcbiAgICB0aGlzLmhlbHBlcnMuYXNzZXJ0QXJndW1lbnRCb29sKGF1dG9XYWl0Rm9yQW5ndWxhciwgJ2F1dG9XYWl0Rm9yQW5ndWxhcicpO1xyXG4gICAgdGhpcy5oZWxwZXJzLmFzc2VydEFyZ3VtZW50VGltZW91dCh0aW1lb3V0LCAndGltZW91dCcpO1xyXG4gICAgdGhpcy5oZWxwZXJzLmFzc2VydEFyZ3VtZW50U3RyaW5nKHJvb3RTZWxlY3RvciwgJ3Jvb3RTZWxlY3RvcicpO1xyXG5cclxuICAgIHRoaXMuYXV0b1dhaXRGb3JBbmd1bGFyID0gYXV0b1dhaXRGb3JBbmd1bGFyO1xyXG4gICAgdGhpcy5hdXRvV2FpdEZvckFuZ3VsYXJSb290U2VsZWN0b3IgPSByb290U2VsZWN0b3I7XHJcbiAgICB0aGlzLmF1dG9XYWl0Rm9yQW5ndWxhclRpbWVvdXQgPSB0aW1lb3V0O1xyXG59Il19
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/ox_modules/module-web/commands/waitForAngular.js

@@ -21,72 +21,69 @@ require("source-map-support/register");
  * @function waitForAngular
  * @param {String=} rootSelector - Selector for root element, needed only for AngularJS (v1). 
  *                                 In Angular (v2) first available root node will be selected automatically.
+ * @param {Boolean=} softWait - If true then do not produce error if stability cannot be attained. Default is false.
  * @param {Number=} timeout - Timeout in milliseconds. Default is 60 seconds.
  * @example <caption>[javascript] Usage example</caption>
  * web.init();
  * web.open("www.yourwebsite.com");
  * web.waitForAngular();
  */
-async function waitForAngular(rootSelector, timeout = 60 * 1000) {
+async function waitForAngular(rootSelector, softWait = false, timeout = 60 * 1000) {
   this.helpers.assertArgumentTimeout(timeout, 'timeout');
 
   try {
     await this.driver.waitUntil(async () => {
-      // in AngularJS (v1) window.angular will be defined 
-      // in Angular (v2) window.angular will be undefined
-      const angular1 = await this.driver.execute(() => {
-        // eslint-disable-next-line no-undef
-        return !!window.angular;
-      });
-
-      if (angular1) {
-        this.helpers.assertArgumentString(rootSelector, 'rootSelector');
-        const testable = await this.driver.executeAsync((rootSelector, done) => {
+      try {
+        // in AngularJS (v1) window.angular will be defined 
+        // in Angular (v2) window.angular will be undefined
+        const angular1 = await this.driver.execute(() => {
           // eslint-disable-next-line no-undef
-          const rootElement = window.angular.element(rootSelector); // eslint-disable-next-line no-undef
+          return !!window.angular;
+        });
 
-          const testability = window.angular.getTestability(rootElement);
-          testability.whenStable(() => {
-            done(true);
-          });
-        }, rootSelector);
-        return testable;
-      } else {
-        const stable = await this.driver.executeAsync(done => {
-          try {
+        if (angular1) {
+          this.helpers.assertArgumentString(rootSelector, 'rootSelector');
+          const testable = await this.driver.execute(rootSelector => {
+            // eslint-disable-next-line no-undef
+            const rootElement = window.angular.element(rootSelector); // eslint-disable-next-line no-undef
+
+            const testability = window.angular.getTestability(rootElement);
+            return testability.isStable();
+          }, rootSelector);
+          return testable;
+        } else {
+          const stable = await this.driver.execute(() => {
             // following way of obtaining testability is the same as using: var testability = window.getAllAngularTestabilities()[0];
             // eslint-disable-next-line no-undef
             const rootElement = window.getAllAngularRootElements()[0]; // eslint-disable-next-line no-undef
 
-            const testability = window.getAngularTestability(rootElement);
-            testability.whenStable(() => {
-              done(true);
-            });
-          } catch (e) {
-            done(false);
-          }
-        });
-        const version = await this.driver.execute(() => {
-          // eslint-disable-next-line no-undef
-          const el = document.querySelector('[ng-version]');
+            const testability = window.getAngularTestability(rootElement); // use isStable instead of whenStable due to this issue:
+            // https://stackoverflow.com/questions/54509647/testability-whenstable-returns-testability-isstable-returns-false
 
-          if (!el) {
-            return null;
-          }
+            return testability.isStable();
+          });
+          const version = await this.driver.execute(() => {
+            // eslint-disable-next-line no-undef
+            const el = document.querySelector('[ng-version]');
 
-          return el.getAttribute('ng-version');
-        });
+            if (!el) {
+              return null;
+            }
 
-        if (version && stable) {
-          return true;
+            return el.getAttribute('ng-version');
+          });
+          return version && stable;
         }
+      } catch (err) {// if we got here then it's executeAsync timeout.
       }
     }, {
       timeout: timeout,
       timeoutMsg: `Unable to attain stability within ${timeout}ms (or this is not an Angular application)`
     });
   } catch (e) {
-    throw new this.OxError(this.errHelper.errorCode.TIMEOUT, e.message);
+    if (!softWait) {
+      throw new this.OxError(this.errHelper.errorCode.TIMEOUT, e.message);
+    }
   }
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/ox_modules/module-web/commands/waitForAngular.js"],"names":["waitForAngular","rootSelector","timeout","helpers","assertArgumentTimeout","driver","waitUntil","angular1","execute","window","angular","assertArgumentString","testable","executeAsync","done","rootElement","element","testability","getTestability","whenStable","stable","getAllAngularRootElements","getAngularTestability","e","version","el","document","querySelector","getAttribute","timeoutMsg","OxError","errHelper","errorCode","TIMEOUT","message"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEO,eAAeA,cAAf,CAA8BC,YAA9B,EAA4CC,OAAO,GAAG,KAAG,IAAzD,EAA+D;AAClE,OAAKC,OAAL,CAAaC,qBAAb,CAAmCF,OAAnC,EAA4C,SAA5C;;AAEA,MAAI;AACA,UAAM,KAAKG,MAAL,CAAYC,SAAZ,CAAsB,YAAY;AAEpC;AACA;AACA,YAAMC,QAAQ,GAAG,MAAM,KAAKF,MAAL,CAAYG,OAAZ,CAAoB,MAAM;AAC7C;AACA,eAAO,CAAC,CAACC,MAAM,CAACC,OAAhB;AACH,OAHsB,CAAvB;;AAKA,UAAIH,QAAJ,EAAc;AACV,aAAKJ,OAAL,CAAaQ,oBAAb,CAAkCV,YAAlC,EAAgD,cAAhD;AACA,cAAMW,QAAQ,GAAG,MAAM,KAAKP,MAAL,CAAYQ,YAAZ,CAAyB,CAACZ,YAAD,EAAea,IAAf,KAAwB;AACpE;AACA,gBAAMC,WAAW,GAAGN,MAAM,CAACC,OAAP,CAAeM,OAAf,CAAuBf,YAAvB,CAApB,CAFoE,CAGpE;;AACA,gBAAMgB,WAAW,GAAGR,MAAM,CAACC,OAAP,CAAeQ,cAAf,CAA8BH,WAA9B,CAApB;AACAE,UAAAA,WAAW,CAACE,UAAZ,CAAuB,MAAM;AACzBL,YAAAA,IAAI,CAAC,IAAD,CAAJ;AACH,WAFD;AAGH,SARsB,EAQpBb,YARoB,CAAvB;AAUA,eAAOW,QAAP;AACH,OAbD,MAaO;AACH,cAAMQ,MAAM,GAAG,MAAM,KAAKf,MAAL,CAAYQ,YAAZ,CAA0BC,IAAD,IAAU;AACpD,cAAI;AACA;AACA;AACA,kBAAMC,WAAW,GAAGN,MAAM,CAACY,yBAAP,GAAmC,CAAnC,CAApB,CAHA,CAIA;;AACA,kBAAMJ,WAAW,GAAGR,MAAM,CAACa,qBAAP,CAA6BP,WAA7B,CAApB;AACAE,YAAAA,WAAW,CAACE,UAAZ,CAAuB,MAAM;AACzBL,cAAAA,IAAI,CAAC,IAAD,CAAJ;AACH,aAFD;AAGH,WATD,CASE,OAAOS,CAAP,EAAU;AACRT,YAAAA,IAAI,CAAC,KAAD,CAAJ;AACH;AACJ,SAboB,CAArB;AAeA,cAAMU,OAAO,GAAG,MAAM,KAAKnB,MAAL,CAAYG,OAAZ,CAAoB,MAAM;AAC5C;AACA,gBAAMiB,EAAE,GAAGC,QAAQ,CAACC,aAAT,CAAuB,cAAvB,CAAX;;AACA,cAAI,CAACF,EAAL,EAAS;AACL,mBAAO,IAAP;AACH;;AACD,iBAAOA,EAAE,CAACG,YAAH,CAAgB,YAAhB,CAAP;AACH,SAPqB,CAAtB;;AASA,YAAIJ,OAAO,IAAIJ,MAAf,EAAuB;AACnB,iBAAO,IAAP;AACH;AACJ;AACJ,KAnDK,EAmDJ;AACElB,MAAAA,OAAO,EAAEA,OADX;AAEE2B,MAAAA,UAAU,EAAG,qCAAoC3B,OAAQ;AAF3D,KAnDI,CAAN;AAuDH,GAxDD,CAwDE,OAAOqB,CAAP,EAAU;AACR,UAAM,IAAI,KAAKO,OAAT,CAAiB,KAAKC,SAAL,CAAeC,SAAf,CAAyBC,OAA1C,EAAmDV,CAAC,CAACW,OAArD,CAAN;AACH;AACJ","sourcesContent":["/*\r\n * Copyright (C) 2015-present CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\n\r\n/**\r\n * @summary Wait for Angular based app will be loaded\r\n * @function waitForAngular\r\n * @param {String=} rootSelector - Selector for root element, needed only for AngularJS (v1). \r\n *                                 In Angular (v2) first available root node will be selected automatically.\r\n * @param {Number=} timeout - Timeout in milliseconds. Default is 60 seconds.\r\n * @example <caption>[javascript] Usage example</caption>\r\n * web.init();\r\n * web.open(\"www.yourwebsite.com\");\r\n * web.waitForAngular();\r\n */\r\n\r\nexport async function waitForAngular(rootSelector, timeout = 60*1000) {\r\n    this.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n\r\n    try {\r\n        await this.driver.waitUntil(async () => {\r\n\r\n            // in AngularJS (v1) window.angular will be defined \r\n            // in Angular (v2) window.angular will be undefined\r\n            const angular1 = await this.driver.execute(() => {\r\n                // eslint-disable-next-line no-undef\r\n                return !!window.angular;\r\n            });\r\n\r\n            if (angular1) {\r\n                this.helpers.assertArgumentString(rootSelector, 'rootSelector');\r\n                const testable = await this.driver.executeAsync((rootSelector, done) => {\r\n                    // eslint-disable-next-line no-undef\r\n                    const rootElement = window.angular.element(rootSelector);\r\n                    // eslint-disable-next-line no-undef\r\n                    const testability = window.angular.getTestability(rootElement);\r\n                    testability.whenStable(() => {\r\n                        done(true);\r\n                    });\r\n                }, rootSelector);\r\n\r\n                return testable;\r\n            } else {\r\n                const stable = await this.driver.executeAsync((done) => {\r\n                    try {\r\n                        // following way of obtaining testability is the same as using: var testability = window.getAllAngularTestabilities()[0];\r\n                        // eslint-disable-next-line no-undef\r\n                        const rootElement = window.getAllAngularRootElements()[0];\r\n                        // eslint-disable-next-line no-undef\r\n                        const testability = window.getAngularTestability(rootElement);\r\n                        testability.whenStable(() => {\r\n                            done(true);\r\n                        });\r\n                    } catch (e) {\r\n                        done(false);\r\n                    }\r\n                });\r\n\r\n                const version = await this.driver.execute(() => {\r\n                    // eslint-disable-next-line no-undef\r\n                    const el = document.querySelector('[ng-version]');\r\n                    if (!el) {\r\n                        return null;\r\n                    }\r\n                    return el.getAttribute('ng-version');\r\n                });\r\n\r\n                if (version && stable) {\r\n                    return true;\r\n                }\r\n            }\r\n        },{\r\n            timeout: timeout,\r\n            timeoutMsg: `Unable to attain stability within ${timeout}ms (or this is not an Angular application)`\r\n        });\r\n    } catch (e) {\r\n        throw new this.OxError(this.errHelper.errorCode.TIMEOUT, e.message);\r\n    }\r\n}"]}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../src/ox_modules/module-web/commands/waitForAngular.js"],"names":["waitForAngular","rootSelector","softWait","timeout","helpers","assertArgumentTimeout","driver","waitUntil","angular1","execute","window","angular","assertArgumentString","testable","rootElement","element","testability","getTestability","isStable","stable","getAllAngularRootElements","getAngularTestability","version","el","document","querySelector","getAttribute","err","timeoutMsg","e","OxError","errHelper","errorCode","TIMEOUT","message"],"mappings":";;;;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEO,eAAeA,cAAf,CAA8BC,YAA9B,EAA4CC,QAAQ,GAAG,KAAvD,EAA8DC,OAAO,GAAG,KAAG,IAA3E,EAAiF;AACpF,OAAKC,OAAL,CAAaC,qBAAb,CAAmCF,OAAnC,EAA4C,SAA5C;;AAEA,MAAI;AACA,UAAM,KAAKG,MAAL,CAAYC,SAAZ,CAAsB,YAAY;AACpC,UAAI;AAEA;AACA;AACA,cAAMC,QAAQ,GAAG,MAAM,KAAKF,MAAL,CAAYG,OAAZ,CAAoB,MAAM;AAC7C;AACA,iBAAO,CAAC,CAACC,MAAM,CAACC,OAAhB;AACH,SAHsB,CAAvB;;AAKA,YAAIH,QAAJ,EAAc;AACV,eAAKJ,OAAL,CAAaQ,oBAAb,CAAkCX,YAAlC,EAAgD,cAAhD;AACA,gBAAMY,QAAQ,GAAG,MAAM,KAAKP,MAAL,CAAYG,OAAZ,CAAqBR,YAAD,IAAkB;AACzD;AACA,kBAAMa,WAAW,GAAGJ,MAAM,CAACC,OAAP,CAAeI,OAAf,CAAuBd,YAAvB,CAApB,CAFyD,CAGzD;;AACA,kBAAMe,WAAW,GAAGN,MAAM,CAACC,OAAP,CAAeM,cAAf,CAA8BH,WAA9B,CAApB;AACA,mBAAOE,WAAW,CAACE,QAAZ,EAAP;AACH,WANsB,EAMpBjB,YANoB,CAAvB;AAQA,iBAAOY,QAAP;AACH,SAXD,MAWO;AACH,gBAAMM,MAAM,GAAG,MAAM,KAAKb,MAAL,CAAYG,OAAZ,CAAoB,MAAM;AAC3C;AACA;AACA,kBAAMK,WAAW,GAAGJ,MAAM,CAACU,yBAAP,GAAmC,CAAnC,CAApB,CAH2C,CAI1C;;AACD,kBAAMJ,WAAW,GAAGN,MAAM,CAACW,qBAAP,CAA6BP,WAA7B,CAApB,CAL2C,CAM3C;AACA;;AACA,mBAAOE,WAAW,CAACE,QAAZ,EAAP;AACH,WAToB,CAArB;AAWA,gBAAMI,OAAO,GAAG,MAAM,KAAKhB,MAAL,CAAYG,OAAZ,CAAoB,MAAM;AAC5C;AACA,kBAAMc,EAAE,GAAGC,QAAQ,CAACC,aAAT,CAAuB,cAAvB,CAAX;;AACA,gBAAI,CAACF,EAAL,EAAS;AACL,qBAAO,IAAP;AACH;;AACD,mBAAOA,EAAE,CAACG,YAAH,CAAgB,YAAhB,CAAP;AACH,WAPqB,CAAtB;AASA,iBAAQJ,OAAO,IAAIH,MAAnB;AACH;AACJ,OA3CD,CA2CE,OAAOQ,GAAP,EAAY,CACV;AACH;AACJ,KA/CK,EA+CJ;AACExB,MAAAA,OAAO,EAAEA,OADX;AAEEyB,MAAAA,UAAU,EAAG,qCAAoCzB,OAAQ;AAF3D,KA/CI,CAAN;AAmDH,GApDD,CAoDE,OAAO0B,CAAP,EAAU;AACR,QAAI,CAAC3B,QAAL,EAAe;AACX,YAAM,IAAI,KAAK4B,OAAT,CAAiB,KAAKC,SAAL,CAAeC,SAAf,CAAyBC,OAA1C,EAAmDJ,CAAC,CAACK,OAArD,CAAN;AACH;AACJ;AACJ","sourcesContent":["/*\r\n * Copyright (C) 2015-present CloudBeat Limited\r\n *\r\n * This program is free software: you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation, either version 3 of the License, or\r\n * (at your option) any later version.\r\n */\r\n\r\n/**\r\n * @summary Wait for Angular based app will be loaded\r\n * @function waitForAngular\r\n * @param {String=} rootSelector - Selector for root element, needed only for AngularJS (v1). \r\n *                                 In Angular (v2) first available root node will be selected automatically.\r\n * @param {Boolean=} softWait - If true then do not produce error if stability cannot be attained. Default is false.\r\n * @param {Number=} timeout - Timeout in milliseconds. Default is 60 seconds.\r\n * @example <caption>[javascript] Usage example</caption>\r\n * web.init();\r\n * web.open(\"www.yourwebsite.com\");\r\n * web.waitForAngular();\r\n */\r\n\r\nexport async function waitForAngular(rootSelector, softWait = false, timeout = 60*1000) {\r\n    this.helpers.assertArgumentTimeout(timeout, 'timeout');\r\n\r\n    try {\r\n        await this.driver.waitUntil(async () => {\r\n            try {\r\n\r\n                // in AngularJS (v1) window.angular will be defined \r\n                // in Angular (v2) window.angular will be undefined\r\n                const angular1 = await this.driver.execute(() => {\r\n                    // eslint-disable-next-line no-undef\r\n                    return !!window.angular;\r\n                });\r\n\r\n                if (angular1) {\r\n                    this.helpers.assertArgumentString(rootSelector, 'rootSelector');\r\n                    const testable = await this.driver.execute((rootSelector) => {\r\n                        // eslint-disable-next-line no-undef\r\n                        const rootElement = window.angular.element(rootSelector);\r\n                        // eslint-disable-next-line no-undef\r\n                        const testability = window.angular.getTestability(rootElement);\r\n                        return testability.isStable();\r\n                    }, rootSelector);\r\n\r\n                    return testable;\r\n                } else {\r\n                    const stable = await this.driver.execute(() => {\r\n                        // following way of obtaining testability is the same as using: var testability = window.getAllAngularTestabilities()[0];\r\n                        // eslint-disable-next-line no-undef\r\n                        const rootElement = window.getAllAngularRootElements()[0];\r\n                         // eslint-disable-next-line no-undef\r\n                        const testability = window.getAngularTestability(rootElement);\r\n                        // use isStable instead of whenStable due to this issue:\r\n                        // https://stackoverflow.com/questions/54509647/testability-whenstable-returns-testability-isstable-returns-false\r\n                        return testability.isStable();\r\n                    });\r\n\r\n                    const version = await this.driver.execute(() => {\r\n                        // eslint-disable-next-line no-undef\r\n                        const el = document.querySelector('[ng-version]');\r\n                        if (!el) {\r\n                            return null;\r\n                        }\r\n                        return el.getAttribute('ng-version');\r\n                    });\r\n\r\n                    return (version && stable);\r\n                }\r\n            } catch (err) {\r\n                // if we got here then it's executeAsync timeout.\r\n            }\r\n        },{\r\n            timeout: timeout,\r\n            timeoutMsg: `Unable to attain stability within ${timeout}ms (or this is not an Angular application)`\r\n        });\r\n    } catch (e) {\r\n        if (!softWait) {\r\n            throw new this.OxError(this.errHelper.errorCode.TIMEOUT, e.message);\r\n        }\r\n    }\r\n}"]}