@itmetsam/samurai-framework 0.21.3 → 0.21.5

package/dist/api.d.ts

@@ -2,5 +2,7 @@ export { test, describe, beforeEach, afterEach, beforeAll, afterAll, } from "./r
 export { expect } from "./assert/expect.js";
 export { defineConfig } from "./config/config.js";
 export { defineStep, type StepDefinition, type StepResult, type StepRunInput, } from "./flows/steps/index.js";
-export type { AllHookFixtures, TestDetails, TestFixtures, TestOptions, TestOutputs, } from "./types/test.js";
+export type { AllHookFixtures, TestAnnotation, TestAttachment, TestDetails, TestFixtures, TestInfo, TestOptions, TestOutputs, TestStepEntry, } from "./types/test.js";
+export type { FixtureOptions } from "./types/extend.js";
+export type { ColorScheme, StorageState, StorageStateCookie, UseOptions, } from "./types/use.js";
 export { generatedFile, type GeneratedFile, type FileInput, } from "./browser/generated-files.js";

package/dist/assert/asymmetric.d.ts

@@ -0,0 +1,29 @@
+import { inspect } from "node:util";
+/**
+ * A placeholder inside an expected value that matches a whole family of values, as in Jest and Playwright:
+ * `expect(x).toEqual({ id: expect.any(Number) })`
+ */
+export declare abstract class AsymmetricMatcher {
+    abstract asymmetricMatch(actual: unknown): boolean;
+    abstract toString(): string;
+    [inspect.custom](): string;
+}
+/** Matches an instance of `type` (primitives for `String`, `Number`, `Boolean`, `BigInt`, `Symbol`; any non-null object for `Object`; a function for `Function`) */
+export declare const any: (type: unknown) => AsymmetricMatcher;
+/** Matches anything but `null` and `undefined` */
+export declare const anything: () => AsymmetricMatcher;
+/** Matches a string that contains `part` */
+export declare const stringContaining: (part: string) => AsymmetricMatcher;
+/** Matches a string that matches the RegExp (a string pattern is compiled to one) */
+export declare const stringMatching: (pattern: string | RegExp) => AsymmetricMatcher;
+/** Matches an array that has an equal item for each of `items`, in any order and with others besides */
+export declare const arrayContaining: (items: unknown[]) => AsymmetricMatcher;
+/** Matches an object that has each key of `shape` with an equal value, and may have others */
+export declare const objectContaining: (shape: object) => AsymmetricMatcher;
+/**
+ * The meaning of `toEqual`: `isDeepStrictEqual` (so an `undefined` property differs from a missing one),
+ * except that asymmetric matchers inside arrays and plain objects of `expected` match by their own rule
+ */
+export declare function equalsWith(actual: unknown, expected: unknown): boolean;
+/** `toMatchObject`: plain objects in `expected` need only the keys they name; arrays still need the same length */
+export declare function subsetMatches(actual: unknown, expected: unknown): boolean;

package/dist/assert/asymmetric.js

