@wdio/browser-runner 7.20.8-alpha.504

package/LICENSE-MIT

@@ -0,0 +1,20 @@
+Copyright (c) OpenJS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,4 @@
+WebdriverIO Local Runner
+========================
+
+> A WebdriverIO runner to run tests locally

package/build/browser/commands/debug.d.ts

@@ -0,0 +1,2 @@
+export default function debug(): Promise<unknown>;
+//# sourceMappingURL=debug.d.ts.map

package/build/browser/commands/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../src/browser/commands/debug.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,KAAK,qBAK5B"}

package/build/browser/commands/debug.js

@@ -0,0 +1,6 @@
+export default function debug() {
+    return new Promise((resolve) => {
+        console.log('%cDebug Mode Enabled', 'background: #ea5906; color: #fff; padding: 3px; border-radius: 5px;', 'enter the command `wdioDebugContinue()` in the console to continue');
+        window.wdioDebugContinue = resolve;
+    });
+}

package/build/browser/commands/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: Record<string, PropertyDescriptor>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/build/browser/commands/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/browser/commands/index.ts"],"names":[],"mappings":";AAGA,wBAG4C"}

package/build/browser/commands/index.js

@@ -0,0 +1,6 @@
+import debug from './debug.js';
+const browserCommands = [debug];
+export default browserCommands.reduce((commands, fn) => {
+    commands[fn.name] = { value: fn };
+    return commands;
+}, {});

package/build/browser/driver.d.ts

@@ -0,0 +1,4 @@
+export default class ProxyDriver {
+    static newSession(params: any, modifier: never, userPrototype: Record<string, PropertyDescriptor>, commandWrapper: any): any;
+}
+//# sourceMappingURL=driver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"driver.d.ts","sourceRoot":"","sources":["../../src/browser/driver.ts"],"names":[],"mappings":"AAUA,MAAM,CAAC,OAAO,OAAO,WAAW;IAC5B,MAAM,CAAC,UAAU,CACb,MAAM,EAAE,GAAG,EACX,QAAQ,EAAE,KAAK,EACf,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,EACjD,cAAc,EAAE,GAAG;CAuG1B"}

package/build/browser/driver.js

@@ -0,0 +1,101 @@
+import { commands } from 'virtual:wdio';
+import { webdriverMonad } from '@wdio/utils';
+import { getEnvironmentVars } from 'webdriver';
+import browserCommands from './commands/index.js';
+const COMMAND_TIMEOUT = 30 * 1000; // 30s
+const CONSOLE_METHODS = ['log', 'info', 'warn', 'error', 'debug'];
+export default class ProxyDriver {
+    static newSession(params, modifier, userPrototype, commandWrapper) {
+        const commandMessages = new Map();
+        const wsUrl = 'ws://' + window.location.host + '/ws';
+        const [cid] = window.location.pathname.slice(1).split('/');
+        if (!cid) {
+            throw new Error('"cid" query parameter is missing');
+        }
+        console.log(`[WDIO] Connect to testrunner: ${wsUrl}`);
+        const socket = new WebSocket(wsUrl);
+        const connectPromise = new Promise((resolve) => {
+            console.log('[WDIO] Connected to testrunner');
+            socket.addEventListener('open', resolve);
+        });
+        /**
+         * log all console events once connected
+         */
+        connectPromise.then(() => {
+            for (const method of CONSOLE_METHODS) {
+                const origCommand = console[method].bind(console);
+                console[method] = (...args) => {
+                    socket.send(JSON.stringify({
+                        name: 'consoleEvent',
+                        type: method,
+                        args,
+                        cid
+                    }));
+                    origCommand(...args);
+                };
+            }
+        });
+        socket.addEventListener('message', (ev) => {
+            try {
+                const payload = JSON.parse(ev.data);
+                if (!payload.id) {
+                    return console.error(`Message without id: ${JSON.stringify(ev.data)}`);
+                }
+                const commandMessage = commandMessages.get(payload.id);
+                if (!commandMessage) {
+                    return console.error(`Unknown command id "${payload.id}"`);
+                }
+                if (payload.error) {
+                    console.log(`[WDIO] ${(new Date()).toISOString()} - id: ${payload.id} - ERROR: ${JSON.stringify(payload.result)}`);
+                    return commandMessage.reject(new Error(payload.error));
+                }
+                console.log(`[WDIO] ${(new Date()).toISOString()} - id: ${payload.id} - RESULT: ${JSON.stringify(payload.result)}`);
+                commandMessage.resolve(payload.result);
+            }
+            catch (err) {
+                console.error(`Failed handling command socket message "${err.message}"`);
+            }
+        });
+        let commandId = 0;
+        const environmentPrototype = getEnvironmentVars(params);
+        const protocolCommands = commands.reduce((prev, commandName) => {
+            prev[commandName] = {
+                value: async (...args) => {
+                    if (socket.readyState !== 1) {
+                        await connectPromise;
+                    }
+                    commandId++;
+                    console.log(`[WDIO] ${(new Date()).toISOString()} - id: ${commandId} - COMMAND: ${commandName}(${args.join(', ')})`);
+                    socket.send(JSON.stringify({ commandName, args, id: commandId, cid }));
+                    return new Promise((resolve, reject) => {
+                        const commandTimeout = setTimeout(() => reject(new Error(`Command "${commandName}" timed out`)), COMMAND_TIMEOUT);
+                        commandMessages.set(commandId, { resolve, reject, commandTimeout });
+                    });
+                }
+            };
+            return prev;
+        }, {});
+        const prototype = {
+            /**
+             * custom protocol commands that communicate with Vite
+             */
+            ...protocolCommands,
+            /**
+             * environment flags
+             */
+            ...environmentPrototype,
+            /**
+             * unmodified WebdriverIO commands
+             */
+            ...userPrototype,
+            /**
+             * custom browser specific commands
+             */
+            ...browserCommands
+        };
+        prototype.emit = { writable: true, value: () => { } };
+        prototype.on = { writable: true, value: () => { } };
+        const monad = webdriverMonad(params, modifier, prototype);
+        return monad(window.__wdioEnv__.sessionId, commandWrapper);
+    }
+}

