@serenity-js/webdriverio 2.32.2 → 3.0.0-rc.0

package/src/screenplay/questions/Text.ts

@@ -1,140 +0,0 @@
-import { Answerable, AnswersQuestions, MetaQuestion, Question, UsesAbilities } from '@serenity-js/core';
-import type { Element, ElementArray } from 'webdriverio';
-
-import { TargetNestedElement, TargetNestedElements } from './targets';
-
-/**
- * @desc
- *  Resolves to the visible (i.e. not hidden by CSS) `innerText` of:
- *  - a given {@link WebElement}, represented by Answerable<{@link @wdio/types~Element}>
- *  - a group of {@link WebElement}s, represented by Answerable<{@link @wdio/types~ElementArray}>
- *
- *  The result includes the visible text of any sub-elements, without any leading or trailing whitespace.
- *
- * @example <caption>Example widget</caption>
- *  <h1>Shopping list</h1>
- *  <ul id="shopping-list">
- *    <li>Coffee<li>
- *    <li class="bought">Honey<li>
- *    <li>Chocolate<li>
- *  </ul>
- *
- * @example <caption>Retrieve text of a single element</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { Ensure, equals } from '@serenity-js/assertions';
- *  import { BrowseTheWeb, by, Target, Text } from '@serenity-js/webdriverio';
- *
- *  const header = () =>
- *      Target.the('header').located(by.tagName('h1'))
- *
- *  actorCalled('Lisa')
- *      .whoCan(BrowseTheWeb.using(browser))
- *      .attemptsTo(
- *          Ensure.that(Text.of(header()), equals('Shopping list')),
- *      )
- *
- * @example <caption>Retrieve text of a multiple elements</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { Ensure, equals } from '@serenity-js/assertions';
- *  import { BrowseTheWeb, by, Target, Text } from '@serenity-js/webdriverio';
- *
- *  const shoppingListItems = () =>
- *      Target.the('shopping list items').located(by.css('#shopping-list li'))
- *
- *  actorCalled('Lisa')
- *      .whoCan(BrowseTheWeb.using(browser))
- *      .attemptsTo(
- *          Ensure.that(
- *              Text.ofAll(shoppingListItems()),
- *              equals([ 'Coffee', 'Honey', 'Chocolate' ])
- *          ),
- *      )
- *
- * @example <caption>Find element with matching text</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { contain, Ensure } from '@serenity-js/assertions';
- *  import { BrowseTheWeb, by, CSSClasses, Target, Text } from '@serenity-js/webdriverio';
- *
- *  const shoppingListItemCalled = (name: string) =>
- *      Target.the('shopping list items').located(by.css('#shopping-list li'))
- *          .where(Text, equals(name))
- *          .first()
- *
- *  actorCalled('Lisa')
- *      .whoCan(BrowseTheWeb.using(browser))
- *      .attemptsTo(
- *          Ensure.that(
- *              CSSClasses.of(shoppingListItemCalled('Honey)),
- *              contain('bought')
- *          ),
- *      )
- *
- * @public
- * @see {@link Target}
- */
-export class Text {
-
-    /**
-     * @desc
-     *  Retrieves text of a single {@link WebElement},
-     *  represented by Answerable<{@link @wdio/types~Element}>.
-     *
-     * @param {Answerable<Element<'async'>>} element
-     * @returns {Question<Promise<string>> & MetaQuestion<Answerable<Element<'async'>>, Promise<string>>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/questions~MetaQuestion}
-     */
-    static of(element: Answerable<Element<'async'>>): Question<Promise<string>> & MetaQuestion<Answerable<Element<'async'>>, Promise<string>> {
-        return new TextOfSingleElement(element);
-    }
-
-    /**
-     * @desc
-     *  Retrieves text of a group of {@link WebElement}s,
-     *  represented by Answerable<{@link @wdio/types~ElementArray}>
-     *
-     * @param {Answerable<ElementArray>} elements
-     * @returns {Question<Promise<string[]>> & MetaQuestion<Answerable<Element<'async'>>, Promise<string[]>>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/questions~MetaQuestion}
-     */
-    static ofAll(elements: Answerable<ElementArray>): Question<Promise<string[]>> & MetaQuestion<Answerable<Element<'async'>>, Promise<string[]>> {
-        return new TextOfMultipleElements(elements);
-    }
-}
-
-class TextOfSingleElement
-    extends Question<Promise<string>>
-    implements MetaQuestion<Answerable<Element<'async'>>, Promise<string>>
-{
-    constructor(private readonly element: Answerable<Element<'async'>>) {
-        super(`the text of ${ element }`);
-    }
-
-    of(parent: Answerable<Element<'async'>>): Question<Promise<string>> {
-        return new TextOfSingleElement(new TargetNestedElement(parent, this.element));
-    }
-
-    answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<string> {
-        return actor.answer(this.element)
-            .then(element => element.getText())
-    }
-}
-
-class TextOfMultipleElements
-    extends Question<Promise<string[]>>
-    implements MetaQuestion<Answerable<Element<'async'>>, Promise<string[]>>
-{
-    constructor(private readonly elements: Answerable<ElementArray>) {
-        super(`the text of ${ elements }`);
-    }
-
-    of(parent: Answerable<Element<'async'>>): Question<Promise<string[]>> {
-        return new TextOfMultipleElements(new TargetNestedElements(parent, this.elements));
-    }
-
-    async answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<string[]> {
-        const elements = await actor.answer(this.elements);
-        return Promise.all(elements.map(answer => answer.getText()));
-    }
-}

