@appium/base-driver 8.2.4 → 8.4.0

package/build/lib/index.d.ts

@@ -0,0 +1,183 @@
+export { DriverCore } from "./basedriver/core";
+export default BaseDriver;
+import { BaseDriver } from "./basedriver/driver";
+import { DeviceSettings } from "./basedriver/device-settings";
+export const routeConfiguringFunction: typeof protocol.routeConfiguringFunction;
+export const errors: {
+    NotYetImplementedError: typeof import("./protocol/errors").NotYetImplementedError;
+    NotImplementedError: typeof import("./protocol/errors").NotImplementedError;
+    BadParametersError: typeof import("./protocol/errors").BadParametersError;
+    InvalidArgumentError: typeof import("./protocol/errors").InvalidArgumentError;
+    NoSuchDriverError: typeof import("./protocol/errors").NoSuchDriverError;
+    NoSuchElementError: typeof import("./protocol/errors").NoSuchElementError;
+    UnknownCommandError: typeof import("./protocol/errors").UnknownCommandError;
+    StaleElementReferenceError: typeof import("./protocol/errors").StaleElementReferenceError;
+    ElementNotVisibleError: typeof import("./protocol/errors").ElementNotVisibleError;
+    InvalidElementStateError: typeof import("./protocol/errors").InvalidElementStateError;
+    UnknownError: typeof import("./protocol/errors").UnknownError;
+    ElementIsNotSelectableError: typeof import("./protocol/errors").ElementIsNotSelectableError;
+    ElementClickInterceptedError: typeof import("./protocol/errors").ElementClickInterceptedError;
+    ElementNotInteractableError: typeof import("./protocol/errors").ElementNotInteractableError;
+    InsecureCertificateError: typeof import("./protocol/errors").InsecureCertificateError;
+    JavaScriptError: typeof import("./protocol/errors").JavaScriptError;
+    XPathLookupError: typeof import("./protocol/errors").XPathLookupError;
+    TimeoutError: typeof import("./protocol/errors").TimeoutError;
+    NoSuchWindowError: typeof import("./protocol/errors").NoSuchWindowError;
+    NoSuchCookieError: typeof import("./protocol/errors").NoSuchCookieError;
+    InvalidCookieDomainError: typeof import("./protocol/errors").InvalidCookieDomainError;
+    InvalidCoordinatesError: typeof import("./protocol/errors").InvalidCoordinatesError;
+    UnableToSetCookieError: typeof import("./protocol/errors").UnableToSetCookieError;
+    UnexpectedAlertOpenError: typeof import("./protocol/errors").UnexpectedAlertOpenError;
+    NoAlertOpenError: typeof import("./protocol/errors").NoAlertOpenError;
+    ScriptTimeoutError: typeof import("./protocol/errors").ScriptTimeoutError;
+    InvalidElementCoordinatesError: typeof import("./protocol/errors").InvalidElementCoordinatesError;
+    IMENotAvailableError: typeof import("./protocol/errors").IMENotAvailableError;
+    IMEEngineActivationFailedError: typeof import("./protocol/errors").IMEEngineActivationFailedError;
+    InvalidSelectorError: typeof import("./protocol/errors").InvalidSelectorError;
+    SessionNotCreatedError: typeof import("./protocol/errors").SessionNotCreatedError;
+    MoveTargetOutOfBoundsError: typeof import("./protocol/errors").MoveTargetOutOfBoundsError;
+    NoSuchAlertError: typeof import("./protocol/errors").NoSuchAlertError;
+    NoSuchContextError: typeof import("./protocol/errors").NoSuchContextError;
+    InvalidContextError: typeof import("./protocol/errors").InvalidContextError;
+    NoSuchFrameError: typeof import("./protocol/errors").NoSuchFrameError;
+    UnableToCaptureScreen: typeof import("./protocol/errors").UnableToCaptureScreen;
+    UnknownMethodError: typeof import("./protocol/errors").UnknownMethodError;
+    UnsupportedOperationError: typeof import("./protocol/errors").UnsupportedOperationError;
+    ProxyRequestError: typeof import("./protocol/errors").ProxyRequestError;
+};
+export const isErrorType: typeof protocol.isErrorType;
+import { PROTOCOLS } from "./constants";
+export const errorFromMJSONWPStatusCode: typeof protocol.errorFromMJSONWPStatusCode;
+export const errorFromW3CJsonCode: typeof protocol.errorFromW3CJsonCode;
+export const determineProtocol: typeof protocol.determineProtocol;
+export const ALL_COMMANDS: any[];
+export const METHOD_MAP: import("@appium/types").MethodMap<import("@appium/types").ExternalDriver>;
+export const routeToCommandName: typeof protocol.routeToCommandName;
+export const NO_SESSION_ID_COMMANDS: string[];
+export const isSessionCommand: typeof protocol.isSessionCommand;
+import { DEFAULT_BASE_PATH } from "./constants";
+export const CREATE_SESSION_COMMAND: "createSession";
+export const DELETE_SESSION_COMMAND: "deleteSession";
+export const GET_STATUS_COMMAND: "getStatus";
+export const STATIC_DIR: string;
+export const server: typeof serverIndex.server;
+export const normalizeBasePath: typeof serverIndex.normalizeBasePath;
+export const JWProxy: typeof proxyIndex.JWProxy;
+export const statusCodes: {
+    Success: {
+        code: number;
+        summary: string;
+    };
+    NoSuchDriver: {
+        code: number;
+        summary: string;
+    };
+    NoSuchElement: {
+        code: number;
+        summary: string;
+    };
+    NoSuchFrame: {
+        code: number;
+        summary: string;
+    };
+    UnknownCommand: {
+        code: number;
+        summary: string;
+    };
+    StaleElementReference: {
+        code: number;
+        summary: string;
+    };
+    ElementNotVisible: {
+        code: number;
+        summary: string;
+    };
+    InvalidElementState: {
+        code: number;
+        summary: string;
+    };
+    UnknownError: {
+        code: number;
+        summary: string;
+    };
+    ElementIsNotSelectable: {
+        code: number;
+        summary: string;
+    };
+    JavaScriptError: {
+        code: number;
+        summary: string;
+    };
+    XPathLookupError: {
+        code: number;
+        summary: string;
+    };
+    Timeout: {
+        code: number;
+        summary: string;
+    };
+    NoSuchWindow: {
+        code: number;
+        summary: string;
+    };
+    InvalidCookieDomain: {
+        code: number;
+        summary: string;
+    };
+    UnableToSetCookie: {
+        code: number;
+        summary: string;
+    };
+    UnexpectedAlertOpen: {
+        code: number;
+        summary: string;
+    };
+    NoAlertOpenError: {
+        code: number;
+        summary: string;
+    };
+    ScriptTimeout: {
+        code: number;
+        summary: string;
+    };
+    InvalidElementCoordinates: {
+        code: number;
+        summary: string;
+    };
+    IMENotAvailable: {
+        code: number;
+        summary: string;
+    };
+    IMEEngineActivationFailed: {
+        code: number;
+        summary: string;
+    };
+    InvalidSelector: {
+        code: number;
+        summary: string;
+    };
+    SessionNotCreatedException: {
+        code: number;
+        summary: string;
+    };
+    MoveTargetOutOfBounds: {
+        code: number;
+        summary: string;
+    };
+    NoSuchContext: {
+        code: number;
+        summary: string;
+    };
+};
+export const getSummaryByCode: typeof statusIndex.getSummaryByCode;
+export const processCapabilities: typeof caps.processCapabilities;
+export const isStandardCap: typeof caps.isStandardCap;
+export const validateCaps: typeof caps.validateCaps;
+export const DEFAULT_WS_PATHNAME_PREFIX: "/ws";
+import * as protocol from "./protocol";
+import * as serverIndex from "./express/server";
+import * as proxyIndex from "./jsonwp-proxy/proxy";
+import * as statusIndex from "./jsonwp-status/status";
+import * as caps from "./basedriver/capabilities";
+export { BaseDriver, DeviceSettings, PROTOCOLS, errorFromMJSONWPStatusCode as errorFromCode, DEFAULT_BASE_PATH };
+//# sourceMappingURL=index.d.ts.map

