@vitest/browser 2.0.4 → 2.1.0-beta.1

package/dist/locators/index.d.ts

@@ -0,0 +1,261 @@
+import { UserEventClickOptions, UserEventHoverOptions, UserEventFillOptions, UserEventDragAndDropOptions, LocatorScreenshotOptions, LocatorByRoleOptions, LocatorOptions } from '@vitest/browser/context';
+
+type ClauseCombinator = '' | '>' | '+' | '~' | '>=';
+type CSSFunctionArgument = CSSComplexSelector | number | string;
+interface CSSFunction {
+    name: string;
+    args: CSSFunctionArgument[];
+}
+interface CSSSimpleSelector {
+    css?: string;
+    functions: CSSFunction[];
+}
+interface CSSComplexSelector {
+    simples: {
+        selector: CSSSimpleSelector;
+        combinator: ClauseCombinator;
+    }[];
+}
+type CSSComplexSelectorList = CSSComplexSelector[];
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface NestedSelectorBody {
+    parsed: ParsedSelector;
+    distance?: number;
+}
+interface ParsedSelectorPart {
+    name: string;
+    body: string | CSSComplexSelectorList | NestedSelectorBody;
+    source: string;
+}
+interface ParsedSelector {
+    parts: ParsedSelectorPart[];
+    capture?: number;
+}
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface GenerateSelectorOptions {
+    testIdAttributeName: string;
+}
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface ElementText {
+    full: string;
+    normalized: string;
+    immediate: string[];
+}
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface QueryContext {
+    scope: Element | Document;
+    pierceShadow: boolean;
+    originalScope?: Element | Document;
+}
+type Selector = any;
+interface SelectorEvaluator {
+    query: (context: QueryContext, selector: Selector) => Element[];
+    matches: (element: Element, selector: Selector, context: QueryContext) => boolean;
+}
+interface SelectorEngine$1 {
+    matches?: (element: Element, args: (string | number | Selector)[], context: QueryContext, evaluator: SelectorEvaluator) => boolean;
+    query?: (context: QueryContext, args: (string | number | Selector)[], evaluator: SelectorEvaluator) => Element[];
+}
+declare class SelectorEvaluatorImpl implements SelectorEvaluator {
+    private _engines;
+    private _cacheQueryCSS;
+    private _cacheMatches;
+    private _cacheQuery;
+    private _cacheMatchesSimple;
+    private _cacheMatchesParents;
+    private _cacheCallMatches;
+    private _cacheCallQuery;
+    private _cacheQuerySimple;
+    _cacheText: Map<Element | ShadowRoot, ElementText>;
+    private _scoreMap;
+    private _retainCacheCounter;
+    constructor(extraEngines: Map<string, SelectorEngine$1>);
+    begin(): void;
+    end(): void;
+    private _cached;
+    private _checkSelector;
+    matches(element: Element, s: Selector, context: QueryContext): boolean;
+    query(context: QueryContext, s: any): Element[];
+    _markScore(element: Element, score: number): void;
+    private _hasScopeClause;
+    private _expandContextForScopeMatching;
+    private _matchesSimple;
+    private _querySimple;
+    private _matchesParents;
+    private _matchesEngine;
+    private _queryEngine;
+    private _callMatches;
+    private _callQuery;
+    private _matchesCSS;
+    _queryCSS(context: QueryContext, css: string): Element[];
+    private _getEngine;
+}
+
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+interface IvyaOptions {
+    testIdAttribute: string;
+    browser: 'webkit' | 'chromium' | 'firefox';
+}
+interface IvyaConfiguration {
+    testIdAttribute?: string;
+    browser: 'webkit' | 'chromium' | 'firefox';
+}
+declare class Ivya {
+    /** @internal */
+    _engines: Map<string, SelectorEngine>;
+    /** @internal */
+    _evaluator: SelectorEvaluatorImpl;
+    static options: IvyaOptions;
+    private static singleton;
+    static create(options: IvyaConfiguration): Ivya;
+    private constructor();
+    queryLocatorSelector(locator: string, root?: Node, strict?: boolean): Element | null;
+    queryLocatorSelectorAll(locator: string, root?: Node): Element[];
+    querySelector(selector: ParsedSelector, root: Node, strict?: boolean): Element | null;
+    private strictModeViolationError;
+    generateSelectorSimple(targetElement: Element, options?: GenerateSelectorOptions): string;
+    parseSelector(selector: string): ParsedSelector;
+    previewNode(node: Node): string;
+    querySelectorAll(selector: ParsedSelector, root: Node): Element[];
+    private _queryEngineAll;
+    private _queryNth;
+    private _queryLayoutSelector;
+    private createStacklessError;
+    private _createTextEngine;
+    private _createAttributeEngine;
+    private _createCSSEngine;
+    private _createNamedAttributeEngine;
+    private _createVisibleEngine;
+    private _createHasEngine;
+    private _createHasNotEngine;
+    private _createInternalChainEngine;
+    private _createInternalLabelEngine;
+    private _createInternalHasTextEngine;
+    private _createInternalHasNotTextEngine;
+}
+type SelectorRoot = Element | ShadowRoot | Document;
+interface SelectorEngine {
+    queryAll: (root: SelectorRoot, selector: string | any) => Element[];
+}
+
+declare const selectorEngine: Ivya;
+declare abstract class Locator {
+    abstract selector: string;
+    private _parsedSelector;
+    protected _pwSelector?: string | undefined;
+    protected _forceElement?: Element | undefined;
+    click(options?: UserEventClickOptions): Promise<void>;
+    dblClick(options?: UserEventClickOptions): Promise<void>;
+    tripleClick(options?: UserEventClickOptions): Promise<void>;
+    clear(): Promise<void>;
+    hover(options: UserEventHoverOptions): Promise<void>;
+    unhover(options: UserEventHoverOptions): Promise<void>;
+    fill(text: string, options?: UserEventFillOptions): Promise<void>;
+    dropTo(target: Locator, options?: UserEventDragAndDropOptions): Promise<void>;
+    selectOptions(value: HTMLElement | HTMLElement[] | Locator | Locator[] | string | string[]): Promise<void>;
+    screenshot(options: Omit<LocatorScreenshotOptions, 'base64'> & {
+        base64: true;
+    }): Promise<{
+        path: string;
+        base64: string;
+    }>;
+    screenshot(options?: LocatorScreenshotOptions): Promise<string>;
+    protected abstract locator(selector: string): Locator;
+    protected abstract elementLocator(element: Element): Locator;
+    getByRole(role: string, options?: LocatorByRoleOptions): Locator;
+    getByAltText(text: string | RegExp, options?: LocatorOptions): Locator;
+    getByLabelText(text: string | RegExp, options?: LocatorOptions): Locator;
+    getByPlaceholder(text: string | RegExp, options?: LocatorOptions): Locator;
+    getByTestId(testId: string | RegExp): Locator;
+    getByText(text: string | RegExp, options?: LocatorOptions): Locator;
+    getByTitle(title: string | RegExp, options?: LocatorOptions): Locator;
+    query(): Element | null;
+    element(): Element;
+    elements(): Element[];
+    all(): Locator[];
+    private get state();
+    private get worker();
+    private get rpc();
+    protected triggerCommand<T>(command: string, ...args: any[]): Promise<T>;
+}
+
+export { Locator, selectorEngine };