package/src/screenplay/questions/Value.ts

@@ -1,82 +0,0 @@
-import { Answerable, AnswersQuestions, MetaQuestion, Question, UsesAbilities } from '@serenity-js/core';
-import { formatted } from '@serenity-js/core/lib/io';
-import { Element } from 'webdriverio';
-
-import { TargetNestedElement } from './targets';
-
-/**
- * @desc
- *  Returns the `value` attribute of a given {@link WebElement},
- *  represented by Answerable<{@link @wdio/types~Element}>
- *
- * @example <caption>Example widget</caption>
- *  <input type="text" id="username" value="Alice" />
- *
- * @example <caption>Retrieve CSS classes of a given WebElement</caption>
- *  import { actorCalled } from '@serenity-js/core';
- *  import { Ensure, equals } from '@serenity-js/assertions';
- *  import { BrowseTheWeb, by, Value, Target } from '@serenity-js/webdriverio';
- *
- *  const usernameField = () =>
- *      Target.the('username field').located(by.id('username'))
- *
- *  actorCalled('Lisa')
- *      .whoCan(BrowseTheWeb.using(browser))
- *      .attemptsTo(
- *          Ensure.that(Value.of(usernameField), equals('Alice')),
- *      )
- *
- * @extends {@serenity-js/core/lib/screenplay~Question}
- * @implements {@serenity-js/core/lib/screenplay/questions~MetaQuestion}
- */
-export class Value
-    extends Question<Promise<string>>
-    implements MetaQuestion<Answerable<Element<'async'>>, Promise<string>>
-{
-    /**
-     * @param {Answerable<Element<'async'>>} element
-     * @returns {Value}
-     */
-    static of(element: Answerable<Element<'async'>>): Question<Promise<string>> & MetaQuestion<Answerable<Element<'async'>>, Promise<string>> {
-        return new Value(element);
-    }
-
-    /**
-     * @param {Answerable<Element<'async'>>} element
-     */
-    constructor(private readonly element: Answerable<Element<'async'>>) {
-        super(formatted`the value of ${ element }`);
-    }
-
-    /**
-     * @desc
-     *  Resolves to the value of a given [`input`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input)
-     *  {@link WebElement}, located in the context of a `parent` element.
-     *
-     * @param {Answerable<Element<'async'>>} parent
-     * @returns {Question<Promise<string>>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/questions~MetaQuestion}
-     */
-    of(parent: Answerable<Element<'async'>>): Question<Promise<string>> {
-        return new Value(new TargetNestedElement(parent, this.element));
-    }
-
-    /**
-     * @desc
-     *  Makes the provided {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     *  answer this {@link @serenity-js/core/lib/screenplay~Question}.
-     *
-     * @param {AnswersQuestions & UsesAbilities} actor
-     * @returns {Promise<void>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/actor~Actor}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~AnswersQuestions}
-     * @see {@link @serenity-js/core/lib/screenplay/actor~UsesAbilities}
-     */
-    async answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<string> {
-        const element = await actor.answer(this.element);
-
-        return element.getValue();
-    }
-}

