@wdio/browser-runner 9.0.0-alpha.78 → 9.0.0

package/build/communicator.js

@@ -1,82 +0,0 @@
-import libSourceMap from 'istanbul-lib-source-maps';
-import libCoverage from 'istanbul-lib-coverage';
-import logger from '@wdio/logger';
-import { MESSAGE_TYPES } from '@wdio/types';
-import { SESSIONS } from './constants.js';
-import { WDIO_EVENT_NAME } from './constants.js';
-const log = logger('@wdio/browser-runner');
-export class ServerWorkerCommunicator {
-    #mapStore = libSourceMap.createSourceMapStore();
-    #config;
-    #msgId = 0;
-    /**
-     * keep track of custom commands per session
-     */
-    #customCommands = new Map();
-    /**
-     * keep track of request/response messages on browser/worker level
-     */
-    #pendingMessages = new Map();
-    coverageMaps = [];
-    constructor(config) {
-        this.#config = config;
-    }
-    register(server, worker) {
-        server.onBrowserEvent((data, client) => this.#onBrowserEvent(data, client, worker));
-        worker.on('message', this.#onWorkerMessage.bind(this));
-    }
-    async #onWorkerMessage(payload) {
-        if (payload.name === 'sessionStarted' && !SESSIONS.has(payload.cid)) {
-            SESSIONS.set(payload.cid, {
-                args: this.#config.mochaOpts || {},
-                config: this.#config,
-                capabilities: payload.content.capabilities,
-                sessionId: payload.content.sessionId,
-                injectGlobals: payload.content.injectGlobals
-            });
-        }
-        if (payload.name === 'sessionEnded') {
-            SESSIONS.delete(payload.cid);
-        }
-        if (payload.name === 'workerEvent' && payload.args.type === MESSAGE_TYPES.coverageMap) {
-            const coverageMapData = payload.args.value;
-            this.coverageMaps.push(await this.#mapStore.transformCoverage(libCoverage.createCoverageMap(coverageMapData)));
-        }
-        if (payload.name === 'workerEvent' && payload.args.type === MESSAGE_TYPES.customCommand) {
-            const { commandName, cid } = payload.args.value;
-            if (!this.#customCommands.has(cid)) {
-                this.#customCommands.set(cid, new Set());
-            }
-            const customCommands = this.#customCommands.get(cid) || new Set();
-            customCommands.add(commandName);
-            return;
-        }
-        if (payload.name === 'workerResponse') {
-            const msg = this.#pendingMessages.get(payload.args.id);
-            if (!msg) {
-                return log.error(`Couldn't find message with id ${payload.args.id} from type ${payload.args.message.type}`);
-            }
-            this.#pendingMessages.delete(payload.args.id);
-            return msg.client.send(WDIO_EVENT_NAME, payload.args.message);
-        }
-    }
-    #onBrowserEvent(message, client, worker) {
-        /**
-         * some browser events don't need to go through the worker process
-         */
-        if (message.type === MESSAGE_TYPES.initiateBrowserStateRequest) {
-            const result = {
-                type: MESSAGE_TYPES.initiateBrowserStateResponse,
-                value: {
-                    customCommands: [...(this.#customCommands.get(message.value.cid) || [])]
-                }
-            };
-            return client.send(WDIO_EVENT_NAME, result);
-        }
-        const id = this.#msgId++;
-        const msg = { id, client };
-        this.#pendingMessages.set(id, msg);
-        const args = { id, message };
-        return worker.postMessage('workerRequest', args, true);
-    }
-}

package/build/constants.js

@@ -1,89 +0,0 @@
-export const SESSIONS = new Map();
-export const WDIO_EVENT_NAME = 'wdio:workerMessage';
-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 FRAMEWORK_SUPPORT_ERROR = 'Currently only "mocha" is supported as framework when using @wdio/browser-runner.';
-export const DEFAULT_INCLUDE = ['**'];
-export const DEFAULT_FILE_EXTENSIONS = ['.js', '.cjs', '.mjs', '.ts', '.mts', '.cts', '.tsx', '.jsx', '.vue', '.svelte'];
-export const DEFAULT_REPORTS_DIRECTORY = 'coverage';
-export const DEFAULT_AUTOMOCK = true;
-export const DEFAULT_MOCK_DIRECTORY = '__mocks__';
-export const SUMMARY_REPORTER = 'json-summary';
-export const COVERAGE_FACTORS = ['lines', 'functions', 'branches', 'statements'];
-export const DEFAULT_COVERAGE_REPORTS = ['text', 'html', 'clover', SUMMARY_REPORTER];
-export const GLOBAL_TRESHOLD_REPORTING = 'ERROR: Coverage for %s (%s%) does not meet global threshold (%s%)';
-export const FILE_TRESHOLD_REPORTING = 'ERROR: Coverage for %s (%s%) does not meet threshold (%s%) for %s';
-export const MOCHA_VARIABELS = /*css*/ `:root {
-    --mocha-color: #000;
-    --mocha-bg-color: #fff;
-    --mocha-pass-icon-color: #00d6b2;
-    --mocha-pass-color: #fff;
-    --mocha-pass-shadow-color: rgba(0, 0, 0, .2);
-    --mocha-pass-mediump-color: #c09853;
-    --mocha-pass-slow-color: #b94a48;
-    --mocha-test-pending-color: #0b97c4;
-    --mocha-test-pending-icon-color: #0b97c4;
-    --mocha-test-fail-color: #c00;
-    --mocha-test-fail-icon-color: #c00;
-    --mocha-test-fail-pre-color: #000;
-    --mocha-test-fail-pre-error-color: #c00;
-    --mocha-test-html-error-color: #000;
-    --mocha-box-shadow-color: #eee;
-    --mocha-box-bottom-color: #ddd;
-    --mocha-test-replay-color: #000;
-    --mocha-test-replay-bg-color: #eee;
-    --mocha-stats-color: #888;
-    --mocha-stats-em-color: #000;
-    --mocha-stats-hover-color: #eee;
-    --mocha-error-color: #c00;
-
-    --mocha-code-comment: #ddd;
-    --mocha-code-init: #2f6fad;
-    --mocha-code-string: #5890ad;
-    --mocha-code-keyword: #8a6343;
-    --mocha-code-number: #2f6fad;
-}
-
-@media (prefers-color-scheme: dark) {
-    :root {
-        --mocha-color: #fff;
-        --mocha-bg-color: #222;
-        --mocha-pass-icon-color: #00d6b2;
-        --mocha-pass-color: #222;
-        --mocha-pass-shadow-color: rgba(255, 255, 255, .2);
-        --mocha-pass-mediump-color: #f1be67;
-        --mocha-pass-slow-color: #f49896;
-        --mocha-test-pending-color: #0b97c4;
-        --mocha-test-pending-icon-color: #0b97c4;
-        --mocha-test-fail-color: #f44;
-        --mocha-test-fail-icon-color: #f44;
-        --mocha-test-fail-pre-color: #fff;
-        --mocha-test-fail-pre-error-color: #f44;
-        --mocha-test-html-error-color: #fff;
-        --mocha-box-shadow-color: #444;
-        --mocha-box-bottom-color: #555;
-        --mocha-test-replay-color: #fff;
-        --mocha-test-replay-bg-color: #444;
-        --mocha-stats-color: #aaa;
-        --mocha-stats-em-color: #fff;
-        --mocha-stats-hover-color: #444;
-        --mocha-error-color: #f44;
-
-        --mocha-code-comment: #ddd;
-        --mocha-code-init: #9cc7f1;
-        --mocha-code-string: #80d4ff;
-        --mocha-code-keyword: #e3a470;
-        --mocha-code-number: #4ca7ff;
-    }
-}
-`;

package/build/types.js

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

package/build/utils.js

@@ -1,86 +0,0 @@
-import util from 'node:util';
-import { deepmerge } from 'deepmerge-ts';
-import logger from '@wdio/logger';
-import { COVERAGE_FACTORS, GLOBAL_TRESHOLD_REPORTING, FILE_TRESHOLD_REPORTING } from './constants.js';
-const log = logger('@wdio/browser-runner');
-export function makeHeadless(options, caps) {
-    const capability = caps.alwaysMatch || caps;
-    if (!capability.browserName) {
-        throw new Error('No "browserName" defined in capability object. It seems you are trying to run tests ' +
-            'in a non web environment, however WebdriverIOs browser runner only supports web environments');
-    }
-    if (
-    // either user sets headless option implicitly
-    (typeof options.headless === 'boolean' && !options.headless) ||
-        // or CI environment is set
-        (typeof process.env.CI !== 'undefined' && !process.env.CI) ||
-        // or non are set
-        (typeof options.headless !== 'boolean' && typeof process.env.CI === 'undefined')) {
-        return caps;
-    }
-    if (capability.browserName === 'chrome') {
-        return deepmerge(capability, {
-            'goog:chromeOptions': {
-                args: ['headless', 'disable-gpu']
-            }
-        });
-    }
-    else if (capability.browserName === 'firefox') {
-        return deepmerge(capability, {
-            'moz:firefoxOptions': {
-                args: ['-headless']
-            }
-        });
-    }
-    else if (capability.browserName === 'msedge' || capability.browserName === 'edge') {
-        return deepmerge(capability, {
-            'ms:edgeOptions': {
-                args: ['--headless']
-            }
-        });
-    }
-    log.error(`Headless mode not supported for browser "${capability.browserName}"`);
-    return caps;
-}
-/**
- * Open with devtools open when in watch mode
- */
-export function adjustWindowInWatchMode(config, caps) {
-    if (!config.watch) {
-        return caps;
-    }
-    const capability = caps.alwaysMatch || caps;
-    if (config.watch && capability.browserName === 'chrome') {
-        return deepmerge(capability, {
-            'goog:chromeOptions': {
-                args: ['auto-open-devtools-for-tabs', 'window-size=1600,1200'],
-                prefs: {
-                    devtools: {
-                        preferences: {
-                            'panel-selectedTab': '"console"'
-                        }
-                    }
-                }
-            }
-        });
-    }
-    /**
-     * TODO: add support for other browsers (if possible)
-     * } else if (...) { }
-     */
-    return caps;
-}
-export function getCoverageByFactor(options, summary, fileName) {
-    return COVERAGE_FACTORS.map((factor) => {
-        const treshold = options[factor];
-        if (!treshold) {
-            return;
-        }
-        if (summary[factor].pct >= treshold) {
-            return;
-        }
-        return fileName
-            ? util.format(FILE_TRESHOLD_REPORTING, factor, summary[factor].pct, treshold, fileName)
-            : util.format(GLOBAL_TRESHOLD_REPORTING, factor, summary[factor].pct, treshold);
-    }).filter(Boolean);
-}

package/build/vite/constants.js

@@ -1,55 +0,0 @@
-import topLevelAwait from 'vite-plugin-top-level-await';
-import { esbuildCommonjs } from '@originjs/vite-plugin-commonjs';
-import { codeFrameFix } from './plugins/esbuild.js';
-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],
-    solid: ['vite-plugin-solid', 'default', undefined],
-    stencil: undefined,
-    lit: undefined
-};
-export const DEFAULT_VITE_CONFIG = {
-    configFile: false,
-    server: { host: 'localhost' },
-    logLevel: 'silent',
-    plugins: [topLevelAwait()],
-    build: {
-        sourcemap: 'inline',
-        commonjsOptions: {
-            include: [/node_modules/],
-        }
-    },
-    optimizeDeps: {
-        /**
-         * the following deps are CJS packages and need to be optimized (compiled to ESM) by Vite
-         */
-        include: [
-            'expect', 'minimatch', 'css-shorthand-properties', 'lodash.merge', 'lodash.zip', 'ws',
-            'lodash.clonedeep', 'lodash.pickby', 'lodash.flattendeep', 'aria-query', 'grapheme-splitter',
-            'css-value', 'rgb2hex', 'p-iteration', 'deepmerge-ts', 'jest-util', 'jest-matcher-utils', 'split2'
-        ],
-        esbuildOptions: {
-            logLevel: 'silent',
-            // Node.js global to browser globalThis
-            define: {
-                global: 'globalThis',
-            },
-            // Enable esbuild polyfill plugins
-            plugins: [
-                esbuildCommonjs(['@testing-library/vue']),
-                codeFrameFix()
-            ],
-        },
-    }
-};

package/build/vite/frameworks/index.js

@@ -1,19 +0,0 @@
-import { isNuxtFramework, optimizeForNuxt } from './nuxt.js';
-import { isUsingTailwindCSS, optimizeForTailwindCSS } from './tailwindcss.js';
-import { isUsingStencilJS, optimizeForStencil } from './stencil.js';
-export default async function updateViteConfig(options, config) {
-    const optimizations = {};
-    const rootDir = options.rootDir || config.rootDir || process.cwd();
-    const isNuxt = await isNuxtFramework(rootDir);
-    if (isNuxt) {
-        Object.assign(optimizations, await optimizeForNuxt(options, config));
-    }
-    const isTailwind = await isUsingTailwindCSS(rootDir);
-    if (isTailwind) {
-        Object.assign(optimizations, await optimizeForTailwindCSS(rootDir));
-    }
-    if (await isUsingStencilJS(rootDir, options)) {
-        Object.assign(optimizations, await optimizeForStencil(rootDir));
-    }
-    return optimizations;
-}

package/build/vite/frameworks/nuxt.js

@@ -1,61 +0,0 @@
-import url from 'node:url';
-import path from 'node:path';
-import logger from '@wdio/logger';
-import { resolve } from 'import-meta-resolve';
-import { hasFileByExtensions, hasDir } from '../utils.js';
-const log = logger('@wdio/browser-runner:NuxtOptimization');
-export async function isNuxtFramework(rootDir) {
-    return (await Promise.all([
-        hasFileByExtensions(path.join(rootDir, 'nuxt.config')),
-        hasDir(path.join(rootDir, '.nuxt'))
-    ])).filter(Boolean).length > 0;
-}
-export async function optimizeForNuxt(options, config) {
-    const Unimport = (await import('unimport/unplugin')).default;
-    const { scanDirExports, scanExports } = await import('unimport');
-    const { loadNuxtConfig } = await import('@nuxt/kit');
-    const rootDir = config.rootDir || process.cwd();
-    const nuxtOptions = await loadNuxtConfig({ rootDir });
-    if (nuxtOptions.imports?.autoImport === false) {
-        return {};
-    }
-    const nuxtDepPath = await resolve('nuxt', import.meta.url);
-    const composablesDirs = [];
-    for (const layer of nuxtOptions._layers) {
-        composablesDirs.push(path.resolve(layer.config.srcDir, 'composables'));
-        composablesDirs.push(path.resolve(layer.config.srcDir, 'utils'));
-        for (const dir of (layer.config.imports?.dirs ?? [])) {
-            if (!dir) {
-                continue;
-            }
-            composablesDirs.push(path.resolve(layer.config.srcDir, dir));
-        }
-    }
-    const composableImports = await Promise.all([
-        scanDirExports([
-            ...composablesDirs,
-            path.resolve(path.dirname(url.fileURLToPath(nuxtDepPath)), 'app', 'components')
-        ]),
-        scanExports(path.resolve(path.dirname(url.fileURLToPath(nuxtDepPath)), 'app', 'composables', 'index.js'))
-    ]).then((scannedExports) => scannedExports.flat().map((ci) => {
-        /**
-         * auto mock nuxt composables as they can't be loaded within the browser
-         */
-        if (ci.from.includes('/nuxt/dist/app/composables')) {
-            ci.from = 'virtual:wdio';
-            ci.name = 'wrappedFn';
-        }
-        return ci;
-    }));
-    const viteConfig = {
-        resolve: {
-            alias: nuxtOptions.alias || {}
-        },
-        plugins: [Unimport.vite({
-                presets: ['vue'],
-                imports: composableImports
-            })]
-    };
-    log.info(`Optimized Vite config for Nuxt project at ${rootDir}`);
-    return viteConfig;
-}

package/build/vite/frameworks/stencil.js

@@ -1,165 +0,0 @@
-import path from 'node:path';
-import url from 'node:url';
-import { findStaticImports, parseStaticImport } from 'mlly';
-import { hasFileByExtensions } from '../utils.js';
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url));
-const STENCIL_IMPORT = '@stencil/core';
-export async function isUsingStencilJS(rootDir, options) {
-    return Boolean(options.preset === 'stencil' || await hasFileByExtensions(path.join(rootDir, 'stencil.config')));
-}
-export async function optimizeForStencil(rootDir) {
-    const stencilConfig = await importStencilConfig(rootDir);
-    const stencilPlugins = stencilConfig.config.plugins;
-    const stencilOptimizations = {
-        plugins: [await stencilVitePlugin(rootDir)],
-        optimizeDeps: { include: [] }
-    };
-    if (stencilPlugins) {
-        const esbuildPlugin = stencilPlugins.find((plugin) => plugin.name === 'esbuild-plugin');
-        if (esbuildPlugin) {
-            stencilOptimizations.optimizeDeps?.include?.push(...esbuildPlugin.options.include);
-        }
-    }
-    /**
-     * testing helper from the stencil core package is unfortunately exported as CJS
-     * module, in order to be able to use it in the browser we have to optimize it
-     * it to compile it to ESM
-     */
-    stencilOptimizations.optimizeDeps?.include?.push('@wdio/browser-runner/stencil > @stencil/core/internal/testing/index.js');
-    return stencilOptimizations;
-}
-async function stencilVitePlugin(rootDir) {
-    const { transpileSync, ts } = await import('@stencil/core/compiler/stencil.js');
-    const stencilHelperPath = path.resolve(__dirname, '..', '..', 'browser', 'integrations', 'stencil.js');
-    return {
-        name: 'wdio-stencil',
-        enforce: 'pre',
-        resolveId(source) {
-            if (source === '@wdio/browser-runner/stencil') {
-                return stencilHelperPath;
-            }
-        },
-        transform: function (code, id) {
-            const staticImports = findStaticImports(code);
-            const stencilImports = staticImports
-                .filter((imp) => imp.specifier === STENCIL_IMPORT)
-                .map((imp) => parseStaticImport(imp));
-            const isStencilComponent = stencilImports.some((imp) => 'Component' in (imp.namedImports || {}));
-            /**
-             * if file doesn't define a Stencil component
-             */
-            if (!isStencilComponent) {
-                /**
-                 * if a test imports the `@wdio/browser-runner/stencil` package we want to automatically
-                 * import `h` and `Fragment` from the `@stencil/core` package
-                 */
-                const stencilHelperImport = staticImports.find((imp) => imp.specifier === '@wdio/browser-runner/stencil');
-                if (stencilHelperImport) {
-                    const imports = parseStaticImport(stencilHelperImport);
-                    if ('render' in (imports.namedImports || {})) {
-                        code = injectStencilImports(code, stencilImports);
-                    }
-                }
-                return { code };
-            }
-            const tsCompilerOptions = getCompilerOptions(ts, rootDir);
-            const opts = {
-                componentExport: 'module',
-                componentMetadata: 'compilerstatic',
-                coreImportPath: '@stencil/core/internal/client',
-                currentDirectory: rootDir,
-                file: path.basename(id),
-                module: 'esm',
-                sourceMap: 'inline',
-                style: 'static',
-                proxy: 'defineproperty',
-                styleImportData: 'queryparams',
-                transformAliasedImportPaths: process.env.__STENCIL_TRANSPILE_PATHS__ === 'true',
-                target: tsCompilerOptions?.target || 'es2018',
-                paths: tsCompilerOptions?.paths,
-                baseUrl: tsCompilerOptions?.baseUrl,
-            };
-            const transpiledCode = transpileSync(code, opts);
-            /**
-             * StencilJS applies only a getter to the component without having a setter defined.
-             * This causes issue in the browser as there is a check that the setter is defined
-             * if the getter is defined. We can work around this by defining a setter.
-             */
-            let transformedCode = transpiledCode.code.replace('static get style()', 'static set style(_) {}\n    static get style()');
-            /**
-             * StencilJS does not import the `h` or `Fragment` function by default. We need to add it so the user
-             * doesn't need to.
-             */
-            transformedCode = injectStencilImports(transformedCode, stencilImports);
-            /**
-             * Ensure that CSS imports by Stencil have an `&inline` query parameter
-             */
-            findStaticImports(transformedCode)
-                .filter((imp) => imp.specifier.includes('&encapsulation=shadow'))
-                .forEach((imp) => {
-                const cssPath = path.resolve(path.dirname(id), imp.specifier);
-                transformedCode = transformedCode.replace(imp.code, `import ${imp.imports.trim()} from '/@fs/${cssPath}&inline';\n`);
-            });
-            return {
-                ...transpiledCode,
-                code: transformedCode,
-                inputFilePath: id
-            };
-        }
-    };
-}
-/**
- * StencilJS does not import the `h` or `Fragment` function by default. We need to add it so the user
- * doesn't need to.
- */
-function injectStencilImports(code, imports) {
-    const hasRenderFunctionImport = imports.some((imp) => 'h' in (imp.namedImports || {}));
-    if (!hasRenderFunctionImport) {
-        code = `import { h } from '@stencil/core/internal/client';\n${code}`;
-    }
-    const hasFragmentImport = imports.some((imp) => 'Fragment' in (imp.namedImports || {}));
-    if (!hasFragmentImport) {
-        code = `import { Fragment } from '@stencil/core/internal/client';\n${code}`;
-    }
-    return code;
-}
-let _tsCompilerOptions = null;
-/**
- * Read the TypeScript compiler configuration file from disk
- * @param rootDir the location to search for the config file
- * @returns the configuration, or `null` if the file cannot be found
- */
-function getCompilerOptions(ts, rootDir) {
-    if (_tsCompilerOptions) {
-        return _tsCompilerOptions;
-    }
-    if (typeof rootDir !== 'string') {
-        return null;
-    }
-    const tsconfigFilePath = ts.findConfigFile(rootDir, ts.sys.fileExists);
-    if (!tsconfigFilePath) {
-        return null;
-    }
-    const tsconfigResults = ts.readConfigFile(tsconfigFilePath, ts.sys.readFile);
-    if (tsconfigResults.error) {
-        throw new Error(tsconfigResults.error);
-    }
-    const parseResult = ts.parseJsonConfigFileContent(tsconfigResults.config, ts.sys, rootDir, undefined, tsconfigFilePath);
-    _tsCompilerOptions = parseResult.options;
-    return _tsCompilerOptions;
-}
-/**
- * helper method to import a Stencil config file
- */
-export async function importStencilConfig(rootDir) {
-    const configPath = path.join(rootDir, 'stencil.config.ts');
-    const config = await import(configPath).catch(() => ({ config: {} }));
-    /**
-     * if we import the config within a CJS environment we need to
-     * access the default property even though there is a named export
-     */
-    if ('default' in config) {
-        return config.default;
-    }
-    return config;
-}