package/dist/locators/index.js

@@ -0,0 +1,2 @@
+import '@vitest/browser/context';
+export { L as Locator, s as selectorEngine } from '../index-BRfqvYVY.js';

package/dist/locators/playwright.js

@@ -0,0 +1,42 @@
+import { page, server } from '@vitest/browser/context';
+import { g as getByLabelSelector, a as getByRoleSelector, b as getByTestIdSelector, c as getByAltTextSelector, d as getByPlaceholderSelector, e as getByTextSelector, f as getByTitleSelector, s as selectorEngine, L as Locator } from '../index-BRfqvYVY.js';
+
+page.extend({
+  getByLabelText(text, options) {
+    return new PlaywrightLocator(getByLabelSelector(text, options));
+  },
+  getByRole(role, options) {
+    return new PlaywrightLocator(getByRoleSelector(role, options));
+  },
+  getByTestId(testId) {
+    return new PlaywrightLocator(getByTestIdSelector(server.config.browser.locators.testIdAttribute, testId));
+  },
+  getByAltText(text, options) {
+    return new PlaywrightLocator(getByAltTextSelector(text, options));
+  },
+  getByPlaceholder(text, options) {
+    return new PlaywrightLocator(getByPlaceholderSelector(text, options));
+  },
+  getByText(text, options) {
+    return new PlaywrightLocator(getByTextSelector(text, options));
+  },
+  getByTitle(title, options) {
+    return new PlaywrightLocator(getByTitleSelector(title, options));
+  },
+  elementLocator(element) {
+    return new PlaywrightLocator(selectorEngine.generateSelectorSimple(element), element);
+  }
+});
+class PlaywrightLocator extends Locator {
+  constructor(selector, _forceElement) {
+    super();
+    this.selector = selector;
+    this._forceElement = _forceElement;
+  }
+  locator(selector) {
+    return new PlaywrightLocator(`${this.selector} >> ${selector}`);
+  }
+  elementLocator(element) {
+    return new PlaywrightLocator(selectorEngine.generateSelectorSimple(element), element);
+  }
+}