package/src/screenplay/questions/Website.ts

@@ -1,34 +0,0 @@
-import { Question } from '@serenity-js/core';
-
-import { BrowseTheWeb } from '../abilities';
-
-export class Website {
-
-    /**
-     * @desc
-     *  Retrieves the document title of the current top-level browsing context, equivalent to calling `document.title`.
-     *
-     * @returns {@serenity-js/core/lib/screenplay~Question<Promise<string>>}
-     *
-     * @see https://webdriver.io/docs/api/webdriver/#gettitle
-     */
-    static title(): Question<Promise<string>> {
-        return Question.about(`the title of the current page`, actor =>
-            BrowseTheWeb.as(actor).browser.getTitle(),
-        );
-    }
-
-    /**
-     * @desc
-     *  Retrieves the URL of the current top-level browsing context.
-     *
-     * @returns {@serenity-js/core/lib/screenplay~Question<Promise<string>>}
-     *
-     * @see https://webdriver.io/docs/api/webdriver/#geturl
-     */
-    static url(): Question<Promise<string>> {
-        return Question.about(`the url of the current page`, actor =>
-            BrowseTheWeb.as(actor).browser.getUrl(),
-        );
-    }
-}

package/src/screenplay/questions/index.ts

@@ -1,10 +0,0 @@
-export * from './Attribute';
-export * from './CSSClasses';
-export * from './LastScriptExecution';
-export * from './locators';
-export * from './NestedTargetBuilder';
-export * from './TargetBuilder';
-export * from './targets';
-export * from './Text';
-export * from './Value';
-export * from './Website';

package/src/screenplay/questions/lists.ts

