@qaguardian/playwright-score 2.2.0 → 2.3.0

package/dist/rules/no-self-fulfilling-fallback.js

@@ -0,0 +1,221 @@
+import { FN_TYPES, isExpectCall, memberName, resolveConstInit, unwrap, walk } from './ast-util.js';
+const CHECKS = new Set([
+    'isVisible', 'isHidden', 'isEnabled', 'isDisabled', 'isChecked', 'isEditable', 'count',
+    'textContent', 'innerText', 'inputValue', 'getAttribute', 'allTextContents', 'allInnerTexts',
+]);
+const NEGATIVE_STATE_CHECKS = new Set(['isHidden', 'isDisabled']);
+// Only actions that SUPPLY content count. A click-only fallback is the
+// "make sure the menu/toggle is open, then assert" setup idiom (checked on
+// rill, mattermost: all click-only hits were setup, not self-fulfilment;
+// `press('Escape')` in an else branch was setup too, so press is excluded).
+const ACTIONS = new Set(['fill', 'type', 'pressSequentially', 'selectOption', 'setInputFiles']);
+export const noSelfFulfillingFallback = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Disallow fallbacks that perform the expected state themselves before asserting it' },
+        messages: {
+            fallback: 'Self-fulfilling fallback: when the app does not produce this state, the test performs the actions itself and then asserts the result. The assertion can no longer detect the app failing to do it. Assert first and fail, or remove the fallback.',
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: { testAliasNames: { items: { type: 'string' }, type: 'array' } },
+                type: 'object',
+            },
+        ],
+    },
+    create(context) {
+        const aliases = context.options[0]?.testAliasNames ?? [];
+        const testNames = new Set(['test', ...aliases]);
+        const text = (n) => context.sourceCode.getText(n).replace(/\s+/g, '');
+        function isTestCallback(fn) {
+            const call = fn.parent;
+            if (!call || call.type !== 'CallExpression' || !(call.arguments ?? []).includes(fn))
+                return false;
+            let c = call.callee;
+            if (c?.type === 'MemberExpression')
+                c = c.object?.type === 'MemberExpression' ? c.object.object : c.object;
+            return c?.type === 'Identifier' && !!c.name && testNames.has(c.name);
+        }
+        function inTest(n) {
+            for (let p = n.parent; p; p = p.parent)
+                if (FN_TYPES.has(p.type) && isTestCallback(p))
+                    return true;
+            return false;
+        }
+        /** Does the expression contain a state check (resolving one level of const)? */
+        function hasCheck(e, depth = 0) {
+            let found = false;
+            walk(e, (n) => {
+                if (found)
+                    return false;
+                if (n.type === 'CallExpression' && CHECKS.has(memberName(n.callee) ?? ''))
+                    found = true;
+                else if (n.type === 'MemberExpression' && !n.computed && n.property?.name === 'length')
+                    found = true;
+                else if (n.type === 'Identifier' && depth < 2) {
+                    const init = resolveConstInit(context, n);
+                    if (init && hasCheck(init, depth + 1))
+                        found = true;
+                }
+                return undefined;
+            });
+            return found;
+        }
+        function isZeroish(n) {
+            return !!n && n.type === 'Literal' && (n.value === 0 || n.value === '' || n.value === false);
+        }
+        /** The test expression is true when the app did NOT produce the state. */
+        function negated(e, depth = 0) {
+            const n = unwrap(e);
+            if (!n || depth > 3)
+                return false;
+            if (n.type === 'UnaryExpression' && n.operator === '!')
+                return hasCheck(n.argument ?? undefined);
+            if (n.type === 'LogicalExpression')
+                return negated(n.left, depth + 1) || negated(n.right, depth + 1);
+            if (n.type === 'BinaryExpression') {
+                const op = n.operator;
+                const l = unwrap(n.left);
+                const r = unwrap(n.right);
+                if ((op === '===' || op === '==') && hasCheck(l) && isZeroish(r))
+                    return true;
+                if ((op === '<' && hasCheck(l) && r?.type === 'Literal' && r.value === 1))
+                    return true;
+                if ((op === '!==' || op === '!=') && hasCheck(l) && r?.type === 'Literal' && typeof r.value === 'string')
+                    return true;
+                return false;
+            }
+            if (n.type === 'CallExpression')
+                return NEGATIVE_STATE_CHECKS.has(memberName(n.callee) ?? '');
+            if (n.type === 'Identifier' && depth < 2) {
+                const init = resolveConstInit(context, n);
+                // `const hidden = await x.isHidden(); if (hidden)`
+                return init ? negated(init, depth + 1) : false;
+            }
+            return false;
+        }
+        function positive(e) {
+            return hasCheck(e) && !negated(e);
+        }
+        /** Receiver texts of member calls and expect() subjects in a subtree. */
+        function keys(root, depth = 0) {
+            const out = new Set();
+            walk(root, (n) => {
+                if (n.type === 'CallExpression') {
+                    if (isExpectCall(n)) {
+                        const a = unwrap((n.arguments ?? [])[0]);
+                        if (a)
+                            addKey(out, a, depth);
+                    }
+                    else if (n.callee?.type === 'MemberExpression') {
+                        addKey(out, n.callee.object, depth);
+                    }
+                }
+            });
+            return out;
+        }
+        function addKey(out, n, depth) {
+            const u = unwrap(n);
+            if (!u)
+                return;
+            const t = text(u);
+            if (t === 'page' || t === 'this.page' || t === 'expect' || t === 'test' || t.length < 3)
+                return;
+            out.add(t);
+            if (u.type === 'Identifier' && depth < 2) {
+                const init = resolveConstInit(context, u);
+                if (init)
+                    for (const k of keys(init, depth + 1))
+                        out.add(k);
+                if (init)
+                    addKey(out, init, depth + 1);
+            }
+        }
+        function overlap(a, b) {
+            for (const x of a)
+                for (const y of b)
+                    if (x === y)
+                        return true;
+            return false;
+        }
+        function hasAction(branch) {
+            let has = false;
+            const targets = new Set();
+            walk(branch, (n) => {
+                if (n.type === 'CallExpression' && ACTIONS.has(memberName(n.callee) ?? '')) {
+                    has = true;
+                    addKey(targets, n.callee?.object, 0);
+                }
+            });
+            return { has, targets };
+        }
+        function expectsAfter(siblings, from) {
+            const found = [];
+            for (const s of siblings.slice(from + 1)) {
+                walk(s, (n) => {
+                    if (isExpectCall(n))
+                        found.push(n);
+                });
+            }
+            return found;
+        }
+        function evaluate(stmt, siblings, idx) {
+            let fallback;
+            let condKeys = new Set();
+            if (stmt.type === 'IfStatement') {
+                const test = stmt.test;
+                if (negated(test))
+                    fallback = stmt.consequent;
+                else if (positive(test) && stmt.alternate)
+                    fallback = stmt.alternate;
+                if (!fallback)
+                    return;
+                condKeys = keys(test);
+                // keys() only sees member-call receivers/expect subjects; a const-derived test needs its init too.
+                walk(test, (n) => {
+                    if (n.type === 'Identifier') {
+                        const init = resolveConstInit(context, n);
+                        if (init)
+                            for (const k of keys(init))
+                                condKeys.add(k);
+                    }
+                });
+            }
+            else if (stmt.type === 'TryStatement' && stmt.handler) {
+                let guarded = false;
+                walk(stmt.block, (n) => {
+                    if (isExpectCall(n) || (n.type === 'CallExpression' && CHECKS.has(memberName(n.callee) ?? '')))
+                        guarded = true;
+                });
+                if (!guarded)
+                    return;
+                fallback = stmt.handler.body;
+                condKeys = keys(stmt.block);
+            }
+            else
+                return;
+            const act = hasAction(fallback);
+            if (!act.has)
+                return;
+            const expects = expectsAfter(siblings, idx);
+            if (expects.length === 0)
+                return;
+            const later = new Set();
+            for (const e of expects)
+                for (const k of keys(e))
+                    later.add(k);
+            if (overlap(condKeys, later) || overlap(act.targets, later)) {
+                context.report({ node: stmt, messageId: 'fallback' });
+            }
+        }
+        function onBlock(raw) {
+            const block = raw;
+            if (!inTest(block))
+                return;
+            const body = (Array.isArray(block.body) ? block.body : []);
+            body.forEach((s, i) => evaluate(s, body, i));
+        }
+        return { BlockStatement: onBlock };
+    },
+};