package/build/browser/mock.d.ts

@@ -0,0 +1,24 @@
+/**
+ * this file content is assigned to modules we mock out for browser compatibility
+ */
+export declare const createRequire: () => {
+    (): void;
+    resolve(): void;
+};
+export declare const SUPPORTED_BROWSER: never[];
+export declare const locatorStrategy: {};
+export declare class EventEmitter {
+}
+export declare const URL: {
+    new (url: string | URL, base?: string | URL | undefined): URL;
+    prototype: URL;
+    createObjectURL(obj: Blob | MediaSource): string;
+    revokeObjectURL(url: string): void;
+};
+export declare const pathToFileURL: () => string;
+export declare const fileURLToPath: () => string;
+export declare const dirname: () => string;
+export declare const resolve: () => string;
+declare const _default: () => void;
+export default _default;
+//# sourceMappingURL=mock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mock.d.ts","sourceRoot":"","sources":["../../src/browser/mock.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,aAAa;;;CAIzB,CAAA;AAED,eAAO,MAAM,iBAAiB,SAAK,CAAA;AACnC,eAAO,MAAM,eAAe,IAAK,CAAA;AACjC,qBAAa,YAAY;CAAG;AAC5B,eAAO,MAAM,GAAG;;;;;CAAa,CAAA;AAC7B,eAAO,MAAM,aAAa,cAAW,CAAA;AACrC,eAAO,MAAM,aAAa,cAAW,CAAA;AACrC,eAAO,MAAM,OAAO,cAAW,CAAA;AAC/B,eAAO,MAAM,OAAO,cAAW,CAAA;;AAC/B,wBAAuB"}

package/build/browser/mock.js

@@ -0,0 +1,18 @@
+/**
+ * this file content is assigned to modules we mock out for browser compatibility
+ */
+export const createRequire = () => {
+    const require = () => { };
+    require.resolve = () => { };
+    return require;
+};
+export const SUPPORTED_BROWSER = [];
+export const locatorStrategy = {};
+export class EventEmitter {
+}
+export const URL = window.URL;
+export const pathToFileURL = () => '';
+export const fileURLToPath = () => '';
+export const dirname = () => '';
+export const resolve = () => '';
+export default () => { };

package/build/browser/reporter.d.ts

@@ -0,0 +1,7 @@
+declare const BaseReporter: any;
+export default class HTMLReporter extends BaseReporter {
+    constructor(runner: any, options: any);
+    addCodeToggle(): void;
+}
+export {};
+//# sourceMappingURL=reporter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../../src/browser/reporter.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,YAAY,KAAuB,CAAA;AAEzC,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,YAAY;gBACrC,MAAM,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG;IAItC,aAAa;CAChB"}

package/build/browser/reporter.js

@@ -0,0 +1,8 @@
+// @ts-ignore
+const BaseReporter = Mocha.reporters.html;
+export default class HTMLReporter extends BaseReporter {
+    constructor(runner, options) {
+        super(runner, options);
+    }
+    addCodeToggle() { }
+}

package/build/browser/setup.d.ts