@@ -1,161 +0,0 @@
-import { Answerable, AnswersQuestions, Expectation, ExpectationMet, MetaQuestion, Question, UsesAbilities } from '@serenity-js/core';
-import { formatted } from '@serenity-js/core/lib/io';
-import { ListAdapter } from '@serenity-js/core/lib/screenplay/questions/lists';
-import type { Element, ElementArray } from 'webdriverio';
-
-/**
- * @desc
- *  Adapts {@link ElementArray} so that it can be used with {@link @serenity-js/core/lib/screenplay/questions~List}.
- *
- *  You most likely won't need to use this class directly. Instead, check out {@link Target} and {@link Target.all}.
- *
- * @see {@link Target}
- *
- * @implements {@serenity-js/core/lib/screenplay/questions/lists~ListAdapter}
- */
-export class ElementArrayListAdapter implements ListAdapter<Promise<Element<'async'>>, Promise<ElementArray>> {
-
-    constructor(private readonly collection: Answerable<ElementArray>) {
-    }
-
-    /**
-     * @desc
-     *  Returns the number of {@link Element}s that the underlying {@link ElementArray} contains,
-     *  left after applying any filters.
-     *
-     * @param {AnswersQuestions & UsesAbilities} actor
-     * @returns {Promise<number>}
-     */
-    async count(actor: AnswersQuestions & UsesAbilities): Promise<number> {
-        const elements = await this.elements(actor);
-        return elements.length;
-    }
-
-    /**
-     * @desc
-     *  Returns the first of {@link Element}s that the underlying {@link ElementArray} contains,
-     *  left after applying any filters
-     *
-     * @param {AnswersQuestions & UsesAbilities} actor
-     * @returns {Element<'async'>}
-     */
-    async first(actor: AnswersQuestions & UsesAbilities): Promise<Element<'async'>> {
-        const elements = await this.elements(actor);
-        return elements[0];
-    }
-
-    /**
-     * @desc
-     *  Returns the last of {@link Element}s that the underlying {@link ElementArray} contains,
-     *  left after applying any filters
-     *
-     * @param {AnswersQuestions & UsesAbilities} actor
-     * @returns {Element<'async'>}
-     */
-    async last(actor: AnswersQuestions & UsesAbilities): Promise<Element<'async'>> {
-        const elements = await this.elements(actor);
-        return elements[elements.length - 1];
-    }
-
-    /**
-     * @desc
-     *  Returns the nth of {@link Element}s that the underlying {@link ElementArray} contains,
-     *  left after applying any filters
-     *
-     * @param {AnswersQuestions & UsesAbilities} actor
-     *
-     * @param {number} index
-     *  Zero-based index of the item to return
-     *
-     * @returns {Element<'async'>}
-     */
-    async get(actor: AnswersQuestions & UsesAbilities, index: number): Promise<Element<'async'>> {
-        const elements = await this.elements(actor);
-        return elements[index];
-    }
-
-    /**
-     * @desc
-     *  Returns the underlying {@link ElementArray},
-     *  with any filters applied.
-     *
-     * @param {AnswersQuestions & UsesAbilities} actor
-     * @returns {Element<'async'>}
-     */
-    items(actor: AnswersQuestions & UsesAbilities): Promise<ElementArray> {
-        return this.elements(actor);
-    }
-
-    /**
-     * @desc
-     *  Filters the underlying {@link ElementArray} so that the result contains only those {@link Element<'async'>}s that meet the {@link Expectation}
-     *
-     * @param {@serenity-js/core/lib/screenplay/questions~MetaQuestion<Answerable<Element<'async'>>, Promise<Answer_Type> | Answer_Type>} question
-     * @param {@serenity-js/core/lib/screenplay/questions~Expectation<any, Answer_Type>} expectation
-     *
-     * @returns {@serenity-js/core/lib/screenplay/questions/lists~ListAdapter<Element<'async'>, ElementArrayFinder>}
-     *
-     * @see {@link @serenity-js/core/lib/screenplay/questions~MetaQuestion}
-     */
-    withFilter<Answer_Type>(
-        question: MetaQuestion<Answerable<Element<'async'>>, Promise<Answer_Type> | Answer_Type>,
-        expectation: Expectation<any, Answer_Type>
-    ): ListAdapter<Promise<Element<'async'>>, Promise<ElementArray>> {
-        return new ElementArrayListAdapter(
-            new ElementArrayListFilter(this.collection, question, expectation)
-        );
-    }
-
-    /**
-     * @desc
-     *  Returns a human-readable description of the underlying {@link ElementArray}.
-     *
-     * @returns {string}
-     */
-    toString(): string {
-        return formatted `${ this.collection }`;
-    }
-
-    private elements(actor: AnswersQuestions & UsesAbilities): Promise<ElementArray> {
-        return actor.answer(this.collection);
-    }
-}
-
-/**
- * @private
- */
-class ElementArrayListFilter<Answer_Type>
-    extends Question<Promise<ElementArray>>
-{
-    constructor(
-        private readonly collection: Answerable<ElementArray>,
-        private readonly question: MetaQuestion<Answerable<Element<'async'>>, Promise<Answer_Type> | Answer_Type>,
-        private readonly expectation: Expectation<any, Answer_Type>
-    ) {
-        super([
-            formatted `${ collection }`,
-            collection instanceof ElementArrayListFilter ? 'and' : 'where',
-            formatted `${ question } does ${ expectation }`
-        ].join(' '));
-    }
-
-    async answeredBy(actor: AnswersQuestions & UsesAbilities): Promise<ElementArray> {
-
-        const collection = await actor.answer(this.collection);
-        const outcomes   = await Promise.all(
-            collection.map((element: Element<'async'>) =>
-                actor.answer(this.question.of(element))
-                    .then((answer: Answer_Type) => this.expectation.answeredBy(actor)(answer))
-            )
-        );
-
-        const matching = collection.filter((element: Element<'async'>, index: number) => outcomes[index] instanceof ExpectationMet) as ElementArray;
-
-        matching.selector   = collection.selector;
-        matching.parent     = collection.parent;
-        matching.foundWith  = collection.foundWith;
-        matching.props      = collection.props;
-
-        return matching;
-    }
-}

package/src/screenplay/questions/locators.ts