package/dist/rules/no-shared-mutable-state.d.ts

@@ -0,0 +1,4 @@
+import type { Rule } from 'eslint';
+export declare const noSharedMutableState: Rule.RuleModule;
+/** Report-only companion: serial mode declares order dependence. */
+export declare const serialModeDependency: Rule.RuleModule;

package/dist/rules/no-shared-mutable-state.js

@@ -0,0 +1,186 @@
+import { TEST_ALIAS_SCHEMA, enclosingFunction, hookName, isDescribeCall, isInSerialScope, isSerialConfigureCall, isSerialDescribeCall, isTestDeclaration, propName, testNamesFromOptions, unwrap, } from './rule-util.js';
+/**
+ * `pwscore/no-shared-mutable-state` (QAG-287). A module-level or
+ * describe-level `let`/`var` (or a `const` bound to an object/array
+ * literal, `new Map()` or `new Set()`) that one `test(...)` body assigns or
+ * mutates and a DIFFERENT `test(...)` body reads without writing it
+ * itself. Run alone, in another order or on another worker, the reader sees
+ * the initial value, so the suite is order-dependent.
+ *
+ * Not matched: variables in serial mode (`test.describe.serial`, or
+ * `test.describe.configure({ mode: 'serial' })` at file level or in an
+ * enclosing describe); assignment only inside `beforeEach`/`beforeAll`/`afterEach`
+ * (setup); a variable that any `beforeEach` assigns (it is reset before each
+ * test); a reader that also writes the variable itself (its own setup);
+ * variables declared inside a test.
+ * Mutation = assignment, `++`/`--`, member assignment (`v.x = 1`), or a
+ * call of `push/pop/shift/unshift/splice/set/add/delete/clear/sort/reverse`.
+ *
+ * Companion `pwscore/serial-mode-dependency` is report-only information:
+ * `test.describe.configure({ mode: 'serial' })` and `test.describe.serial()`
+ * declare that tests depend on order; not an error on its own.
+ */
+const MUTATORS = new Set(['push', 'pop', 'shift', 'unshift', 'splice', 'set', 'add', 'delete', 'clear', 'sort', 'reverse']);
+export const noSharedMutableState = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Disallow state written in one test and read in another' },
+        messages: {
+            shared: '`{{name}}` is written in test "{{writer}}" and read in this test. Tests that share state depend on run order and break under retries or parallel workers. Create the state inside each test (or a fixture/beforeEach).',
+        },
+        schema: TEST_ALIAS_SCHEMA,
+    },
+    create(context) {
+        const testNames = testNamesFromOptions(context.options);
+        /** The test(...) call (and its title) whose callback contains `node`, if any. */
+        const owningTest = (node) => {
+            let fn = enclosingFunction(node);
+            while (fn) {
+                const call = fn.parent;
+                if (call?.type === 'CallExpression' && call.arguments.includes(fn)) {
+                    if (isTestDeclaration(call, testNames))
+                        return call;
+                    if (hookName(call, testNames))
+                        return undefined;
+                }
+                fn = enclosingFunction(fn);
+            }
+            return undefined;
+        };
+        const owningHook = (node) => {
+            let fn = enclosingFunction(node);
+            while (fn) {
+                const call = fn.parent;
+                if (call?.type === 'CallExpression' && call.arguments.includes(fn)) {
+                    const h = hookName(call, testNames);
+                    if (h)
+                        return h;
+                    if (isTestDeclaration(call, testNames))
+                        return undefined;
+                }
+                fn = enclosingFunction(fn);
+            }
+            return undefined;
+        };
+        /** Declared directly at module level or directly in a describe callback. */
+        const isSharedScope = (decl) => {
+            const fn = enclosingFunction(decl);
+            if (!fn)
+                return true;
+            const call = fn.parent;
+            return call?.type === 'CallExpression' && call.arguments.includes(fn) && isDescribeCall(call, testNames);
+        };
+        const isMutableInit = (kind, init) => {
+            if (kind !== 'const')
+                return true;
+            const i = unwrap(init);
+            return (!!i &&
+                (i.type === 'ObjectExpression' ||
+                    i.type === 'ArrayExpression' ||
+                    (i.type === 'NewExpression' && i.callee?.type === 'Identifier' && (i.callee.name === 'Map' || i.callee.name === 'Set'))));
+        };
+        const titleOf = (call) => {
+            const t = call.arguments?.[0];
+            return t?.type === 'Literal' && typeof t.value === 'string' ? t.value : 'another test';
+        };
+        /** Is this reference a write/mutation of the variable? */
+        const isMutation = (id, ref) => {
+            if (ref.isWrite())
+                return true;
+            let child = id;
+            let parent = id.parent;
+            while (parent?.type === 'MemberExpression' && parent.object === child) {
+                const gp = parent.parent;
+                if (gp?.type === 'AssignmentExpression' && gp.left === parent)
+                    return true;
+                if (gp?.type === 'UpdateExpression')
+                    return true;
+                if (gp?.type === 'CallExpression' && gp.callee === parent) {
+                    const name = propName(parent);
+                    if (name && MUTATORS.has(name) && parent.object === id)
+                        return true;
+                }
+                child = parent;
+                parent = gp;
+            }
+            return false;
+        };
+        return {
+            VariableDeclaration(node) {
+                if (!isSharedScope(node))
+                    return;
+                for (const decl of node.declarations) {
+                    if (decl.id?.type !== 'Identifier' || !isMutableInit(node.kind, decl.init))
+                        continue;
+                    const [variable] = context.sourceCode.getDeclaredVariables(decl);
+                    if (!variable)
+                        continue;
+                    // Serial mode is Playwright's documented way to share state in order.
+                    if (isInSerialScope(decl, testNames))
+                        continue;
+                    const writes = new Map(); // test call -> write node
+                    const reads = new Map(); // test call -> first read identifier
+                    let hookReset = false;
+                    for (const ref of variable.references) {
+                        const id = ref.identifier;
+                        if (id === decl.id)
+                            continue;
+                        const test = owningTest(id);
+                        const mutation = isMutation(id, ref);
+                        if (!test) {
+                            if (mutation && owningHook(id) === 'beforeEach')
+                                hookReset = true;
+                            continue;
+                        }
+                        if (mutation) {
+                            if (!writes.has(test))
+                                writes.set(test, id);
+                        }
+                        else if (ref.isRead() && !reads.has(test)) {
+                            reads.set(test, id);
+                        }
+                    }
+                    if (hookReset || writes.size === 0)
+                        continue;
+                    for (const [test, id] of reads) {
+                        if (writes.has(test))
+                            continue;
+                        // Serial mode orders the tests that share state: skip a writer/reader
+                        // pair only when BOTH sit in a serial scope.
+                        const readerSerial = isInSerialScope(test, testNames);
+                        const writer = [...writes.keys()].find((w) => !(readerSerial && isInSerialScope(w, testNames)));
+                        if (!writer)
+                            continue;
+                        context.report({
+                            node: id,
+                            messageId: 'shared',
+                            data: { name: decl.id.name, writer: titleOf(writer) },
+                        });
+                        break; // one finding per variable
+                    }
+                }
+            },
+        };
+    },
+};
+/** Report-only companion: serial mode declares order dependence. */
+export const serialModeDependency = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Report serial-mode describe blocks (tests depend on order)' },
+        messages: {
+            serial: 'Serial mode: the tests in this scope depend on running in order, so one failure skips the rest and retries rerun the whole group. Information only.',
+        },
+        schema: TEST_ALIAS_SCHEMA,
+    },
+    create(context) {
+        const testNames = testNamesFromOptions(context.options);
+        return {
+            CallExpression(node) {
+                if (isSerialDescribeCall(node, testNames) || isSerialConfigureCall(node, testNames)) {
+                    context.report({ node: node, messageId: 'serial' });
+                }
+            },
+        };
+    },
+};

