webdriver 7.17.0 → 7.18.1

package/build/command.d.ts

@@ -0,0 +1,5 @@
+import type { CommandEndpoint } from '@wdio/protocols';
+import { WebDriverResponse } from './request';
+import { BaseClient } from './types';
+export default function (method: string, endpointUri: string, commandInfo: CommandEndpoint, doubleEncodeVariables?: boolean): (this: BaseClient, ...args: any[]) => Promise<WebDriverResponse>;
+//# sourceMappingURL=command.d.ts.map

package/build/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../src/command.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAGtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAIpC,MAAM,CAAC,OAAO,WACV,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,eAAe,EAC5B,qBAAqB,UAAQ,UAIU,UAAU,WAAW,GAAG,EAAE,KAAG,QAAQ,iBAAiB,CAAC,CA0FjG"}

package/build/command.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("@wdio/logger"));
+const utils_1 = require("@wdio/utils");
+const factory_1 = __importDefault(require("./request/factory"));
+const log = (0, logger_1.default)('webdriver');
+function default_1(method, endpointUri, commandInfo, doubleEncodeVariables = false) {
+    const { command, ref, parameters, variables = [], isHubCommand = false } = commandInfo;
+    return function protocolCommand(...args) {
+        let endpoint = endpointUri; // clone endpointUri in case we change it
+        const commandParams = [...variables.map((v) => Object.assign(v, {
+                /**
+                 * url variables are:
+                 */
+                required: true,
+                type: 'string' // have to be always type of string
+            })), ...parameters];
+        const commandUsage = `${command}(${commandParams.map((p) => p.name).join(', ')})`;
+        const moreInfo = `\n\nFor more info see ${ref}\n`;
+        const body = {};
+        /**
+         * parameter check
+         */
+        const minAllowedParams = commandParams.filter((param) => param.required).length;
+        if (args.length < minAllowedParams || args.length > commandParams.length) {
+            const parameterDescription = commandParams.length
+                ? `\n\nProperty Description:\n${commandParams.map((p) => `  "${p.name}" (${p.type}): ${p.description}`).join('\n')}`
+                : '';
+            throw new Error(`Wrong parameters applied for ${command}\n` +
+                `Usage: ${commandUsage}` +
+                parameterDescription +
+                moreInfo);
+        }
+        /**
+         * parameter type check
+         */
+        for (const [it, arg] of Object.entries(args)) {
+            const i = parseInt(it, 10);
+            const commandParam = commandParams[i];
+            if (!(0, utils_1.isValidParameter)(arg, commandParam.type)) {
+                /**
+                 * ignore if argument is not required
+                 */
+                if (typeof arg === 'undefined' && !commandParam.required) {
+                    continue;
+                }
+                const actual = commandParam.type.endsWith('[]')
+                    ? `(${(Array.isArray(arg) ? arg : [arg]).map((a) => (0, utils_1.getArgumentType)(a))})[]`
+                    : (0, utils_1.getArgumentType)(arg);
+                throw new Error(`Malformed type for "${commandParam.name}" parameter of command ${command}\n` +
+                    `Expected: ${commandParam.type}\n` +
+                    `Actual: ${actual}` +
+                    moreInfo);
+            }
+            /**
+             * inject url variables
+             */
+            if (i < variables.length) {
+                const encodedArg = doubleEncodeVariables ? encodeURIComponent(encodeURIComponent(arg)) : encodeURIComponent(arg);
+                endpoint = endpoint.replace(`:${commandParams[i].name}`, encodedArg);
+                continue;
+            }
+            /**
+             * rest of args are part of body payload
+             */
+            body[commandParams[i].name] = arg;
+        }
+        const request = factory_1.default.getInstance(method, endpoint, body, isHubCommand);
+        this.emit('command', { method, endpoint, body });
+        log.info('COMMAND', (0, utils_1.commandCallStructure)(command, args));
+        return request.makeRequest(this.options, this.sessionId).then((result) => {
+            if (result.value != null) {
+                log.info('RESULT', /screenshot|recording/i.test(command)
+                    && typeof result.value === 'string' && result.value.length > 64
+                    ? `${result.value.substr(0, 61)}...` : result.value);
+            }
+            this.emit('result', { method, endpoint, body, result });
+            if (command === 'deleteSession') {
+                logger_1.default.clearLogger();
+            }
+            return result.value;
+        });
+    };
+}
+exports.default = default_1;

package/build/constants.d.ts