@@ -0,0 +1,9 @@
+declare type WDIOErrorEvent = Pick<ErrorEvent, 'filename' | 'message'>;
+declare global {
+    interface Window {
+        __wdioErrors__: WDIOErrorEvent[];
+    }
+}
+export declare function setupEnv(): Promise<void>;
+export {};
+//# sourceMappingURL=setup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../src/browser/setup.ts"],"names":[],"mappings":"AAKA,aAAK,cAAc,GAAG,IAAI,CAAC,UAAU,EAAE,UAAU,GAAG,SAAS,CAAC,CAAA;AAE9D,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM;QACZ,cAAc,EAAE,cAAc,EAAE,CAAA;KACnC;CACJ;AAQD,wBAAsB,QAAQ,kBAW7B"}

package/build/browser/setup.js

@@ -0,0 +1,21 @@
+import { automationProtocolPath } from 'virtual:wdio';
+import { expect } from 'expect-webdriverio';
+import { remote } from 'webdriverio';
+import { _setGlobal } from '@wdio/globals';
+window.__wdioErrors__ = [];
+addEventListener('error', (ev) => window.__wdioErrors__.push({
+    filename: ev.filename,
+    message: ev.message
+}));
+export async function setupEnv() {
+    const injectGlobals = window.__wdioEnv__.injectGlobals;
+    const browser = await remote({
+        automationProtocol: automationProtocolPath,
+        capabilities: window.__wdioEnv__.capabilities
+    });
+    _setGlobal('browser', browser, injectGlobals);
+    _setGlobal('driver', browser, injectGlobals);
+    _setGlobal('expect', expect, injectGlobals);
+    _setGlobal('$', browser.$.bind(browser), injectGlobals);
+    _setGlobal('$$', browser.$.bind(browser), injectGlobals);
+}

package/build/constants.d.ts

@@ -0,0 +1,19 @@
+import type { Browser } from 'webdriverio';
+import type { Environment, FrameworkPreset } from './types';
+export declare const SESSIONS: Map<string, Environment>;
+export declare const BROWSER_POOL: Map<string, Browser<'async'>>;
+export declare const EVENTS: {
+    readonly suite: "suite:start";
+    readonly 'suite end': "suite:end";
+    readonly test: "test:start";
+    readonly 'test end': "test:end";
+    readonly hook: "hook:start";
+    readonly 'hook end': "hook:end";
+    readonly pass: "test:pass";
+    readonly fail: "test:fail";
+    readonly retry: "test:retry";
+    readonly pending: "test:pending";
+};
+export declare const PRESET_DEPENDENCIES: Record<FrameworkPreset, [string, string, any] | undefined>;
+export declare const FRAMEWORK_SUPPORT_ERROR = "Currently only \"mocha\" is supported as framework when using @wdio/browser-runner.";
+//# 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;AAC1C,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAE3D,eAAO,MAAM,QAAQ,0BAAiC,CAAA;AACtD,eAAO,MAAM,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAa,CAAA;AAEpE,eAAO,MAAM,MAAM;;;;;;;;;;;CAWT,CAAA;AAEV,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAe1F,CAAA;AAED,eAAO,MAAM,uBAAuB,wFAAsF,CAAA"}

package/build/constants.js

@@ -0,0 +1,31 @@
+export const SESSIONS = new Map();
+export const BROWSER_POOL = new Map();
+export const EVENTS = {
+    'suite': 'suite:start',
+    'suite end': 'suite:end',
+    'test': 'test:start',
+    'test end': 'test:end',
+    'hook': 'hook:start',
+    'hook end': 'hook:end',
+    'pass': 'test:pass',
+    'fail': 'test:fail',
+    'retry': 'test:retry',
+    'pending': 'test:pending'
+};
+export const PRESET_DEPENDENCIES = {
+    react: ['@vitejs/plugin-react', 'default', {
+            babel: {
+                assumptions: {
+                    setPublicClassFields: true
+                },
+                parserOpts: {
+                    plugins: ['decorators-legacy', 'classProperties']
+                }
+            }
+        }],
+    preact: ['@preact/preset-vite', 'default', undefined],
+    vue: ['@vitejs/plugin-vue', 'default', undefined],
+    svelte: ['@sveltejs/vite-plugin-svelte', 'svelte', undefined],
+    lit: undefined
+};
+export const FRAMEWORK_SUPPORT_ERROR = 'Currently only "mocha" is supported as framework when using @wdio/browser-runner.';

package/build/index.d.ts