package/dist/locators/preview.js

@@ -0,0 +1,86 @@
+import { page, server } from '@vitest/browser/context';
+import { userEvent } from '@testing-library/user-event';
+import { g as getByLabelSelector, a as getByRoleSelector, b as getByTestIdSelector, c as getByAltTextSelector, d as getByPlaceholderSelector, e as getByTextSelector, f as getByTitleSelector, s as selectorEngine, L as Locator, h as convertElementToCssSelector } from '../index-BRfqvYVY.js';
+
+page.extend({
+  getByLabelText(text, options) {
+    return new PreviewLocator(getByLabelSelector(text, options));
+  },
+  getByRole(role, options) {
+    return new PreviewLocator(getByRoleSelector(role, options));
+  },
+  getByTestId(testId) {
+    return new PreviewLocator(getByTestIdSelector(server.config.browser.locators.testIdAttribute, testId));
+  },
+  getByAltText(text, options) {
+    return new PreviewLocator(getByAltTextSelector(text, options));
+  },
+  getByPlaceholder(text, options) {
+    return new PreviewLocator(getByPlaceholderSelector(text, options));
+  },
+  getByText(text, options) {
+    return new PreviewLocator(getByTextSelector(text, options));
+  },
+  getByTitle(title, options) {
+    return new PreviewLocator(getByTitleSelector(title, options));
+  },
+  elementLocator(element) {
+    return new PreviewLocator(selectorEngine.generateSelectorSimple(element), element);
+  }
+});
+class PreviewLocator extends Locator {
+  constructor(_pwSelector, _forceElement) {
+    super();
+    this._pwSelector = _pwSelector;
+    this._forceElement = _forceElement;
+  }
+  get selector() {
+    const selectors = this.elements().map((element) => convertElementToCssSelector(element));
+    if (!selectors.length) {
+      throw new Error(`element not found: ${this._pwSelector}`);
+    }
+    return selectors.join(", ");
+  }
+  click() {
+    return userEvent.click(this.element());
+  }
+  dblClick() {
+    return userEvent.dblClick(this.element());
+  }
+  tripleClick() {
+    return userEvent.tripleClick(this.element());
+  }
+  hover() {
+    return userEvent.hover(this.element());
+  }
+  unhover() {
+    return userEvent.unhover(this.element());
+  }
+  fill(text) {
+    return userEvent.type(this.element(), text);
+  }
+  selectOptions(options_) {
+    const options = (Array.isArray(options_) ? options_ : [options_]).map((option) => {
+      if (typeof option !== "string" && "element" in option) {
+        return option.element();
+      }
+      return option;
+    });
+    return userEvent.selectOptions(this.element(), options);
+  }
+  async dropTo() {
+    throw new Error('The "preview" provider doesn\'t support `dropTo` method.');
+  }
+  clear() {
+    return userEvent.clear(this.element());
+  }
+  async screenshot() {
+    throw new Error('The "preview" provider doesn\'t support `screenshot` method.');
+  }
+  locator(selector) {
+    return new PreviewLocator(`${this._pwSelector} >> ${selector}`);
+  }
+  elementLocator(element) {
+    return new PreviewLocator(selectorEngine.generateSelectorSimple(element), element);
+  }
+}

package/dist/locators/webdriverio.js