@@ -0,0 +1,166 @@
+import { inspect, isDeepStrictEqual } from "node:util";
+import { format } from "./assertion-error.js";
+/**
+ * A placeholder inside an expected value that matches a whole family of values, as in Jest and Playwright:
+ * `expect(x).toEqual({ id: expect.any(Number) })`
+ */
+export class AsymmetricMatcher {
+    [inspect.custom]() {
+        return this.toString();
+    }
+}
+class Any extends AsymmetricMatcher {
+    constructor(type) {
+        super();
+        this.type = type;
+        if (typeof type !== "function") {
+            throw new TypeError("expect.any() expects a class or constructor");
+        }
+    }
+    asymmetricMatch(actual) {
+        switch (this.type) {
+            case String:
+                return typeof actual === "string" || actual instanceof String;
+            case Number:
+                return typeof actual === "number" || actual instanceof Number;
+            case Boolean:
+                return typeof actual === "boolean" || actual instanceof Boolean;
+            case BigInt:
+                return typeof actual === "bigint";
+            case Symbol:
+                return typeof actual === "symbol";
+            case Function:
+                return typeof actual === "function";
+            case Object:
+                return typeof actual === "object" && actual !== null;
+        }
+        return actual instanceof this.type;
+    }
+    toString() {
+        return `Any<${this.type.name}>`;
+    }
+}
+class Anything extends AsymmetricMatcher {
+    asymmetricMatch(actual) {
+        return actual !== null && actual !== undefined;
+    }
+    toString() {
+        return "Anything";
+    }
+}
+class StringContaining extends AsymmetricMatcher {
+    constructor(part) {
+        super();
+        this.part = part;
+    }
+    asymmetricMatch(actual) {
+        return typeof actual === "string" && actual.includes(this.part);
+    }
+    toString() {
+        return `StringContaining ${format(this.part)}`;
+    }
+}
+class StringMatching extends AsymmetricMatcher {
+    constructor(pattern) {
+        super();
+        this.pattern = typeof pattern === "string" ? new RegExp(pattern) : pattern;
+    }
+    asymmetricMatch(actual) {
+        // search() ignores lastIndex, so a global RegExp gives the same answer on every call
+        return typeof actual === "string" && actual.search(this.pattern) !== -1;
+    }
+    toString() {
+        return `StringMatching ${format(this.pattern)}`;
+    }
+}
+class ArrayContaining extends AsymmetricMatcher {
+    constructor(items) {
+        super();
+        this.items = items;
+    }
+    asymmetricMatch(actual) {
+        return (Array.isArray(actual) &&
+            this.items.every((item) => actual.some((o) => equalsWith(o, item))));
+    }
+    toString() {
+        return `ArrayContaining ${format(this.items)}`;
+    }
+}
+class ObjectContaining extends AsymmetricMatcher {
+    constructor(shape) {
+        super();
+        this.shape = shape;
+    }
+    asymmetricMatch(actual) {
+        if (typeof actual !== "object" || actual === null)
+            return false;
+        return Object.entries(this.shape).every(([key, item]) => key in actual && equalsWith(actual[key], item));
+    }
+    toString() {
+        return `ObjectContaining ${format(this.shape)}`;
+    }
+}
+/** Matches an instance of `type` (primitives for `String`, `Number`, `Boolean`, `BigInt`, `Symbol`; any non-null object for `Object`; a function for `Function`) */
+export const any = (type) => new Any(type);
+/** Matches anything but `null` and `undefined` */
+export const anything = () => new Anything();
+/** Matches a string that contains `part` */
+export const stringContaining = (part) => new StringContaining(part);
+/** Matches a string that matches the RegExp (a string pattern is compiled to one) */
+export const stringMatching = (pattern) => new StringMatching(pattern);
+/** Matches an array that has an equal item for each of `items`, in any order and with others besides */
+export const arrayContaining = (items) => new ArrayContaining(items);
+/** Matches an object that has each key of `shape` with an equal value, and may have others */
+export const objectContaining = (shape) => new ObjectContaining(shape);
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/** Whether `value` is, or holds in arrays and plain objects, an asymmetric matcher */
+function holdsMatcher(value, seen = new Set()) {
+    if (value instanceof AsymmetricMatcher)
+        return true;
+    if (typeof value !== "object" || value === null || seen.has(value))
+        return false;
+    if (!Array.isArray(value) && !isPlainObject(value))
+        return false;
+    seen.add(value);
+    return Object.values(value).some((item) => holdsMatcher(item, seen));
+}
+/**
+ * The meaning of `toEqual`: `isDeepStrictEqual` (so an `undefined` property differs from a missing one),
+ * except that asymmetric matchers inside arrays and plain objects of `expected` match by their own rule
+ */
+export function equalsWith(actual, expected) {
+    if (!holdsMatcher(expected))
+        return isDeepStrictEqual(actual, expected);
+    return walk(actual, expected, equalsWith, false);
+}
+/** `toMatchObject`: plain objects in `expected` need only the keys they name; arrays still need the same length */
+export function subsetMatches(actual, expected) {
+    return walk(actual, expected, subsetMatches, true);
+}
+function walk(actual, expected, recurse, subset) {
+    if (expected instanceof AsymmetricMatcher)
+        return expected.asymmetricMatch(actual);
+    if (Array.isArray(expected)) {
+        return (Array.isArray(actual) &&
+            actual.length === expected.length &&
+            expected.every((item, i) => recurse(actual[i], item)));
+    }
+    if (isPlainObject(expected)) {
+        if (typeof actual !== "object" || actual === null)
+            return false;
+        const keys = Object.keys(expected);
+        if (subset) {
+            return keys.every((key) => key in actual && recurse(actual[key], expected[key]));
+        }
+        return (Object.getPrototypeOf(actual) === Object.getPrototypeOf(expected) &&
+            Object.keys(actual).length === keys.length &&
+            keys.every((key) => Object.prototype.hasOwnProperty.call(actual, key) &&
+                recurse(actual[key], expected[key])));
+    }
+    return isDeepStrictEqual(actual, expected);
+}