@@ -0,0 +1,27 @@
+import LocalRunner, { RunArgs } from '@wdio/local-runner';
+import type { Options } from '@wdio/types';
+import type { BrowserRunnerOptions as BrowserRunnerOptionsImport } from './types';
+export default class BrowserRunner extends LocalRunner {
+    #private;
+    private options;
+    private config;
+    constructor(options: BrowserRunnerOptionsImport, config: Options.Testrunner);
+    /**
+     * nothing to initialise when running locally
+     */
+    initialise(): Promise<void>;
+    run(runArgs: RunArgs): import("@wdio/local-runner/build/worker.js").default;
+    /**
+     * shutdown vite server
+     *
+     * @return {Promise}  resolves when vite server has been shutdown
+     */
+    shutdown(): Promise<void>;
+}
+declare global {
+    namespace WebdriverIO {
+        interface BrowserRunnerOptions extends BrowserRunnerOptionsImport {
+        }
+    }
+}
+//# 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":"AAEA,OAAO,WAAW,EAAE,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAA;AAKzD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAI1C,OAAO,KAAK,EAAE,oBAAoB,IAAI,0BAA0B,EAAgB,MAAM,SAAS,CAAA;AAI/F,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,WAAW;;IAMtC,OAAO,CAAC,OAAO;IAA8B,OAAO,CAAC,MAAM;gBAAnD,OAAO,EAAE,0BAA0B,EAAU,MAAM,EAAE,OAAO,CAAC,UAAU;IAW3F;;OAEG;IACG,UAAU;IAgChB,GAAG,CAAE,OAAO,EAAE,OAAO;IA8BrB;;;;OAIG;IACG,QAAQ;CAOjB;AAED,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,WAAW,CAAC;QAClB,UAAU,oBAAqB,SAAQ,0BAA0B;SAAG;KACvE;CACJ"}

package/build/index.js