@@ -1,254 +0,0 @@
-import { Question } from '@serenity-js/core';
-import type { Browser, Element, ElementArray, Selector } from 'webdriverio';
-
-import { BrowseTheWeb } from '../abilities';
-
-/**
- * @desc
- *  Represents a way to retrieve one and multiple Web elements using a given strategy.
- *
- * @see {@link by}
- * @see {@link Locators}
- */
-export class Locator {
-    constructor(
-        private readonly description: string,
-        private readonly locateOne: (browserInstance: Browser<'async'>) => Promise<Element<'async'>>,
-        private readonly locateAll: (browserInstance: Browser<'async'>) => Promise<ElementArray>,
-    ) {
-    }
-
-    /**
-     * @desc
-     *  Returns a {@link @serenity-js/core/lib/screenplay~Question} that resolves
-     *  to the first Web element found using a given strategy.
-     *
-     * @returns {@serenity-js/core/lib/screenplay~Question<Promise<Element<'async'>>>}
-     */
-    firstMatching(): Question<Promise<Element<'async'>>> {
-        return Question.about(this.description, actor =>
-            this.locateOne(BrowseTheWeb.as(actor).browser)
-        )
-    }
-
-    /**
-     * @desc
-     *  Returns a {@link @serenity-js/core/lib/screenplay~Question} that resolves
-     *  to all the Web elements found using a given strategy.
-     *
-     * @returns {@serenity-js/core/lib/screenplay~Question<Promise<ElementArray>>}
-     */
-    allMatching(): Question<Promise<ElementArray>> {
-        return Question.about(this.description, actor =>
-            this.locateAll(BrowseTheWeb.as(actor).browser)
-        )
-    }
-}
-
-/**
- * @desc
- *  {@link Locator} factory. You probably want to use {@link by} instead in your tests.
- */
-export class Locators {
-    /**
-     * @desc
-     *  Locates elements by their `id` attribute.
-     *
-     * @example <caption>Example widget</caption>
-     *  <input id="username" />
-     *
-     * @example
-     *  import { by, Target } from '@serenity-js/webdriverio';
-     *
-     *  const usernameField = Target.the('username field').located(by.id('username'));
-     *
-     * @param {string} id
-     * @returns {Locator}
-     *
-     * @see {@link Target}
-     * @see https://webdriver.io/docs/selectors/#id
-     */
-    id(id: string): Locator {
-        return new Locator(
-            `by id #${ id }`,
-            browser => browser.$(`#${id}`) as unknown as Promise<Element<'async'>>,
-            browser => browser.$$(`#${id}`),
-        )
-    }
-
-    /**
-     * @desc
-     *  Locates elements using a CSS selector
-     *
-     * @example <caption>Example widget</caption>
-     *  <div id="article">
-     *      <h1>Title</h1>
-     *      <h2>Section 1</h2>
-     *      <h2>Section 2</h2>
-     *  </div>
-     *
-     * @example <caption>Locating a single element</caption>
-     *  import { by, Target } from '@serenity-js/webdriverio';
-     *
-     *  const title = Target.the('article title').located(by.css('#article h1'));
-     *
-     * @example <caption>Locating multiple elements</caption>
-     *  import { by, Target } from '@serenity-js/webdriverio';
-     *
-     *  const titles = Target.all('section titles').located(by.css('#article h2'));
-     *
-     * @param {Selector} selector
-     * @returns {Locator}
-     *
-     * @see {@link Target}
-     * @see https://webdriver.io/docs/selectors/#css-query-selector
-     */
-    css(selector: Selector): Locator {
-        return new Locator(
-            `by css ${ selector }`,
-            browser => browser.$(selector) as unknown as Promise<Element<'async'>>,
-            browser => browser.$$(selector),
-        )
-    }
-
-    /**
-     * @desc
-     *  Locates elements by HTML tag name
-     *
-     * @example <caption>Example widget</caption>
-     *  <ul>
-     *      <li>Item 1</li>
-     *      <li>Item 2</li>
-     *  </ul>
-     *  <span>Total price: £5</span>
-     *
-     * @example <caption>Locating a single element</caption>
-     *  import { by, Target } from '@serenity-js/webdriverio';
-     *
-     *  const totalPrice = Target.the('total price').located(by.tagName('span'));
-     *
-     * @example <caption>Locating multiple elements</caption>
-     *  import { by, Target } from '@serenity-js/webdriverio';
-     *
-     *  const items = Target.all('shopping basket items').located(by.tagName('li'));
-     *
-     * @param {string} tagName
-     * @returns {Locator}
-     *
-     * @see {@link Target}
-     * @see https://webdriver.io/docs/selectors/#tag-name
-     */
-    tagName(tagName: string): Locator {
-        return new Locator(
-            `by tag name <${ tagName } />`,
-            browser => browser.$(`<${ tagName } />`) as unknown as Promise<Element<'async'>>,
-            browser => browser.$$(`<${ tagName } />`),
-        )
-    }
-
-    /**
-     * @desc
-     *  Locates an HTML anchor element with a specific text in it.
-     *
-     * @example <caption>Example widget</caption>
-     *  <a href="https://serenity-js.org">Serenity/JS</a>
-     *
-     * @example <caption>Locating a single element</caption>
-     *  import { by, Target } from '@serenity-js/webdriverio';
-     *
-     *  const serenityWebsite = Target.the('Serenity/JS website link').located(by.linkText('Serenity/JS'));
-     *
-     * @example <caption>Locating multiple elements</caption>
-     *  import { by, Target } from '@serenity-js/webdriverio';
-     *
-     *  const items = Target.all('Serenity/JS website links').located(by.linkText('Serenity/JS'));
-     *
-     * @param {string} linkText
-     * @returns {Locator}
-     *
-     * @see {@link Target}
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a
-     * @see https://webdriver.io/docs/selectors/#link-text
-     */
-    linkText(linkText: string): Locator {
-        return new Locator(
-            `by link text ${ linkText }`,
-            browser => browser.$(`=${ linkText }`) as unknown as Promise<Element<'async'>>,
-            browser => browser.$$(`=${ linkText }`),
-        )
-    }
-
-    /**
-     * @desc
-     *  Locates an HTML anchor element with which visible text partially matches `partialLinkText`
-     *
-     * @example <caption>Example widget</caption>
-     *  <a href="https://serenity-js.org">Serenity/JS</a>
-     *  <a href="https://serenity-bdd.info/#/">Serenity BDD</a>
-     *
-     * @example <caption>Locating a single element</caption>
-     *  import { by, Target } from '@serenity-js/webdriverio';
-     *
-     *  const serenityWebsite = Target.the('Serenity/JS website link').located(by.partialLinkText('JS'));
-     *
-     * @example <caption>Locating multiple elements</caption>
-     *  import { by, Target } from '@serenity-js/webdriverio';
-     *
-     *  const serenityWebsites = Target.all('Serenity frameworks').located(by.partialLinkText('Serenity'));
-     *
-     * @param {string} partialLinkText
-     * @returns {Locator}
-     *
-     * @see {@link Target}
-     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a
-     * @see https://webdriver.io/docs/selectors/#link-text
-     */
-    partialLinkText(partialLinkText: string): Locator {
-        return new Locator(
-            `by partial link text ${ partialLinkText }`,
-            browser => browser.$(`*=${ partialLinkText }`) as unknown as Promise<Element<'async'>>,
-            browser => browser.$$(`*=${ partialLinkText }`),
-        )
-    }
-
-    /**
-     * @desc
-     *  Locates elements using an [XPath](https://developer.mozilla.org/en-US/docs/Web/XPath) selector.
-     *
-     *  Please note that whenever possible you should use {@link Locators#id} and {@link Locators#css} locators
-     *  instead of XPath to make your tests more robust.
-     *
-     * @example <caption>Example widget</caption>
-     *  <div id="article">
-     *      <h1>Title</h1>
-     *      <h2>Section 1</h2>
-     *      <h2>Section 2</h2>
-     *  </div>
-     *
-     * @example <caption>Locating a single element</caption>
-     *  import { by, Target } from '@serenity-js/webdriverio';
-     *
-     *  const title = Target.the('article title').located(by.xpath('//*[@id="article"]/h1'));
-     *
-     * @example <caption>Locating multiple elements</caption>
-     *  import { by, Target } from '@serenity-js/webdriverio';
-     *
-     *  const title = Target.the('article title').located(by.xpath('//*[@id="article"]/h2'));
-     *
-     * @param {string} xpath
-     * @returns {Locator}
-     *
-     * @see {@link Target}
-     * @see https://developer.mozilla.org/en-US/docs/Web/XPath
-     * @see https://webdriver.io/docs/selectors/#xpath
-     */
-    xpath(xpath: string): Locator {
-        return new Locator(
-            `by xpath ${ xpath }`,
-            browser => browser.$(xpath) as unknown as Promise<Element<'async'>>,
-            browser => browser.$$(xpath),
-        )
-    }
-}
-
-export const by = new Locators();