package/dist/assert/element-probes.d.ts

@@ -0,0 +1,20 @@
+import type Locator from "../locator/locator.js";
+/** The state a checkbox-like element is in */
+export type CheckedState = boolean | "mixed";
+/** Whether the element is the active element of its document or shadow root */
+export declare function readFocused(locator: Locator): Promise<boolean | null>;
+/** The element's JS property `name`, wrapped as `{ value }`; null when nothing matches */
+export declare function readJSProperty(locator: Locator, name: string): Promise<{
+    value: unknown;
+} | null>;
+/** The share (0 to 1) of the element inside the viewport, as an IntersectionObserver reports it; null when nothing matches */
+export declare function readViewportRatio(locator: Locator): Promise<number | null>;
+/** The `id` property ("" when it has none), or null when nothing matches */
+export declare function readId(locator: Locator): Promise<string | null>;
+/**
+ * Input and textarea: the value is empty. Anything else: no element children and no text besides whitespace.
+ * Null when nothing matches.
+ */
+export declare function readEmpty(locator: Locator): Promise<boolean | null>;
+/** true, false or "mixed" (an indeterminate checkbox, or `aria-checked="mixed"`); null when nothing matches */
+export declare function readCheckedState(locator: Locator): Promise<CheckedState | null>;

package/dist/assert/element-probes.js

@@ -0,0 +1,45 @@
+/**
+ * Runs `body` in the page with the first match as `el` (and the optional `arg`) and answers its result, or
+ * null when nothing matches. Reads never wait and do not enforce strict mode: they use the first match.
+ */
+function readFirst(locator, body, arg) {
+    return locator.evaluateAll(`(els, arg) => { const el = els[0]; if (!el) return null; ${body} }`, arg);
+}
+/** Whether the element is the active element of its document or shadow root */
+export function readFocused(locator) {
+    return readFirst(locator, `return el.getRootNode().activeElement === el;`);
+}
+/** The element's JS property `name`, wrapped as `{ value }`; null when nothing matches */
+export function readJSProperty(locator, name) {
+    return readFirst(locator, `return { value: el[arg] };`, name);
+}
+/** The share (0 to 1) of the element inside the viewport, as an IntersectionObserver reports it; null when nothing matches */
+export function readViewportRatio(locator) {
+    return readFirst(locator, `return new Promise((resolve) => {
+      const observer = new IntersectionObserver((entries) => {
+        observer.disconnect();
+        resolve(entries[entries.length - 1].intersectionRatio);
+      });
+      observer.observe(el);
+    });`);
+}
+/** The `id` property ("" when it has none), or null when nothing matches */
+export function readId(locator) {
+    return readFirst(locator, `return el.id;`);
+}
+/**
+ * Input and textarea: the value is empty. Anything else: no element children and no text besides whitespace.
+ * Null when nothing matches.
+ */
+export function readEmpty(locator) {
+    return readFirst(locator, `if (el.tagName === "INPUT" || el.tagName === "TEXTAREA") return el.value === "";
+    return el.children.length === 0 && (el.textContent || "").trim() === "";`);
+}
+/** true, false or "mixed" (an indeterminate checkbox, or `aria-checked="mixed"`); null when nothing matches */
+export function readCheckedState(locator) {
+    return readFirst(locator, `const type = (el.getAttribute("type") || "").toLowerCase();
+    const input = el.tagName === "INPUT" && (type === "checkbox" || type === "radio");
+    if (input && el.indeterminate) return "mixed";
+    if ((input && el.checked) || el.getAttribute("aria-checked") === "true") return true;
+    return el.getAttribute("aria-checked") === "mixed" ? "mixed" : false;`);
+}