package/build/vite/frameworks/tailwindcss.js

@@ -1,28 +0,0 @@
-import url from 'node:url';
-import path from 'node:path';
-import { resolve } from 'import-meta-resolve';
-import { hasFileByExtensions } from '../utils.js';
-/**
- * returns `true` if TailwindCSS config exist but no postcss.config
- * (if a `postcss.config` exists it will be automatically picked up by Vite)
- */
-export function isUsingTailwindCSS(rootDir) {
-    return Promise.all([
-        hasFileByExtensions(path.join(rootDir, 'tailwind.config')),
-        hasFileByExtensions(path.join(rootDir, 'postcss.config'))
-    ]).then(([hasTailwindConfig, hasPostCSSConfig]) => {
-        return hasTailwindConfig && !hasPostCSSConfig;
-    });
-}
-/**
- * add tailwind plugin if installed as dependency
- */
-export async function optimizeForTailwindCSS(rootDir) {
-    const viteConfig = {};
-    const tailwindcssPath = await resolve('tailwindcss', url.pathToFileURL(path.resolve(rootDir, 'index.js')).href);
-    const tailwindcss = (await import(tailwindcssPath)).default;
-    viteConfig.css = {
-        postcss: { plugins: [tailwindcss] }
-    };
-    return viteConfig;
-}