@@ -0,0 +1,8 @@
+import type { Options } from '@wdio/types';
+export declare const DEFAULTS: Options.Definition<Required<Options.WebDriver>>;
+export declare const VALID_CAPS: string[];
+export declare const REG_EXPS: {
+    commandName: RegExp;
+    execFn: RegExp;
+};
+//# sourceMappingURL=constants.d.ts.map

package/build/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAE1C,eAAO,MAAM,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,SAAS,CAAC,CA0IpE,CAAA;AAED,eAAO,MAAM,UAAU,UAItB,CAAA;AAED,eAAO,MAAM,QAAQ;;;CAGpB,CAAA"}

package/build/constants.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REG_EXPS = exports.VALID_CAPS = exports.DEFAULTS = void 0;
+exports.DEFAULTS = {
+    /**
+     * protocol of automation driver
+     */
+    protocol: {
+        type: 'string',
+        default: 'http',
+        match: /(http|https)/
+    },
+    /**
+     * hostname of automation driver
+     */
+    hostname: {
+        type: 'string',
+        default: 'localhost'
+    },
+    /**
+     * port of automation driver
+     */
+    port: {
+        type: 'number',
+        default: 4444
+    },
+    /**
+     * path to WebDriver endpoints
+     */
+    path: {
+        type: 'string',
+        validate: (path) => {
+            if (!path.startsWith('/')) {
+                throw new TypeError('The option "path" needs to start with a "/"');
+            }
+            return true;
+        },
+        default: '/'
+    },
+    /**
+     * A key-value store of query parameters to be added to every selenium request
+     */
+    queryParams: {
+        type: 'object'
+    },
+    /**
+     * cloud user if applicable
+     */
+    user: {
+        type: 'string'
+    },
+    /**
+     * access key to user
+     */
+    key: {
+        type: 'string'
+    },
+    /**
+     * capability of WebDriver session
+     */
+    capabilities: {
+        type: 'object',
+        required: true
+    },
+    /**
+     * Level of logging verbosity
+     */
+    logLevel: {
+        type: 'string',
+        default: 'info',
+        match: /(trace|debug|info|warn|error|silent)/
+    },
+    /**
+     * directory for log files
+     */
+    outputDir: {
+        type: 'string'
+    },
+    /**
+     * Timeout for any WebDriver request to a driver or grid
+     */
+    connectionRetryTimeout: {
+        type: 'number',
+        default: 120000
+    },
+    /**
+     * Count of request retries to the Selenium server
+     */
+    connectionRetryCount: {
+        type: 'number',
+        default: 3
+    },
+    /**
+     * Override default agent
+     */
+    agent: {
+        type: 'object'
+    },
+    /**
+     * Override default agent
+     */
+    logLevels: {
+        type: 'object'
+    },
+    /**
+     * Pass custom headers
+     */
+    headers: {
+        type: 'object'
+    },
+    /**
+     * Function transforming the request options before the request is made
+     */
+    transformRequest: {
+        type: 'function',
+        default: (requestOptions) => requestOptions
+    },
+    /**
+     * Function transforming the response object after it is received
+     */
+    transformResponse: {
+        type: 'function',
+        default: (response) => response
+    },
+    /**
+     * Appium direct connect options server (https://appiumpro.com/editions/86-connecting-directly-to-appium-hosts-in-distributed-environments)
+     * Whether to allow direct connect caps to adjust endpoint details (Appium only)
+     */
+    enableDirectConnect: {
+        type: 'boolean',
+        default: true
+    },
+    /**
+     * Whether it requires SSL certificates to be valid in HTTP/s requests
+     * for an environment which cannot get process environment well.
+     */
+    strictSSL: {
+        type: 'boolean',
+        default: true
+    }
+};
+exports.VALID_CAPS = [
+    'browserName', 'browserVersion', 'platformName', 'acceptInsecureCerts',
+    'pageLoadStrategy', 'proxy', 'setWindowRect', 'timeouts', 'strictFileInteractability',
+    'unhandledPromptBehavior'
+];
+exports.REG_EXPS = {
+    commandName: /.*\/session\/[0-9a-f-]+\/(.*)/,
+    execFn: /return \(([\s\S]*)\)\.apply\(null, arguments\)/
+};

package/build/index.d.ts

