@appium/base-driver 8.5.2 → 8.5.5

package/lib/protocol/errors.js

@@ -1,7 +1,7 @@
 import ES6Error from 'es6-error';
 import _ from 'lodash';
-import { util, logger } from '@appium/support';
-import { StatusCodes as HTTPStatusCodes } from 'http-status-codes';
+import {util, logger} from '@appium/support';
+import {StatusCodes as HTTPStatusCodes} from 'http-status-codes';
 
 const mjsonwpLog = logger.getLogger('MJSONWP');
 const w3cLog = logger.getLogger('W3C');
@@ -10,7 +10,7 @@ const W3C_UNKNOWN_ERROR = 'unknown error';
 
 // base error class for all of our errors
 export class ProtocolError extends ES6Error {
-  constructor (msg, jsonwpCode, w3cStatus, error) {
+  constructor(msg, jsonwpCode, w3cStatus, error) {
     super(msg);
     this.jsonwpCode = jsonwpCode;
     this.error = error || W3C_UNKNOWN_ERROR;
@@ -21,11 +21,11 @@ export class ProtocolError extends ES6Error {
     this._stacktrace = null;
   }
 
-  get stacktrace () {
+  get stacktrace() {
     return this._stacktrace || this.stack;
   }
 
-  set stacktrace (value) {
+  set stacktrace(value) {
     this._stacktrace = value;
   }
 }
@@ -35,587 +35,719 @@ export class ProtocolError extends ES6Error {
 // https://w3c.github.io/webdriver/webdriver-spec.html#dfn-error-code
 
 export class NoSuchDriverError extends ProtocolError {
-  static code () {
+  static code() {
     return 6;
   }
   // W3C Error is called InvalidSessionID
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
-  static error () {
+  static error() {
     return 'invalid session id';
   }
-  constructor (err) {
-    super(err || 'A session is either terminated or not started', NoSuchDriverError.code(),
-          NoSuchDriverError.w3cStatus(), NoSuchDriverError.error());
+  constructor(err) {
+    super(
+      err || 'A session is either terminated or not started',
+      NoSuchDriverError.code(),
+      NoSuchDriverError.w3cStatus(),
+      NoSuchDriverError.error()
+    );
   }
 }
 
 export class NoSuchElementError extends ProtocolError {
-  static code () {
+  static code() {
     return 7;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
-  static error () {
+  static error() {
     return 'no such element';
   }
-  constructor (err) {
-    super(err || 'An element could not be located on the page using the given ' +
-          'search parameters.', NoSuchElementError.code(), NoSuchElementError.w3cStatus(),
-          NoSuchElementError.error());
+  constructor(err) {
+    super(
+      err || 'An element could not be located on the page using the given ' + 'search parameters.',
+      NoSuchElementError.code(),
+      NoSuchElementError.w3cStatus(),
+      NoSuchElementError.error()
+    );
   }
 }
 
 export class NoSuchFrameError extends ProtocolError {
-  static code () {
+  static code() {
     return 8;
   }
-  static error () {
+  static error() {
     return 'no such frame';
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
-  constructor (err) {
-    super(err || 'A request to switch to a frame could not be satisfied because ' +
-          'the frame could not be found.', NoSuchFrameError.code(),
-          NoSuchFrameError.w3cStatus(), NoSuchFrameError.error());
+  constructor(err) {
+    super(
+      err ||
+        'A request to switch to a frame could not be satisfied because ' +
+          'the frame could not be found.',
+      NoSuchFrameError.code(),
+      NoSuchFrameError.w3cStatus(),
+      NoSuchFrameError.error()
+    );
   }
 }
 
 export class UnknownCommandError extends ProtocolError {
-  static code () {
+  static code() {
     return 9;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
-  static error () {
+  static error() {
     return 'unknown command';
   }
-  constructor (err) {
-    super(err || 'The requested resource could not be found, or a request was ' +
+  constructor(err) {
+    super(
+      err ||
+        'The requested resource could not be found, or a request was ' +
           'received using an HTTP method that is not supported by the mapped ' +
-          'resource.', UnknownCommandError.code(), UnknownCommandError.w3cStatus(), UnknownCommandError.error());
+          'resource.',
+      UnknownCommandError.code(),
+      UnknownCommandError.w3cStatus(),
+      UnknownCommandError.error()
+    );
   }
 }
 
 export class StaleElementReferenceError extends ProtocolError {
-  static code () {
+  static code() {
     return 10;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
-  static error () {
+  static error() {
     return 'stale element reference';
   }
-  constructor (err) {
-    super(err || 'An element command failed because the referenced element is no ' +
-          'longer attached to the DOM.', StaleElementReferenceError.code(),
-          StaleElementReferenceError.w3cStatus(), StaleElementReferenceError.error());
+  constructor(err) {
+    super(
+      err ||
+        'An element command failed because the referenced element is no ' +
+          'longer attached to the DOM.',
+      StaleElementReferenceError.code(),
+      StaleElementReferenceError.w3cStatus(),
+      StaleElementReferenceError.error()
+    );
   }
 }
 
 export class ElementNotVisibleError extends ProtocolError {
-  static code () {
+  static code() {
     return 11;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
-  static error () {
+  static error() {
     return 'element not visible';
   }
-  constructor (err) {
-    super(err || 'An element command could not be completed because the element is ' +
-          'not visible on the page.', ElementNotVisibleError.code(),
-          ElementNotVisibleError.w3cStatus(), ElementNotVisibleError.error());
+  constructor(err) {
+    super(
+      err ||
+        'An element command could not be completed because the element is ' +
+          'not visible on the page.',
+      ElementNotVisibleError.code(),
+      ElementNotVisibleError.w3cStatus(),
+      ElementNotVisibleError.error()
+    );
   }
 }
 
 export class InvalidElementStateError extends ProtocolError {
-  static code () {
+  static code() {
     return 12;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
-  static error () {
+  static error() {
     return 'invalid element state';
   }
-  constructor (err) {
-    super(err || 'An element command could not be completed because the element is ' +
+  constructor(err) {
+    super(
+      err ||
+        'An element command could not be completed because the element is ' +
           'in an invalid state (e.g. attempting to click a disabled element).',
-          InvalidElementStateError.code(), InvalidElementStateError.w3cStatus(),
-          InvalidElementStateError.error());
+      InvalidElementStateError.code(),
+      InvalidElementStateError.w3cStatus(),
+      InvalidElementStateError.error()
+    );
   }
 }
 
 export class UnknownError extends ProtocolError {
-  static code () {
+  static code() {
     return 13;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  static error () {
+  static error() {
     return W3C_UNKNOWN_ERROR;
   }
-  constructor (errorOrMessage) {
+  constructor(errorOrMessage) {
     const origMessage = _.isString((errorOrMessage || {}).message)
       ? errorOrMessage.message
       : errorOrMessage;
-    const message = 'An unknown server-side error occurred while processing the command.' +
+    const message =
+      'An unknown server-side error occurred while processing the command.' +
       (origMessage ? ` Original error: ${origMessage}` : '');
     super(message, UnknownError.code(), UnknownError.w3cStatus(), UnknownError.error());
   }
 }
 
 export class UnknownMethodError extends ProtocolError {
-  static code () {
+  static code() {
     return 405;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.METHOD_NOT_ALLOWED;
   }
-  static error () {
+  static error() {
     return 'unknown method';
   }
-  constructor (err) {
-    super(err || 'The requested command matched a known URL but did not match an method for that URL',
-          UnknownMethodError.code(), UnknownMethodError.w3cStatus(), UnknownMethodError.error());
+  constructor(err) {
+    super(
+      err || 'The requested command matched a known URL but did not match an method for that URL',
+      UnknownMethodError.code(),
+      UnknownMethodError.w3cStatus(),
+      UnknownMethodError.error()
+    );
   }
 }
 
 export class UnsupportedOperationError extends ProtocolError {
-  static code () {
+  static code() {
     return 405;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  static error () {
+  static error() {
     return 'unsupported operation';
   }
-  constructor (err) {
-    super(err || 'A server-side error occurred. Command cannot be supported.',
-          UnsupportedOperationError.code(), UnsupportedOperationError.w3cStatus(),
-          UnsupportedOperationError.error());
+  constructor(err) {
+    super(
+      err || 'A server-side error occurred. Command cannot be supported.',
+      UnsupportedOperationError.code(),
+      UnsupportedOperationError.w3cStatus(),
+      UnsupportedOperationError.error()
+    );
   }
 }
 
 export class ElementIsNotSelectableError extends ProtocolError {
-  static code () {
+  static code() {
     return 15;
   }
-  static error () {
+  static error() {
     return 'element not selectable';
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
-  constructor (err) {
-    super(err || 'An attempt was made to select an element that cannot be selected.',
-          ElementIsNotSelectableError.code(), ElementIsNotSelectableError.w3cStatus(),
-          ElementIsNotSelectableError.error());
+  constructor(err) {
+    super(
+      err || 'An attempt was made to select an element that cannot be selected.',
+      ElementIsNotSelectableError.code(),
+      ElementIsNotSelectableError.w3cStatus(),
+      ElementIsNotSelectableError.error()
+    );
   }
 }
 
 export class ElementClickInterceptedError extends ProtocolError {
-  static code () {
+  static code() {
     return 64;
   }
-  static error () {
+  static error() {
     return 'element click intercepted';
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
-  constructor (err) {
-    super(err || 'The Element Click command could not be completed because the element receiving ' +
+  constructor(err) {
+    super(
+      err ||
+        'The Element Click command could not be completed because the element receiving ' +
           'the events is obscuring the element that was requested clicked',
-          ElementClickInterceptedError.code(), ElementClickInterceptedError.w3cStatus(),
-          ElementClickInterceptedError.error());
+      ElementClickInterceptedError.code(),
+      ElementClickInterceptedError.w3cStatus(),
+      ElementClickInterceptedError.error()
+    );
   }
 }
 
 export class ElementNotInteractableError extends ProtocolError {
-  static code () {
+  static code() {
     return 60;
   }
-  static error () {
+  static error() {
     return 'element not interactable';
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
-  constructor (err) {
-    super(err || 'A command could not be completed because the element is not pointer- or keyboard interactable',
-          ElementNotInteractableError.code(), ElementNotInteractableError.w3cStatus(),
-          ElementNotInteractableError.error());
+  constructor(err) {
+    super(
+      err ||
+        'A command could not be completed because the element is not pointer- or keyboard interactable',
+      ElementNotInteractableError.code(),
+      ElementNotInteractableError.w3cStatus(),
+      ElementNotInteractableError.error()
+    );
   }
 }
 
 export class InsecureCertificateError extends ProtocolError {
-  static error () {
+  static error() {
     return 'insecure certificate';
   }
-  constructor (err) {
-    super(err || 'Navigation caused the user agent to hit a certificate warning, which is usually the result of an expired or invalid TLS certificate',
-      ElementIsNotSelectableError.code(), null, InsecureCertificateError.error());
+  constructor(err) {
+    super(
+      err ||
+        'Navigation caused the user agent to hit a certificate warning, which is usually the result of an expired or invalid TLS certificate',
+      ElementIsNotSelectableError.code(),
+      null,
+      InsecureCertificateError.error()
+    );
   }
 }
 
 export class JavaScriptError extends ProtocolError {
-  static code () {
+  static code() {
     return 17;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  static error () {
+  static error() {
     return 'javascript error';
   }
-  constructor (err) {
-    super(err || 'An error occurred while executing user supplied JavaScript.',
-          JavaScriptError.code(), JavaScriptError.w3cStatus(), JavaScriptError.error());
+  constructor(err) {
+    super(
+      err || 'An error occurred while executing user supplied JavaScript.',
+      JavaScriptError.code(),
+      JavaScriptError.w3cStatus(),
+      JavaScriptError.error()
+    );
   }
 }
 
 export class XPathLookupError extends ProtocolError {
-  static code () {
+  static code() {
     return 19;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
-  static error () {
+  static error() {
     return 'invalid selector';
   }
-  constructor (err) {
-    super(err || 'An error occurred while searching for an element by XPath.',
-          XPathLookupError.code(), XPathLookupError.w3cStatus(), XPathLookupError.error());
+  constructor(err) {
+    super(
+      err || 'An error occurred while searching for an element by XPath.',
+      XPathLookupError.code(),
+      XPathLookupError.w3cStatus(),
+      XPathLookupError.error()
+    );
   }
 }
 
 export class TimeoutError extends ProtocolError {
-  static code () {
+  static code() {
     return 21;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.REQUEST_TIMEOUT;
   }
-  static error () {
+  static error() {
     return 'timeout';
   }
-  constructor (err) {
-    super(err || 'An operation did not complete before its timeout expired.',
-          TimeoutError.code(), TimeoutError.w3cStatus(), TimeoutError.error());
+  constructor(err) {
+    super(
+      err || 'An operation did not complete before its timeout expired.',
+      TimeoutError.code(),
+      TimeoutError.w3cStatus(),
+      TimeoutError.error()
+    );
   }
 }
 
 export class NoSuchWindowError extends ProtocolError {
-  static code () {
+  static code() {
     return 23;
   }
-  static error () {
+  static error() {
     return 'no such window';
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
-  constructor (err) {
-    super(err || 'A request to switch to a different window could not be satisfied ' +
-          'because the window could not be found.', NoSuchWindowError.code(),
-          NoSuchWindowError.w3cStatus(), NoSuchWindowError.error());
+  constructor(err) {
+    super(
+      err ||
+        'A request to switch to a different window could not be satisfied ' +
+          'because the window could not be found.',
+      NoSuchWindowError.code(),
+      NoSuchWindowError.w3cStatus(),
+      NoSuchWindowError.error()
+    );
   }
 }
 
 export class InvalidArgumentError extends ProtocolError {
-  static code () {
+  static code() {
     return 61;
   }
-  static error () {
+  static error() {
     return 'invalid argument';
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
-  constructor (err) {
-    super(err || 'The arguments passed to the command are either invalid or malformed',
-          InvalidArgumentError.code(), InvalidArgumentError.w3cStatus(),
-          InvalidArgumentError.error());
+  constructor(err) {
+    super(
+      err || 'The arguments passed to the command are either invalid or malformed',
+      InvalidArgumentError.code(),
+      InvalidArgumentError.w3cStatus(),
+      InvalidArgumentError.error()
+    );
   }
 }
 
 export class InvalidCookieDomainError extends ProtocolError {
-  static code () {
+  static code() {
     return 24;
   }
-  static error () {
+  static error() {
     return 'invalid cookie domain';
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
-  constructor (err) {
-    super(err || 'An illegal attempt was made to set a cookie under a different ' +
-          'domain than the current page.', InvalidCookieDomainError.code(),
-          InvalidCookieDomainError.w3cStatus(), InvalidCookieDomainError.error());
+  constructor(err) {
+    super(
+      err ||
+        'An illegal attempt was made to set a cookie under a different ' +
+          'domain than the current page.',
+      InvalidCookieDomainError.code(),
+      InvalidCookieDomainError.w3cStatus(),
+      InvalidCookieDomainError.error()
+    );
   }
 }
 
 export class NoSuchCookieError extends ProtocolError {
-  static code () {
+  static code() {
     return 62;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
-  static error () {
+  static error() {
     return 'no such cookie';
   }
-  constructor (err) {
-    super(err || 'No cookie matching the given path name was found amongst the associated cookies of the current browsing context’s active document',
-          NoSuchCookieError.code(), NoSuchCookieError.w3cStatus(), NoSuchCookieError.error());
+  constructor(err) {
+    super(
+      err ||
+        'No cookie matching the given path name was found amongst the associated cookies of the current browsing context’s active document',
+      NoSuchCookieError.code(),
+      NoSuchCookieError.w3cStatus(),
+      NoSuchCookieError.error()
+    );
   }
 }
 
 export class UnableToSetCookieError extends ProtocolError {
-  static code () {
+  static code() {
     return 25;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  static error () {
+  static error() {
     return 'unable to set cookie';
   }
-  constructor (err) {
-    super(err || 'A request to set a cookie\'s value could not be satisfied.',
-          UnableToSetCookieError.code(), UnableToSetCookieError.w3cStatus(), UnableToSetCookieError.error());
+  constructor(err) {
+    super(
+      err || "A request to set a cookie's value could not be satisfied.",
+      UnableToSetCookieError.code(),
+      UnableToSetCookieError.w3cStatus(),
+      UnableToSetCookieError.error()
+    );
   }
 }
 
 export class UnexpectedAlertOpenError extends ProtocolError {
-  static code () {
+  static code() {
     return 26;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  static error () {
+  static error() {
     return 'unexpected alert open';
   }
-  constructor (err) {
-    super(err || 'A modal dialog was open, blocking this operation',
-          UnexpectedAlertOpenError.code(), UnexpectedAlertOpenError.w3cStatus(), UnexpectedAlertOpenError.error());
+  constructor(err) {
+    super(
+      err || 'A modal dialog was open, blocking this operation',
+      UnexpectedAlertOpenError.code(),
+      UnexpectedAlertOpenError.w3cStatus(),
+      UnexpectedAlertOpenError.error()
+    );
   }
 }
 
 export class NoAlertOpenError extends ProtocolError {
-  static code () {
+  static code() {
     return 27;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.NOT_FOUND;
   }
-  static error () {
+  static error() {
     return 'no such alert';
   }
-  constructor (err) {
-    super(err || 'An attempt was made to operate on a modal dialog when one ' +
-          'was not open.', NoAlertOpenError.code(), NoAlertOpenError.w3cStatus(), NoAlertOpenError.error());
+  constructor(err) {
+    super(
+      err || 'An attempt was made to operate on a modal dialog when one ' + 'was not open.',
+      NoAlertOpenError.code(),
+      NoAlertOpenError.w3cStatus(),
+      NoAlertOpenError.error()
+    );
   }
 }
 
 export class NoSuchAlertError extends NoAlertOpenError {}
 
 export class ScriptTimeoutError extends ProtocolError {
-  static code () {
+  static code() {
     return 28;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.REQUEST_TIMEOUT;
   }
-  static error () {
+  static error() {
     return 'script timeout';
   }
-  constructor (err) {
-    super(err || 'A script did not complete before its timeout expired.',
-          ScriptTimeoutError.code(), ScriptTimeoutError.w3cStatus(), ScriptTimeoutError.error());
+  constructor(err) {
+    super(
+      err || 'A script did not complete before its timeout expired.',
+      ScriptTimeoutError.code(),
+      ScriptTimeoutError.w3cStatus(),
+      ScriptTimeoutError.error()
+    );
   }
 }
 
 export class InvalidElementCoordinatesError extends ProtocolError {
-  static code () {
+  static code() {
     return 29;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
-  static error () {
+  static error() {
     return 'invalid coordinates';
   }
-  constructor (err) {
-    super(err || 'The coordinates provided to an interactions operation are invalid.',
-          InvalidElementCoordinatesError.code(), InvalidElementCoordinatesError.w3cStatus(),
-          InvalidElementCoordinatesError.error());
+  constructor(err) {
+    super(
+      err || 'The coordinates provided to an interactions operation are invalid.',
+      InvalidElementCoordinatesError.code(),
+      InvalidElementCoordinatesError.w3cStatus(),
+      InvalidElementCoordinatesError.error()
+    );
   }
 }
 
 export class InvalidCoordinatesError extends InvalidElementCoordinatesError {}
 
 export class IMENotAvailableError extends ProtocolError {
-  static code () {
+  static code() {
     return 30;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  static error () {
+  static error() {
     return 'unsupported operation';
   }
-  constructor (err) {
-    super(err || 'IME was not available.', IMENotAvailableError.code(),
-          IMENotAvailableError.w3cStatus(), IMENotAvailableError.error());
+  constructor(err) {
+    super(
+      err || 'IME was not available.',
+      IMENotAvailableError.code(),
+      IMENotAvailableError.w3cStatus(),
+      IMENotAvailableError.error()
+    );
   }
 }
 
 export class IMEEngineActivationFailedError extends ProtocolError {
-  static code () {
+  static code() {
     return 31;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  static error () {
+  static error() {
     return 'unsupported operation';
   }
-  constructor (err) {
-    super(err || 'An IME engine could not be started.',
-          IMEEngineActivationFailedError.code(), IMEEngineActivationFailedError.w3cStatus(),
-          IMEEngineActivationFailedError.error());
+  constructor(err) {
+    super(
+      err || 'An IME engine could not be started.',
+      IMEEngineActivationFailedError.code(),
+      IMEEngineActivationFailedError.w3cStatus(),
+      IMEEngineActivationFailedError.error()
+    );
   }
 }
 
 export class InvalidSelectorError extends ProtocolError {
-  static code () {
+  static code() {
     return 32;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.BAD_REQUEST;
   }
-  static error () {
+  static error() {
     return 'invalid selector';
   }
-  constructor (err) {
-    super(err || 'Argument was an invalid selector (e.g. XPath/CSS).',
-          InvalidSelectorError.code(), InvalidSelectorError.w3cStatus(),
-          InvalidSelectorError.error());
+  constructor(err) {
+    super(
+      err || 'Argument was an invalid selector (e.g. XPath/CSS).',
+      InvalidSelectorError.code(),
+      InvalidSelectorError.w3cStatus(),
+      InvalidSelectorError.error()
+    );
   }
 }
 
 export class SessionNotCreatedError extends ProtocolError {
-  static code () {
+  static code() {
     return 33;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  static error () {
+  static error() {
     return 'session not created';
   }
-  constructor (details) {
+  constructor(details) {
     let message = 'A new session could not be created.';
     if (details) {
       message += ` Details: ${details}`;
     }
 
-    super(message, SessionNotCreatedError.code(), SessionNotCreatedError.w3cStatus(), SessionNotCreatedError.error());
+    super(
+      message,
+      SessionNotCreatedError.code(),
+      SessionNotCreatedError.w3cStatus(),
+      SessionNotCreatedError.error()
+    );
   }
 }
 
 export class MoveTargetOutOfBoundsError extends ProtocolError {
-  static code () {
+  static code() {
     return 34;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  static error () {
+  static error() {
     return 'move target out of bounds';
   }
-  constructor (err) {
-    super(err || 'Target provided for a move action is out of bounds.',
-          MoveTargetOutOfBoundsError.code(), MoveTargetOutOfBoundsError.w3cStatus(), MoveTargetOutOfBoundsError.error());
+  constructor(err) {
+    super(
+      err || 'Target provided for a move action is out of bounds.',
+      MoveTargetOutOfBoundsError.code(),
+      MoveTargetOutOfBoundsError.w3cStatus(),
+      MoveTargetOutOfBoundsError.error()
+    );
   }
 }
 
 export class NoSuchContextError extends ProtocolError {
-  static code () {
+  static code() {
     return 35;
   }
-  constructor (err) {
+  constructor(err) {
     super(err || 'No such context found.', NoSuchContextError.code());
   }
 }
 
 export class InvalidContextError extends ProtocolError {
-  static code () {
+  static code() {
     return 36;
   }
-  constructor (err) {
-    super(err || 'That command could not be executed in the current context.',
-          InvalidContextError.code());
+  constructor(err) {
+    super(
+      err || 'That command could not be executed in the current context.',
+      InvalidContextError.code()
+    );
   }
 }
 
 // These are aliases for UnknownMethodError
 export class NotYetImplementedError extends UnknownMethodError {
-  constructor (err) {
+  constructor(err) {
     super(err || 'Method has not yet been implemented');
   }
 }
 export class NotImplementedError extends UnknownMethodError {
-  constructor (err) {
+  constructor(err) {
     super(err || 'Method is not implemented');
   }
 }
 
 export class UnableToCaptureScreen extends ProtocolError {
-  static code () {
+  static code() {
     return 63;
   }
-  static w3cStatus () {
+  static w3cStatus() {
     return HTTPStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  static error () {
+  static error() {
     return 'unable to capture screen';
   }
-  constructor (err) {
-    super(err || 'A screen capture was made impossible',
-          UnableToCaptureScreen.code(), UnableToCaptureScreen.w3cStatus(), UnableToCaptureScreen.error());
+  constructor(err) {
+    super(
+      err || 'A screen capture was made impossible',
+      UnableToCaptureScreen.code(),
+      UnableToCaptureScreen.w3cStatus(),
+      UnableToCaptureScreen.error()
+    );
   }
 }
 
-
 // Equivalent to W3C InvalidArgumentError
 export class BadParametersError extends ES6Error {
-  static error () {
+  static error() {
     return 'invalid argument';
   }
-  constructor (requiredParams, actualParams, errMessage) {
+  constructor(requiredParams, actualParams, errMessage) {
     let message;
     if (!errMessage) {
-      message = `Parameters were incorrect. We wanted ` +
-          `${JSON.stringify(requiredParams)} and you ` +
-          `sent ${JSON.stringify(actualParams)}`;
+      message =
+        `Parameters were incorrect. We wanted ` +
+        `${JSON.stringify(requiredParams)} and you ` +
+        `sent ${JSON.stringify(actualParams)}`;
     } else {
-      message = `Parameters were incorrect. You sent ${JSON.stringify(actualParams)}, ${errMessage}`;
+      message = `Parameters were incorrect. You sent ${JSON.stringify(
+        actualParams
+      )}, ${errMessage}`;
     }
     super(message);
     this.w3cStatus = HTTPStatusCodes.BAD_REQUEST;
@@ -629,7 +761,7 @@ export class BadParametersError extends ES6Error {
  * for proxy failure to generate the client response.
  */
 export class ProxyRequestError extends ES6Error {
-  constructor (err, responseError, httpStatus) {
+  constructor(err, responseError, httpStatus) {
     let responseErrorObj = util.safeJsonParse(responseError);
     if (!_.isPlainObject(responseErrorObj)) {
       responseErrorObj = {};
@@ -638,7 +770,10 @@ export class ProxyRequestError extends ES6Error {
     if (!_.isEmpty(responseErrorObj)) {
       if (_.isString(responseErrorObj.value)) {
         origMessage = responseErrorObj.value;
-      } else if (_.isPlainObject(responseErrorObj.value) && _.isString(responseErrorObj.value.message)) {
+      } else if (
+        _.isPlainObject(responseErrorObj.value) &&
+        _.isString(responseErrorObj.value.message)
+      ) {
         origMessage = responseErrorObj.value.message;
       }
     }
@@ -655,81 +790,89 @@ export class ProxyRequestError extends ES6Error {
     }
   }
 
-  getActualError () {
+  getActualError() {
     // If it's MJSONWP error, returns actual error cause for request failure based on `jsonwp.status`
     if (util.hasValue(this.jsonwp?.status) && util.hasValue(this.jsonwp?.value)) {
       return errorFromMJSONWPStatusCode(this.jsonwp.status, this.jsonwp.value);
     } else if (util.hasValue(this.w3c) && _.isNumber(this.w3cStatus) && this.w3cStatus >= 300) {
-      return errorFromW3CJsonCode(this.w3c.error, this.w3c.message || this.message, this.w3c.stacktrace);
+      return errorFromW3CJsonCode(
+        this.w3c.error,
+        this.w3c.message || this.message,
+        this.w3c.stacktrace
+      );
     }
     return new UnknownError(this.message);
   }
 }
 // map of error class name to error class
-const errors = {NotYetImplementedError,
-                NotImplementedError,
-                BadParametersError,
-                InvalidArgumentError,
-                NoSuchDriverError,
-                NoSuchElementError,
-                UnknownCommandError,
-                StaleElementReferenceError,
-                ElementNotVisibleError,
-                InvalidElementStateError,
-                UnknownError,
-                ElementIsNotSelectableError,
-                ElementClickInterceptedError,
-                ElementNotInteractableError,
-                InsecureCertificateError,
-                JavaScriptError,
-                XPathLookupError,
-                TimeoutError,
-                NoSuchWindowError,
-                NoSuchCookieError,
-                InvalidCookieDomainError,
-                InvalidCoordinatesError,
-                UnableToSetCookieError,
-                UnexpectedAlertOpenError,
-                NoAlertOpenError,
-                ScriptTimeoutError,
-                InvalidElementCoordinatesError,
-                IMENotAvailableError,
-                IMEEngineActivationFailedError,
-                InvalidSelectorError,
-                SessionNotCreatedError,
-                MoveTargetOutOfBoundsError,
-                NoSuchAlertError,
-                NoSuchContextError,
-                InvalidContextError,
-                NoSuchFrameError,
-                UnableToCaptureScreen,
-                UnknownMethodError,
-                UnsupportedOperationError,
-                ProxyRequestError};
+const errors = {
+  NotYetImplementedError,
+  NotImplementedError,
+  BadParametersError,
+  InvalidArgumentError,
+  NoSuchDriverError,
+  NoSuchElementError,
+  UnknownCommandError,
+  StaleElementReferenceError,
+  ElementNotVisibleError,
+  InvalidElementStateError,
+  UnknownError,
+  ElementIsNotSelectableError,
+  ElementClickInterceptedError,
+  ElementNotInteractableError,
+  InsecureCertificateError,
+  JavaScriptError,
+  XPathLookupError,
+  TimeoutError,
+  NoSuchWindowError,
+  NoSuchCookieError,
+  InvalidCookieDomainError,
+  InvalidCoordinatesError,
+  UnableToSetCookieError,
+  UnexpectedAlertOpenError,
+  NoAlertOpenError,
+  ScriptTimeoutError,
+  InvalidElementCoordinatesError,
+  IMENotAvailableError,
+  IMEEngineActivationFailedError,
+  InvalidSelectorError,
+  SessionNotCreatedError,
+  MoveTargetOutOfBoundsError,
+  NoSuchAlertError,
+  NoSuchContextError,
+  InvalidContextError,
+  NoSuchFrameError,
+  UnableToCaptureScreen,
+  UnknownMethodError,
+  UnsupportedOperationError,
+  ProxyRequestError,
+};
 
 // map of error code to error class
 const jsonwpErrorCodeMap = {};
 for (let ErrorClass of _.values(errors)) {
-  if (ErrorClass.code) {
+  if ('code' in ErrorClass) {
     jsonwpErrorCodeMap[ErrorClass.code()] = ErrorClass;
   }
 }
 
 const w3cErrorCodeMap = {};
 for (let ErrorClass of _.values(errors)) {
-  if (ErrorClass.error) {
+  if ('error' in ErrorClass) {
     w3cErrorCodeMap[ErrorClass.error()] = ErrorClass;
   }
 }
 
-function isUnknownError (err) {
-  return !err.constructor.name ||
-         !_.values(errors).find(function equalNames (error) {
-           return error.name === err.constructor.name;
-         });
+function isUnknownError(err) {
+  return (
+    !err.constructor.name ||
+    !_.values(errors).find(function equalNames(error) {
+      return error.name === err.constructor.name;
+    })
+  );
 }
 
-function isErrorType (err, type) {
+function isErrorType(err, type) {
   // `name` property is the constructor name
   if (type.name === ProtocolError.name) {
     // `jsonwpCode` is `0` on success
@@ -755,7 +898,7 @@ function isErrorType (err, type) {
  * @param {string|Object} value The error message, or an object with a `message` property
  * @return {ProtocolError} The error that is associated with provided JSONWP status code
  */
-function errorFromMJSONWPStatusCode (code, value = '') {
+function errorFromMJSONWPStatusCode(code, value = '') {
   // if `value` is an object, pull message from it, otherwise use the plain
   // value, or default to an empty string, if null
   const message = (value || {}).message || value || '';
@@ -774,7 +917,7 @@ function errorFromMJSONWPStatusCode (code, value = '') {
  * @param {?string} stacktrace an optional error stacktrace
  * @return {ProtocolError}  The error that is associated with the W3C error string
  */
-function errorFromW3CJsonCode (code, message, stacktrace = null) {
+function errorFromW3CJsonCode(code, message, stacktrace = null) {
   if (code && w3cErrorCodeMap[code.toLowerCase()]) {
     w3cLog.debug(`Matched W3C error code '${code}' to ${w3cErrorCodeMap[code.toLowerCase()].name}`);
     const resultError = new w3cErrorCodeMap[code.toLowerCase()](message);
@@ -787,20 +930,29 @@ function errorFromW3CJsonCode (code, message, stacktrace = null) {
   return resultError;
 }
 
+/**
+ *
+ * @param {any} err
+ * @returns {err is ProtocolError}
+ */
+function isProtocolError(err) {
+  return 'w3cStatus' in err;
+}
+
 /**
  * Convert an Appium error to proper W3C HTTP response
- * @param {ProtocolError} err The error that needs to be translated
+ * @param {ProtocolError|MJSONWPError} err The error that needs to be translated
  */
-function getResponseForW3CError (err) {
+function getResponseForW3CError(err) {
   let httpStatus;
 
   // W3C defined error message (https://www.w3.org/TR/webdriver/#dfn-error-code)
   let w3cErrorString;
 
-  if (!err.w3cStatus) {
+  if (!isProtocolError(err)) {
     err = util.hasValue(err.status)
-      // If it's a JSONWP error, find corresponding error
-      ? errorFromMJSONWPStatusCode(err.status, err.value)
+      ? // If it's a JSONWP error, find corresponding error
+        errorFromMJSONWPStatusCode(err.status, err.value)
       : new errors.UnknownError(err.message);
   }
 
@@ -823,7 +975,7 @@ function getResponseForW3CError (err) {
       error: w3cErrorString,
       message: err.message,
       stacktrace: err.stacktrace || err.stack,
-    }
+    },
   };
   return [httpStatus, httpResBody];
 }
@@ -832,17 +984,19 @@ function getResponseForW3CError (err) {
  * Convert an Appium error to a proper JSONWP response
  * @param {ProtocolError} err The error to be converted
  */
-function getResponseForJsonwpError (err) {
+function getResponseForJsonwpError(err) {
   if (isUnknownError(err)) {
     err = new errors.UnknownError(err);
   }
   // MJSONWP errors are usually 500 status code so set it to that by default
   let httpStatus = HTTPStatusCodes.INTERNAL_SERVER_ERROR;
+
+  /** @type {HttpResultBody} */
   let httpResBody = {
     status: err.jsonwpCode,
     value: {
-      message: err.message
-    }
+      message: err.message,
+    },
   };
 
   if (isErrorType(err, errors.BadParametersError)) {
@@ -850,8 +1004,10 @@ function getResponseForJsonwpError (err) {
     mjsonwpLog.debug(`Bad parameters: ${err}`);
     httpStatus = HTTPStatusCodes.BAD_REQUEST;
     httpResBody = err.message;
-  } else if (isErrorType(err, errors.NotYetImplementedError) ||
-             isErrorType(err, errors.NotImplementedError)) {
+  } else if (
+    isErrorType(err, errors.NotYetImplementedError) ||
+    isErrorType(err, errors.NotImplementedError)
+  ) {
     // respond with a 501 if the method is not implemented
     httpStatus = HTTPStatusCodes.NOT_IMPLEMENTED;
   } else if (isErrorType(err, errors.NoSuchDriverError)) {
@@ -859,12 +1015,33 @@ function getResponseForJsonwpError (err) {
     httpStatus = HTTPStatusCodes.NOT_FOUND;
   }
 
-
   return [httpStatus, httpResBody];
 }
 
 export {
-  errors, isErrorType, isUnknownError,
-  errorFromMJSONWPStatusCode, errorFromW3CJsonCode,
-  getResponseForW3CError, getResponseForJsonwpError,
+  errors,
+  isErrorType,
+  isUnknownError,
+  errorFromMJSONWPStatusCode,
+  errorFromW3CJsonCode,
+  getResponseForW3CError,
+  getResponseForJsonwpError,
 };
+
+/**
+ * @typedef { string | {value: HttpResultBodyValue, status?: number } } HttpResultBody
+ */
+
+/**
+ * @typedef HttpResultBodyValue
+ * @property {string} [message]
+ * @property {string|Error} [error]
+ * @property {string} [stacktrace]
+ */
+
+/**
+ * @typedef MJSONWPError
+ * @property {number} status
+ * @property {string|object} value
+ * @property {string} message
+ */