package/build/vite/mock.js

@@ -1,50 +0,0 @@
-import path from 'node:path';
-import { getManualMocks } from './utils.js';
-import { DEFAULT_MOCK_DIRECTORY, DEFAULT_AUTOMOCK } from '../constants.js';
-const FIXTURE_PREFIX = '/@fixture/';
-export class MockHandler {
-    #automock;
-    #automockDir;
-    #manualMocksList;
-    #mocks = new Map();
-    #unmocked = [];
-    manualMocks = [];
-    constructor(options, config) {
-        this.#automock = typeof options.automock === 'boolean' ? options.automock : DEFAULT_AUTOMOCK;
-        this.#automockDir = path.resolve(config.rootDir, options.automockDir || DEFAULT_MOCK_DIRECTORY);
-        this.#manualMocksList = getManualMocks(this.#automockDir);
-    }
-    get mocks() {
-        return this.#mocks;
-    }
-    unmock(moduleName) {
-        this.#unmocked.push(moduleName);
-    }
-    async resolveId(id) {
-        const manualMocksList = await this.#manualMocksList;
-        const mockPath = manualMocksList.find((m) => (
-        // e.g. someModule
-        id === m[1].replace(path.sep, '/') ||
-            // e.g. @some/module
-            id.slice(1) === m[1].replace(path.sep, '/')));
-        /**
-         * return manual mock if `automock` is enabled or a manual mock was set via `mock('module')`
-         */
-        if ((this.manualMocks.includes(id) || this.#automock) && mockPath && !this.#unmocked.includes(id)) {
-            return mockPath[0];
-        }
-        /**
-         * return fixture
-         */
-        if (id.startsWith(FIXTURE_PREFIX)) {
-            return path.resolve(this.#automockDir, id.slice(FIXTURE_PREFIX.length));
-        }
-    }
-    /**
-     * reset manual mocks between tests
-     */
-    resetMocks() {
-        this.manualMocks = [];
-        this.#unmocked = [];
-    }
-}

package/build/vite/plugins/esbuild.js

@@ -1,25 +0,0 @@
-import fs from 'node:fs/promises';
-export function codeFrameFix() {
-    return {
-        name: 'wdio:codeFrameFix',
-        setup(build) {
-            build.onLoad({ filter: /@babel\/code-frame/, namespace: 'file' }, 
-            /**
-             * mock @babel/code-frame as it fails in Safari due
-             * to usage of chalk
-             */
-            async ({ path: id }) => {
-                const code = await fs.readFile(id).then((buf) => buf.toString(), () => undefined);
-                if (!code) {
-                    return;
-                }
-                return {
-                    contents: code.replace('require("@babel/highlight");', /*js*/ `{
-                            shouldHighlight: false,
-                            reset: () => {}
-                        }`)
-                };
-            });
-        }
-    };
-}