@@ -0,0 +1,27 @@
+import type { Options } from '@wdio/types';
+import command from './command';
+import { DEFAULTS } from './constants';
+import { getPrototype } from './utils';
+import type { Client, AttachOptions } from './types';
+export default class WebDriver {
+    static newSession(options: Options.WebDriver, modifier?: (...args: any[]) => any, userPrototype?: {}, customCommandWrapper?: (...args: any[]) => any): Promise<Client>;
+    /**
+     * allows user to attach to existing sessions
+     */
+    static attachToSession(options?: AttachOptions, modifier?: (...args: any[]) => any, userPrototype?: {}, commandWrapper?: (...args: any[]) => any): Client;
+    /**
+     * Changes The instance session id and browser capabilities for the new session
+     * directly into the passed in browser object
+     *
+     * @param   {Object} instance  the object we get from a new browser session.
+     * @returns {string}           the new session id of the browser
+    */
+    static reloadSession(instance: Client): Promise<string>;
+    static get WebDriver(): typeof WebDriver;
+}
+/**
+ * Helper methods consumed by webdriverio package
+ */
+export { getPrototype, DEFAULTS, command };
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAgB,MAAM,aAAa,CAAA;AAExD,OAAO,OAAO,MAAM,WAAW,CAAA;AAC/B,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,EAAyB,YAAY,EAA0C,MAAM,SAAS,CAAA;AACrG,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAgB,MAAM,SAAS,CAAA;AAIlE,MAAM,CAAC,OAAO,OAAO,SAAS;WACb,UAAU,CACnB,OAAO,EAAE,OAAO,CAAC,SAAS,EAC1B,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAClC,aAAa,KAAK,EAClB,oBAAoB,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAC/C,OAAO,CAAC,MAAM,CAAC;IA4ClB;;OAEG;IACH,MAAM,CAAC,eAAe,CAClB,OAAO,CAAC,EAAE,aAAa,EACvB,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EAClC,aAAa,KAAK,EAClB,cAAc,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GACzC,MAAM;IAwBT;;;;;;MAME;WACW,aAAa,CAAE,QAAQ,EAAE,MAAM;IAW5C,MAAM,KAAK,SAAS,qBAEnB;CACJ;AAED;;GAEG;AACH,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAA;AAC1C,cAAc,SAAS,CAAA"}

package/build/index.js

@@ -0,0 +1,110 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = exports.DEFAULTS = exports.getPrototype = void 0;
+const path_1 = __importDefault(require("path"));
+const logger_1 = __importDefault(require("@wdio/logger"));
+const utils_1 = require("@wdio/utils");
+const config_1 = require("@wdio/config");
+const command_1 = __importDefault(require("./command"));
+exports.command = command_1.default;
+const constants_1 = require("./constants");
+Object.defineProperty(exports, "DEFAULTS", { enumerable: true, get: function () { return constants_1.DEFAULTS; } });
+const utils_2 = require("./utils");
+Object.defineProperty(exports, "getPrototype", { enumerable: true, get: function () { return utils_2.getPrototype; } });
+const log = (0, logger_1.default)('webdriver');
+class WebDriver {
+    static async newSession(options, modifier, userPrototype = {}, customCommandWrapper) {
+        const params = (0, config_1.validateConfig)(constants_1.DEFAULTS, options);
+        if (!options.logLevels || !options.logLevels.webdriver) {
+            logger_1.default.setLevel('webdriver', params.logLevel);
+        }
+        /**
+         * Store all log events in a file
+         */
+        if (params.outputDir && !process.env.WDIO_LOG_PATH) {
+            process.env.WDIO_LOG_PATH = path_1.default.join(params.outputDir, 'wdio.log');
+        }
+        log.info('Initiate new session using the WebDriver protocol');
+        const requestedCapabilities = { ...params.capabilities };
+        const { sessionId, capabilities } = await (0, utils_2.startWebDriverSession)(params);
+        const environment = (0, utils_1.sessionEnvironmentDetector)({ capabilities, requestedCapabilities });
+        const environmentPrototype = (0, utils_2.getEnvironmentVars)(environment);
+        const protocolCommands = (0, utils_2.getPrototype)(environment);
+        const prototype = { ...protocolCommands, ...environmentPrototype, ...userPrototype };
+        const monad = (0, utils_1.webdriverMonad)({ ...params, requestedCapabilities }, modifier, prototype);
+        const client = monad(sessionId, customCommandWrapper);
+        /**
+         * if the server responded with direct connect information, update the
+         * client options to speak directly to the appium host instead of a load
+         * balancer (see https://github.com/appium/python-client#direct-connect-urls
+         * for example). But only do this if the user has enabled this
+         * behavior in the first place.
+         */
+        if (params.enableDirectConnect) {
+            (0, utils_2.setupDirectConnect)(client);
+        }
+        return client;
+    }
+    /**
+     * allows user to attach to existing sessions
+     */
+    static attachToSession(options, modifier, userPrototype = {}, commandWrapper) {
+        if (!options || typeof options.sessionId !== 'string') {
+            throw new Error('sessionId is required to attach to existing session');
+        }
+        // logLevel can be undefined in watch mode when SIGINT is called
+        if (options.logLevel) {
+            logger_1.default.setLevel('webdriver', options.logLevel);
+        }
+        options.capabilities = options.capabilities || {};
+        options.isW3C = options.isW3C === false ? false : true;
+        options.protocol = options.protocol || constants_1.DEFAULTS.protocol.default;
+        options.hostname = options.hostname || constants_1.DEFAULTS.hostname.default;
+        options.port = options.port || constants_1.DEFAULTS.port.default;
+        options.path = options.path || constants_1.DEFAULTS.path.default;
+        const environmentPrototype = (0, utils_2.getEnvironmentVars)(options);
+        const protocolCommands = (0, utils_2.getPrototype)(options);
+        const prototype = { ...protocolCommands, ...environmentPrototype, ...userPrototype };
+        const monad = (0, utils_1.webdriverMonad)(options, modifier, prototype);
+        return monad(options.sessionId, commandWrapper);
+    }
+    /**
+     * Changes The instance session id and browser capabilities for the new session
+     * directly into the passed in browser object
+     *
+     * @param   {Object} instance  the object we get from a new browser session.
+     * @returns {string}           the new session id of the browser
+    */
+    static async reloadSession(instance) {
+        const params = {
+            ...instance.options,
+            capabilities: instance.requestedCapabilities
+        };
+        const { sessionId, capabilities } = await (0, utils_2.startWebDriverSession)(params);
+        instance.sessionId = sessionId;
+        instance.capabilities = capabilities;
+        return sessionId;
+    }
+    static get WebDriver() {
+        return WebDriver;
+    }
+}
+exports.default = WebDriver;
+__exportStar(require("./types"), exports);