package/dist/assert/expect.d.ts

@@ -1,15 +1,26 @@
 import Page from "../browser/page.js";
 import Locator from "../locator/locator.js";
+import { any, anything, arrayContaining, objectContaining, stringContaining, stringMatching } from "./asymmetric.js";
+import { poll } from "./retry-assertions.js";
 import { LocatorAssertions } from "./locator-assertions.js";
 import { PageAssertions } from "./page-assertions.js";
 import { ValueAssertions } from "./value-assertions.js";
 export { takePendingAssertions } from "./pending-assertions.js";
-export { LocatorAssertions } from "./locator-assertions.js";
-export { PageAssertions } from "./page-assertions.js";
-export { ValueAssertions } from "./value-assertions.js";
-/** Auto-retrying assertions on a page element */
-export declare function expect(locator: Locator): LocatorAssertions;
-/** Auto-retrying assertions on the page URL and title */
-export declare function expect(page: Page): PageAssertions;
-/** Synchronous assertions on a plain value */
-export declare function expect<T>(value: T): ValueAssertions<T>;
+/** `expect`: the assertions for a locator, a page or a plain value, plus the asymmetric matchers */
+export interface Expect {
+    /** Auto-retrying assertions on a page element */
+    (locator: Locator): LocatorAssertions;
+    /** Auto-retrying assertions on the page URL and title */
+    (page: Page): PageAssertions;
+    /** Synchronous assertions on a plain value */
+    <T>(value: T): ValueAssertions<T>;
+    /** The value matchers, retried until they pass: `await expect.poll(() => getStatus()).toBe("done")` */
+    poll: typeof poll;
+    any: typeof any;
+    anything: typeof anything;
+    stringContaining: typeof stringContaining;
+    stringMatching: typeof stringMatching;
+    arrayContaining: typeof arrayContaining;
+    objectContaining: typeof objectContaining;
+}
+export declare const expect: Expect;

package/dist/assert/expect.js

@@ -1,16 +1,24 @@
 import Page from "../browser/page.js";
 import Locator from "../locator/locator.js";
+import { any, anything, arrayContaining, objectContaining, stringContaining, stringMatching, } from "./asymmetric.js";
+import { poll } from "./retry-assertions.js";
 import { LocatorAssertions } from "./locator-assertions.js";
 import { PageAssertions } from "./page-assertions.js";
 import { ValueAssertions } from "./value-assertions.js";
 export { takePendingAssertions } from "./pending-assertions.js";
