@appium/base-driver 8.5.6 → 8.6.1

package/build/lib/express/server.d.ts

@@ -19,13 +19,75 @@ export type StartServerOpts = {
      */
     hostname?: string | undefined;
 };
-export function server(opts?: {}): Promise<any>;
-export function configureServer({ app, addRoutes, allowCors, basePath, extraMethodMap, }: {
-    app: any;
-    addRoutes: any;
+export type AppiumServer = import('@appium/types').AppiumServer;
+export type AppiumServerSocket = import('@appium/types').AppiumServerSocket;
+export type MethodMap = import('@appium/types').MethodMap;
+/**
+ * Options for {@linkcode configureHttp }
+ */
+export type ConfigureHttpOpts = {
+    /**
+     * - HTTP server instance
+     */
+    httpServer: import('http').Server;
+    /**
+     * - Rejection function from `Promise` constructor
+     */
+    reject: (error?: any) => void;
+    /**
+     * - Keep-alive timeout in milliseconds
+     */
+    keepAliveTimeout: number;
+};
+/**
+ * Options for {@linkcode server }
+ */
+export type ServerOpts = {
+    routeConfiguringFunction: RouteConfiguringFunction;
+    port: number;
+    hostname?: string | undefined;
     allowCors?: boolean | undefined;
     basePath?: string | undefined;
-    extraMethodMap?: {} | undefined;
-}): void;
-export function normalizeBasePath(basePath: any): any;
+    extraMethodMap?: MethodMap | undefined;
+    serverUpdaters?: import("@appium/types").UpdateServerCallback[] | undefined;
+    keepAliveTimeout?: number | undefined;
+};
+/**
+ * A function which configures routes
+ */
+export type RouteConfiguringFunction = (app: import('express').Express, opts?: RouteConfiguringFunctionOpts | undefined) => void;
+/**
+ * Options for a {@linkcode RouteConfiguringFunction }
+ */
+export type RouteConfiguringFunctionOpts = {
+    basePath?: string | undefined;
+    extraMethodMap?: MethodMap | undefined;
+};
+/**
+ * Options for {@linkcode configureServer }
+ */
+export type ConfigureServerOpts = {
+    app: import('express').Express;
+    addRoutes: RouteConfiguringFunction;
+    allowCors?: boolean | undefined;
+    basePath?: string | undefined;
+    extraMethodMap?: MethodMap | undefined;
+};
+/**
+ *
+ * @param {ServerOpts} opts
+ * @returns {Promise<AppiumServer>}
+ */
+export function server(opts: ServerOpts): Promise<AppiumServer>;
+/**
+ * Sets up some Express middleware and stuff
+ * @param {ConfigureServerOpts} opts
+ */
+export function configureServer({ app, addRoutes, allowCors, basePath, extraMethodMap, }: ConfigureServerOpts): void;
+/**
+ * Normalize base path string
+ * @param {string} basePath
+ * @returns {string}
+ */
+export function normalizeBasePath(basePath: string): string;
 //# sourceMappingURL=server.d.ts.map

package/build/lib/express/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../lib/express/server.js"],"names":[],"mappings":";;;;;;;gBAyOc,OAAO,MAAM,EAAE,MAAM;;;;UACrB,MAAM;;;;sBACN,MAAM;;;;;;AA3MpB,gDA8CC;AAED;;;;;;SA6CC;AAqFD,sDAgBC"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../lib/express/server.js"],"names":[],"mappings":";;;;;;;gBA6Qc,OAAO,MAAM,EAAE,MAAM;;;;UACrB,MAAM;;;;sBACN,MAAM;;;;;;2BAKP,OAAO,eAAe,EAAE,YAAY;iCACpC,OAAO,eAAe,EAAE,kBAAkB;wBAC1C,OAAO,eAAe,EAAE,SAAS;;;;;;;;gBAMhC,OAAO,MAAM,EAAE,MAAM;;;;qBACZ,GAAG,KAAK,IAAI;;;;sBACrB,MAAM;;;;;;8BAMN,wBAAwB;UACxB,MAAM;;;;;;;;;;;6CAYT,OAAO,SAAS,EAAE,OAAO,sDAEvB,IAAI;;;;;;;;;;;;SAaH,OAAO,SAAS,EAAE,OAAO;eACzB,wBAAwB;;;;;AAjStC;;;;GAIG;AACH,6BAHW,UAAU,GACR,QAAQ,YAAY,CAAC,CAqDjC;AAED;;;GAGG;AACH,0FAFW,mBAAmB,QA+C7B;AAsGD;;;;GAIG;AACH,4CAHW,MAAM,GACJ,MAAM,CAkBlB"}

package/build/lib/express/server.js

@@ -45,11 +45,11 @@ var _events = require("events");
 
 const KEEP_ALIVE_TIMEOUT_MS = 10 * 60 * 1000;
 