package/build/request/browser.d.ts

@@ -0,0 +1,14 @@
+import { Options } from '@wdio/types';
+import WebDriverRequest from './index';
+declare type RequestLibOptions = Options.RequestLibOptions;
+declare type RequestOptions = Omit<Options.WebDriver, 'capabilities'>;
+export default class BrowserRequest extends WebDriverRequest {
+    constructor(method: string, endpoint: string, body?: Record<string, unknown>, isHubCommand?: boolean);
+    protected _createOptions(options: RequestOptions, sessionId?: string): RequestLibOptions;
+    protected _libRequest(url: URL, options: RequestLibOptions): Promise<{
+        statusCode: number;
+        body: any;
+    }>;
+}
+export {};
+//# sourceMappingURL=browser.d.ts.map

package/build/request/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/request/browser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAErC,OAAO,gBAAgB,MAAM,SAAS,CAAA;AAGtC,aAAK,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAA;AAClD,aAAK,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,cAAc,CAAC,CAAA;AAU7D,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,gBAAgB;gBAE3C,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAE,OAAe;IAI5G,SAAS,CAAC,cAAc,CAAE,OAAO,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,iBAAiB;cAIzE,WAAW,CAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,iBAAiB;;;;CA8BpE"}

package/build/request/browser.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("@wdio/logger"));
+const index_1 = __importDefault(require("./index"));
+const ky_1 = __importDefault(require("ky"));
+const log = (0, logger_1.default)('webdriver');
+const UNSUPPORTED_OPTS = [
+    'agent',
+    'responseType',
+    'searchParams',
+];
+class BrowserRequest extends index_1.default {
+    constructor(method, endpoint, body, isHubCommand = false) {
+        super(method, endpoint, body, isHubCommand);
+    }
+    _createOptions(options, sessionId) {
+        return super._createOptions(options, sessionId, true);
+    }
+    async _libRequest(url, options) {
+        const kyOptions = {};
+        for (const opt of Object.keys(options)) {
+            if (typeof options[opt] !== 'undefined' &&
+                UNSUPPORTED_OPTS.includes(opt) &&
+                options[opt] !== this.defaultOptions[opt]) {
+                log.info(`Browser-based webdriver does not support the '${String(opt)}' option; behavior may be unexpected`);
+                continue;
+            }
+            // @ts-expect-error
+            kyOptions[opt] = options[opt];
+        }
+        if (options.username && options.password) {
+            const encodedAuth = Buffer.from(`${options.username}:${options.password}`, 'utf8').toString('base64');
+            kyOptions.headers = {
+                ...kyOptions.headers,
+                Authorization: `Basic ${encodedAuth}`
+            };
+        }
+        const res = await (0, ky_1.default)(url, kyOptions);
+        return {
+            statusCode: res.status,
+            body: await res.json(),
+        };
+    }
+}
+exports.default = BrowserRequest;