@@ -0,0 +1,98 @@
+import logger from '@wdio/logger';
+import getPort from 'get-port';
+import LocalRunner from '@wdio/local-runner';
+import { attach } from 'webdriverio';
+import { createServer } from 'vite';
+import { FRAMEWORK_SUPPORT_ERROR, SESSIONS, BROWSER_POOL } from './constants.js';
+import { getViteConfig } from './utils.js';
+const log = logger('@wdio/browser-runner');
+export default class BrowserRunner extends LocalRunner {
+    options;
+    config;
+    #options;
+    #config;
+    #server;
+    #wss;
+    constructor(options, config) {
+        super(options, config);
+        this.options = options;
+        this.config = config;
+        if (config.framework !== 'mocha') {
+            throw new Error(FRAMEWORK_SUPPORT_ERROR);
+        }
+        this.#options = options;
+        this.#config = config;
+    }
+    /**
+     * nothing to initialise when running locally
+     */
+    async initialise() {
+        const rootDir = this.#options.rootDir || process.cwd();
+        log.info('Initiate browser environment');
+        try {
+            const port = await getPort();
+            const [viteConfig, wss] = await getViteConfig(this.#options, rootDir, port);
+            this.#server = await createServer(viteConfig);
+            await this.#server.listen();
+            log.info(`Vite server started successfully on port ${port}, root directory: ${rootDir}`);
+            /**
+             * propagate console events
+             */
+            wss.on('connection', (ws) => ws.on('message', (payload) => {
+                try {
+                    const message = JSON.parse(payload);
+                    const isWDIOLog = Boolean(typeof message.args[0] === 'string' && message.args[0].startsWith('[WDIO]'));
+                    if (message.name !== 'consoleEvent' || isWDIOLog) {
+                        return;
+                    }
+                    console[message.type](`[${message.cid}]`, ...(message.args || []));
+                }
+                catch (err) {
+                    return;
+                }
+            }));
+        }
+        catch (err) {
+            throw new Error(`Vite server failed to start: ${err.stack}`);
+        }
+        await super.initialise();
+    }
+    run(runArgs) {
+        if (runArgs.command === 'run') {
+            runArgs.args.baseUrl = `http://localhost:${this.#server?.config.server.port}`;
+        }
+        const worker = super.run(runArgs);
+        worker.on('message', async (payload) => {
+            if (payload.name === 'sessionStarted') {
+                SESSIONS.set(payload.cid, {
+                    args: this.#config.mochaOpts || {},
+                    capabilities: payload.content.capabilities,
+                    sessionId: payload.content.sessionId,
+                    injectGlobals: payload.content.injectGlobals
+                });
+                BROWSER_POOL.set(payload.cid, await attach({
+                    sessionId: payload.content.sessionId,
+                    options: this.#config,
+                    capabilities: payload.content.capabilities
+                }));
+            }
+            if (payload.name === 'sessionEnded') {
+                SESSIONS.delete(payload.cid);
+                BROWSER_POOL.delete(payload.cid);
+            }
+        });
+        return worker;
+    }
+    /**
+     * shutdown vite server
+     *
+     * @return {Promise}  resolves when vite server has been shutdown
+     */
+    async shutdown() {
+        await super.shutdown();
+        if (this.#server) {
+            log.info('Shutting down Vite server');
+            await this.#server.close();
+        }
+    }
+}

package/build/plugins/testrunner.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export declare function testrunner(options: WebdriverIO.BrowserRunnerOptions): Plugin;
+//# sourceMappingURL=testrunner.d.ts.map

package/build/plugins/testrunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testrunner.d.ts","sourceRoot":"","sources":["../../src/plugins/testrunner.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAyClC,wBAAgB,UAAU,CAAE,OAAO,EAAE,WAAW,CAAC,oBAAoB,GAAG,MAAM,CA0G7E"}

package/build/plugins/testrunner.js

@@ -0,0 +1,121 @@
+import url from 'node:url';
+import path from 'node:path';
+import logger from '@wdio/logger';
+import { createRequire } from 'node:module';
+import { WebDriverProtocol, MJsonWProtocol, JsonWProtocol, AppiumProtocol, ChromiumProtocol, SauceLabsProtocol, SeleniumProtocol, GeckoProtocol, WebDriverBidiProtocol } from '@wdio/protocols';
+import { SESSIONS } from '../constants.js';
+import { getTemplate, getErrorTemplate } from '../utils.js';
+const log = logger('@wdio/browser-runner:plugin');
+const require = createRequire(import.meta.url);
+const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
+const commands = {
+    ...WebDriverProtocol,
+    ...MJsonWProtocol,
+    ...JsonWProtocol,
+    ...AppiumProtocol,
+    ...ChromiumProtocol,
+    ...SauceLabsProtocol,
+    ...SeleniumProtocol,
+    ...GeckoProtocol,
+    ...WebDriverBidiProtocol
+};
+const protocolCommandList = Object.values(commands).map((endpoint) => Object.values(endpoint).map(({ command }) => command)).flat();
+const WDIO_PACKAGES = ['webdriverio', 'expect-webdriverio'];
+const virtualModuleId = 'virtual:wdio';
+const resolvedVirtualModuleId = '\0' + virtualModuleId;
+const MODULES_TO_MOCK = [
+    'node:module', 'node:events', 'node:path', 'node:url', 'puppeteer-core', 'archiver',
+    'query-selector-shadow-dom/plugins/puppeteer/index.js',
+    'query-selector-shadow-dom/plugins/webdriverio/index.js',
+    'glob', 'devtools'
+];
+export function testrunner(options) {
+    const automationProtocolPath = path.resolve(__dirname, '..', 'browser', 'driver.js');
+    const mockModulePath = path.resolve(__dirname, '..', 'browser', 'mock.js');
+    const setupModulePath = path.resolve(__dirname, '..', 'browser', 'setup.js');
+    const reporterPath = path.resolve(__dirname, '..', 'browser', 'reporter.js');
+    return {
+        name: 'wdio:testrunner',
+        enforce: 'pre',
+        resolveId: (id) => {
+            if (id === virtualModuleId) {
+                return resolvedVirtualModuleId;
+            }
+            if (id === '@wdio/browser-runner/setup') {
+                return setupModulePath;
+            }
+            if (id === '@wdio/browser-runner/reporter') {
+                return reporterPath;
+            }
+            /**
+             * make sure WDIO imports are resolved properly as ESM module
+             */
+            if (id.startsWith('@wdio') || WDIO_PACKAGES.includes(id)) {
+                return require.resolve(id).replace('/cjs', '');
+            }
+            /**
+             * mock out imports that we can't transpile into browser land
+             */
+            if (MODULES_TO_MOCK.includes(id)) {
+                return mockModulePath;
+            }
+        },
+        load(id) {
+            /**
+             * provide a list of protocol commands to generate the prototype in the browser
+             */
+            if (id === resolvedVirtualModuleId) {
+                return /*js*/ `
+                    export const commands = ${JSON.stringify(protocolCommandList)}
+                    export const automationProtocolPath = ${JSON.stringify(automationProtocolPath)}
+                `;
+            }
+        },
+        transform(code, id) {
+            if (id.includes('.vite/deps/expect.js')) {
+                return {
+                    code: code.replace('var fs = _interopRequireWildcard(require_graceful_fs());', 'var fs = {};').replace('var expect_default = require_build11();', 'var expect_default = require_build11();\nwindow.expect = expect_default.default;').replace('process.stdout.isTTY', 'false')
+                };
+            }
+            return { code };
+        },
+        configureServer(server) {
+            return () => {
+                server.middlewares.use('/', async (req, res, next) => {
+                    log.info(`Received request for: ${req.url}`);
+                    if (!req.url) {
+                        return next();
+                    }
+                    const urlParsed = url.parse(req.url);
+                    // if request is not html , directly return next()
+                    if (!urlParsed.pathname || !urlParsed.path || !urlParsed.pathname.endsWith('test.html')) {
+                        return next();
+                    }
+                    const urlParamString = new URLSearchParams(urlParsed.query || '');
+                    const [cid] = urlParsed.pathname.slice(1).split('/');
+                    const spec = urlParamString.get('spec');
+                    if (!cid || !SESSIONS.has(cid)) {
+                        log.error(`No environment found for ${cid || 'non determined environment'}`);
+                        return next();
+                    }
+                    if (!spec) {
+                        log.error('No spec file was defined to run for this environment');
+                        return next();
+                    }
+                    const env = SESSIONS.get(cid);
+                    try {
+                        const template = await getTemplate(options, env, spec);
+                        log.debug(`Render template for ${req.url}`);
+                        res.end(await server.transformIndexHtml(`${req.url}`, template));
+                    }
+                    catch (err) {
+                        const template = await getErrorTemplate(req.url, err);
+                        log.error(`Failed to render template: ${err.message}`);
+                        res.end(await server.transformIndexHtml(`${req.url}`, template));
+                    }
+                    return next();
+                });
+            };
+        }
+    };
+}

package/build/types.d.ts

@@ -0,0 +1,42 @@
+import type { InlineConfig } from 'vite';
+import type { Workers, Capabilities } from '@wdio/types';
+declare global {
+    interface Window {
+        __wdioEnv__: Environment;
+        wdioDebugContinue: (value: unknown) => void;
+    }
+}
+export declare type FrameworkPreset = 'react' | 'preact' | 'vue' | 'svelte' | 'lit';
+export interface BrowserRunnerOptions {
+    /**
+     * Project root directory
+     * @default process.cwd()
+     */
+    rootDir?: string;
+    /**
+     * WebdriverIOs browser runner supports a set of presets to test for a specific framework.
+     */
+    preset?: FrameworkPreset;
+    /**
+     * Vite configuration to overwrite the preset
+     */
+    viteConfig?: InlineConfig;
+}
+export interface RunArgs extends Workers.WorkerRunPayload {
+    command: string;
+    args: any;
+    cid: string;
+}
+export interface Environment {
+    args: any;
+    capabilities: Capabilities.RemoteCapability;
+    sessionId: string;
+    injectGlobals: boolean;
+}
+export interface ConsoleEvent {
+    name: 'consoleEvent';
+    type: 'log' | 'info' | 'warn' | 'debug' | 'error';
+    args: unknown[];
+    cid: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AACxC,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAExD,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM;QACZ,WAAW,EAAE,WAAW,CAAA;QACxB,iBAAiB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;KAC9C;CACJ;AAED,oBAAY,eAAe,GAAG,OAAO,GAAG,QAAQ,GAAG,KAAK,GAAG,QAAQ,GAAG,KAAK,CAAA;AAE3E,MAAM,WAAW,oBAAoB;IACjC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;OAEG;IACH,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB;;OAEG;IACH,UAAU,CAAC,EAAE,YAAY,CAAA;CAC5B;AAED,MAAM,WAAW,OAAQ,SAAQ,OAAO,CAAC,gBAAgB;IACrD,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,GAAG,CAAA;IACT,GAAG,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,GAAG,CAAA;IACT,YAAY,EAAE,YAAY,CAAC,gBAAgB,CAAA;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,OAAO,CAAA;CACzB;AAED,MAAM,WAAW,YAAY;IACzB,IAAI,EAAE,cAAc,CAAA;IACpB,IAAI,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;IACjD,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,GAAG,EAAE,MAAM,CAAA;CACd"}

package/build/types.js

@@ -0,0 +1 @@
+export {};

package/build/utils.d.ts

@@ -0,0 +1,7 @@
+import { WebSocketServer } from 'ws';
+import type { InlineConfig } from 'vite';
+import type { Environment } from './types';
+export declare function getTemplate(options: WebdriverIO.BrowserRunnerOptions, env: Environment, spec: string): Promise<string>;
+export declare function getErrorTemplate(filename: string, error: Error): Promise<string>;
+export declare function getViteConfig(options: WebdriverIO.BrowserRunnerOptions, root: string, port: number): Promise<[Partial<InlineConfig>, WebSocketServer]>;
+//# sourceMappingURL=utils.d.ts.map

package/build/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,eAAe,EAAa,MAAM,IAAI,CAAA;AAI/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAKxC,OAAO,KAAK,EAAE,WAAW,EAAmB,MAAM,SAAS,CAAA;AAI3D,wBAAsB,WAAW,CAAE,OAAO,EAAE,WAAW,CAAC,oBAAoB,EAAE,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,mBA2E3G;AAED,wBAAsB,gBAAgB,CAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,mBAUrE;AAiBD,wBAAsB,aAAa,CAC/B,OAAO,EAAE,WAAW,CAAC,oBAAoB,EACzC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACb,OAAO,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,eAAe,CAAC,CAAC,CAyEnD"}

package/build/utils.js

@@ -0,0 +1,210 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import getPort from 'get-port';
+import topLevelAwait from 'vite-plugin-top-level-await';
+import { WebSocketServer } from 'ws';
+import { esbuildCommonjs } from '@originjs/vite-plugin-commonjs';
+import { NodeGlobalsPolyfillPlugin } from '@esbuild-plugins/node-globals-polyfill';
+import logger from '@wdio/logger';
+import { testrunner } from './plugins/testrunner.js';
+import { EVENTS, PRESET_DEPENDENCIES, BROWSER_POOL } from './constants.js';
+const log = logger('@wdio/browser-runner');
+export async function getTemplate(options, env, spec) {
+    const root = options.rootDir || process.cwd();
+    const require = createRequire(path.join(root, 'node_modules'));
+    const listeners = Object.entries(EVENTS).map(([mochaEvent, wdioEvent]) => (
+    /*js*/ `runner.on('${mochaEvent}', (payload) => {
+            window.__wdioEvents__.push(formatMessage({ type: '${wdioEvent}', payload, err: payload.err }))
+        })`)).join('\n');
+    let vueDeps = '';
+    if (options.preset === 'vue') {
+        try {
+            const vueDir = path.dirname(require.resolve('vue'));
+            const vueScript = (await fs.readFile(path.join(vueDir, 'dist', 'vue.global.prod.js'), 'utf-8')).toString();
+            vueDeps += /*html*/ `
+            <script type="module">
+                ${vueScript}
+                window.Vue = Vue
+            </script>`;
+            const vueCompilerDir = path.dirname(require.resolve('@vue/compiler-dom'));
+            const vueCompilerScript = (await fs.readFile(path.join(vueCompilerDir, 'dist', 'compiler-dom.global.prod.js'), 'utf-8')).toString();
+            vueDeps += /*html*/ `
+            <script type="module">
+                ${vueCompilerScript}
+                window.VueCompilerDOM = VueCompilerDOM
+            </script>`;
+        }
+        catch (err) {
+            throw new Error(`Fail to set-up Vue environment: ${err.message}\n\n` +
+                'Make sure you have "vue" and "@vue/compiler-dom" installed as dependencies!');
+        }
+    }
+    return /* html */ `
+    <!doctype html>
+    <html>
+        <head>
+            <title>WebdriverIO Browser Test</title>
+            <link rel="stylesheet" href="https://unpkg.com/mocha@10.0.0/mocha.css">
+            <script type="module">
+                /**
+                 * Inject environment variables
+                 */
+                window.__wdioEnv__ = ${JSON.stringify(env)}
+            </script>
+            ${vueDeps}
+            <script type="module">
+            import Mocha from 'https://esm.sh/mocha@10.0.0'
+            import HTMLReporter from '@wdio/browser-runner/reporter'
+            const mochaOpts = ${JSON.stringify(env.args || {})}
+            const mocha = Mocha.setup({
+                ...mochaOpts,
+                reporter: HTMLReporter
+            })
+            </script>
+        </head>
+        <body>
+            <div id="mocha"></div>
+            <script async type="module">
+                import { setupEnv } from '@wdio/browser-runner/setup'
+                import { formatMessage } from '@wdio/mocha-framework/common'
+
+                await setupEnv()
+                await import('${spec}')
+
+                window.__wdioEvents__ = []
+                console.log('[WDIO] Start Mocha testsuite')
+                const runner = mocha.run((failures) => {
+                    window.__wdioFailures__ = failures
+                })
+                ${listeners}
+            </script>
+        </body>
+    </html>`;
+}
+export async function getErrorTemplate(filename, error) {
+    return /*html*/ `
+        <pre>${error.stack}</pre>
+        <script type="module">
+            window.__wdioErrors__ = [{
+                filename: "${filename}",
+                message: \`${error.message}\`
+            }]
+        </script>
+    `;
+}
+async function userfriendlyImport(preset, pkg) {
+    if (!pkg) {
+        return {};
+    }
+    try {
+        return await import(pkg);
+    }
+    catch (err) {
+        throw new Error(`Couldn't load preset "${preset}" given important dependency ("${pkg}") is not installed.\n` +
+            `Please run:\n\n\tnpm install ${pkg}\n\tor\n\tyarn add --dev ${pkg}`);
+    }
+}
+export async function getViteConfig(options, root, port) {
+    const wsPort = await getPort();
+    const wss = new WebSocketServer({ port: wsPort });
+    wss.on('connection', (ws) => ws.on('message', handleBrowserCommand(ws)));
+    /**
+     * user provided vite config
+     */
+    if (options.viteConfig) {
+        options.viteConfig.plugins = [
+            ...(options.viteConfig.plugins || []),
+            testrunner(options)
+        ];
+        options.viteConfig.server = {
+            ...(options.viteConfig.server || {}),
+            proxy: {
+                ...(options.viteConfig.server?.proxy || {}),
+                '/ws': {
+                    target: `ws://localhost:${wsPort}`,
+                    ws: true
+                }
+            }
+        };
+        return [options.viteConfig, wss];
+    }
+    const config = {
+        configFile: false,
+        root,
+        server: {
+            port,
+            host: 'localhost',
+            proxy: {
+                '/ws': {
+                    target: `ws://localhost:${wsPort}`,
+                    ws: true
+                }
+            }
+        },
+        logLevel: 'silent',
+        plugins: [
+            testrunner(options),
+            topLevelAwait()
+        ],
+        optimizeDeps: {
+            include: ['expect', 'jest-matcher-utils'],
+            esbuildOptions: {
+                logLevel: 'silent',
+                // Node.js global to browser globalThis
+                define: {
+                    global: 'globalThis',
+                },
+                // Enable esbuild polyfill plugins
+                plugins: [
+                    NodeGlobalsPolyfillPlugin({
+                        process: true,
+                        buffer: true
+                    }),
+                    esbuildCommonjs(['@testing-library/vue'])
+                ],
+            },
+        }
+    };
+    if (options.preset) {
+        const [pkg, importProp, opts] = PRESET_DEPENDENCIES[options.preset] || [];
+        const plugin = (await userfriendlyImport(options.preset, pkg))[importProp || 'default'];
+        if (plugin) {
+            config.plugins.push(plugin(opts));
+        }
+    }
+    return [config, wss];
+}
+function handleBrowserCommand(ws) {
+    return async (data) => {
+        try {
+            const payload = JSON.parse(data.toString());
+            if (!payload.commandName) {
+                return;
+            }
+            log.info(`Received browser message: ${data}`);
+            const cid = payload.cid;
+            if (typeof cid !== 'string') {
+                return ws.send(JSON.stringify({
+                    id: payload.id,
+                    error: `No "cid" property passed into command message with id "${payload.id}"`
+                }));
+            }
+            const browser = await BROWSER_POOL.get(payload.cid);
+            if (!browser) {
+                return ws.send(JSON.stringify({
+                    id: payload.id,
+                    error: `Couldn't find browser with cid "${payload.cid}"`
+                }));
+            }
+            const result = await browser[payload.commandName](...payload.args);
+            const resultMsg = JSON.stringify({ id: payload.id, result });
+            log.info(`Return command result: ${resultMsg}`);
+            return ws.send(resultMsg);
+        }
+        catch (err) {
+            log.error(`Failed handling command: ${err.message}`);
+            return ws.send(JSON.stringify({ error: `Failed handling command message: ${err.message}` }));
+        }
+    };
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@wdio/browser-runner",
+  "version": "7.20.8-alpha.504+428a9d729",
+  "description": "A WebdriverIO runner to run unit tests tests in the browser.",
+  "author": "Christian Bromann <mail@bromann.dev>",
+  "homepage": "https://github.com/webdriverio/webdriverio/tree/main/packages/wdio-browser-runner",
+  "license": "MIT",
+  "engines": {
+    "node": "^16.13 || >=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/webdriverio/webdriverio.git",
+    "directory": "packages/wdio-browser-runner"
+  },
+  "keywords": [
+    "webdriver",
+    "webdriverio",
+    "wdio",
+    "wdio-runner"
+  ],
+  "bugs": {
+    "url": "https://github.com/webdriverio/webdriverio/issues"
+  },
+  "type": "module",
+  "exports": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "typeScriptVersion": "3.8.3",
+  "dependencies": {
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@esbuild-plugins/node-globals-polyfill": "^0.1.1",
+    "@originjs/vite-plugin-commonjs": "^1.0.3",
+    "@wdio/globals": "7.20.8-alpha.504+428a9d729",
+    "@wdio/local-runner": "7.20.8-alpha.504+428a9d729",
+    "@wdio/logger": "7.20.8-alpha.504+428a9d729",
+    "@wdio/mocha-framework": "7.20.8-alpha.504+428a9d729",
+    "@wdio/protocols": "7.20.8-alpha.504+428a9d729",
+    "@wdio/runner": "7.20.8-alpha.504+428a9d729",
+    "@wdio/types": "7.20.8-alpha.504+428a9d729",
+    "expect-webdriverio": "^4.0.0-alpha.4",
+    "get-port": "^6.1.2",
+    "vite": "^3.1.7",
+    "vite-plugin-top-level-await": "^1.2.1",
+    "webdriver": "7.20.8-alpha.504+428a9d729",
+    "webdriverio": "7.20.8-alpha.504+428a9d729",
+    "ws": "^8.10.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.3"
+  },
+  "gitHead": "428a9d729ae6231968a60908732fa3f607d195e9"
+}