package/dist/rules/no-swallowed-assertion.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An assertion whose failure is caught and discarded cannot fail the test.
+ *
+ * Matches:
+ *  1. `try { ... expect(x).matcher() ... } catch { ... }` where the catch
+ *     body does not throw, call expect / test.fail / a fail-ish helper,
+ *     return a value, or assign/mutate outer state (any of which may carry
+ *     the failure to a later assertion). Skipped inside loops (retry idiom).
+ *  2. `await expect(x).matcher().catch(<fn that does not throw>)` as a
+ *     statement (result discarded).
+ */
+import type { Rule } from 'eslint';
+export declare const noSwallowedAssertion: Rule.RuleModule;

package/dist/rules/no-swallowed-assertion.js

@@ -0,0 +1,113 @@
+import { FN_TYPES, memberName, parseMatcherCall, walk } from './ast-util.js';
+const LOOPS = new Set(['ForStatement', 'ForInStatement', 'ForOfStatement', 'WhileStatement', 'DoWhileStatement']);
+const FAILISH = /fail|error|throw|assert|report|expect/i;
+const LOGGERS = /^(console|logger|log|logging|consola|pino|winston|bunyan|debug)$/i;
+/** `console.error(...)`, `logger.warn(...)`, `this.logger.error(...)`: logging reports, it does not fail. */
+function isLoggerCall(callee) {
+    if (callee?.type !== 'MemberExpression')
+        return false;
+    let o = callee.object;
+    while (o) {
+        if (o.type === 'Identifier')
+            return LOGGERS.test(o.name ?? '');
+        if (o.type !== 'MemberExpression')
+            return false;
+        if (!o.computed && o.property?.type === 'Identifier' && LOGGERS.test(o.property.name ?? ''))
+            return true;
+        o = o.object;
+    }
+    return false;
+}
+/** True when `body` can carry the failure onward: throw, expect, test.fail, return value, assignment, fail-ish call. */
+function propagates(body) {
+    let ok = false;
+    walk(body, (n) => {
+        if (ok)
+            return false;
+        if (n.type === 'ThrowStatement')
+            ok = true;
+        else if (n.type === 'ReturnStatement' && n.argument)
+            ok = true;
+        else if (n.type === 'AssignmentExpression' || n.type === 'UpdateExpression')
+            ok = true;
+        else if (n.type === 'CallExpression') {
+            const c = n.callee;
+            if (isLoggerCall(c))
+                return undefined; // a log line is not a failure
+            const name = c?.type === 'Identifier' ? c.name : memberName(c);
+            if (c?.type === 'MemberExpression' && c.object?.type === 'Identifier' && c.object.name === 'expect')
+                ok = true;
+            else if (c?.type === 'MemberExpression' && memberName(c) === 'skip')
+                ok = true; // test.skip(...) in the catch: a deliberate, visible outcome
+            else if (name && FAILISH.test(name))
+                ok = true;
+            else if (name && ['push', 'add', 'set'].includes(name))
+                ok = true; // collects errors for later
+        }
+        return undefined;
+    }, true);
+    return ok;
+}
+export const noSwallowedAssertion = {
+    meta: {
+        type: 'problem',
+        docs: { description: 'Disallow assertions whose failure is caught and discarded' },
+        messages: {
+            swallowed: 'This assertion is inside a try/catch that swallows its failure, so it can never fail the test. Rethrow in the catch, or drop the try.',
+            swallowedCatch: 'This assertion ends in .catch(...) that discards the failure, so it can never fail the test. Remove the .catch.',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            TryStatement(raw) {
+                const node = raw;
+                if (!node.handler)
+                    return;
+                let hasExpect = false;
+                walk(node.block, (n) => {
+                    if (n.type === 'CallExpression' && parseMatcherCall(n))
+                        hasExpect = true;
+                });
+                if (!hasExpect)
+                    return;
+                if (propagates(node.handler.body))
+                    return;
+                for (let p = node.parent; p; p = p.parent) {
+                    if (LOOPS.has(p.type))
+                        return;
+                    if (FN_TYPES.has(p.type))
+                        break;
+                }
+                context.report({ node: raw, messageId: 'swallowed' });
+            },
+            CallExpression(raw) {
+                const node = raw;
+                if (memberName(node.callee) !== 'catch')
+                    return;
+                const inner = node.callee?.object;
+                if (!inner || !parseMatcherCall(inner))
+                    return;
+                const handler = (node.arguments ?? [])[0];
+                if (!handler)
+                    return;
+                // Result must be discarded: `await expect(...).catch(...)` as a statement.
+                let up = node.parent;
+                if (up?.type === 'AwaitExpression')
+                    up = up.parent;
+                if (up?.type !== 'ExpressionStatement')
+                    return;
+                const isFn = FN_TYPES.has(handler.type);
+                const isConsole = handler.type === 'MemberExpression' && handler.object?.name === 'console';
+                if (!isFn && !isConsole)
+                    return;
+                if (isFn) {
+                    const body = handler.body;
+                    if (body && body.type === 'BlockStatement' && propagates(body))
+                        return;
+                }
+                context.report({ node: raw, messageId: 'swallowedCatch' });
+            },
+        };
+    },
+};