@@ -0,0 +1,83 @@
+import { page, server } from '@vitest/browser/context';
+import { g as getByLabelSelector, a as getByRoleSelector, b as getByTestIdSelector, c as getByAltTextSelector, d as getByPlaceholderSelector, e as getByTextSelector, f as getByTitleSelector, s as selectorEngine, L as Locator, h as convertElementToCssSelector } from '../index-BRfqvYVY.js';
+
+page.extend({
+  getByLabelText(text, options) {
+    return new WebdriverIOLocator(getByLabelSelector(text, options));
+  },
+  getByRole(role, options) {
+    return new WebdriverIOLocator(getByRoleSelector(role, options));
+  },
+  getByTestId(testId) {
+    return new WebdriverIOLocator(getByTestIdSelector(server.config.browser.locators.testIdAttribute, testId));
+  },
+  getByAltText(text, options) {
+    return new WebdriverIOLocator(getByAltTextSelector(text, options));
+  },
+  getByPlaceholder(text, options) {
+    return new WebdriverIOLocator(getByPlaceholderSelector(text, options));
+  },
+  getByText(text, options) {
+    return new WebdriverIOLocator(getByTextSelector(text, options));
+  },
+  getByTitle(title, options) {
+    return new WebdriverIOLocator(getByTitleSelector(title, options));
+  },
+  elementLocator(element) {
+    return new WebdriverIOLocator(selectorEngine.generateSelectorSimple(element), element);
+  }
+});
+class WebdriverIOLocator extends Locator {
+  constructor(_pwSelector, _forceElement) {
+    super();
+    this._pwSelector = _pwSelector;
+    this._forceElement = _forceElement;
+  }
+  get selector() {
+    const selectors = this.elements().map((element) => convertElementToCssSelector(element));
+    if (!selectors.length) {
+      throw new Error(`element not found: ${this._pwSelector}`);
+    }
+    return selectors.join(", ");
+  }
+  selectOptions(value) {
+    const values = getWebdriverioSelectOptions(this.element(), value);
+    return this.triggerCommand("__vitest_selectOptions", this.selector, values);
+  }
+  locator(selector) {
+    return new WebdriverIOLocator(`${this._pwSelector} >> ${selector}`);
+  }
+  elementLocator(element) {
+    return new WebdriverIOLocator(selectorEngine.generateSelectorSimple(element), element);
+  }
+}
+function getWebdriverioSelectOptions(element, value) {
+  const options = [...element.querySelectorAll("option")];
+  const arrayValues = Array.isArray(value) ? value : [value];
+  if (!arrayValues.length) {
+    return [];
+  }
+  if (arrayValues.length > 1) {
+    throw new Error(`Provider "webdriverio" doesn't support selecting multiple values at once`);
+  }
+  const optionValue = arrayValues[0];
+  if (typeof optionValue !== "string") {
+    const element2 = "element" in optionValue ? optionValue.element() : optionValue;
+    const index = options.indexOf(element2);
+    if (index === -1) {
+      throw new Error(`The element ${selectorEngine.previewNode(element2)} was not found in the "select" options.`);
+    }
+    return [{ index }];
+  }
+  const valueIndex = options.findIndex((option) => option.value === optionValue);
+  if (valueIndex !== -1) {
+    return [{ index: valueIndex }];
+  }
+  const labelIndex = options.findIndex(
+    (option) => option.textContent?.trim() === optionValue || option.ariaLabel === optionValue
+  );
+  if (labelIndex === -1) {
+    throw new Error(`The option "${optionValue}" was not found in the "select" options.`);
+  }
+  return [{ index: labelIndex }];
+}

package/jest-dom.d.ts

@@ -1,102 +1,6 @@
 // Disable automatic exports.
 