-async function server(opts = {}) {
+async function server(opts) {
   const {
     routeConfiguringFunction,
     port,
-    hostname = null,
+    hostname,
     allowCors = true,
     basePath = _constants.DEFAULT_BASE_PATH,
     extraMethodMap = {},
@@ -62,7 +62,7 @@ async function server(opts = {}) {
 
   return await new _bluebird.default(async (resolve, reject) => {
     try {
-      configureHttp({
+      const appiumServer = configureHttp({
         httpServer,
         reject,
         keepAliveTimeout
@@ -76,7 +76,7 @@ async function server(opts = {}) {
       });
 
       for (const updater of serverUpdaters) {
-        await updater(app, httpServer);
+        await updater(app, appiumServer);
       }
 
       app.all('*', _middleware.catch404Handler);
@@ -86,7 +86,7 @@ async function server(opts = {}) {
         port,
         keepAliveTimeout
       });
-      resolve(httpServer);
+      resolve(appiumServer);
     } catch (err) {
       reject(err);
     }
@@ -144,13 +144,14 @@ function configureHttp({
     notifier: new _events.EventEmitter(),
     closed: false
   };
-  httpServer.addWebSocketHandler = _websocket.addWebSocketHandler;
-  httpServer.removeWebSocketHandler = _websocket.removeWebSocketHandler;
-  httpServer.removeAllWebSocketHandlers = _websocket.removeAllWebSocketHandlers;
-  httpServer.getWebSocketHandlers = _websocket.getWebSocketHandlers;
-  const close = httpServer.close.bind(httpServer);
-
-  httpServer.close = async () => await new _bluebird.default((resolve, reject) => {
+  const appiumServer = httpServer;
+  appiumServer.addWebSocketHandler = _websocket.addWebSocketHandler;
+  appiumServer.removeWebSocketHandler = _websocket.removeWebSocketHandler;
+  appiumServer.removeAllWebSocketHandlers = _websocket.removeAllWebSocketHandlers;
+  appiumServer.getWebSocketHandlers = _websocket.getWebSocketHandlers;
+  const close = appiumServer.close.bind(appiumServer);
+
+  appiumServer.close = async () => await new _bluebird.default((resolve, reject) => {
     serverState.closed = true;
     serverState.notifier.emit('shutdown');
 
@@ -166,7 +167,7 @@ function configureHttp({
     });
   });
 
-  httpServer.on('error', err => {
+  appiumServer.on('error', err => {
     if (err.code === 'EADDRNOTAVAIL') {
       _logger.default.error('Could not start REST http interface listener. ' + 'Requested address is not available.');
     } else {
@@ -175,7 +176,7 @@ function configureHttp({
 
     reject(err);
   });
-  httpServer.on('connection', socket => {
+  appiumServer.on('connection', socket => {
     socket.setTimeout(keepAliveTimeout);
     socket.on('error', reject);
 
@@ -187,7 +188,7 @@ function configureHttp({
     socket.once('close', () => serverState.notifier.removeListener('shutdown', destroy));
     serverState.notifier.once('shutdown', destroy);
   });
-  httpServer.on('request', function (req, res) {
+  appiumServer.on('request', function (req, res) {
     const socket = req.connection || req.socket;
     socket._openReqCount++;
     res.on('finish', function () {
@@ -198,6 +199,7 @@ function configureHttp({
       }
     });
   });
+  return appiumServer;
 }
 
 async function startServer({
@@ -229,4 +231,4 @@ function normalizeBasePath(basePath) {
 
   return basePath;
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["KEEP_ALIVE_TIMEOUT_MS","server","opts","routeConfiguringFunction","port","hostname","allowCors","basePath","DEFAULT_BASE_PATH","extraMethodMap","serverUpdaters","keepAliveTimeout","app","express","httpServer","http","createServer","B","resolve","reject","configureHttp","configureServer","addRoutes","updater","all","catch404Handler","startServer","err","normalizeBasePath","use","endLogFormatter","favicon","path","STATIC_DIR","static","produceError","produceCrash","allowCrossDomain","allowCrossDomainAsyncExecute","handleIdempotency","fixPythonContentType","defaultToJSONContentType","bodyParser","urlencoded","extended","methodOverride","catchAllHandler","json","limit","startLogFormatter","welcome","guineaPig","guineaPigScrollable","guineaPigAppBanner","serverState","notifier","EventEmitter","closed","addWebSocketHandler","removeWebSocketHandler","removeAllWebSocketHandlers","getWebSocketHandlers","close","bind","emit","log","info","on","code","error","socket","setTimeout","destroy","_openReqCount","once","removeListener","req","res","connection","start","promisify","listen","context","startPromise","headersTimeout","_","isString","Error","replace"],"sources":["../../../lib/express/server.js"],"sourcesContent":["import _ from 'lodash';\nimport path from 'path';\nimport express from 'express';\nimport http from 'http';\nimport favicon from 'serve-favicon';\nimport bodyParser from 'body-parser';\nimport methodOverride from 'method-override';\nimport log from './logger';\nimport {startLogFormatter, endLogFormatter} from './express-logging';\nimport {\n  allowCrossDomain,\n  fixPythonContentType,\n  defaultToJSONContentType,\n  catchAllHandler,\n  allowCrossDomainAsyncExecute,\n  handleIdempotency,\n  catch404Handler,\n} from './middleware';\nimport {guineaPig, guineaPigScrollable, guineaPigAppBanner, welcome, STATIC_DIR} from './static';\nimport {produceError, produceCrash} from './crash';\nimport {\n  addWebSocketHandler,\n  removeWebSocketHandler,\n  removeAllWebSocketHandlers,\n  getWebSocketHandlers,\n} from './websocket';\nimport B from 'bluebird';\nimport {DEFAULT_BASE_PATH} from '../constants';\nimport {EventEmitter} from 'events';\n\nconst KEEP_ALIVE_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes\n\nasync function server(opts = {}) {\n  const {\n    routeConfiguringFunction,\n    port,\n    hostname = null,\n    allowCors = true,\n    basePath = DEFAULT_BASE_PATH,\n    extraMethodMap = {},\n    serverUpdaters = [],\n    keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS,\n  } = opts;\n\n  // create the actual http server\n  const app = express();\n  const httpServer = http.createServer(app);\n  return await new B(async (resolve, reject) => {\n    // we put an async function as the promise constructor because we want some things to happen in\n    // serial (application of plugin updates, for example). But we still need to use a promise here\n    // because some elements of server start failure only happen in httpServer listeners. So the\n    // way we resolve it is to use an async function here but to wrap all the inner logic in\n    // try/catch so any errors can be passed to reject.\n    try {\n      configureHttp({httpServer, reject, keepAliveTimeout});\n      configureServer({\n        app,\n        addRoutes: routeConfiguringFunction,\n        allowCors,\n        basePath,\n        extraMethodMap,\n      });\n      // allow extensions to update the app and http server objects\n      for (const updater of serverUpdaters) {\n        await updater(app, httpServer);\n      }\n\n      // once all configurations and updaters have been applied, make sure to set up a catchall\n      // handler so that anything unknown 404s. But do this after everything else since we don't\n      // want to block extensions' ability to add routes if they want.\n      app.all('*', catch404Handler);\n\n      await startServer({httpServer, hostname, port, keepAliveTimeout});\n      resolve(httpServer);\n    } catch (err) {\n      reject(err);\n    }\n  });\n}\n\nfunction configureServer({\n  app,\n  addRoutes,\n  allowCors = true,\n  basePath = DEFAULT_BASE_PATH,\n  extraMethodMap = {},\n}) {\n  basePath = normalizeBasePath(basePath);\n\n  app.use(endLogFormatter);\n\n  // set up static assets\n  app.use(favicon(path.resolve(STATIC_DIR, 'favicon.ico')));\n  app.use(express.static(STATIC_DIR));\n\n  // crash routes, for testing\n  app.use(`${basePath}/produce_error`, produceError);\n  app.use(`${basePath}/crash`, produceCrash);\n\n  // add middlewares\n  if (allowCors) {\n    app.use(allowCrossDomain);\n  } else {\n    app.use(allowCrossDomainAsyncExecute(basePath));\n  }\n  app.use(handleIdempotency);\n  app.use(fixPythonContentType(basePath));\n  app.use(defaultToJSONContentType);\n  app.use(bodyParser.urlencoded({extended: true}));\n  app.use(methodOverride());\n  app.use(catchAllHandler);\n\n  // make sure appium never fails because of a file size upload limit\n  app.use(bodyParser.json({limit: '1gb'}));\n\n  // set up start logging (which depends on bodyParser doing its thing)\n  app.use(startLogFormatter);\n\n  addRoutes(app, {basePath, extraMethodMap});\n\n  // dynamic routes for testing, etc.\n  app.all('/welcome', welcome);\n  app.all('/test/guinea-pig', guineaPig);\n  app.all('/test/guinea-pig-scrollable', guineaPigScrollable);\n  app.all('/test/guinea-pig-app-banner', guineaPigAppBanner);\n}\n\nfunction configureHttp({httpServer, reject, keepAliveTimeout}) {\n  const serverState = {\n    notifier: new EventEmitter(),\n    closed: false,\n  };\n  httpServer.addWebSocketHandler = addWebSocketHandler;\n  httpServer.removeWebSocketHandler = removeWebSocketHandler;\n  httpServer.removeAllWebSocketHandlers = removeAllWebSocketHandlers;\n  httpServer.getWebSocketHandlers = getWebSocketHandlers;\n\n  // http.Server.close() only stops new connections, but we need to wait until\n  // all connections are closed and the `close` event is emitted\n  const close = httpServer.close.bind(httpServer);\n  httpServer.close = async () =>\n    await new B((resolve, reject) => {\n      // https://github.com/nodejs/node-v0.x-archive/issues/9066#issuecomment-124210576\n      serverState.closed = true;\n      serverState.notifier.emit('shutdown');\n      log.info('Waiting until the server is closed');\n      httpServer.on('close', () => {\n        log.info('Received server close event');\n        resolve();\n      });\n      close((err) => {\n        if (err) reject(err); // eslint-disable-line curly\n      });\n    });\n\n  httpServer.on('error', (err) => {\n    if (err.code === 'EADDRNOTAVAIL') {\n      log.error(\n        'Could not start REST http interface listener. ' + 'Requested address is not available.'\n      );\n    } else {\n      log.error(\n        'Could not start REST http interface listener. The requested ' +\n          'port may already be in use. Please make sure there is no ' +\n          'other instance of this server running already.'\n      );\n    }\n    reject(err);\n  });\n\n  httpServer.on('connection', (socket) => {\n    socket.setTimeout(keepAliveTimeout);\n    socket.on('error', reject);\n\n    function destroy() {\n      socket.destroy();\n    }\n    socket._openReqCount = 0;\n    socket.once('close', () => serverState.notifier.removeListener('shutdown', destroy));\n    serverState.notifier.once('shutdown', destroy);\n  });\n\n  httpServer.on('request', function (req, res) {\n    const socket = req.connection || req.socket;\n    socket._openReqCount++;\n    res.on('finish', function () {\n      socket._openReqCount--;\n      if (serverState.closed && socket._openReqCount === 0) {\n        socket.destroy();\n      }\n    });\n  });\n}\n\n/**\n *\n * @param {StartServerOpts} opts\n */\nasync function startServer({httpServer, port, hostname, keepAliveTimeout}) {\n  // If the hostname is omitted, the server will accept\n  // connections on any IP address\n  /** @type {(port: number, hostname?: string) => B<http.Server>} */\n  const start = B.promisify(httpServer.listen, {context: httpServer});\n  const startPromise = start(port, hostname);\n  httpServer.keepAliveTimeout = keepAliveTimeout;\n  // headers timeout must be greater than keepAliveTimeout\n  httpServer.headersTimeout = keepAliveTimeout + 5 * 1000;\n  await startPromise;\n}\n\nfunction normalizeBasePath(basePath) {\n  if (!_.isString(basePath)) {\n    throw new Error(`Invalid path prefix ${basePath}`);\n  }\n\n  // ensure the path prefix does not end in '/', since our method map\n  // starts all paths with '/'\n  basePath = basePath.replace(/\\/$/, '');\n\n  // likewise, ensure the path prefix does always START with /, unless the path\n  // is empty meaning no base path at all\n  if (basePath !== '' && basePath[0] !== '/') {\n    basePath = `/${basePath}`;\n  }\n\n  return basePath;\n}\n\nexport {server, configureServer, normalizeBasePath};\n\n/**\n * Options for {@linkcode startServer}.\n * @typedef StartServerOpts\n * @property {import('http').Server} httpServer - HTTP server instance\n * @property {number} port - Port to run on\n * @property {number} keepAliveTimeout - Keep-alive timeout in milliseconds\n * @property {string} [hostname] - Optional hostname\n */\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["KEEP_ALIVE_TIMEOUT_MS","server","opts","routeConfiguringFunction","port","hostname","allowCors","basePath","DEFAULT_BASE_PATH","extraMethodMap","serverUpdaters","keepAliveTimeout","app","express","httpServer","http","createServer","B","resolve","reject","appiumServer","configureHttp","configureServer","addRoutes","updater","all","catch404Handler","startServer","err","normalizeBasePath","use","endLogFormatter","favicon","path","STATIC_DIR","static","produceError","produceCrash","allowCrossDomain","allowCrossDomainAsyncExecute","handleIdempotency","fixPythonContentType","defaultToJSONContentType","bodyParser","urlencoded","extended","methodOverride","catchAllHandler","json","limit","startLogFormatter","welcome","guineaPig","guineaPigScrollable","guineaPigAppBanner","serverState","notifier","EventEmitter","closed","addWebSocketHandler","removeWebSocketHandler","removeAllWebSocketHandlers","getWebSocketHandlers","close","bind","emit","log","info","on","code","error","socket","setTimeout","destroy","_openReqCount","once","removeListener","req","res","connection","start","promisify","listen","context","startPromise","headersTimeout","_","isString","Error","replace"],"sources":["../../../lib/express/server.js"],"sourcesContent":["import _ from 'lodash';\nimport path from 'path';\nimport express from 'express';\nimport http from 'http';\nimport favicon from 'serve-favicon';\nimport bodyParser from 'body-parser';\nimport methodOverride from 'method-override';\nimport log from './logger';\nimport {startLogFormatter, endLogFormatter} from './express-logging';\nimport {\n  allowCrossDomain,\n  fixPythonContentType,\n  defaultToJSONContentType,\n  catchAllHandler,\n  allowCrossDomainAsyncExecute,\n  handleIdempotency,\n  catch404Handler,\n} from './middleware';\nimport {guineaPig, guineaPigScrollable, guineaPigAppBanner, welcome, STATIC_DIR} from './static';\nimport {produceError, produceCrash} from './crash';\nimport {\n  addWebSocketHandler,\n  removeWebSocketHandler,\n  removeAllWebSocketHandlers,\n  getWebSocketHandlers,\n} from './websocket';\nimport B from 'bluebird';\nimport {DEFAULT_BASE_PATH} from '../constants';\nimport {EventEmitter} from 'events';\n\nconst KEEP_ALIVE_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes\n\n/**\n *\n * @param {ServerOpts} opts\n * @returns {Promise<AppiumServer>}\n */\nasync function server(opts) {\n  const {\n    routeConfiguringFunction,\n    port,\n    hostname,\n    allowCors = true,\n    basePath = DEFAULT_BASE_PATH,\n    extraMethodMap = {},\n    serverUpdaters = [],\n    keepAliveTimeout = KEEP_ALIVE_TIMEOUT_MS,\n  } = opts;\n\n  // create the actual http server\n  const app = express();\n  const httpServer = http.createServer(app);\n  return await new B(async (resolve, reject) => {\n    // we put an async function as the promise constructor because we want some things to happen in\n    // serial (application of plugin updates, for example). But we still need to use a promise here\n    // because some elements of server start failure only happen in httpServer listeners. So the\n    // way we resolve it is to use an async function here but to wrap all the inner logic in\n    // try/catch so any errors can be passed to reject.\n    try {\n      const appiumServer = configureHttp({\n        httpServer,\n        reject,\n        keepAliveTimeout,\n      });\n      configureServer({\n        app,\n        addRoutes: routeConfiguringFunction,\n        allowCors,\n        basePath,\n        extraMethodMap,\n      });\n      // allow extensions to update the app and http server objects\n      for (const updater of serverUpdaters) {\n        await updater(app, appiumServer);\n      }\n\n      // once all configurations and updaters have been applied, make sure to set up a catchall\n      // handler so that anything unknown 404s. But do this after everything else since we don't\n      // want to block extensions' ability to add routes if they want.\n      app.all('*', catch404Handler);\n\n      await startServer({httpServer, hostname, port, keepAliveTimeout});\n\n      resolve(appiumServer);\n    } catch (err) {\n      reject(err);\n    }\n  });\n}\n\n/**\n * Sets up some Express middleware and stuff\n * @param {ConfigureServerOpts} opts\n */\nfunction configureServer({\n  app,\n  addRoutes,\n  allowCors = true,\n  basePath = DEFAULT_BASE_PATH,\n  extraMethodMap = {},\n}) {\n  basePath = normalizeBasePath(basePath);\n\n  app.use(endLogFormatter);\n\n  // set up static assets\n  app.use(favicon(path.resolve(STATIC_DIR, 'favicon.ico')));\n  app.use(express.static(STATIC_DIR));\n\n  // crash routes, for testing\n  app.use(`${basePath}/produce_error`, produceError);\n  app.use(`${basePath}/crash`, produceCrash);\n\n  // add middlewares\n  if (allowCors) {\n    app.use(allowCrossDomain);\n  } else {\n    app.use(allowCrossDomainAsyncExecute(basePath));\n  }\n  app.use(handleIdempotency);\n  app.use(fixPythonContentType(basePath));\n  app.use(defaultToJSONContentType);\n  app.use(bodyParser.urlencoded({extended: true}));\n  app.use(methodOverride());\n  app.use(catchAllHandler);\n\n  // make sure appium never fails because of a file size upload limit\n  app.use(bodyParser.json({limit: '1gb'}));\n\n  // set up start logging (which depends on bodyParser doing its thing)\n  app.use(startLogFormatter);\n\n  addRoutes(app, {basePath, extraMethodMap});\n\n  // dynamic routes for testing, etc.\n  app.all('/welcome', welcome);\n  app.all('/test/guinea-pig', guineaPig);\n  app.all('/test/guinea-pig-scrollable', guineaPigScrollable);\n  app.all('/test/guinea-pig-app-banner', guineaPigAppBanner);\n}\n\n/**\n * Monkeypatches the `http.Server` instance and returns a {@linkcode AppiumServer}.\n * This function _mutates_ the `httpServer` parameter.\n * @param {ConfigureHttpOpts} opts\n * @returns {AppiumServer}\n */\nfunction configureHttp({httpServer, reject, keepAliveTimeout}) {\n  const serverState = {\n    notifier: new EventEmitter(),\n    closed: false,\n  };\n  // TS does not love monkeypatching.\n  const appiumServer = /** @type {AppiumServer} */ (/** @type {unknown} */ (httpServer));\n  appiumServer.addWebSocketHandler = addWebSocketHandler;\n  appiumServer.removeWebSocketHandler = removeWebSocketHandler;\n  appiumServer.removeAllWebSocketHandlers = removeAllWebSocketHandlers;\n  appiumServer.getWebSocketHandlers = getWebSocketHandlers;\n\n  // http.Server.close() only stops new connections, but we need to wait until\n  // all connections are closed and the `close` event is emitted\n  const close = appiumServer.close.bind(appiumServer);\n  appiumServer.close = async () =>\n    await new B((resolve, reject) => {\n      // https://github.com/nodejs/node-v0.x-archive/issues/9066#issuecomment-124210576\n      serverState.closed = true;\n      serverState.notifier.emit('shutdown');\n      log.info('Waiting until the server is closed');\n      httpServer.on('close', () => {\n        log.info('Received server close event');\n        resolve();\n      });\n      close((err) => {\n        if (err) reject(err); // eslint-disable-line curly\n      });\n    });\n\n  appiumServer.on(\n    'error',\n    /** @param {NodeJS.ErrnoException} err */ (err) => {\n      if (err.code === 'EADDRNOTAVAIL') {\n        log.error(\n          'Could not start REST http interface listener. ' + 'Requested address is not available.'\n        );\n      } else {\n        log.error(\n          'Could not start REST http interface listener. The requested ' +\n            'port may already be in use. Please make sure there is no ' +\n            'other instance of this server running already.'\n        );\n      }\n      reject(err);\n    }\n  );\n\n  appiumServer.on(\n    'connection',\n    /** @param {AppiumServerSocket} socket */ (socket) => {\n      socket.setTimeout(keepAliveTimeout);\n      socket.on('error', reject);\n\n      function destroy() {\n        socket.destroy();\n      }\n      socket._openReqCount = 0;\n      socket.once('close', () => serverState.notifier.removeListener('shutdown', destroy));\n      serverState.notifier.once('shutdown', destroy);\n    }\n  );\n\n  appiumServer.on('request', function (req, res) {\n    const socket = /** @type {AppiumServerSocket} */ (req.connection || req.socket);\n    socket._openReqCount++;\n    res.on('finish', function () {\n      socket._openReqCount--;\n      if (serverState.closed && socket._openReqCount === 0) {\n        socket.destroy();\n      }\n    });\n  });\n\n  return appiumServer;\n}\n\n/**\n * Starts an {@linkcode AppiumServer}\n * @param {StartServerOpts} opts\n * @returns {Promise<void>}\n */\nasync function startServer({httpServer, port, hostname, keepAliveTimeout}) {\n  // If the hostname is omitted, the server will accept\n  // connections on any IP address\n  /** @type {(port: number, hostname?: string) => B<http.Server>} */\n  const start = B.promisify(httpServer.listen, {context: httpServer});\n  const startPromise = start(port, hostname);\n  httpServer.keepAliveTimeout = keepAliveTimeout;\n  // headers timeout must be greater than keepAliveTimeout\n  httpServer.headersTimeout = keepAliveTimeout + 5 * 1000;\n  await startPromise;\n}\n\n/**\n * Normalize base path string\n * @param {string} basePath\n * @returns {string}\n */\nfunction normalizeBasePath(basePath) {\n  if (!_.isString(basePath)) {\n    throw new Error(`Invalid path prefix ${basePath}`);\n  }\n\n  // ensure the path prefix does not end in '/', since our method map\n  // starts all paths with '/'\n  basePath = basePath.replace(/\\/$/, '');\n\n  // likewise, ensure the path prefix does always START with /, unless the path\n  // is empty meaning no base path at all\n  if (basePath !== '' && basePath[0] !== '/') {\n    basePath = `/${basePath}`;\n  }\n\n  return basePath;\n}\n\nexport {server, configureServer, normalizeBasePath};\n\n/**\n * Options for {@linkcode startServer}.\n * @typedef StartServerOpts\n * @property {import('http').Server} httpServer - HTTP server instance\n * @property {number} port - Port to run on\n * @property {number} keepAliveTimeout - Keep-alive timeout in milliseconds\n * @property {string} [hostname] - Optional hostname\n */\n\n/**\n * @typedef {import('@appium/types').AppiumServer} AppiumServer\n * @typedef {import('@appium/types').AppiumServerSocket} AppiumServerSocket\n * @typedef {import('@appium/types').MethodMap} MethodMap\n */\n\n/**\n * Options for {@linkcode configureHttp}\n * @typedef ConfigureHttpOpts\n * @property {import('http').Server} httpServer - HTTP server instance\n * @property {(error?: any) => void} reject - Rejection function from `Promise` constructor\n * @property {number} keepAliveTimeout - Keep-alive timeout in milliseconds\n */\n\n/**\n * Options for {@linkcode server}\n * @typedef ServerOpts\n * @property {RouteConfiguringFunction} routeConfiguringFunction\n * @property {number} port\n * @property {string} [hostname]\n * @property {boolean} [allowCors]\n * @property {string} [basePath]\n * @property {MethodMap} [extraMethodMap]\n * @property {import('@appium/types').UpdateServerCallback[]} [serverUpdaters]\n * @property {number} [keepAliveTimeout]\n */\n\n/**\n * A function which configures routes\n * @callback RouteConfiguringFunction\n * @param {import('express').Express} app\n * @param {RouteConfiguringFunctionOpts} [opts]\n * @returns {void}\n */\n\n/**\n * Options for a {@linkcode RouteConfiguringFunction}\n * @typedef RouteConfiguringFunctionOpts\n * @property {string} [basePath]\n * @property {MethodMap} [extraMethodMap]\n */\n\n/**\n * Options for {@linkcode configureServer}\n * @typedef ConfigureServerOpts\n * @property {import('express').Express} app\n * @property {RouteConfiguringFunction} addRoutes\n * @property {boolean} [allowCors]\n * @property {string} [basePath]\n * @property {MethodMap} [extraMethodMap]\n */\n"],"mappings":";;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AASA;;AACA;;AACA;;AAMA;;AACA;;AACA;;AAEA,MAAMA,qBAAqB,GAAG,KAAK,EAAL,GAAU,IAAxC;;AAOA,eAAeC,MAAf,CAAsBC,IAAtB,EAA4B;EAC1B,MAAM;IACJC,wBADI;IAEJC,IAFI;IAGJC,QAHI;IAIJC,SAAS,GAAG,IAJR;IAKJC,QAAQ,GAAGC,4BALP;IAMJC,cAAc,GAAG,EANb;IAOJC,cAAc,GAAG,EAPb;IAQJC,gBAAgB,GAAGX;EARf,IASFE,IATJ;EAYA,MAAMU,GAAG,GAAG,IAAAC,gBAAA,GAAZ;;EACA,MAAMC,UAAU,GAAGC,aAAA,CAAKC,YAAL,CAAkBJ,GAAlB,CAAnB;;EACA,OAAO,MAAM,IAAIK,iBAAJ,CAAM,OAAOC,OAAP,EAAgBC,MAAhB,KAA2B;IAM5C,IAAI;MACF,MAAMC,YAAY,GAAGC,aAAa,CAAC;QACjCP,UADiC;QAEjCK,MAFiC;QAGjCR;MAHiC,CAAD,CAAlC;MAKAW,eAAe,CAAC;QACdV,GADc;QAEdW,SAAS,EAAEpB,wBAFG;QAGdG,SAHc;QAIdC,QAJc;QAKdE;MALc,CAAD,CAAf;;MAQA,KAAK,MAAMe,OAAX,IAAsBd,cAAtB,EAAsC;QACpC,MAAMc,OAAO,CAACZ,GAAD,EAAMQ,YAAN,CAAb;MACD;;MAKDR,GAAG,CAACa,GAAJ,CAAQ,GAAR,EAAaC,2BAAb;MAEA,MAAMC,WAAW,CAAC;QAACb,UAAD;QAAaT,QAAb;QAAuBD,IAAvB;QAA6BO;MAA7B,CAAD,CAAjB;MAEAO,OAAO,CAACE,YAAD,CAAP;IACD,CA1BD,CA0BE,OAAOQ,GAAP,EAAY;MACZT,MAAM,CAACS,GAAD,CAAN;IACD;EACF,CAnCY,CAAb;AAoCD;;AAMD,SAASN,eAAT,CAAyB;EACvBV,GADuB;EAEvBW,SAFuB;EAGvBjB,SAAS,GAAG,IAHW;EAIvBC,QAAQ,GAAGC,4BAJY;EAKvBC,cAAc,GAAG;AALM,CAAzB,EAMG;EACDF,QAAQ,GAAGsB,iBAAiB,CAACtB,QAAD,CAA5B;EAEAK,GAAG,CAACkB,GAAJ,CAAQC,+BAAR;EAGAnB,GAAG,CAACkB,GAAJ,CAAQ,IAAAE,qBAAA,EAAQC,aAAA,CAAKf,OAAL,CAAagB,kBAAb,EAAyB,aAAzB,CAAR,CAAR;EACAtB,GAAG,CAACkB,GAAJ,CAAQjB,gBAAA,CAAQsB,MAAR,CAAeD,kBAAf,CAAR;EAGAtB,GAAG,CAACkB,GAAJ,CAAS,GAAEvB,QAAS,gBAApB,EAAqC6B,mBAArC;EACAxB,GAAG,CAACkB,GAAJ,CAAS,GAAEvB,QAAS,QAApB,EAA6B8B,mBAA7B;;EAGA,IAAI/B,SAAJ,EAAe;IACbM,GAAG,CAACkB,GAAJ,CAAQQ,4BAAR;EACD,CAFD,MAEO;IACL1B,GAAG,CAACkB,GAAJ,CAAQ,IAAAS,wCAAA,EAA6BhC,QAA7B,CAAR;EACD;;EACDK,GAAG,CAACkB,GAAJ,CAAQU,6BAAR;EACA5B,GAAG,CAACkB,GAAJ,CAAQ,IAAAW,gCAAA,EAAqBlC,QAArB,CAAR;EACAK,GAAG,CAACkB,GAAJ,CAAQY,oCAAR;EACA9B,GAAG,CAACkB,GAAJ,CAAQa,mBAAA,CAAWC,UAAX,CAAsB;IAACC,QAAQ,EAAE;EAAX,CAAtB,CAAR;EACAjC,GAAG,CAACkB,GAAJ,CAAQ,IAAAgB,uBAAA,GAAR;EACAlC,GAAG,CAACkB,GAAJ,CAAQiB,2BAAR;EAGAnC,GAAG,CAACkB,GAAJ,CAAQa,mBAAA,CAAWK,IAAX,CAAgB;IAACC,KAAK,EAAE;EAAR,CAAhB,CAAR;EAGArC,GAAG,CAACkB,GAAJ,CAAQoB,iCAAR;EAEA3B,SAAS,CAACX,GAAD,EAAM;IAACL,QAAD;IAAWE;EAAX,CAAN,CAAT;EAGAG,GAAG,CAACa,GAAJ,CAAQ,UAAR,EAAoB0B,eAApB;EACAvC,GAAG,CAACa,GAAJ,CAAQ,kBAAR,EAA4B2B,iBAA5B;EACAxC,GAAG,CAACa,GAAJ,CAAQ,6BAAR,EAAuC4B,2BAAvC;EACAzC,GAAG,CAACa,GAAJ,CAAQ,6BAAR,EAAuC6B,0BAAvC;AACD;;AAQD,SAASjC,aAAT,CAAuB;EAACP,UAAD;EAAaK,MAAb;EAAqBR;AAArB,CAAvB,EAA+D;EAC7D,MAAM4C,WAAW,GAAG;IAClBC,QAAQ,EAAE,IAAIC,oBAAJ,EADQ;IAElBC,MAAM,EAAE;EAFU,CAApB;EAKA,MAAMtC,YAAY,GAAwDN,UAA1E;EACAM,YAAY,CAACuC,mBAAb,GAAmCA,8BAAnC;EACAvC,YAAY,CAACwC,sBAAb,GAAsCA,iCAAtC;EACAxC,YAAY,CAACyC,0BAAb,GAA0CA,qCAA1C;EACAzC,YAAY,CAAC0C,oBAAb,GAAoCA,+BAApC;EAIA,MAAMC,KAAK,GAAG3C,YAAY,CAAC2C,KAAb,CAAmBC,IAAnB,CAAwB5C,YAAxB,CAAd;;EACAA,YAAY,CAAC2C,KAAb,GAAqB,YACnB,MAAM,IAAI9C,iBAAJ,CAAM,CAACC,OAAD,EAAUC,MAAV,KAAqB;IAE/BoC,WAAW,CAACG,MAAZ,GAAqB,IAArB;IACAH,WAAW,CAACC,QAAZ,CAAqBS,IAArB,CAA0B,UAA1B;;IACAC,eAAA,CAAIC,IAAJ,CAAS,oCAAT;;IACArD,UAAU,CAACsD,EAAX,CAAc,OAAd,EAAuB,MAAM;MAC3BF,eAAA,CAAIC,IAAJ,CAAS,6BAAT;;MACAjD,OAAO;IACR,CAHD;IAIA6C,KAAK,CAAEnC,GAAD,IAAS;MACb,IAAIA,GAAJ,EAAST,MAAM,CAACS,GAAD,CAAN;IACV,CAFI,CAAL;EAGD,CAZK,CADR;;EAeAR,YAAY,CAACgD,EAAb,CACE,OADF,EAE6CxC,GAAD,IAAS;IACjD,IAAIA,GAAG,CAACyC,IAAJ,KAAa,eAAjB,EAAkC;MAChCH,eAAA,CAAII,KAAJ,CACE,mDAAmD,qCADrD;IAGD,CAJD,MAIO;MACLJ,eAAA,CAAII,KAAJ,CACE,iEACE,2DADF,GAEE,gDAHJ;IAKD;;IACDnD,MAAM,CAACS,GAAD,CAAN;EACD,CAfH;EAkBAR,YAAY,CAACgD,EAAb,CACE,YADF,EAE6CG,MAAD,IAAY;IACpDA,MAAM,CAACC,UAAP,CAAkB7D,gBAAlB;IACA4D,MAAM,CAACH,EAAP,CAAU,OAAV,EAAmBjD,MAAnB;;IAEA,SAASsD,OAAT,GAAmB;MACjBF,MAAM,CAACE,OAAP;IACD;;IACDF,MAAM,CAACG,aAAP,GAAuB,CAAvB;IACAH,MAAM,CAACI,IAAP,CAAY,OAAZ,EAAqB,MAAMpB,WAAW,CAACC,QAAZ,CAAqBoB,cAArB,CAAoC,UAApC,EAAgDH,OAAhD,CAA3B;IACAlB,WAAW,CAACC,QAAZ,CAAqBmB,IAArB,CAA0B,UAA1B,EAAsCF,OAAtC;EACD,CAZH;EAeArD,YAAY,CAACgD,EAAb,CAAgB,SAAhB,EAA2B,UAAUS,GAAV,EAAeC,GAAf,EAAoB;IAC7C,MAAMP,MAAM,GAAsCM,GAAG,CAACE,UAAJ,IAAkBF,GAAG,CAACN,MAAxE;IACAA,MAAM,CAACG,aAAP;IACAI,GAAG,CAACV,EAAJ,CAAO,QAAP,EAAiB,YAAY;MAC3BG,MAAM,CAACG,aAAP;;MACA,IAAInB,WAAW,CAACG,MAAZ,IAAsBa,MAAM,CAACG,aAAP,KAAyB,CAAnD,EAAsD;QACpDH,MAAM,CAACE,OAAP;MACD;IACF,CALD;EAMD,CATD;EAWA,OAAOrD,YAAP;AACD;;AAOD,eAAeO,WAAf,CAA2B;EAACb,UAAD;EAAaV,IAAb;EAAmBC,QAAnB;EAA6BM;AAA7B,CAA3B,EAA2E;EAIzE,MAAMqE,KAAK,GAAG/D,iBAAA,CAAEgE,SAAF,CAAYnE,UAAU,CAACoE,MAAvB,EAA+B;IAACC,OAAO,EAAErE;EAAV,CAA/B,CAAd;;EACA,MAAMsE,YAAY,GAAGJ,KAAK,CAAC5E,IAAD,EAAOC,QAAP,CAA1B;EACAS,UAAU,CAACH,gBAAX,GAA8BA,gBAA9B;EAEAG,UAAU,CAACuE,cAAX,GAA4B1E,gBAAgB,GAAG,IAAI,IAAnD;EACA,MAAMyE,YAAN;AACD;;AAOD,SAASvD,iBAAT,CAA2BtB,QAA3B,EAAqC;EACnC,IAAI,CAAC+E,eAAA,CAAEC,QAAF,CAAWhF,QAAX,CAAL,EAA2B;IACzB,MAAM,IAAIiF,KAAJ,CAAW,uBAAsBjF,QAAS,EAA1C,CAAN;EACD;;EAIDA,QAAQ,GAAGA,QAAQ,CAACkF,OAAT,CAAiB,KAAjB,EAAwB,EAAxB,CAAX;;EAIA,IAAIlF,QAAQ,KAAK,EAAb,IAAmBA,QAAQ,CAAC,CAAD,CAAR,KAAgB,GAAvC,EAA4C;IAC1CA,QAAQ,GAAI,IAAGA,QAAS,EAAxB;EACD;;EAED,OAAOA,QAAP;AACD"}

package/build/lib/express/websocket.d.ts

@@ -1,67 +1,49 @@
-export type WebSocketServer = import('http').Server & {
-    webSocketsMapping: Record<string, import('ws').Server>;
-};
+export type AppiumServer = import('@appium/types').AppiumServer;
 /**
  * Adds websocket handler to express server instance.
  * It is expected this function is called in Express
  * server instance context.
  *
- * @this {WebSocketServer} - An instance of express HTTP server.
+ * @this {AppiumServer} - An instance of express HTTP server.
  * @param {string} handlerPathname - Web socket endpoint path starting with
  * a single slash character. It is recommended to always add
  * DEFAULT_WS_PATHNAME_PREFIX to all web socket pathnames.
- * @param {Object} handlerServer - WebSocket server instance. See
+ * @param {import('ws').Server} handlerServer - WebSocket server instance. See
  * https://github.com/websockets/ws/pull/885 for more details
  * on how to configure the handler properly.
+ * @returns {Promise<void>}
  */
-export function addWebSocketHandler(this: WebSocketServer, handlerPathname: string, handlerServer: any): Promise<void>;
-export class addWebSocketHandler {
-    /**
-     * Adds websocket handler to express server instance.
-     * It is expected this function is called in Express
-     * server instance context.
-     *
-     * @this {WebSocketServer} - An instance of express HTTP server.
-     * @param {string} handlerPathname - Web socket endpoint path starting with
-     * a single slash character. It is recommended to always add
-     * DEFAULT_WS_PATHNAME_PREFIX to all web socket pathnames.
-     * @param {Object} handlerServer - WebSocket server instance. See
-     * https://github.com/websockets/ws/pull/885 for more details
-     * on how to configure the handler properly.
-     */
-    constructor(this: WebSocketServer, handlerPathname: string, handlerServer: any);
-    webSocketsMapping: {};
-}
+export function addWebSocketHandler(this: import("@appium/types").AppiumServer, handlerPathname: string, handlerServer: import('ws').Server): Promise<void>;
 /**
  * Removes existing websocket handler from express server instance.
  * The call is ignored if the given `handlerPathname` handler
  * is not present in the handlers list.
  * It is expected this function is called in Express
  * server instance context.
- *
+ * @this {AppiumServer}
  * @param {string} handlerPathname - Websocket endpoint path.
  * @returns {Promise<boolean>} true if the handlerPathname was found and deleted
  */
-export function removeWebSocketHandler(handlerPathname: string): Promise<boolean>;
+export function removeWebSocketHandler(this: import("@appium/types").AppiumServer, handlerPathname: string): Promise<boolean>;
 /**
  * Removes all existing websocket handler from express server instance.
  * It is expected this function is called in Express
  * server instance context.
- *
+ * @this {AppiumServer}
  * @returns {Promise<boolean>} true if at least one handler has been deleted
  */
-export function removeAllWebSocketHandlers(): Promise<boolean>;
+export function removeAllWebSocketHandlers(this: import("@appium/types").AppiumServer): Promise<boolean>;
 /**
  * Returns web socket handlers registered for the given server
  * instance.
  * It is expected this function is called in Express
  * server instance context.
  *
+ * @this {AppiumServer}
  * @param {string?} [keysFilter] - Only include pathnames with given
  * `keysFilter` value if set. All pairs will be included by default.
- * @returns {Promise<Object>} pathnames to websocket server isntances mapping
- * matching the search criteria or an empty object otherwise.
+ * @returns {Promise<Record<string, import('ws').Server>>} pathnames to websocket server instances mapping matching the search criteria or an empty object otherwise.
  */
-export function getWebSocketHandlers(keysFilter?: string | null | undefined): Promise<any>;
+export function getWebSocketHandlers(this: import("@appium/types").AppiumServer, keysFilter?: string | null | undefined): Promise<Record<string, import('ws').Server>>;
 export const DEFAULT_WS_PATHNAME_PREFIX: "/ws";
 //# sourceMappingURL=websocket.d.ts.map

package/build/lib/express/websocket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../../lib/express/websocket.js"],"names":[],"mappings":"8BAkIa,OAAO,MAAM,EAAE,MAAM,GAAG;IAAC,iBAAiB,EAAE,OAAO,MAAM,EAAC,OAAO,IAAI,EAAE,MAAM,CAAC,CAAA;CAAC;AA5H5F;;;;;;;;;;;;GAYG;AAEH,4EARW,MAAM,qCAgChB;;IAtCD;;;;;;;;;;;;OAYG;IAEH,oDARW,MAAM,sBAgChB;IAtBG,sBAA2B;;AAiD/B;;;;;;;;;GASG;AAEH,wDAJW,MAAM,GACJ,QAAQ,OAAO,CAAC,CAqB5B;AAED;;;;;;GAMG;AACH,8CAFa,QAAQ,OAAO,CAAC,CAY5B;AAzED;;;;;;;;;;GAUG;AAEH,8EAJa,YAAe,CAe3B;AAjED,+CAAyC"}
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../../lib/express/websocket.js"],"names":[],"mappings":"2BAoIa,OAAO,eAAe,EAAE,YAAY;AA7HjD;;;;;;;;;;;;;GAaG;AACH,iGARW,MAAM,iBAGN,OAAO,IAAI,EAAE,MAAM,GAGjB,QAAQ,IAAI,CAAC,CA2BzB;AA2BD;;;;;;;;;GASG;AAEH,oGAJW,MAAM,GACJ,QAAQ,OAAO,CAAC,CAqB5B;AAED;;;;;;GAMG;AACH,wFAFa,QAAQ,OAAO,CAAC,CAY5B;AAzED;;;;;;;;;;GAUG;AAEH,0HAHa,QAAQ,OAAO,MAAM,EAAE,OAAO,IAAI,EAAE,MAAM,CAAC,CAAC,CAcxD;AAlED,+CAAyC"}

package/build/lib/express/websocket.js

@@ -23,9 +23,11 @@ const DEFAULT_WS_PATHNAME_PREFIX = '/ws';
 exports.DEFAULT_WS_PATHNAME_PREFIX = DEFAULT_WS_PATHNAME_PREFIX;
 
 async function addWebSocketHandler(handlerPathname, handlerServer) {
+  const server = this;
+
   if (_lodash.default.isUndefined(this.webSocketsMapping)) {
-    this.webSocketsMapping = {};
-    this.on('upgrade', (request, socket, head) => {
+    server.webSocketsMapping = {};
+    server.on('upgrade', (request, socket, head) => {
       let currentPathname;
 
       try {
@@ -34,7 +36,7 @@ async function addWebSocketHandler(handlerPathname, handlerServer) {
         currentPathname = request.url;
       }
 
-      for (const [pathname, wsServer] of _lodash.default.toPairs(this.webSocketsMapping)) {
+      for (const [pathname, wsServer] of _lodash.default.toPairs(server.webSocketsMapping)) {
         if (currentPathname === pathname) {
           wsServer.handleUpgrade(request, socket, head, ws => {
             wsServer.emit('connection', ws, request);
@@ -95,4 +97,4 @@ async function removeAllWebSocketHandlers() {
 
   return _lodash.default.some(await _bluebird.default.all(_lodash.default.keys(this.webSocketsMapping).map(pathname => this.removeWebSocketHandler(pathname))));
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DEFAULT_WS_PATHNAME_PREFIX","addWebSocketHandler","handlerPathname","handlerServer","_","isUndefined","webSocketsMapping","on","request","socket","head","currentPathname","URL","url","pathname","wsServer","toPairs","handleUpgrade","ws","emit","destroy","getWebSocketHandlers","keysFilter","isEmpty","reduce","acc","isString","includes","removeWebSocketHandler","close","client","clients","terminate","ign","removeAllWebSocketHandlers","some","B","all","keys","map"],"sources":["../../../lib/express/websocket.js"],"sourcesContent":["import _ from 'lodash';\nimport {URL} from 'url';\nimport B from 'bluebird';\n\nconst DEFAULT_WS_PATHNAME_PREFIX = '/ws';\n\n/**\n * Adds websocket handler to express server instance.\n * It is expected this function is called in Express\n * server instance context.\n *\n * @this {WebSocketServer} - An instance of express HTTP server.\n * @param {string} handlerPathname - Web socket endpoint path starting with\n * a single slash character. It is recommended to always add\n * DEFAULT_WS_PATHNAME_PREFIX to all web socket pathnames.\n * @param {Object} handlerServer - WebSocket server instance. See\n * https://github.com/websockets/ws/pull/885 for more details\n * on how to configure the handler properly.\n */\n// eslint-disable-next-line require-await\nasync function addWebSocketHandler(handlerPathname, handlerServer) {\n  if (_.isUndefined(this.webSocketsMapping)) {\n    this.webSocketsMapping = {};\n    // https://github.com/websockets/ws/pull/885\n    this.on('upgrade', (request, socket, head) => {\n      let currentPathname;\n      try {\n        // @ts-expect-error\n        currentPathname = new URL(request.url).pathname;\n      } catch {\n        currentPathname = request.url;\n      }\n      for (const [pathname, wsServer] of _.toPairs(this.webSocketsMapping)) {\n        if (currentPathname === pathname) {\n          wsServer.handleUpgrade(request, socket, head, (ws) => {\n            wsServer.emit('connection', ws, request);\n          });\n          return;\n        }\n      }\n      socket.destroy();\n    });\n  }\n  this.webSocketsMapping[handlerPathname] = handlerServer;\n}\n\n/**\n * Returns web socket handlers registered for the given server\n * instance.\n * It is expected this function is called in Express\n * server instance context.\n *\n * @param {string?} [keysFilter] - Only include pathnames with given\n * `keysFilter` value if set. All pairs will be included by default.\n * @returns {Promise<Object>} pathnames to websocket server isntances mapping\n * matching the search criteria or an empty object otherwise.\n */\n// eslint-disable-next-line require-await\nasync function getWebSocketHandlers(keysFilter = null) {\n  if (_.isEmpty(this.webSocketsMapping)) {\n    return {};\n  }\n\n  return _.toPairs(this.webSocketsMapping).reduce((acc, [pathname, wsServer]) => {\n    if (!_.isString(keysFilter) || pathname.includes(keysFilter)) {\n      acc[pathname] = wsServer;\n    }\n    return acc;\n  }, {});\n}\n\n/**\n * Removes existing websocket handler from express server instance.\n * The call is ignored if the given `handlerPathname` handler\n * is not present in the handlers list.\n * It is expected this function is called in Express\n * server instance context.\n *\n * @param {string} handlerPathname - Websocket endpoint path.\n * @returns {Promise<boolean>} true if the handlerPathname was found and deleted\n */\n// eslint-disable-next-line require-await\nasync function removeWebSocketHandler(handlerPathname) {\n  const wsServer = this.webSocketsMapping?.[handlerPathname];\n  if (!wsServer) {\n    return false;\n  }\n\n  try {\n    wsServer.close();\n    for (const client of wsServer.clients || []) {\n      client.terminate();\n    }\n    return true;\n  } catch (ign) {\n    // ignore\n  } finally {\n    delete this.webSocketsMapping[handlerPathname];\n  }\n  return false;\n}\n\n/**\n * Removes all existing websocket handler from express server instance.\n * It is expected this function is called in Express\n * server instance context.\n *\n * @returns {Promise<boolean>} true if at least one handler has been deleted\n */\nasync function removeAllWebSocketHandlers() {\n  if (_.isEmpty(this.webSocketsMapping)) {\n    return false;\n  }\n\n  return _.some(\n    await B.all(\n      _.keys(this.webSocketsMapping).map((pathname) => this.removeWebSocketHandler(pathname))\n    )\n  );\n}\n\nexport {\n  addWebSocketHandler,\n  removeWebSocketHandler,\n  removeAllWebSocketHandlers,\n  getWebSocketHandlers,\n  DEFAULT_WS_PATHNAME_PREFIX,\n};\n\n/**\n * @typedef {import('http').Server & {webSocketsMapping: Record<string,import('ws').Server>}} WebSocketServer\n */\n"],"mappings":";;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AAEA,MAAMA,0BAA0B,GAAG,KAAnC;;;AAgBA,eAAeC,mBAAf,CAAmCC,eAAnC,EAAoDC,aAApD,EAAmE;EACjE,IAAIC,eAAA,CAAEC,WAAF,CAAc,KAAKC,iBAAnB,CAAJ,EAA2C;IACzC,KAAKA,iBAAL,GAAyB,EAAzB;IAEA,KAAKC,EAAL,CAAQ,SAAR,EAAmB,CAACC,OAAD,EAAUC,MAAV,EAAkBC,IAAlB,KAA2B;MAC5C,IAAIC,eAAJ;;MACA,IAAI;QAEFA,eAAe,GAAG,IAAIC,QAAJ,CAAQJ,OAAO,CAACK,GAAhB,EAAqBC,QAAvC;MACD,CAHD,CAGE,MAAM;QACNH,eAAe,GAAGH,OAAO,CAACK,GAA1B;MACD;;MACD,KAAK,MAAM,CAACC,QAAD,EAAWC,QAAX,CAAX,IAAmCX,eAAA,CAAEY,OAAF,CAAU,KAAKV,iBAAf,CAAnC,EAAsE;QACpE,IAAIK,eAAe,KAAKG,QAAxB,EAAkC;UAChCC,QAAQ,CAACE,aAAT,CAAuBT,OAAvB,EAAgCC,MAAhC,EAAwCC,IAAxC,EAA+CQ,EAAD,IAAQ;YACpDH,QAAQ,CAACI,IAAT,CAAc,YAAd,EAA4BD,EAA5B,EAAgCV,OAAhC;UACD,CAFD;UAGA;QACD;MACF;;MACDC,MAAM,CAACW,OAAP;IACD,CAjBD;EAkBD;;EACD,KAAKd,iBAAL,CAAuBJ,eAAvB,IAA0CC,aAA1C;AACD;;AAcD,eAAekB,oBAAf,CAAoCC,UAAU,GAAG,IAAjD,EAAuD;EACrD,IAAIlB,eAAA,CAAEmB,OAAF,CAAU,KAAKjB,iBAAf,CAAJ,EAAuC;IACrC,OAAO,EAAP;EACD;;EAED,OAAOF,eAAA,CAAEY,OAAF,CAAU,KAAKV,iBAAf,EAAkCkB,MAAlC,CAAyC,CAACC,GAAD,EAAM,CAACX,QAAD,EAAWC,QAAX,CAAN,KAA+B;IAC7E,IAAI,CAACX,eAAA,CAAEsB,QAAF,CAAWJ,UAAX,CAAD,IAA2BR,QAAQ,CAACa,QAAT,CAAkBL,UAAlB,CAA/B,EAA8D;MAC5DG,GAAG,CAACX,QAAD,CAAH,GAAgBC,QAAhB;IACD;;IACD,OAAOU,GAAP;EACD,CALM,EAKJ,EALI,CAAP;AAMD;;AAaD,eAAeG,sBAAf,CAAsC1B,eAAtC,EAAuD;EAAA;;EACrD,MAAMa,QAAQ,4BAAG,KAAKT,iBAAR,0DAAG,sBAAyBJ,eAAzB,CAAjB;;EACA,IAAI,CAACa,QAAL,EAAe;IACb,OAAO,KAAP;EACD;;EAED,IAAI;IACFA,QAAQ,CAACc,KAAT;;IACA,KAAK,MAAMC,MAAX,IAAqBf,QAAQ,CAACgB,OAAT,IAAoB,EAAzC,EAA6C;MAC3CD,MAAM,CAACE,SAAP;IACD;;IACD,OAAO,IAAP;EACD,CAND,CAME,OAAOC,GAAP,EAAY,CAEb,CARD,SAQU;IACR,OAAO,KAAK3B,iBAAL,CAAuBJ,eAAvB,CAAP;EACD;;EACD,OAAO,KAAP;AACD;;AASD,eAAegC,0BAAf,GAA4C;EAC1C,IAAI9B,eAAA,CAAEmB,OAAF,CAAU,KAAKjB,iBAAf,CAAJ,EAAuC;IACrC,OAAO,KAAP;EACD;;EAED,OAAOF,eAAA,CAAE+B,IAAF,CACL,MAAMC,iBAAA,CAAEC,GAAF,CACJjC,eAAA,CAAEkC,IAAF,CAAO,KAAKhC,iBAAZ,EAA+BiC,GAA/B,CAAoCzB,QAAD,IAAc,KAAKc,sBAAL,CAA4Bd,QAA5B,CAAjD,CADI,CADD,CAAP;AAKD"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["DEFAULT_WS_PATHNAME_PREFIX","addWebSocketHandler","handlerPathname","handlerServer","server","_","isUndefined","webSocketsMapping","on","request","socket","head","currentPathname","URL","url","pathname","wsServer","toPairs","handleUpgrade","ws","emit","destroy","getWebSocketHandlers","keysFilter","isEmpty","reduce","acc","isString","includes","removeWebSocketHandler","close","client","clients","terminate","ign","removeAllWebSocketHandlers","some","B","all","keys","map"],"sources":["../../../lib/express/websocket.js"],"sourcesContent":["/* eslint-disable require-await */\nimport _ from 'lodash';\nimport {URL} from 'url';\nimport B from 'bluebird';\n\nconst DEFAULT_WS_PATHNAME_PREFIX = '/ws';\n\n/**\n * Adds websocket handler to express server instance.\n * It is expected this function is called in Express\n * server instance context.\n *\n * @this {AppiumServer} - An instance of express HTTP server.\n * @param {string} handlerPathname - Web socket endpoint path starting with\n * a single slash character. It is recommended to always add\n * DEFAULT_WS_PATHNAME_PREFIX to all web socket pathnames.\n * @param {import('ws').Server} handlerServer - WebSocket server instance. See\n * https://github.com/websockets/ws/pull/885 for more details\n * on how to configure the handler properly.\n * @returns {Promise<void>}\n */\nasync function addWebSocketHandler(handlerPathname, handlerServer) {\n  const server = /** @type {AppiumServer} */ (this);\n  if (_.isUndefined(this.webSocketsMapping)) {\n    server.webSocketsMapping = {};\n    // https://github.com/websockets/ws/pull/885\n    server.on('upgrade', (request, socket, head) => {\n      let currentPathname;\n      try {\n        // @ts-expect-error\n        currentPathname = new URL(request.url).pathname;\n      } catch {\n        currentPathname = request.url;\n      }\n      for (const [pathname, wsServer] of _.toPairs(server.webSocketsMapping)) {\n        if (currentPathname === pathname) {\n          wsServer.handleUpgrade(request, socket, head, (ws) => {\n            wsServer.emit('connection', ws, request);\n          });\n          return;\n        }\n      }\n      socket.destroy();\n    });\n  }\n  this.webSocketsMapping[handlerPathname] = handlerServer;\n}\n\n/**\n * Returns web socket handlers registered for the given server\n * instance.\n * It is expected this function is called in Express\n * server instance context.\n *\n * @this {AppiumServer}\n * @param {string?} [keysFilter] - Only include pathnames with given\n * `keysFilter` value if set. All pairs will be included by default.\n * @returns {Promise<Record<string, import('ws').Server>>} pathnames to websocket server instances mapping matching the search criteria or an empty object otherwise.\n */\n// eslint-disable-next-line require-await\nasync function getWebSocketHandlers(keysFilter = null) {\n  if (_.isEmpty(this.webSocketsMapping)) {\n    return {};\n  }\n\n  return _.toPairs(this.webSocketsMapping).reduce((acc, [pathname, wsServer]) => {\n    if (!_.isString(keysFilter) || pathname.includes(keysFilter)) {\n      acc[pathname] = wsServer;\n    }\n    return acc;\n  }, {});\n}\n\n/**\n * Removes existing websocket handler from express server instance.\n * The call is ignored if the given `handlerPathname` handler\n * is not present in the handlers list.\n * It is expected this function is called in Express\n * server instance context.\n * @this {AppiumServer}\n * @param {string} handlerPathname - Websocket endpoint path.\n * @returns {Promise<boolean>} true if the handlerPathname was found and deleted\n */\n// eslint-disable-next-line require-await\nasync function removeWebSocketHandler(handlerPathname) {\n  const wsServer = this.webSocketsMapping?.[handlerPathname];\n  if (!wsServer) {\n    return false;\n  }\n\n  try {\n    wsServer.close();\n    for (const client of wsServer.clients || []) {\n      client.terminate();\n    }\n    return true;\n  } catch (ign) {\n    // ignore\n  } finally {\n    delete this.webSocketsMapping[handlerPathname];\n  }\n  return false;\n}\n\n/**\n * Removes all existing websocket handler from express server instance.\n * It is expected this function is called in Express\n * server instance context.\n * @this {AppiumServer}\n * @returns {Promise<boolean>} true if at least one handler has been deleted\n */\nasync function removeAllWebSocketHandlers() {\n  if (_.isEmpty(this.webSocketsMapping)) {\n    return false;\n  }\n\n  return _.some(\n    await B.all(\n      _.keys(this.webSocketsMapping).map((pathname) => this.removeWebSocketHandler(pathname))\n    )\n  );\n}\n\nexport {\n  addWebSocketHandler,\n  removeWebSocketHandler,\n  removeAllWebSocketHandlers,\n  getWebSocketHandlers,\n  DEFAULT_WS_PATHNAME_PREFIX,\n};\n\n/**\n * @typedef {import('@appium/types').AppiumServer} AppiumServer\n */\n"],"mappings":";;;;;;;;;;;;;;;AACA;;AACA;;AACA;;AAEA,MAAMA,0BAA0B,GAAG,KAAnC;;;AAgBA,eAAeC,mBAAf,CAAmCC,eAAnC,EAAoDC,aAApD,EAAmE;EACjE,MAAMC,MAAM,GAAgC,IAA5C;;EACA,IAAIC,eAAA,CAAEC,WAAF,CAAc,KAAKC,iBAAnB,CAAJ,EAA2C;IACzCH,MAAM,CAACG,iBAAP,GAA2B,EAA3B;IAEAH,MAAM,CAACI,EAAP,CAAU,SAAV,EAAqB,CAACC,OAAD,EAAUC,MAAV,EAAkBC,IAAlB,KAA2B;MAC9C,IAAIC,eAAJ;;MACA,IAAI;QAEFA,eAAe,GAAG,IAAIC,QAAJ,CAAQJ,OAAO,CAACK,GAAhB,EAAqBC,QAAvC;MACD,CAHD,CAGE,MAAM;QACNH,eAAe,GAAGH,OAAO,CAACK,GAA1B;MACD;;MACD,KAAK,MAAM,CAACC,QAAD,EAAWC,QAAX,CAAX,IAAmCX,eAAA,CAAEY,OAAF,CAAUb,MAAM,CAACG,iBAAjB,CAAnC,EAAwE;QACtE,IAAIK,eAAe,KAAKG,QAAxB,EAAkC;UAChCC,QAAQ,CAACE,aAAT,CAAuBT,OAAvB,EAAgCC,MAAhC,EAAwCC,IAAxC,EAA+CQ,EAAD,IAAQ;YACpDH,QAAQ,CAACI,IAAT,CAAc,YAAd,EAA4BD,EAA5B,EAAgCV,OAAhC;UACD,CAFD;UAGA;QACD;MACF;;MACDC,MAAM,CAACW,OAAP;IACD,CAjBD;EAkBD;;EACD,KAAKd,iBAAL,CAAuBL,eAAvB,IAA0CC,aAA1C;AACD;;AAcD,eAAemB,oBAAf,CAAoCC,UAAU,GAAG,IAAjD,EAAuD;EACrD,IAAIlB,eAAA,CAAEmB,OAAF,CAAU,KAAKjB,iBAAf,CAAJ,EAAuC;IACrC,OAAO,EAAP;EACD;;EAED,OAAOF,eAAA,CAAEY,OAAF,CAAU,KAAKV,iBAAf,EAAkCkB,MAAlC,CAAyC,CAACC,GAAD,EAAM,CAACX,QAAD,EAAWC,QAAX,CAAN,KAA+B;IAC7E,IAAI,CAACX,eAAA,CAAEsB,QAAF,CAAWJ,UAAX,CAAD,IAA2BR,QAAQ,CAACa,QAAT,CAAkBL,UAAlB,CAA/B,EAA8D;MAC5DG,GAAG,CAACX,QAAD,CAAH,GAAgBC,QAAhB;IACD;;IACD,OAAOU,GAAP;EACD,CALM,EAKJ,EALI,CAAP;AAMD;;AAaD,eAAeG,sBAAf,CAAsC3B,eAAtC,EAAuD;EAAA;;EACrD,MAAMc,QAAQ,4BAAG,KAAKT,iBAAR,0DAAG,sBAAyBL,eAAzB,CAAjB;;EACA,IAAI,CAACc,QAAL,EAAe;IACb,OAAO,KAAP;EACD;;EAED,IAAI;IACFA,QAAQ,CAACc,KAAT;;IACA,KAAK,MAAMC,MAAX,IAAqBf,QAAQ,CAACgB,OAAT,IAAoB,EAAzC,EAA6C;MAC3CD,MAAM,CAACE,SAAP;IACD;;IACD,OAAO,IAAP;EACD,CAND,CAME,OAAOC,GAAP,EAAY,CAEb,CARD,SAQU;IACR,OAAO,KAAK3B,iBAAL,CAAuBL,eAAvB,CAAP;EACD;;EACD,OAAO,KAAP;AACD;;AASD,eAAeiC,0BAAf,GAA4C;EAC1C,IAAI9B,eAAA,CAAEmB,OAAF,CAAU,KAAKjB,iBAAf,CAAJ,EAAuC;IACrC,OAAO,KAAP;EACD;;EAED,OAAOF,eAAA,CAAE+B,IAAF,CACL,MAAMC,iBAAA,CAAEC,GAAF,CACJjC,eAAA,CAAEkC,IAAF,CAAO,KAAKhC,iBAAZ,EAA+BiC,GAA/B,CAAoCzB,QAAD,IAAc,KAAKc,sBAAL,CAA4Bd,QAA5B,CAAjD,CADI,CADD,CAAP;AAKD"}

package/build/lib/index.d.ts

@@ -1,184 +1,15 @@
 export { DriverCore } from "./basedriver/core";
+export { DeviceSettings } from "./basedriver/device-settings";
+export { BaseDriver };
 export default BaseDriver;
-export { PREFIXED_APPIUM_OPTS_CAP } from "./basedriver/capabilities";
+export * from "./protocol";
+export { errorFromMJSONWPStatusCode as errorFromCode } from "./protocol";
+export { STATIC_DIR } from "./express/static";
+export { JWProxy } from "./jsonwp-proxy/proxy";
+export { DEFAULT_WS_PATHNAME_PREFIX } from "./express/websocket";
 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("./protocol/routes").MethodMap;
-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 };
+export { DEFAULT_BASE_PATH, PROTOCOLS } from "./constants";
+export { server, normalizeBasePath } from "./express/server";
+export { getSummaryByCode, codes as statusCodes } from "./jsonwp-status/status";
+export { PREFIXED_APPIUM_OPTS_CAP, processCapabilities, isStandardCap, validateCaps } from "./basedriver/capabilities";
 //# sourceMappingURL=index.d.ts.map