package/dist/rules/no-unawaited-action.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from 'eslint';
+export declare const noUnawaitedAction: Rule.RuleModule;

package/dist/rules/no-unawaited-action.js

@@ -0,0 +1,77 @@
+import { isPwReceiver, propName, unwrap, enclosingFunction } from './rule-util.js';
+/**
+ * `pwscore/no-unawaited-action` (QAG-287). A Playwright action or
+ * navigation used as a bare expression statement, inside an async function
+ * (test, hook or helper), with no `await`, `return`, `void`, assignment or
+ * argument position: `page.goto(url);`, `page.getByRole('button').click();`,
+ * `const b = page.locator('#b'); b.fill('x');`.
+ *
+ * Matched shape: ExpressionStatement whose expression is exactly
+ * `<receiver>.<method>(...)`, where the receiver is syntactically a Page or
+ * Locator (see `isPwReceiver`) and `<method>` is an action/navigation/wait
+ * (list below, plus any `waitFor*`). Not matched: anything inside
+ * `Promise.all([...])`, assigned, returned, passed as an argument, chained
+ * into `.catch()`/`.then()`, or in a non-async function.
+ *
+ * Why not eslint-plugin-playwright's `missing-playwright-await` with its
+ * `includePageLocatorMethods` option: it matches the method NAME on any
+ * receiver (`el.click()`, `items.count()`, `$btn.check()` all count), which
+ * is not precise enough for a public score, and it also reports value
+ * getters. This rule requires a Page/Locator receiver.
+ */
+const ACTIONS = new Set([
+    'goto',
+    'reload',
+    'goBack',
+    'goForward',
+    'click',
+    'dblclick',
+    'fill',
+    'clear',
+    'press',
+    'pressSequentially',
+    'type',
+    'check',
+    'uncheck',
+    'setChecked',
+    'selectOption',
+    'hover',
+    'focus',
+    'tap',
+    'dragTo',
+    'dragAndDrop',
+    'setInputFiles',
+    'setContent',
+    'scrollIntoViewIfNeeded',
+]);
+export const noUnawaitedAction = {
+    meta: {
+        type: 'problem',
+        docs: { description: 'Disallow Playwright actions/navigations that are not awaited' },
+        messages: {
+            unawaited: '`{{name}}()` returns a promise that is never awaited, so the test moves on before the action finishes (a flake and a swallowed failure). Add `await`.',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            ExpressionStatement(node) {
+                const expr = node.expression;
+                if (!expr || expr.type !== 'CallExpression')
+                    return;
+                const callee = unwrap(expr.callee);
+                if (callee?.type !== 'MemberExpression')
+                    return;
+                const name = propName(callee);
+                if (!name || !(ACTIONS.has(name) || /^waitFor[A-Z]?/.test(name) || name === 'waitFor'))
+                    return;
+                const fn = enclosingFunction(node);
+                if (!fn || !fn.async)
+                    return;
+                if (!isPwReceiver(context, callee.object))
+                    return;
+                context.report({ node: expr, messageId: 'unawaited', data: { name } });
+            },
+        };
+    },
+};