-
-type ARIAWidgetRole =
-    | "button"
-    | "checkbox"
-    | "gridcell"
-    | "link"
-    | "menuitem"
-    | "menuitemcheckbox"
-    | "menuitemradio"
-    | "option"
-    | "progressbar"
-    | "radio"
-    | "scrollbar"
-    | "searchbox"
-    | "slider"
-    | "spinbutton"
-    | "switch"
-    | "tab"
-    | "tabpanel"
-    | "textbox"
-    | "treeitem";
-
-type ARIACompositeWidgetRole =
-    | "combobox"
-    | "grid"
-    | "listbox"
-    | "menu"
-    | "menubar"
-    | "radiogroup"
-    | "tablist"
-    | "tree"
-    | "treegrid";
-
-type ARIADocumentStructureRole =
-    | "application"
-    | "article"
-    | "blockquote"
-    | "caption"
-    | "cell"
-    | "columnheader"
-    | "definition"
-    | "deletion"
-    | "directory"
-    | "document"
-    | "emphasis"
-    | "feed"
-    | "figure"
-    | "generic"
-    | "group"
-    | "heading"
-    | "img"
-    | "insertion"
-    | "list"
-    | "listitem"
-    | "math"
-    | "meter"
-    | "none"
-    | "note"
-    | "paragraph"
-    | "presentation"
-    | "row"
-    | "rowgroup"
-    | "rowheader"
-    | "separator"
-    | "strong"
-    | "subscript"
-    | "superscript"
-    | "table"
-    | "term"
-    | "time"
-    | "toolbar"
-    | "tooltip";
-
-type ARIALandmarkRole =
-    | "banner"
-    | "complementary"
-    | "contentinfo"
-    | "form"
-    | "main"
-    | "navigation"
-    | "region"
-    | "search";
-
-type ARIALiveRegionRole = "alert" | "log" | "marquee" | "status" | "timer";
-
-type ARIAWindowRole = "alertdialog" | "dialog";
-
-type ARIAUncategorizedRole = "code";
-
-type ARIARole =
-    | ARIAWidgetRole
-    | ARIACompositeWidgetRole
-    | ARIADocumentStructureRole
-    | ARIALandmarkRole
-    | ARIALiveRegionRole
-    | ARIAWindowRole
-    | ARIAUncategorizedRole;
+import { ARIARole } from './aria-role.ts'
 
 declare namespace matchers {
   interface TestingLibraryMatchers<E, R> {

package/matchers.d.ts

@@ -1,3 +1,4 @@
+import type { Locator } from '@vitest/browser/context'
 import type jsdomMatchers from './jest-dom.js'
 import type { Assertion } from 'vitest'
 
@@ -15,7 +16,7 @@ declare module 'vitest' {
   type PromisifyDomAssertion<T> = Promisify<Assertion<T>>
 
   interface ExpectStatic {
-    element: <T extends Element>(element: T, options?: ExpectPollOptions) => PromisifyDomAssertion<Awaited<T>>
+    element: <T extends Element | Locator>(element: T, options?: ExpectPollOptions) => PromisifyDomAssertion<Awaited<Element>>
   }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/browser",
   "type": "module",
-  "version": "2.0.4",
+  "version": "2.1.0-beta.1",
   "description": "Browser running for Vitest",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -40,6 +40,10 @@
     "./providers/playwright": {
       "types": "./providers/playwright.d.ts"
     },
+    "./locator": {
+      "types": "./dist/locators/index.d.ts",
+      "default": "./dist/locators/index.js"
+    },
     "./*": "./*"
   },
   "main": "./dist/index.js",
@@ -54,7 +58,7 @@
   "peerDependencies": {
     "playwright": "*",
     "webdriverio": "*",
-    "vitest": "2.0.4"
+    "vitest": "2.1.0-beta.1"
   },
   "peerDependenciesMeta": {
     "playwright": {
@@ -68,30 +72,31 @@
     }
   },
   "dependencies": {
-    "@testing-library/dom": "^10.3.1",
+    "@testing-library/dom": "^10.4.0",
     "@testing-library/user-event": "^14.5.2",
-    "magic-string": "^0.30.10",
-    "msw": "^2.3.1",
+    "magic-string": "^0.30.11",
+    "msw": "^2.3.5",
     "sirv": "^2.0.4",
     "ws": "^8.18.0",
-    "@vitest/utils": "2.0.4"
+    "@vitest/utils": "2.1.0-beta.1"
   },
   "devDependencies": {
-    "@testing-library/jest-dom": "^6.4.6",
-    "@types/ws": "^8.5.11",
+    "@testing-library/jest-dom": "^6.4.8",
+    "@types/ws": "^8.5.12",
     "@wdio/protocols": "^8.38.0",
     "birpc": "0.2.17",
     "flatted": "^3.3.1",
+    "ivya": "^1.1.0",
     "pathe": "^1.1.2",
     "periscopic": "^4.0.2",
-    "playwright": "^1.45.1",
-    "playwright-core": "^1.45.1",
+    "playwright": "^1.45.3",
+    "playwright-core": "^1.45.3",
     "safaridriver": "^0.1.2",
     "webdriverio": "^8.39.1",
-    "@vitest/ui": "2.0.4",
-    "@vitest/runner": "2.0.4",
-    "@vitest/ws-client": "2.0.4",
-    "vitest": "2.0.4"
+    "@vitest/runner": "2.1.0-beta.1",
+    "@vitest/ui": "2.1.0-beta.1",
+    "@vitest/ws-client": "2.1.0-beta.1",
+    "vitest": "2.1.0-beta.1"
   },
   "scripts": {
     "build": "rimraf dist && pnpm build:node && pnpm build:client",

package/providers/playwright.d.ts

@@ -39,9 +39,10 @@ declare module '@vitest/browser/context' {
   export interface UserEventHoverOptions extends PWHoverOptions {}
   export interface UserEventClickOptions extends PWClickOptions {}
   export interface UserEventDoubleClickOptions extends PWDoubleClickOptions {}
+  export interface UserEventTripleClickOptions extends PWClickOptions {}
   export interface UserEventFillOptions extends PWFillOptions {}
   export interface UserEventSelectOptions extends PWSelectOptions {}
-  export interface UserEventDragOptions extends UserEventDragAndDropOptions {}
+  export interface UserEventDragAndDropOptions extends PWDragAndDropOptions {}
 
   export interface ScreenshotOptions extends PWScreenshotOptions {}