@appium/base-driver 8.3.1 → 8.4.0

package/build/lib/helpers/capabilities.js

@@ -5,6 +5,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.fixCaps = fixCaps;
 exports.isW3cCaps = isW3cCaps;
 
 require("source-map-support/register");
@@ -34,4 +35,43 @@ function isW3cCaps(caps) {
 
   return false;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+
+function fixCaps(originalCaps, desiredCapConstraints, log) {
+  let caps = _lodash.default.clone(originalCaps);
+
+  let booleanCaps = _lodash.default.keys(_lodash.default.pickBy(desiredCapConstraints, k => k.isBoolean === true));
+
+  for (let cap of booleanCaps) {
+    let value = originalCaps[cap];
+
+    if (_lodash.default.isString(value)) {
+      value = value.toLowerCase();
+
+      if (value === 'true' || value === 'false') {
+        log.warn(`Capability '${cap}' changed from string to boolean. This may cause unexpected behavior`);
+        caps[cap] = value === 'true';
+      }
+    }
+  }
+
+  let intCaps = _lodash.default.keys(_lodash.default.pickBy(desiredCapConstraints, k => k.isNumber === true));
+
+  for (let cap of intCaps) {
+    let value = originalCaps[cap];
+
+    if (_lodash.default.isString(value)) {
+      value = value.trim();
+      let newValue = parseInt(value, 10);
+
+      if (value !== `${newValue}`) {
+        newValue = parseFloat(value);
+      }
+
+      log.warn(`Capability '${cap}' changed from string ('${value}') to integer (${newValue}). This may cause unexpected behavior`);
+      caps[cap] = newValue;
+    }
+  }
+
+  return caps;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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.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 deviceSettings = _interopRequireWildcard(require("./basedriver/device-settings"));
+var _core = require("./basedriver/core");
+
+var _deviceSettings = require("./basedriver/device-settings");
 
 var protocol = _interopRequireWildcard(require("./protocol"));
 
@@ -45,18 +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
-} = deviceSettings;
-exports.DeviceSettings = DeviceSettings;
-var _default = BaseDriver;
+_bluebird.default.config({
+  cancellation: true
+});
+
+var _default = _driver.BaseDriver;
 exports.default = _default;
 const {
-  Protocol,
   routeConfiguringFunction,
   errors,
   isErrorType,
@@ -67,7 +88,6 @@ const {
   routeToCommandName,
   NO_SESSION_ID_COMMANDS,
   isSessionCommand,
-  normalizeBasePath,
   determineProtocol,
   CREATE_SESSION_COMMAND,
   DELETE_SESSION_COMMAND,
@@ -77,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;
@@ -88,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
@@ -119,4 +139,4 @@ const {
   DEFAULT_WS_PATHNAME_PREFIX
 } = ws;
 exports.DEFAULT_WS_PATHNAME_PREFIX = DEFAULT_WS_PATHNAME_PREFIX;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL2xpYi9pbmRleC5qcyJdLCJuYW1lcyI6WyJCIiwiY29uZmlnIiwiY2FuY2VsbGF0aW9uIiwiQmFzZURyaXZlciIsInJvdXRlQ29uZmlndXJpbmdGdW5jdGlvbiIsImVycm9ycyIsImlzRXJyb3JUeXBlIiwiZXJyb3JGcm9tTUpTT05XUFN0YXR1c0NvZGUiLCJlcnJvckZyb21XM0NKc29uQ29kZSIsIkFMTF9DT01NQU5EUyIsIk1FVEhPRF9NQVAiLCJyb3V0ZVRvQ29tbWFuZE5hbWUiLCJOT19TRVNTSU9OX0lEX0NPTU1BTkRTIiwiaXNTZXNzaW9uQ29tbWFuZCIsImRldGVybWluZVByb3RvY29sIiwiQ1JFQVRFX1NFU1NJT05fQ09NTUFORCIsIkRFTEVURV9TRVNTSU9OX0NPTU1BTkQiLCJHRVRfU1RBVFVTX0NPTU1BTkQiLCJwcm90b2NvbCIsIlNUQVRJQ19ESVIiLCJzdGF0aWNJbmRleCIsInNlcnZlciIsIm5vcm1hbGl6ZUJhc2VQYXRoIiwic2VydmVySW5kZXgiLCJKV1Byb3h5IiwicHJveHlJbmRleCIsImNvZGVzIiwic3RhdHVzQ29kZXMiLCJnZXRTdW1tYXJ5QnlDb2RlIiwic3RhdHVzSW5kZXgiLCJwcm9jZXNzQ2FwYWJpbGl0aWVzIiwiaXNTdGFuZGFyZENhcCIsInZhbGlkYXRlQ2FwcyIsImNhcHMiLCJERUZBVUxUX1dTX1BBVEhOQU1FX1BSRUZJWCIsIndzIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFQTs7QUFPQTs7QUFDQTs7QUFDQTs7QUFPQTs7QUFDQTs7QUFzQkE7O0FBSUE7O0FBS0E7O0FBS0E7O0FBS0E7O0FBS0E7Ozs7OztBQTdEQUEsa0JBQUVDLE1BQUYsQ0FBUztBQUNQQyxFQUFBQSxZQUFZLEVBQUU7QUFEUCxDQUFUOztlQVVlQyxrQjs7QUFTZixNQUFNO0FBQ0pDLEVBQUFBLHdCQURJO0FBQ3NCQyxFQUFBQSxNQUR0QjtBQUM4QkMsRUFBQUEsV0FEOUI7QUFFSkMsRUFBQUEsMEJBRkk7QUFFd0JDLEVBQUFBLG9CQUZ4QjtBQUU4Q0MsRUFBQUEsWUFGOUM7QUFFNERDLEVBQUFBLFVBRjVEO0FBR0pDLEVBQUFBLGtCQUhJO0FBR2dCQyxFQUFBQSxzQkFIaEI7QUFHd0NDLEVBQUFBLGdCQUh4QztBQUlKQyxFQUFBQSxpQkFKSTtBQUllQyxFQUFBQSxzQkFKZjtBQUtKQyxFQUFBQSxzQkFMSTtBQUtvQkMsRUFBQUE7QUFMcEIsSUFNRkMsUUFOSjs7Ozs7Ozs7Ozs7Ozs7O0FBbUJBLE1BQU07QUFBRUMsRUFBQUE7QUFBRixJQUFpQkMsV0FBdkI7O0FBSUEsTUFBTTtBQUFFQyxFQUFBQSxNQUFGO0FBQVVDLEVBQUFBO0FBQVYsSUFBZ0NDLFdBQXRDOzs7QUFLQSxNQUFNO0FBQUVDLEVBQUFBO0FBQUYsSUFBY0MsVUFBcEI7O0FBS0EsTUFBTTtBQUFFQyxFQUFBQSxLQUFLLEVBQUVDLFdBQVQ7QUFBc0JDLEVBQUFBO0FBQXRCLElBQTJDQyxXQUFqRDs7O0FBS0EsTUFBTTtBQUFFQyxFQUFBQSxtQkFBRjtBQUF1QkMsRUFBQUEsYUFBdkI7QUFBc0NDLEVBQUFBO0FBQXRDLElBQXVEQyxJQUE3RDs7OztBQUtBLE1BQU07QUFBRUMsRUFBQUE7QUFBRixJQUFpQ0MsRUFBdkMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcblxuaW1wb3J0IEIgZnJvbSAnYmx1ZWJpcmQnO1xuXG5CLmNvbmZpZyh7XG4gIGNhbmNlbGxhdGlvbjogdHJ1ZSxcbn0pO1xuXG4vLyBCYXNlRHJpdmVyIGV4cG9ydHNcbmltcG9ydCB7IEJhc2VEcml2ZXIgfSBmcm9tICcuL2Jhc2Vkcml2ZXIvZHJpdmVyJztcbmV4cG9ydCB7IERyaXZlckNvcmUgfSBmcm9tICcuL2Jhc2Vkcml2ZXIvY29yZSc7XG5pbXBvcnQgeyBEZXZpY2VTZXR0aW5ncyB9IGZyb20gJy4vYmFzZWRyaXZlci9kZXZpY2Utc2V0dGluZ3MnO1xuXG5leHBvcnQgeyBCYXNlRHJpdmVyLCBEZXZpY2VTZXR0aW5ncyB9O1xuZXhwb3J0IGRlZmF1bHQgQmFzZURyaXZlcjtcblxuXG4vLyBNSlNPTldQIGV4cG9ydHNcbmltcG9ydCAqIGFzIHByb3RvY29sIGZyb20gJy4vcHJvdG9jb2wnO1xuaW1wb3J0IHtcbiAgREVGQVVMVF9CQVNFX1BBVEgsIFBST1RPQ09MU1xufSBmcm9tICcuL2NvbnN0YW50cyc7XG5cbmNvbnN0IHtcbiAgcm91dGVDb25maWd1cmluZ0Z1bmN0aW9uLCBlcnJvcnMsIGlzRXJyb3JUeXBlLFxuICBlcnJvckZyb21NSlNPTldQU3RhdHVzQ29kZSwgZXJyb3JGcm9tVzNDSnNvbkNvZGUsIEFMTF9DT01NQU5EUywgTUVUSE9EX01BUCxcbiAgcm91dGVUb0NvbW1hbmROYW1lLCBOT19TRVNTSU9OX0lEX0NPTU1BTkRTLCBpc1Nlc3Npb25Db21tYW5kLFxuICBkZXRlcm1pbmVQcm90b2NvbCwgQ1JFQVRFX1NFU1NJT05fQ09NTUFORCxcbiAgREVMRVRFX1NFU1NJT05fQ09NTUFORCwgR0VUX1NUQVRVU19DT01NQU5ELFxufSA9IHByb3RvY29sO1xuXG5leHBvcnQge1xuICByb3V0ZUNvbmZpZ3VyaW5nRnVuY3Rpb24sIGVycm9ycywgaXNFcnJvclR5cGUsIFBST1RPQ09MUyxcbiAgZXJyb3JGcm9tTUpTT05XUFN0YXR1c0NvZGUsIGVycm9yRnJvbVczQ0pzb25Db2RlLCBkZXRlcm1pbmVQcm90b2NvbCxcbiAgZXJyb3JGcm9tTUpTT05XUFN0YXR1c0NvZGUgYXMgZXJyb3JGcm9tQ29kZSwgQUxMX0NPTU1BTkRTLCBNRVRIT0RfTUFQLFxuICByb3V0ZVRvQ29tbWFuZE5hbWUsIE5PX1NFU1NJT05fSURfQ09NTUFORFMsIGlzU2Vzc2lvbkNvbW1hbmQsXG4gIERFRkFVTFRfQkFTRV9QQVRILCBDUkVBVEVfU0VTU0lPTl9DT01NQU5ELFxuICBERUxFVEVfU0VTU0lPTl9DT01NQU5ELCBHRVRfU1RBVFVTX0NPTU1BTkQsXG59O1xuXG4vLyBFeHByZXNzIGV4cG9ydHNcbmltcG9ydCAqIGFzIHN0YXRpY0luZGV4IGZyb20gJy4vZXhwcmVzcy9zdGF0aWMnO1xuY29uc3QgeyBTVEFUSUNfRElSIH0gPSBzdGF0aWNJbmRleDtcbmV4cG9ydCB7IFNUQVRJQ19ESVIgfTtcblxuaW1wb3J0ICogYXMgc2VydmVySW5kZXggZnJvbSAnLi9leHByZXNzL3NlcnZlcic7XG5jb25zdCB7IHNlcnZlciwgbm9ybWFsaXplQmFzZVBhdGggfSA9IHNlcnZlckluZGV4O1xuZXhwb3J0IHsgc2VydmVyLCBub3JtYWxpemVCYXNlUGF0aCB9O1xuXG4vLyBqc29ud3AtcHJveHkgZXhwb3J0c1xuaW1wb3J0ICogYXMgcHJveHlJbmRleCBmcm9tICcuL2pzb253cC1wcm94eS9wcm94eSc7XG5jb25zdCB7IEpXUHJveHkgfSA9IHByb3h5SW5kZXg7XG5leHBvcnQgeyBKV1Byb3h5IH07XG5cbi8vIGpzb253cC1zdGF0dXMgZXhwb3J0c1xuaW1wb3J0ICogYXMgc3RhdHVzSW5kZXggZnJvbSAnLi9qc29ud3Atc3RhdHVzL3N0YXR1cyc7XG5jb25zdCB7IGNvZGVzOiBzdGF0dXNDb2RlcywgZ2V0U3VtbWFyeUJ5Q29kZSB9ID0gc3RhdHVzSW5kZXg7XG5leHBvcnQgeyBzdGF0dXNDb2RlcywgZ2V0U3VtbWFyeUJ5Q29kZSB9O1xuXG4vLyBXM0MgY2FwYWJpbGl0aWVzIHBhcnNlclxuaW1wb3J0ICogYXMgY2FwcyBmcm9tICcuL2Jhc2Vkcml2ZXIvY2FwYWJpbGl0aWVzJztcbmNvbnN0IHsgcHJvY2Vzc0NhcGFiaWxpdGllcywgaXNTdGFuZGFyZENhcCwgdmFsaWRhdGVDYXBzIH0gPSBjYXBzO1xuZXhwb3J0IHsgcHJvY2Vzc0NhcGFiaWxpdGllcywgaXNTdGFuZGFyZENhcCwgdmFsaWRhdGVDYXBzIH07XG5cbi8vIFdlYiBzb2NrZXQgaGVscGVyc1xuaW1wb3J0ICogYXMgd3MgZnJvbSAnLi9leHByZXNzL3dlYnNvY2tldCc7XG5jb25zdCB7IERFRkFVTFRfV1NfUEFUSE5BTUVfUFJFRklYIH0gPSB3cztcbmV4cG9ydCB7IERFRkFVTFRfV1NfUEFUSE5BTUVfUFJFRklYIH07XG4iXX0=

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/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"}

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

@@ -0,0 +1,159 @@
+export default codes;
+export namespace codes {
+    namespace Success {
+        const code: number;
+        const summary: string;
+    }
+    namespace NoSuchDriver {
+        const code_1: number;
+        export { code_1 as code };
+        const summary_1: string;
+        export { summary_1 as summary };
+    }
+    namespace NoSuchElement {
+        const code_2: number;
+        export { code_2 as code };
+        const summary_2: string;
+        export { summary_2 as summary };
+    }
+    namespace NoSuchFrame {
+        const code_3: number;
+        export { code_3 as code };
+        const summary_3: string;
+        export { summary_3 as summary };
+    }
+    namespace UnknownCommand {
+        const code_4: number;
+        export { code_4 as code };
+        const summary_4: string;
+        export { summary_4 as summary };
+    }
+    namespace StaleElementReference {
+        const code_5: number;
+        export { code_5 as code };
+        const summary_5: string;
+        export { summary_5 as summary };
+    }
+    namespace ElementNotVisible {
+        const code_6: number;
+        export { code_6 as code };
+        const summary_6: string;
+        export { summary_6 as summary };
+    }
+    namespace InvalidElementState {
+        const code_7: number;
+        export { code_7 as code };
+        const summary_7: string;
+        export { summary_7 as summary };
+    }
+    namespace UnknownError {
+        const code_8: number;
+        export { code_8 as code };
+        const summary_8: string;
+        export { summary_8 as summary };
+    }
+    namespace ElementIsNotSelectable {
+        const code_9: number;
+        export { code_9 as code };
+        const summary_9: string;
+        export { summary_9 as summary };
+    }
+    namespace JavaScriptError {
+        const code_10: number;
+        export { code_10 as code };
+        const summary_10: string;
+        export { summary_10 as summary };
+    }
+    namespace XPathLookupError {
+        const code_11: number;
+        export { code_11 as code };
+        const summary_11: string;
+        export { summary_11 as summary };
+    }
+    namespace Timeout {
+        const code_12: number;
+        export { code_12 as code };
+        const summary_12: string;
+        export { summary_12 as summary };
+    }
+    namespace NoSuchWindow {
+        const code_13: number;
+        export { code_13 as code };
+        const summary_13: string;
+        export { summary_13 as summary };
+    }
+    namespace InvalidCookieDomain {
+        const code_14: number;
+        export { code_14 as code };
+        const summary_14: string;
+        export { summary_14 as summary };
+    }
+    namespace UnableToSetCookie {
+        const code_15: number;
+        export { code_15 as code };
+        const summary_15: string;
+        export { summary_15 as summary };
+    }
+    namespace UnexpectedAlertOpen {
+        const code_16: number;
+        export { code_16 as code };
+        const summary_16: string;
+        export { summary_16 as summary };
+    }
+    namespace NoAlertOpenError {
+        const code_17: number;
+        export { code_17 as code };
+        const summary_17: string;
+        export { summary_17 as summary };
+    }
+    namespace ScriptTimeout {
+        const code_18: number;
+        export { code_18 as code };
+        const summary_18: string;
+        export { summary_18 as summary };
+    }
+    namespace InvalidElementCoordinates {
+        const code_19: number;
+        export { code_19 as code };
+        const summary_19: string;
+        export { summary_19 as summary };
+    }
+    namespace IMENotAvailable {
+        const code_20: number;
+        export { code_20 as code };
+        const summary_20: string;
+        export { summary_20 as summary };
+    }
+    namespace IMEEngineActivationFailed {
+        const code_21: number;
+        export { code_21 as code };
+        const summary_21: string;
+        export { summary_21 as summary };
+    }
+    namespace InvalidSelector {
+        const code_22: number;
+        export { code_22 as code };
+        const summary_22: string;
+        export { summary_22 as summary };
+    }
+    namespace SessionNotCreatedException {
+        const code_23: number;
+        export { code_23 as code };
+        const summary_23: string;
+        export { summary_23 as summary };
+    }
+    namespace MoveTargetOutOfBounds {
+        const code_24: number;
+        export { code_24 as code };
+        const summary_24: string;
+        export { summary_24 as summary };
+    }
+    namespace NoSuchContext {
+        const code_25: number;
+        export { code_25 as code };
+        const summary_25: string;
+        export { summary_25 as summary };
+    }
+}
+export function getSummaryByCode(code: any): string;
+//# sourceMappingURL=status.d.ts.map

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

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