package/build/request/factory.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import WebDriverRequest from './index';
+import type { URL as URLType } from 'url';
+export default class RequestFactory {
+    static getInstance(method: string, endpoint: string, body?: Record<string, unknown>, isHubCommand?: boolean): WebDriverRequest;
+}
+export declare class URLFactory {
+    static getInstance(uri: string): URLType;
+}
+//# sourceMappingURL=factory.d.ts.map

package/build/request/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/request/factory.ts"],"names":[],"mappings":";AAAA,OAAO,gBAAgB,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,GAAG,IAAI,OAAO,EAAE,MAAM,KAAK,CAAA;AAEzC,MAAM,CAAC,OAAO,OAAO,cAAc;IAC/B,MAAM,CAAC,WAAW,CACd,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,YAAY,GAAE,OAAe,GAC9B,gBAAgB;CAYtB;AAED,qBAAa,UAAU;IACnB,MAAM,CAAC,WAAW,CAAE,GAAG,EAAE,MAAM,GAAG,OAAO;CAO5C"}

package/build/request/factory.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URLFactory = void 0;
+class RequestFactory {
+    static getInstance(method, endpoint, body, isHubCommand = false) {
+        var _a;
+        if ((_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) {
+            const reqModule = require('./node');
+            // we either need to get the default export explicitly in the prod case, or implicitly
+            // in the case of jest mocking
+            const NodeJSRequest = reqModule.default || reqModule;
+            return new NodeJSRequest(method, endpoint, body, isHubCommand);
+        }
+        const BrowserRequest = require('./browser').default;
+        return new BrowserRequest(method, endpoint, body, isHubCommand);
+    }
+}
+exports.default = RequestFactory;
+class URLFactory {
+    static getInstance(uri) {
+        var _a;
+        if ((_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) {
+            const { URL } = require('url');
+            return new URL(uri);
+        }
+        return new window.URL(uri);
+    }
+}
+exports.URLFactory = URLFactory;

package/build/request/index.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import type { URL } from 'url';
+import type { Options } from '@wdio/types';
+declare type Agents = Options.Agents;
+declare type RequestLibOptions = Options.RequestLibOptions;
+declare type RequestLibResponse = Options.RequestLibResponse;
+declare type RequestOptions = Omit<Options.WebDriver, 'capabilities'>;
+export declare class RequestLibError extends Error {
+    statusCode?: number;
+    body?: any;
+    code?: string;
+}
+export interface WebDriverResponse {
+    value: any;
+    /**
+     * error case
+     * https://w3c.github.io/webdriver/webdriver-spec.html#dfn-send-an-error
+     */
+    error?: string;
+    message?: string;
+    stacktrace?: string;
+    /**
+     * JSONWP property
+     */
+    status?: number;
+    sessionId?: string;
+}
+export default abstract class WebDriverRequest extends EventEmitter {
+    body?: Record<string, unknown>;
+    method: string;
+    endpoint: string;
+    isHubCommand: boolean;
+    requiresSessionId: boolean;
+    defaultAgents: Agents | null;
+    defaultOptions: RequestLibOptions;
+    constructor(method: string, endpoint: string, body?: Record<string, unknown>, isHubCommand?: boolean);
+    makeRequest(options: RequestOptions, sessionId?: string): Promise<WebDriverResponse>;
+    protected _createOptions(options: RequestOptions, sessionId?: string, isBrowser?: boolean): RequestLibOptions;
+    protected _libRequest(url: URL, options: RequestLibOptions): Promise<RequestLibResponse>;
+    private _request;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/request/index.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAErC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAK9B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAM1C,aAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAA;AAC5B,aAAK,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAA;AAClD,aAAK,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAA;AACpD,aAAK,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,cAAc,CAAC,CAAA;AAE7D,qBAAa,eAAgB,SAAQ,KAAK;IACtC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,GAAG,CAAA;IACV,IAAI,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,iBAAiB;IAC9B,KAAK,EAAE,GAAG,CAAA;IACV;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IAEnB;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;CACrB;AAWD,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,gBAAiB,SAAQ,YAAY;IAC/D,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,cAAc,EAAE,iBAAiB,CAKhC;gBAEY,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,GAAE,OAAe;IAU5G,WAAW,CAAE,OAAO,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM;IAYxD,SAAS,CAAC,cAAc,CAAE,OAAO,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,SAAS,GAAE,OAAe,GAAG,iBAAiB;cAiErG,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC;YAIhF,QAAQ;CA8GzB"}