package/build/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.js"],"names":[],"mappings":""}

package/build/lib/index.js

@@ -1,29 +1,55 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.CREATE_SESSION_COMMAND = exports.BaseDriver = exports.BASEDRIVER_HANDLED_SETTINGS = exports.ALL_COMMANDS = void 0;
+exports.ALL_COMMANDS = void 0;
+Object.defineProperty(exports, "BaseDriver", {
+  enumerable: true,
+  get: function () {
+    return _driver.BaseDriver;
+  }
+});
+exports.CREATE_SESSION_COMMAND = void 0;
 Object.defineProperty(exports, "DEFAULT_BASE_PATH", {
   enumerable: true,
   get: function () {
     return _constants.DEFAULT_BASE_PATH;
   }
 });
-exports.NO_SESSION_ID_COMMANDS = exports.METHOD_MAP = exports.JWProxy = exports.GET_STATUS_COMMAND = exports.DeviceSettings = exports.DELETE_SESSION_COMMAND = exports.DEFAULT_WS_PATHNAME_PREFIX = void 0;
+exports.DELETE_SESSION_COMMAND = exports.DEFAULT_WS_PATHNAME_PREFIX = void 0;
+Object.defineProperty(exports, "DeviceSettings", {
+  enumerable: true,
+  get: function () {
+    return _deviceSettings.DeviceSettings;
+  }
+});
+Object.defineProperty(exports, "DriverCore", {
+  enumerable: true,
+  get: function () {
+    return _core.DriverCore;
+  }
+});
+exports.NO_SESSION_ID_COMMANDS = exports.METHOD_MAP = exports.JWProxy = exports.GET_STATUS_COMMAND = void 0;
 Object.defineProperty(exports, "PROTOCOLS", {
   enumerable: true,
   get: function () {
     return _constants.PROTOCOLS;
   }
 });
-exports.validateCaps = exports.statusCodes = exports.server = exports.routeToCommandName = exports.routeConfiguringFunction = exports.processCapabilities = exports.normalizeBasePath = exports.isStandardCap = exports.isSessionCommand = exports.isErrorType = exports.getSummaryByCode = exports.errors = exports.errorFromW3CJsonCode = exports.errorFromMJSONWPStatusCode = exports.errorFromCode = exports.determineProtocol = exports.default = exports.STATIC_DIR = exports.Protocol = void 0;
+exports.validateCaps = exports.statusCodes = exports.server = exports.routeToCommandName = exports.routeConfiguringFunction = exports.processCapabilities = exports.normalizeBasePath = exports.isStandardCap = exports.isSessionCommand = exports.isErrorType = exports.getSummaryByCode = exports.errors = exports.errorFromW3CJsonCode = exports.errorFromMJSONWPStatusCode = exports.errorFromCode = exports.determineProtocol = exports.default = exports.STATIC_DIR = void 0;
 
 require("source-map-support/register");
 
-var driver = _interopRequireWildcard(require("./basedriver/driver"));
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _driver = require("./basedriver/driver");
+
+var _core = require("./basedriver/core");
 
-var deviceSettings = _interopRequireWildcard(require("./basedriver/device-settings"));
+var _deviceSettings = require("./basedriver/device-settings");
 
 var protocol = _interopRequireWildcard(require("./protocol"));
 