package/dist/rules/no-unawaited-expect-value.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A Promise-returning Playwright call used without `await` inside
+ * `expect(...)`, with a matcher that is not a web-first (auto-awaiting)
+ * matcher. The assertion compares a Promise object, not the value.
+ *
+ * Matches `expect(<call>).[not.]<matcher>(...)` where <call> is not awaited,
+ * its method is one of innerText/innerHTML/textContent/inputValue/
+ * getAttribute/isVisible/isHidden/isEnabled/isDisabled/isChecked/isEditable/
+ * count/title/allInnerTexts/allTextContents/boundingBox/content, and the
+ * receiver is syntactically a Page/Locator (page, locator(), getBy*(), a
+ * const from one, `*Locator`/`*Page` names). Also flags an un-awaited such
+ * call as the argument of toBe/toEqual/toStrictEqual. Either position may be
+ * a const initialised (un-awaited) from such a call. Never flags
+ * `.resolves`/`.rejects` chains or web-first matchers.
+ * `playwright/prefer-web-first-assertions` hits on the same line/column are
+ * dropped by eslint-runner in favour of this message.
+ */
+import type { Rule } from 'eslint';
+export declare const PROMISE_METHODS: Set<string>;
+export declare const noUnawaitedExpectValue: Rule.RuleModule;