-export { LocatorAssertions } from "./locator-assertions.js";
-export { PageAssertions } from "./page-assertions.js";
-export { ValueAssertions } from "./value-assertions.js";
-export function expect(value) {
+function expectValue(value) {
     if (value instanceof Locator)
         return new LocatorAssertions(value);
     if (value instanceof Page)
         return new PageAssertions(value);
     return new ValueAssertions(value);
 }
+export const expect = Object.assign(expectValue, {
+    poll,
+    any,
+    anything,
+    stringContaining,
+    stringMatching,
+    arrayContaining,
+    objectContaining,
+});

package/dist/assert/locator-assertion-base.d.ts

@@ -0,0 +1,52 @@
+import type Locator from "../locator/locator.js";
+export interface LocatorAssertionOptions {
+    /** Time (ms) to keep retrying. Defaults to config `expect.timeout`, then 5000 */
+    timeout?: number;
+}
+/** The options of the checks that can keep the text they found */
+export interface TextAssertionOptions extends LocatorAssertionOptions {
+    /** Saves the text that passed (a RegExp's first group, else its match) as this output of the running test */
+    output?: string;
+}
+/** What `readEventually` reads, what it waits for and how its failure is named */
+export interface EventualRead<V> {
+    /** The matcher, with `not.` in front when negated */
+    name: string;
+    locator: Locator;
+    expected: unknown;
+    read: () => Promise<V>;
+    /** True for the read that ends the wait */
+    check: (actual: V) => boolean;
+    /** Time (ms) to keep retrying. Defaults to the expect timeout */
+    timeout?: number | undefined;
+    /** A read of `null` (no element) never passes, and fails as "could not read" */
+    mustExist?: boolean;
+    /** The first line of a failure, instead of `expect(locator).<name>` */
+    call?: string;
+    /** What a failure shows as the received value, when the read is a wrapper around it */
+    display?: (actual: V) => unknown;
+}
+/**
+ * Re-reads the element until `check` passes or the timeout expires, and resolves with the read that passed. A
+ * timeout fails as an `AssertionError` with the last read, or as "could not read" when no read completed.
+ */
+export declare function readEventually<V>({ name, locator, expected, read, check, timeout: perCall, mustExist, call, display, }: EventualRead<V>): Promise<V>;
+export declare class LocatorAssertionBase {
+    protected readonly locator: Locator;
+    protected readonly negated: boolean;
+    constructor(locator: Locator, negated?: boolean);
+    /** The matcher name as failures show it: `not.` in front when negated */
+    protected matcherName(matcher: string): string;
+    /**
+     * Re-reads the element until `check` passes or the timeout expires. With `mustExist`, a read of `null`
+     * (no element) never passes, with or without `.not`, and fails as "could not read"
+     */
+    protected assertEventually<V>(matcher: string, expected: unknown, read: () => Promise<V>, check: (actual: V) => boolean, options?: LocatorAssertionOptions, mustExist?: boolean, save?: (actual: V) => void): Promise<void>;
+    /**
+     * A text check that can keep what it read: with `options.output` the read that passed goes to that output, as
+     * `expected` captures it. The sink is taken now, when the call starts.
+     */
+    protected assertText(matcher: string, expected: string | RegExp, read: () => Promise<string | null>, mode: "exact" | "contains", options?: TextAssertionOptions, normalize?: boolean): Promise<void>;
+    /** For matchers that need an element: `read` answers null when there is none, which never passes */
+    protected assertExisting<V>(matcher: string, expected: unknown, read: () => Promise<V | null>, check: (actual: V) => boolean, options?: LocatorAssertionOptions): Promise<void>;
+}

package/dist/assert/locator-assertion-base.js

@@ -0,0 +1,78 @@
+import { resolveTimeout } from "../config/timeouts.js";
+import { waitUntil, WaitTimeoutError } from "../wait/wait-until.js";
+import { AssertionError } from "./assertion-error.js";
+import { track } from "./pending-assertions.js";
+import { bindOutput } from "../wait/output-sink.js";
+import { captured, normalizedTextCheck, textCheck } from "./text-match.js";
+/**
+ * Re-reads the element until `check` passes or the timeout expires, and resolves with the read that passed. A
+ * timeout fails as an `AssertionError` with the last read, or as "could not read" when no read completed.
+ */
+export async function readEventually({ name, locator, expected, read, check, timeout: perCall, mustExist = false, call, display, }) {
+    const timeout = await resolveTimeout(perCall);
+    try {
+        return await waitUntil(read, (actual) => (mustExist && actual === null ? false : check(actual)), { timeout });
+    }
+    catch (err) {
+        if (!(err instanceof WaitTimeoutError))
+            throw err;
+        // Reads never resolve to undefined, so an undefined `last` means no read completed
+        if (err.last === undefined || (mustExist && err.last === null)) {
+            throw new Error(`${call ?? `expect(locator).${name}`}: could not read ${locator.selector} within ${timeout}ms`);
+        }
+        throw new AssertionError({
+            matcher: name,
+            expected,
+            actual: display ? display(err.last) : err.last,
+            locator: locator.selector,
+            call,
+        });
+    }
+}
+export class LocatorAssertionBase {
+    constructor(locator, negated = false) {
+        this.locator = locator;
+        this.negated = negated;
+    }
+    /** The matcher name as failures show it: `not.` in front when negated */
+    matcherName(matcher) {
+        return this.negated ? `not.${matcher}` : matcher;
+    }
+    /**
+     * Re-reads the element until `check` passes or the timeout expires. With `mustExist`, a read of `null`
+     * (no element) never passes, with or without `.not`, and fails as "could not read"
+     */
+    assertEventually(matcher, expected, read, check, options, mustExist = false, save) {
+        const name = this.negated ? `not.${matcher}` : matcher;
+        return track(`expect(locator).${name}()`, readEventually({
+            name,
+            locator: this.locator,
+            expected,
+            read,
+            check: (actual) => check(actual) !== this.negated,
+            timeout: options?.timeout,
+            mustExist,
+        }).then((actual) => save?.(actual)));
+    }
+    /**
+     * A text check that can keep what it read: with `options.output` the read that passed goes to that output, as
+     * `expected` captures it. The sink is taken now, when the call starts.
+     */
+    assertText(matcher, expected, read, mode, options, normalize = false) {
+        let save;
+        if (options?.output !== undefined) {
+            const call = `expect(locator).${this.negated ? "not." : ""}${matcher}`;
+            if (this.negated)
+                throw new Error(`${call}: output can't be saved from a negated check`);
+            const keep = bindOutput(call, options.output);
+            save = (actual) => keep(captured(expected, actual));
+        }
+        return this.assertEventually(matcher, expected, read, normalize
+            ? normalizedTextCheck(expected, mode)
+            : textCheck(expected, mode), options, false, save);
+    }
+    /** For matchers that need an element: `read` answers null when there is none, which never passes */
+    assertExisting(matcher, expected, read, check, options) {
+        return this.assertEventually(matcher, expected, read, (actual) => actual !== null && check(actual), options, true);
+    }
+}

package/dist/assert/locator-assertions.d.ts

@@ -1,66 +1,43 @@
-import type Locator from "../locator/locator.js";
-export interface LocatorAssertionOptions {
-    /** Time (ms) to keep retrying. Defaults to config `expect.timeout`, then 5000 */
-    timeout?: number;
+import { MoreLocatorAssertions } from "./more-locator-assertions.js";
+import type { LocatorAssertionOptions, TextAssertionOptions } from "./locator-assertion-base.js";
+export { readEventually } from "./locator-assertion-base.js";
+export type { LocatorAssertionOptions, TextAssertionOptions, } from "./locator-assertion-base.js";
+export interface CheckedOptions extends LocatorAssertionOptions {
+    /** The state to expect: `true` (default), `false`, or `"mixed"` (an indeterminate checkbox, or `aria-checked="mixed"`) */
+    checked?: boolean | "mixed";
+    /** Same as `checked: "mixed"` */
+    indeterminate?: boolean;
 }
-/** The options of the checks that can keep the text they found */
-export interface TextAssertionOptions extends LocatorAssertionOptions {
-    /** Saves the text that passed (a RegExp's first group, else its match) as this output of the running test */
-    output?: string;
-}
-/** What `readEventually` reads, what it waits for and how its failure is named */
-export interface EventualRead<V> {
-    /** The matcher, with `not.` in front when negated */
-    name: string;
-    locator: Locator;
-    expected: unknown;
-    read: () => Promise<V>;
-    /** True for the read that ends the wait */
-    check: (actual: V) => boolean;
-    /** Time (ms) to keep retrying. Defaults to the expect timeout */
-    timeout?: number | undefined;
-    /** A read of `null` (no element) never passes, and fails as "could not read" */
-    mustExist?: boolean;
-    /** The first line of a failure, instead of `expect(locator).<name>` */
-    call?: string;
-}
-/**
- * Re-reads the element until `check` passes or the timeout expires, and resolves with the read that passed. A
- * timeout fails as an `AssertionError` with the last read, or as "could not read" when no read completed.
- */
-export declare function readEventually<V>({ name, locator, expected, read, check, timeout: perCall, mustExist, call, }: EventualRead<V>): Promise<V>;
-export declare class LocatorAssertions {
-    private readonly locator;
-    private readonly negated;
-    constructor(locator: Locator, negated?: boolean);
+export declare class LocatorAssertions extends MoreLocatorAssertions {
     /** Inverts the next matcher: it retries until the condition is false */
     get not(): LocatorAssertions;
+    /** The element exists, has a box and isn't hidden by CSS; `visible: false` expects the opposite, as `toBeHidden` */
+    toBeVisible(options?: LocatorAssertionOptions & {
+        visible?: boolean;
+    }): Promise<void>;
     /**
-     * Re-reads the element until `check` passes or the timeout expires. With `mustExist`, a read of `null`
-     * (no element) never passes, with or without `.not`, and fails as "could not read"
+     * Trimmed text content equals `expected` (a string, compared with whitespace collapsed on both sides) or matches it (RegExp).
+     * An array expects one entry per matched element, in order, and as many entries as elements
      */
-    private assertEventually;
+    toHaveText(expected: string | RegExp | Array<string | RegExp>, options?: TextAssertionOptions): Promise<void>;
     /**
-     * A text check that can keep what it read: with `options.output` the read that passed goes to that output, as
-     * `expected` captures it. The sink is taken now, when the call starts.
+     * Text content contains `expected` (a string, compared with whitespace collapsed on both sides) or matches it (RegExp).
+     * An array expects its entries, in order, in some of the matched elements (one entry per element, others may sit between)
      */
-    private assertText;
-    /** For matchers that need an element: `read` answers null when there is none, which never passes */
-    private assertExisting;
-    toBeVisible(options?: LocatorAssertionOptions): Promise<void>;
-    /** Trimmed text content equals `expected` (string) or matches it (RegExp) */
-    toHaveText(expected: string | RegExp, options?: TextAssertionOptions): Promise<void>;
-    /** Text content contains `expected` (string) or matches it (RegExp) */
-    toContainText(expected: string | RegExp, options?: TextAssertionOptions): Promise<void>;
+    toContainText(expected: string | RegExp | Array<string | RegExp>, options?: TextAssertionOptions): Promise<void>;
     toHaveValue(expected: string | RegExp, options?: TextAssertionOptions): Promise<void>;
+    /** The attribute equals `expected` (string) or matches it (RegExp); with only a name (and options), that the attribute exists */
+    toHaveAttribute(name: string, options?: LocatorAssertionOptions): Promise<void>;
     toHaveAttribute(name: string, expected: string | RegExp, options?: TextAssertionOptions): Promise<void>;
     toHaveCount(expected: number, options?: LocatorAssertionOptions): Promise<void>;
     /** The element is missing, or has no box or is hidden by CSS (the opposite of `toBeVisible`) */
     toBeHidden(options?: LocatorAssertionOptions): Promise<void>;
     /** The element exists and is neither `:disabled` nor `aria-disabled="true"`; a missing element never passes, not even with `.not` */
-    toBeEnabled(options?: LocatorAssertionOptions): Promise<void>;
+    toBeEnabled(options?: LocatorAssertionOptions & {
+        enabled?: boolean;
+    }): Promise<void>;
     /** A checked checkbox or radio input, or an element with `aria-checked="true"`; a missing element never passes, not even with `.not` */
-    toBeChecked(options?: LocatorAssertionOptions): Promise<void>;
+    toBeChecked(options?: CheckedOptions): Promise<void>;
     /** The class attribute equals `expected` (string, whitespace collapsed and trimmed on both sides) or matches it (RegExp, tested on the attribute as written) */
     toHaveClass(expected: string | RegExp, options?: LocatorAssertionOptions): Promise<void>;
     /** The computed value of a CSS property equals `expected` (string) or matches it (RegExp); `name` may be camelCase (`backgroundColor`) or kebab-case, `--custom` is kept */