@@ -45,20 +71,13 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const {
-  BaseDriver
-} = driver;
-exports.BaseDriver = BaseDriver;
-const {
-  DeviceSettings,
-  BASEDRIVER_HANDLED_SETTINGS
-} = deviceSettings;
-exports.BASEDRIVER_HANDLED_SETTINGS = BASEDRIVER_HANDLED_SETTINGS;
-exports.DeviceSettings = DeviceSettings;
-var _default = BaseDriver;
+_bluebird.default.config({
+  cancellation: true
+});
+
+var _default = _driver.BaseDriver;
 exports.default = _default;
 const {
-  Protocol,
   routeConfiguringFunction,
   errors,
   isErrorType,
@@ -69,7 +88,6 @@ const {
   routeToCommandName,
   NO_SESSION_ID_COMMANDS,
   isSessionCommand,
-  normalizeBasePath,
   determineProtocol,
   CREATE_SESSION_COMMAND,
   DELETE_SESSION_COMMAND,
@@ -79,7 +97,6 @@ exports.GET_STATUS_COMMAND = GET_STATUS_COMMAND;
 exports.DELETE_SESSION_COMMAND = DELETE_SESSION_COMMAND;
 exports.CREATE_SESSION_COMMAND = CREATE_SESSION_COMMAND;
 exports.determineProtocol = determineProtocol;
-exports.normalizeBasePath = normalizeBasePath;
 exports.isSessionCommand = isSessionCommand;
 exports.NO_SESSION_ID_COMMANDS = NO_SESSION_ID_COMMANDS;
 exports.routeToCommandName = routeToCommandName;
@@ -90,14 +107,15 @@ exports.errorFromCode = exports.errorFromMJSONWPStatusCode = errorFromMJSONWPSta
 exports.isErrorType = isErrorType;
 exports.errors = errors;
 exports.routeConfiguringFunction = routeConfiguringFunction;
-exports.Protocol = Protocol;
 const {
   STATIC_DIR
 } = staticIndex;
 exports.STATIC_DIR = STATIC_DIR;
 const {
-  server
+  server,
+  normalizeBasePath
 } = serverIndex;
+exports.normalizeBasePath = normalizeBasePath;
 exports.server = server;
 const {
   JWProxy
@@ -120,7 +138,5 @@ exports.processCapabilities = processCapabilities;
 const {
   DEFAULT_WS_PATHNAME_PREFIX
 } = ws;
-exports.DEFAULT_WS_PATHNAME_PREFIX = DEFAULT_WS_PATHNAME_PREFIX;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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
+exports.DEFAULT_WS_PATHNAME_PREFIX = DEFAULT_WS_PATHNAME_PREFIX;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/build/lib/jsonwp-proxy/protocol-converter.d.ts

@@ -0,0 +1,48 @@
+export const COMMAND_URLS_CONFLICTS: {
+    commandNames: string[];
+    jsonwpConverter: (url: any) => any;
+    w3cConverter: (url: any) => any;
+}[];
+export default ProtocolConverter;
+declare class ProtocolConverter {
+    constructor(proxyFunc: any, log?: null);
+    proxyFunc: any;
+    _downstreamProtocol: any;
+    _log: any;
+    get log(): any;
+    set downstreamProtocol(arg: any);
+    get downstreamProtocol(): any;
+    /**
+     * W3C /timeouts can take as many as 3 timeout types at once, MJSONWP /timeouts only takes one
+     * at a time. So if we're using W3C and proxying to MJSONWP and there's more than one timeout type
+     * provided in the request, we need to do 3 proxies and combine the result
+     *
+     * @param {Object} body Request body
+     * @return {Array} Array of W3C + MJSONWP compatible timeout objects
+     */
+    getTimeoutRequestObjects(body: any): any[];
+    /**
+     * Proxy an array of timeout objects and merge the result
+     * @param {String} url Endpoint url
+     * @param {String} method Endpoint method
+     * @param {Object} body Request body
+     */
+    proxySetTimeouts(url: string, method: string, body: any): Promise<any[]>;
+    proxySetWindow(url: any, method: any, body: any): Promise<any>;
+    proxySetValue(url: any, method: any, body: any): Promise<any>;
+    proxySetFrame(url: any, method: any, body: any): Promise<any>;
+    proxyPerformActions(url: any, method: any, body: any): Promise<any>;
+    proxyReleaseActions(url: any, method: any): Promise<any>;
+    /**
+     * Handle "crossing" endpoints for the case
+     * when upstream and downstream drivers operate different protocols
+     *
+     * @param {string} commandName
+     * @param {string} url
+     * @param {string} method
+     * @param {?string|object} body
+     * @returns The proxyfying result as [response, responseBody] tuple
+     */
+    convertAndProxy(commandName: string, url: string, method: string, body: (string | object) | null): Promise<any>;
+}
+//# sourceMappingURL=protocol-converter.d.ts.map

package/build/lib/jsonwp-proxy/protocol-converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-converter.d.ts","sourceRoot":"","sources":["../../../lib/jsonwp-proxy/protocol-converter.js"],"names":[],"mappings":"AAOA;;;;IAqCE;;AAKF;IACE,wCAIC;IAHC,eAA0B;IAC1B,yBAA+B;IAC/B,UAAe;IAGjB,eAEC;IAED,iCAEC;IAED,8BAEC;IAED;;;;;;;OAOG;IACH,2CAsBC;IAED;;;;;OAKG;IACH,yEAqBC;IAED,+DAoBC;IAED,8DAsBC;IAED,8DAQC;IAED,oEAKC;IAED,yDAEC;IAED;;;;;;;;;OASG;IACH,6BANW,MAAM,OACN,MAAM,UACN,MAAM,SACL,MAAM,GAAC,MAAM,wBA+CxB;CACF"}

package/build/lib/jsonwp-proxy/protocol-converter.js

@@ -17,8 +17,6 @@ var _helpers = require("../basedriver/helpers");
 
 var _constants = require("../constants");
 
-const log = _support.logger.getLogger('Protocol Converter');
-
 const COMMAND_URLS_CONFLICTS = [{
   commandNames: ['execute', 'executeAsync'],
   jsonwpConverter: url => url.replace(/\/execute.*/, url.includes('async') ? '/execute_async' : '/execute'),
@@ -43,7 +41,6 @@ const COMMAND_URLS_CONFLICTS = [{
   jsonwpConverter: w3cUrl => {
     const w3cPropertyRegex = /\/element\/([^/]+)\/property\/([^/]+)/;
     const jsonwpUrl = w3cUrl.replace(w3cPropertyRegex, '/element/$1/attribute/$2');
-    log.info(`Converting W3C '${w3cUrl}' to '${jsonwpUrl}'`);
     return jsonwpUrl;
   },
   w3cConverter: jsonwpUrl => jsonwpUrl
@@ -54,10 +51,19 @@ const {
   W3C
 } = _constants.PROTOCOLS;
 
+const DEFAULT_LOG = _support.logger.getLogger('Protocol Converter');
+
 class ProtocolConverter {
-  constructor(proxyFunc) {
+  constructor(proxyFunc, log = null) {
     this.proxyFunc = proxyFunc;
     this._downstreamProtocol = null;
+    this._log = log;
+  }
+
+  get log() {
+    var _this$_log;
+
+    return (_this$_log = this._log) !== null && _this$_log !== void 0 ? _this$_log : DEFAULT_LOG;
   }
 
   set downstreamProtocol(value) {
@@ -94,7 +100,7 @@ class ProtocolConverter {
   async proxySetTimeouts(url, method, body) {
     let response, resBody;
     const timeoutRequestObjects = this.getTimeoutRequestObjects(body);
-    log.debug(`Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`);
+    this.log.debug(`Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`);
 
     for (const timeoutObj of timeoutRequestObjects) {
       [response, resBody] = await this.proxyFunc(url, method, timeoutObj);
@@ -116,14 +122,14 @@ class ProtocolConverter {
 
     if (_lodash.default.isPlainObject(bodyObj)) {
       if (this.downstreamProtocol === W3C && _lodash.default.has(bodyObj, 'name') && !_lodash.default.has(bodyObj, 'handle')) {
-        log.debug(`Copied 'name' value '${bodyObj.name}' to 'handle' as per W3C spec`);
+        this.log.debug(`Copied 'name' value '${bodyObj.name}' to 'handle' as per W3C spec`);
         return await this.proxyFunc(url, method, { ...bodyObj,
           handle: bodyObj.name
         });
       }
 
       if (this.downstreamProtocol === MJSONWP && _lodash.default.has(bodyObj, 'handle') && !_lodash.default.has(bodyObj, 'name')) {
-        log.debug(`Copied 'handle' value '${bodyObj.handle}' to 'name' as per JSONWP spec`);
+        this.log.debug(`Copied 'handle' value '${bodyObj.handle}' to 'name' as per JSONWP spec`);
         return await this.proxyFunc(url, method, { ...bodyObj,
           name: bodyObj.handle
         });
@@ -144,10 +150,10 @@ class ProtocolConverter {
 
       if (_support.util.hasValue(text) && !_support.util.hasValue(value)) {
         value = _lodash.default.isString(text) ? [...text] : _lodash.default.isArray(text) ? text : [];
-        log.debug(`Added 'value' property ${JSON.stringify(value)} to 'setValue' request body`);
+        this.log.debug(`Added 'value' property ${JSON.stringify(value)} to 'setValue' request body`);
       } else if (!_support.util.hasValue(text) && _support.util.hasValue(value)) {
         text = _lodash.default.isArray(value) ? value.join('') : _lodash.default.isString(value) ? value : '';
-        log.debug(`Added 'text' property ${JSON.stringify(text)} to 'setValue' request body`);
+        this.log.debug(`Added 'text' property ${JSON.stringify(text)} to 'setValue' request body`);
       }
 
       return await this.proxyFunc(url, method, Object.assign({}, bodyObj, {
@@ -217,11 +223,11 @@ class ProtocolConverter {
       const rewrittenUrl = this.downstreamProtocol === MJSONWP ? jsonwpConverter(url) : w3cConverter(url);
 
       if (rewrittenUrl === url) {
-        log.debug(`Did not know how to rewrite the original URL '${url}' ` + `for ${this.downstreamProtocol} protocol`);
+        this.log.debug(`Did not know how to rewrite the original URL '${url}' ` + `for ${this.downstreamProtocol} protocol`);
         break;
       }
 
-      log.info(`Rewrote the original URL '${url}' to '${rewrittenUrl}' ` + `for ${this.downstreamProtocol} protocol`);
+      this.log.info(`Rewrote the original URL '${url}' to '${rewrittenUrl}' ` + `for ${this.downstreamProtocol} protocol`);
       return await this.proxyFunc(rewrittenUrl, method, body);
     }
 
@@ -231,7 +237,5 @@ class ProtocolConverter {
 }
 
 var _default = ProtocolConverter;
-exports.default = _default;require('source-map-support').install();
-
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/jsonwp-proxy/protocol-converter.js"],"names":["log","logger","getLogger","COMMAND_URLS_CONFLICTS","commandNames","jsonwpConverter","url","replace","includes","w3cConverter","test","w3cUrl","w3cPropertyRegex","jsonwpUrl","info","MJSONWP","W3C","PROTOCOLS","ProtocolConverter","constructor","proxyFunc","_downstreamProtocol","downstreamProtocol","value","getTimeoutRequestObjects","body","_","has","typeToW3C","x","type","ms","typeToJSONWP","toPairs","filter","pair","map","proxySetTimeouts","method","response","resBody","timeoutRequestObjects","debug","JSON","stringify","timeoutObj","statusCode","proxySetWindow","bodyObj","util","safeJsonParse","isPlainObject","name","handle","proxySetValue","hasValue","text","isString","isArray","join","Object","assign","proxySetFrame","id","MJSONWP_ELEMENT_KEY","W3C_ELEMENT_KEY","proxyPerformActions","proxyReleaseActions","convertAndProxy","commandName","rewrittenUrl"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport { logger, util } from '@appium/support';\nimport { duplicateKeys } from '../basedriver/helpers';\nimport {\n  MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, PROTOCOLS\n} from '../constants';\n\nconst log = logger.getLogger('Protocol Converter');\n\n\nexport const COMMAND_URLS_CONFLICTS = [\n  {\n    commandNames: ['execute', 'executeAsync'],\n    jsonwpConverter: (url) => url.replace(/\\/execute.*/,\n      url.includes('async') ? '/execute_async' : '/execute'),\n    w3cConverter: (url) => url.replace(/\\/execute.*/,\n      url.includes('async') ? '/execute/async' : '/execute/sync'),\n  },\n  {\n    commandNames: ['getElementScreenshot'],\n    jsonwpConverter: (url) => url.replace(/\\/element\\/([^/]+)\\/screenshot$/,\n      '/screenshot/$1'),\n    w3cConverter: (url) => url.replace(/\\/screenshot\\/([^/]+)/,\n      '/element/$1/screenshot'),\n  },\n  {\n    commandNames: ['getWindowHandles', 'getWindowHandle'],\n    jsonwpConverter (url) {\n      return /\\/window$/.test(url)\n        ? url.replace(/\\/window$/, '/window_handle')\n        : url.replace(/\\/window\\/handle(s?)$/, '/window_handle$1');\n    },\n    w3cConverter (url) {\n      return /\\/window_handle$/.test(url)\n        ? url.replace(/\\/window_handle$/, '/window')\n        : url.replace(/\\/window_handles$/, '/window/handles');\n    },\n  },\n  {\n    commandNames: ['getProperty'],\n    jsonwpConverter: (w3cUrl) => {\n      const w3cPropertyRegex = /\\/element\\/([^/]+)\\/property\\/([^/]+)/;\n      const jsonwpUrl = w3cUrl.replace(w3cPropertyRegex, '/element/$1/attribute/$2');\n      log.info(`Converting W3C '${w3cUrl}' to '${jsonwpUrl}'`);\n      return jsonwpUrl;\n    },\n    w3cConverter: (jsonwpUrl) => jsonwpUrl // Don't convert JSONWP URL to W3C. W3C accepts /attribute and /property\n  }\n];\n\nconst {MJSONWP, W3C} = PROTOCOLS;\n\n\nclass ProtocolConverter {\n  constructor (proxyFunc) {\n    this.proxyFunc = proxyFunc;\n    this._downstreamProtocol = null;\n  }\n\n  set downstreamProtocol (value) {\n    this._downstreamProtocol = value;\n  }\n\n  get downstreamProtocol () {\n    return this._downstreamProtocol;\n  }\n\n  /**\n   * W3C /timeouts can take as many as 3 timeout types at once, MJSONWP /timeouts only takes one\n   * at a time. So if we're using W3C and proxying to MJSONWP and there's more than one timeout type\n   * provided in the request, we need to do 3 proxies and combine the result\n   *\n   * @param {Object} body Request body\n   * @return {Array} Array of W3C + MJSONWP compatible timeout objects\n   */\n  getTimeoutRequestObjects (body) {\n    if (this.downstreamProtocol === W3C && _.has(body, 'ms') && _.has(body, 'type')) {\n      const typeToW3C = (x) => x === 'page load' ? 'pageLoad' : x;\n      return [{\n        [typeToW3C(body.type)]: body.ms,\n      }];\n    }\n\n    if (this.downstreamProtocol === MJSONWP && (!_.has(body, 'ms') || !_.has(body, 'type'))) {\n      const typeToJSONWP = (x) => x === 'pageLoad' ? 'page load' : x;\n      return _.toPairs(body)\n        // Only transform the entry if ms value is a valid positive float number\n        .filter((pair) => /^\\d+(?:[.,]\\d*?)?$/.test(`${pair[1]}`))\n        .map(function (pair) {\n          return {\n            type: typeToJSONWP(pair[0]),\n            ms: pair[1],\n          };\n        });\n    }\n\n    return [body];\n  }\n\n  /**\n   * Proxy an array of timeout objects and merge the result\n   * @param {String} url Endpoint url\n   * @param {String} method Endpoint method\n   * @param {Object} body Request body\n   */\n  async proxySetTimeouts (url, method, body) {\n    let response, resBody;\n\n    const timeoutRequestObjects = this.getTimeoutRequestObjects(body);\n    log.debug(`Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`);\n    for (const timeoutObj of timeoutRequestObjects) {\n      [response, resBody] = await this.proxyFunc(url, method, timeoutObj);\n\n      // If we got a non-MJSONWP response, return the result, nothing left to do\n      if (this.downstreamProtocol !== MJSONWP) {\n        return [response, resBody];\n      }\n\n      // If we got an error, return the error right away\n      if (response.statusCode >= 400) {\n        return [response, resBody];\n      }\n\n      // ...Otherwise, continue to the next timeouts call\n    }\n    return [response, resBody];\n  }\n\n  async proxySetWindow (url, method, body) {\n    const bodyObj = util.safeJsonParse(body);\n    if (_.isPlainObject(bodyObj)) {\n      if (this.downstreamProtocol === W3C && _.has(bodyObj, 'name') && !_.has(bodyObj, 'handle')) {\n        log.debug(`Copied 'name' value '${bodyObj.name}' to 'handle' as per W3C spec`);\n        return await this.proxyFunc(url, method, {\n          ...bodyObj,\n          handle: bodyObj.name,\n        });\n      }\n      if (this.downstreamProtocol === MJSONWP && _.has(bodyObj, 'handle') && !_.has(bodyObj, 'name')) {\n        log.debug(`Copied 'handle' value '${bodyObj.handle}' to 'name' as per JSONWP spec`);\n        return await this.proxyFunc(url, method, {\n          ...bodyObj,\n          name: bodyObj.handle,\n        });\n      }\n    }\n\n    return await this.proxyFunc(url, method, body);\n  }\n\n  async proxySetValue (url, method, body) {\n    const bodyObj = util.safeJsonParse(body);\n    if (_.isPlainObject(bodyObj) && (util.hasValue(bodyObj.text) || util.hasValue(bodyObj.value))) {\n      let {text, value} = bodyObj;\n      if (util.hasValue(text) && !util.hasValue(value)) {\n        value = _.isString(text)\n          ? [...text]\n          : (_.isArray(text) ? text : []);\n        log.debug(`Added 'value' property ${JSON.stringify(value)} to 'setValue' request body`);\n      } else if (!util.hasValue(text) && util.hasValue(value)) {\n        text = _.isArray(value)\n          ? value.join('')\n          : (_.isString(value) ? value : '');\n        log.debug(`Added 'text' property ${JSON.stringify(text)} to 'setValue' request body`);\n      }\n      return await this.proxyFunc(url, method, Object.assign({}, bodyObj, {\n        text,\n        value,\n      }));\n    }\n\n    return await this.proxyFunc(url, method, body);\n  }\n\n  async proxySetFrame (url, method, body) {\n    const bodyObj = util.safeJsonParse(body);\n    return _.has(bodyObj, 'id') && _.isPlainObject(bodyObj.id)\n      ? await this.proxyFunc(url, method, {\n        ...bodyObj,\n        id: duplicateKeys(bodyObj.id, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY),\n      })\n      : await this.proxyFunc(url, method, body);\n  }\n\n  async proxyPerformActions (url, method, body) {\n    const bodyObj = util.safeJsonParse(body);\n    return _.isPlainObject(bodyObj)\n      ? await this.proxyFunc(url, method, duplicateKeys(bodyObj, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY))\n      : await this.proxyFunc(url, method, body);\n  }\n\n  async proxyReleaseActions (url, method) {\n    return await this.proxyFunc(url, method);\n  }\n\n  /**\n   * Handle \"crossing\" endpoints for the case\n   * when upstream and downstream drivers operate different protocols\n   *\n   * @param {string} commandName\n   * @param {string} url\n   * @param {string} method\n   * @param {?string|object} body\n   * @returns The proxyfying result as [response, responseBody] tuple\n   */\n  async convertAndProxy (commandName, url, method, body) {\n    if (!this.downstreamProtocol) {\n      return await this.proxyFunc(url, method, body);\n    }\n\n    // Same url, but different arguments\n    switch (commandName) {\n      case 'timeouts':\n        return await this.proxySetTimeouts(url, method, body);\n      case 'setWindow':\n        return await this.proxySetWindow(url, method, body);\n      case 'setValue':\n        return await this.proxySetValue(url, method, body);\n      case 'performActions':\n        return await this.proxyPerformActions(url, method, body);\n      case 'releaseActions':\n        return await this.proxyReleaseActions(url, method, body);\n      case 'setFrame':\n        return await this.proxySetFrame(url, method, body);\n      default:\n        break;\n    }\n\n    // Same arguments, but different URLs\n    for (const {commandNames, jsonwpConverter, w3cConverter} of COMMAND_URLS_CONFLICTS) {\n      if (!commandNames.includes(commandName)) {\n        continue;\n      }\n\n      const rewrittenUrl = this.downstreamProtocol === MJSONWP\n        ? jsonwpConverter(url)\n        : w3cConverter(url);\n      if (rewrittenUrl === url) {\n        log.debug(`Did not know how to rewrite the original URL '${url}' ` +\n          `for ${this.downstreamProtocol} protocol`);\n        break;\n      }\n      log.info(`Rewrote the original URL '${url}' to '${rewrittenUrl}' ` +\n        `for ${this.downstreamProtocol} protocol`);\n      return await this.proxyFunc(rewrittenUrl, method, body);\n    }\n\n    // No matches found. Proceed normally\n    return await this.proxyFunc(url, method, body);\n  }\n}\n\nexport default ProtocolConverter;\n"],"file":"lib/jsonwp-proxy/protocol-converter.js","sourceRoot":"../../.."}
+exports.default = _default;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../lib/jsonwp-proxy/protocol-converter.js"],"names":["COMMAND_URLS_CONFLICTS","commandNames","jsonwpConverter","url","replace","includes","w3cConverter","test","w3cUrl","w3cPropertyRegex","jsonwpUrl","MJSONWP","W3C","PROTOCOLS","DEFAULT_LOG","logger","getLogger","ProtocolConverter","constructor","proxyFunc","log","_downstreamProtocol","_log","downstreamProtocol","value","getTimeoutRequestObjects","body","_","has","typeToW3C","x","type","ms","typeToJSONWP","toPairs","filter","pair","map","proxySetTimeouts","method","response","resBody","timeoutRequestObjects","debug","JSON","stringify","timeoutObj","statusCode","proxySetWindow","bodyObj","util","safeJsonParse","isPlainObject","name","handle","proxySetValue","hasValue","text","isString","isArray","join","Object","assign","proxySetFrame","id","MJSONWP_ELEMENT_KEY","W3C_ELEMENT_KEY","proxyPerformActions","proxyReleaseActions","convertAndProxy","commandName","rewrittenUrl","info"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport { logger, util } from '@appium/support';\nimport { duplicateKeys } from '../basedriver/helpers';\nimport {\n  MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, PROTOCOLS\n} from '../constants';\n\nexport const COMMAND_URLS_CONFLICTS = [\n  {\n    commandNames: ['execute', 'executeAsync'],\n    jsonwpConverter: (url) => url.replace(/\\/execute.*/,\n      url.includes('async') ? '/execute_async' : '/execute'),\n    w3cConverter: (url) => url.replace(/\\/execute.*/,\n      url.includes('async') ? '/execute/async' : '/execute/sync'),\n  },\n  {\n    commandNames: ['getElementScreenshot'],\n    jsonwpConverter: (url) => url.replace(/\\/element\\/([^/]+)\\/screenshot$/,\n      '/screenshot/$1'),\n    w3cConverter: (url) => url.replace(/\\/screenshot\\/([^/]+)/,\n      '/element/$1/screenshot'),\n  },\n  {\n    commandNames: ['getWindowHandles', 'getWindowHandle'],\n    jsonwpConverter (url) {\n      return /\\/window$/.test(url)\n        ? url.replace(/\\/window$/, '/window_handle')\n        : url.replace(/\\/window\\/handle(s?)$/, '/window_handle$1');\n    },\n    w3cConverter (url) {\n      return /\\/window_handle$/.test(url)\n        ? url.replace(/\\/window_handle$/, '/window')\n        : url.replace(/\\/window_handles$/, '/window/handles');\n    },\n  },\n  {\n    commandNames: ['getProperty'],\n    jsonwpConverter: (w3cUrl) => {\n      const w3cPropertyRegex = /\\/element\\/([^/]+)\\/property\\/([^/]+)/;\n      const jsonwpUrl = w3cUrl.replace(w3cPropertyRegex, '/element/$1/attribute/$2');\n      return jsonwpUrl;\n    },\n    w3cConverter: (jsonwpUrl) => jsonwpUrl // Don't convert JSONWP URL to W3C. W3C accepts /attribute and /property\n  }\n];\nconst {MJSONWP, W3C} = PROTOCOLS;\nconst DEFAULT_LOG = logger.getLogger('Protocol Converter');\n\n\nclass ProtocolConverter {\n  constructor (proxyFunc, log = null) {\n    this.proxyFunc = proxyFunc;\n    this._downstreamProtocol = null;\n    this._log = log;\n  }\n\n  get log () {\n    return this._log ?? DEFAULT_LOG;\n  }\n\n  set downstreamProtocol (value) {\n    this._downstreamProtocol = value;\n  }\n\n  get downstreamProtocol () {\n    return this._downstreamProtocol;\n  }\n\n  /**\n   * W3C /timeouts can take as many as 3 timeout types at once, MJSONWP /timeouts only takes one\n   * at a time. So if we're using W3C and proxying to MJSONWP and there's more than one timeout type\n   * provided in the request, we need to do 3 proxies and combine the result\n   *\n   * @param {Object} body Request body\n   * @return {Array} Array of W3C + MJSONWP compatible timeout objects\n   */\n  getTimeoutRequestObjects (body) {\n    if (this.downstreamProtocol === W3C && _.has(body, 'ms') && _.has(body, 'type')) {\n      const typeToW3C = (x) => x === 'page load' ? 'pageLoad' : x;\n      return [{\n        [typeToW3C(body.type)]: body.ms,\n      }];\n    }\n\n    if (this.downstreamProtocol === MJSONWP && (!_.has(body, 'ms') || !_.has(body, 'type'))) {\n      const typeToJSONWP = (x) => x === 'pageLoad' ? 'page load' : x;\n      return _.toPairs(body)\n        // Only transform the entry if ms value is a valid positive float number\n        .filter((pair) => /^\\d+(?:[.,]\\d*?)?$/.test(`${pair[1]}`))\n        .map(function (pair) {\n          return {\n            type: typeToJSONWP(pair[0]),\n            ms: pair[1],\n          };\n        });\n    }\n\n    return [body];\n  }\n\n  /**\n   * Proxy an array of timeout objects and merge the result\n   * @param {String} url Endpoint url\n   * @param {String} method Endpoint method\n   * @param {Object} body Request body\n   */\n  async proxySetTimeouts (url, method, body) {\n    let response, resBody;\n\n    const timeoutRequestObjects = this.getTimeoutRequestObjects(body);\n    this.log.debug(`Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`);\n    for (const timeoutObj of timeoutRequestObjects) {\n      [response, resBody] = await this.proxyFunc(url, method, timeoutObj);\n\n      // If we got a non-MJSONWP response, return the result, nothing left to do\n      if (this.downstreamProtocol !== MJSONWP) {\n        return [response, resBody];\n      }\n\n      // If we got an error, return the error right away\n      if (response.statusCode >= 400) {\n        return [response, resBody];\n      }\n\n      // ...Otherwise, continue to the next timeouts call\n    }\n    return [response, resBody];\n  }\n\n  async proxySetWindow (url, method, body) {\n    const bodyObj = util.safeJsonParse(body);\n    if (_.isPlainObject(bodyObj)) {\n      if (this.downstreamProtocol === W3C && _.has(bodyObj, 'name') && !_.has(bodyObj, 'handle')) {\n        this.log.debug(`Copied 'name' value '${bodyObj.name}' to 'handle' as per W3C spec`);\n        return await this.proxyFunc(url, method, {\n          ...bodyObj,\n          handle: bodyObj.name,\n        });\n      }\n      if (this.downstreamProtocol === MJSONWP && _.has(bodyObj, 'handle') && !_.has(bodyObj, 'name')) {\n        this.log.debug(`Copied 'handle' value '${bodyObj.handle}' to 'name' as per JSONWP spec`);\n        return await this.proxyFunc(url, method, {\n          ...bodyObj,\n          name: bodyObj.handle,\n        });\n      }\n    }\n\n    return await this.proxyFunc(url, method, body);\n  }\n\n  async proxySetValue (url, method, body) {\n    const bodyObj = util.safeJsonParse(body);\n    if (_.isPlainObject(bodyObj) && (util.hasValue(bodyObj.text) || util.hasValue(bodyObj.value))) {\n      let {text, value} = bodyObj;\n      if (util.hasValue(text) && !util.hasValue(value)) {\n        value = _.isString(text)\n          ? [...text]\n          : (_.isArray(text) ? text : []);\n        this.log.debug(`Added 'value' property ${JSON.stringify(value)} to 'setValue' request body`);\n      } else if (!util.hasValue(text) && util.hasValue(value)) {\n        text = _.isArray(value)\n          ? value.join('')\n          : (_.isString(value) ? value : '');\n        this.log.debug(`Added 'text' property ${JSON.stringify(text)} to 'setValue' request body`);\n      }\n      return await this.proxyFunc(url, method, Object.assign({}, bodyObj, {\n        text,\n        value,\n      }));\n    }\n\n    return await this.proxyFunc(url, method, body);\n  }\n\n  async proxySetFrame (url, method, body) {\n    const bodyObj = util.safeJsonParse(body);\n    return _.has(bodyObj, 'id') && _.isPlainObject(bodyObj.id)\n      ? await this.proxyFunc(url, method, {\n        ...bodyObj,\n        id: duplicateKeys(bodyObj.id, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY),\n      })\n      : await this.proxyFunc(url, method, body);\n  }\n\n  async proxyPerformActions (url, method, body) {\n    const bodyObj = util.safeJsonParse(body);\n    return _.isPlainObject(bodyObj)\n      ? await this.proxyFunc(url, method, duplicateKeys(bodyObj, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY))\n      : await this.proxyFunc(url, method, body);\n  }\n\n  async proxyReleaseActions (url, method) {\n    return await this.proxyFunc(url, method);\n  }\n\n  /**\n   * Handle \"crossing\" endpoints for the case\n   * when upstream and downstream drivers operate different protocols\n   *\n   * @param {string} commandName\n   * @param {string} url\n   * @param {string} method\n   * @param {?string|object} body\n   * @returns The proxyfying result as [response, responseBody] tuple\n   */\n  async convertAndProxy (commandName, url, method, body) {\n    if (!this.downstreamProtocol) {\n      return await this.proxyFunc(url, method, body);\n    }\n\n    // Same url, but different arguments\n    switch (commandName) {\n      case 'timeouts':\n        return await this.proxySetTimeouts(url, method, body);\n      case 'setWindow':\n        return await this.proxySetWindow(url, method, body);\n      case 'setValue':\n        return await this.proxySetValue(url, method, body);\n      case 'performActions':\n        return await this.proxyPerformActions(url, method, body);\n      case 'releaseActions':\n        return await this.proxyReleaseActions(url, method, body);\n      case 'setFrame':\n        return await this.proxySetFrame(url, method, body);\n      default:\n        break;\n    }\n\n    // Same arguments, but different URLs\n    for (const {commandNames, jsonwpConverter, w3cConverter} of COMMAND_URLS_CONFLICTS) {\n      if (!commandNames.includes(commandName)) {\n        continue;\n      }\n\n      const rewrittenUrl = this.downstreamProtocol === MJSONWP\n        ? jsonwpConverter(url)\n        : w3cConverter(url);\n      if (rewrittenUrl === url) {\n        this.log.debug(`Did not know how to rewrite the original URL '${url}' ` +\n          `for ${this.downstreamProtocol} protocol`);\n        break;\n      }\n      this.log.info(`Rewrote the original URL '${url}' to '${rewrittenUrl}' ` +\n        `for ${this.downstreamProtocol} protocol`);\n      return await this.proxyFunc(rewrittenUrl, method, body);\n    }\n\n    // No matches found. Proceed normally\n    return await this.proxyFunc(url, method, body);\n  }\n}\n\nexport default ProtocolConverter;\n"]}

package/build/lib/jsonwp-proxy/proxy.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+export default JWProxy;
+export class JWProxy {
+    constructor(opts?: {});
+    scheme: any;
+    _activeRequests: any[];
+    _downstreamProtocol: any;
+    httpAgent: http.Agent;
+    httpsAgent: https.Agent;
+    protocolConverter: ProtocolConverter;
+    _log: any;
+    get log(): any;
+    /**
+     * Performs requests to the downstream server
+     *
+     * @private - Do not call this method directly,
+     * it uses client-specific arguments and responses!
+     *
+     * @param {AxiosRequestConfig} requestConfig
+     * @returns {AxiosResponse}
+     */
+    private request;
+    getActiveRequestsCount(): number;
+    cancelActiveRequests(): void;
+    endpointRequiresSessionId(endpoint: any): boolean;
+    set downstreamProtocol(arg: any);
+    get downstreamProtocol(): any;
+    getUrlForProxy(url: any): string;
+    proxy(url: any, method: any, body?: null): Promise<any[]>;
+    sessionId: any;
+    getProtocolFromResBody(resObj: any): string | undefined;
+    requestToCommandName(url: any, method: any): keyof import("@appium/types").ExternalDriver | undefined;
+    proxyCommand(url: any, method: any, body?: null): Promise<any>;
+    command(url: any, method: any, body?: null): Promise<any>;
+    getSessionIdFromUrl(url: any): any;
+    proxyReqRes(req: any, res: any): Promise<void>;
+}
+import http from "http";
+import https from "https";
+import ProtocolConverter from "./protocol-converter";
+//# sourceMappingURL=proxy.d.ts.map

package/build/lib/jsonwp-proxy/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../../lib/jsonwp-proxy/proxy.js"],"names":[],"mappings":";;AAuBA;IACE,uBAsBC;IAZC,YAAuC;IACvC,uBAAyB;IACzB,yBAA+B;IAM/B,sBAA0C;IAC1C,wBAA4C;IAC5C,qCAA+E;IAC/E,UAAoB;IAGtB,eAEC;IAED;;;;;;;;OAQG;IACH,gBAQC;IAED,iCAEC;IAED,6BAEC;IAED,kDAEC;IAED,iCAGC;IAED,8BAEC;IAED,iCA8CC;IAED,0DA2FC;IAjCO,eAA+D;IAmCvE,wDAOC;IAED,sGAaC;IAED,+DAQC;IAED,0DAuCC;IAED,mCAGC;IAED,+CAoBC;CACF"}