@qaguardian/playwright-score 2.1.1 → 2.3.0

package/dist/rules/ast-util.js

@@ -0,0 +1,140 @@
+export const FN_TYPES = new Set(['FunctionExpression', 'ArrowFunctionExpression', 'FunctionDeclaration']);
+/** Walk a subtree. `visit` returns false to skip that node's children. Never descends into nested functions unless `intoFunctions`. */
+export function walk(node, visit, intoFunctions = false) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (Array.isArray(node)) {
+        for (const item of node)
+            walk(item, visit, intoFunctions);
+        return;
+    }
+    const rec = node;
+    if (typeof rec.type !== 'string')
+        return;
+    if (visit(node) === false)
+        return;
+    for (const key of Object.keys(rec)) {
+        if (key === 'parent')
+            continue;
+        const v = rec[key];
+        if (!v || typeof v !== 'object')
+            continue;
+        const child = v;
+        if (!intoFunctions && !Array.isArray(v) && child.type && FN_TYPES.has(child.type))
+            continue;
+        walk(v, visit, intoFunctions);
+    }
+}
+export function unwrap(node) {
+    let n = node ?? undefined;
+    while (n &&
+        (n.type === 'AwaitExpression' ||
+            n.type === 'TSNonNullExpression' ||
+            n.type === 'ChainExpression' ||
+            n.type === 'TSAsExpression' ||
+            n.type === 'ParenthesizedExpression')) {
+        n = (n.type === 'AwaitExpression' ? n.argument : (n.argument ?? n.expression)) ?? undefined;
+    }
+    return n;
+}
+export function memberName(callee) {
+    if (!callee || callee.type !== 'MemberExpression' || callee.computed)
+        return undefined;
+    return callee.property?.type === 'Identifier' ? callee.property.name : undefined;
+}
+/** `expect(...)`, `expect.soft(...)`, `expect.poll(...)`. */
+export function isExpectCall(node) {
+    if (!node || node.type !== 'CallExpression')
+        return false;
+    const c = node.callee;
+    if (c?.type === 'Identifier' && c.name === 'expect')
+        return true;
+    return (c?.type === 'MemberExpression' &&
+        !c.computed &&
+        c.object?.type === 'Identifier' &&
+        c.object.name === 'expect' &&
+        (c.property?.name === 'soft' || c.property?.name === 'poll'));
+}
+/** If `call` is `expect(x).[not.]matcher(...)`, describe it. */
+export function parseMatcherCall(call) {
+    if (call.type !== 'CallExpression')
+        return undefined;
+    const matcher = memberName(call.callee);
+    if (!matcher)
+        return undefined;
+    const modifiers = [];
+    let obj = call.callee?.object;
+    while (obj && obj.type === 'MemberExpression' && !obj.computed && obj.property?.type === 'Identifier') {
+        modifiers.push(obj.property.name ?? '');
+        obj = obj.object;
+    }
+    if (!obj || !isExpectCall(obj))
+        return undefined;
+    if (!modifiers.every((m) => m === 'not' || m === 'resolves' || m === 'rejects'))
+        return undefined;
+    return { expectCall: obj, matcher, modifiers, call };
+}
+/** Scope-resolved `const x = <init>` initialiser for an identifier, if any. */
+export function resolveConstInit(context, id) {
+    if (id.type !== 'Identifier' || !id.name)
+        return undefined;
+    let scope = context.sourceCode.getScope(id);
+    while (scope) {
+        const v = scope.set.get(id.name);
+        if (v) {
+            const def = v.defs[0];
+            if (!def || def.type !== 'Variable')
+                return undefined;
+            if (def.parent?.type === 'VariableDeclaration' && def.parent.kind !== 'const')
+                return undefined;
+            return def.node.id?.type === 'Identifier' ? (def.node.init ?? undefined) : undefined;
+        }
+        scope = scope.upper;
+    }
+    return undefined;
+}
+const CHAIN_OK = new Set(['first', 'last', 'nth', 'filter', 'locator', 'and', 'or', 'frameLocator', 'contentFrame']);
+/** Syntactic Locator: `page.locator(..)`, `x.getBy*(..)`, those chained with first/last/nth/filter/..., or a const initialised from one. */
+export function isLocatorExpr(context, node, depth = 0) {
+    const n = unwrap(node);
+    if (!n || depth > 3)
+        return false;
+    if (n.type === 'Identifier') {
+        const init = resolveConstInit(context, n);
+        return init ? isLocatorExpr(context, init, depth + 1) : false;
+    }
+    if (n.type !== 'CallExpression')
+        return false;
+    const name = memberName(n.callee);
+    if (!name)
+        return false;
+    if (name === 'locator' || name.startsWith('getBy'))
+        return true;
+    if (CHAIN_OK.has(name))
+        return isLocatorExpr(context, n.callee?.object, depth + 1);
+    return false;
+}
+/** Receiver is plausibly a Playwright Page/Locator/Frame (syntactic). */
+export function isPlaywrightReceiver(context, node, depth = 0) {
+    const n = unwrap(node);
+    if (!n || depth > 3)
+        return false;
+    if (isLocatorExpr(context, n))
+        return true;
+    if (n.type === 'Identifier') {
+        return n.name === 'page' || n.name === 'frame' || /[a-z]Locator$/.test(n.name ?? '') || /^(locator|page)$/i.test(n.name ?? '');
+    }
+    if (n.type === 'MemberExpression' && !n.computed) {
+        return n.property?.name === 'page' && n.object?.type === 'ThisExpression';
+    }
+    return false;
+}
+export function nearestFunction(node) {
+    let p = node.parent;
+    while (p) {
+        if (FN_TYPES.has(p.type))
+            return p;
+        p = p.parent;
+    }
+    return undefined;
+}

package/dist/rules/base-plugin.d.ts

@@ -3,16 +3,30 @@
  * style — always active.
  */
 import type { Rule } from 'eslint';
+/**
+ * Rule crashes are contained: an exception thrown while a rule builds its
+ * listeners or runs one on some unusual syntax must not abort the run for
+ * the whole suite. The rule simply reports nothing for that node. Crashes are
+ * recorded so tests can assert there are none.
+ */
+export declare const ruleCrashes: Array<{
+    rule: string;
+    error: unknown;
+}>;
+/** Clear the crash log; scorePaths calls this at the start of every run. */
+export declare function resetRuleCrashes(): void;
+/** Crashes of the current run, one entry per rule, in first-crash order. */
+export declare function summarizeRuleCrashes(): Array<{
+    rule: string;
+    count: number;
+}>;
+export declare function contain(name: string, rule: Rule.RuleModule): Rule.RuleModule;
 export declare const basePlugin: {
     meta: {
         name: string;
         version: string;
     };
     rules: {
-        'no-skipped-test-declaration': Rule.RuleModule;
-        'no-timer-sleep': Rule.RuleModule;
-        'no-coordinate-click': Rule.RuleModule;
-        'no-trivial-assertion': Rule.RuleModule;
-        'no-soft-assertion-only-test': Rule.RuleModule;
+        [k: string]: Rule.RuleModule;
     };
 };

package/dist/rules/base-plugin.js

@@ -1,3 +1,12 @@
+import { noUnawaitedAction } from './no-unawaited-action.js';
+import { noBrittleSelector } from './no-brittle-selector.js';
+import { noSharedMutableState, serialModeDependency } from './no-shared-mutable-state.js';
+import { noExcessiveTimeout } from './no-excessive-timeout.js';
+import { noFixmeTest } from './no-fixme-test.js';
+import { noSwallowedAssertion } from './no-swallowed-assertion.js';
+import { noWeakAssertion } from './no-weak-assertion.js';
+import { noUnawaitedExpectValue } from './no-unawaited-expect-value.js';
+import { noSelfFulfillingFallback } from './no-self-fulfilling-fallback.js';
 /**
  * `testNames` is `'test'` plus any `test.extend(...)`-derived fixture
  * aliases detected by test-aliases.ts (see eslint-runner.ts, which feeds
@@ -175,6 +184,64 @@ function callsResolve(fn, resolveName) {
         call.callee?.type === 'Identifier' &&
         call.callee.name === resolveName);
 }
+const LOOP_TYPES = new Set(['ForStatement', 'ForInStatement', 'ForOfStatement', 'WhileStatement', 'DoWhileStatement']);
+/**
+ * A retry/backoff pause inside a plain helper function (an API retry loop,
+ * `for (...) { try { await call() } catch { await sleep(500) } }`) is not a
+ * test waiting on the UI: it paces calls to a service. Only that shape is
+ * exempt: the sleep sits inside a catch clause, or inside a loop whose body
+ * contains a try/catch, and the enclosing function is *defined* (function
+ * declaration, `const f = () => ...`, class method) and is not itself nested
+ * in a callback handed to a call (a test, hook, describe or step body). A
+ * hand-rolled polling wait (`while (await x.isVisible()) sleep()`), a sleep
+ * directly in a test body or hook, a helper declared inside a test callback
+ * and a bare `sleep()` helper are all still flagged. `from` is the ancestor
+ * index to start climbing from (the Promise executor's own parent).
+ */
+function isRetryBackoffInHelper(ancestors, from) {
+    let retryShape = false;
+    let helperFound = false;
+    for (let i = from; i >= 0; i--) {
+        const anc = ancestors[i];
+        if (!helperFound) {
+            if (anc.type === 'CatchClause')
+                retryShape = true;
+            if (LOOP_TYPES.has(anc.type) && containsTryCatch(anc.body))
+                retryShape = true;
+        }
+        if (!FUNCTION_TYPES.has(anc.type) && anc.type !== 'FunctionDeclaration')
+            continue;
+        const parent = ancestors[i - 1];
+        if (parent?.type === 'CallExpression' || parent?.type === 'NewExpression') {
+            // Callback handed to a call (test body, hook, describe, .then, step):
+            // either the sleep is not in a free-standing helper at all, or the
+            // helper lives inside such a callback. Not exempt either way.
+            return false;
+        }
+        if (helperFound)
+            continue; // a function around the helper: keep checking the callback chain
+        if (anc.type === 'FunctionDeclaration' ||
+            parent?.type === 'MethodDefinition' ||
+            parent?.type === 'PropertyDefinition' ||
+            (parent?.type === 'VariableDeclarator' && parent.init === anc)) {
+            if (!retryShape)
+                return false;
+            helperFound = true;
+        }
+    }
+    return helperFound;
+}
+function containsTryCatch(root) {
+    let found = false;
+    walkNode(root, (n) => {
+        if (n.type !== 'TryStatement' || !n.handler)
+            return;
+        // An empty `try {}` is not a retry shape.
+        if ((n.block?.body ?? []).length > 0)
+            found = true;
+    });
+    return found;
+}
 /**
  * `await new Promise((resolve) => setTimeout(resolve, ms))` is the same
  * hard-coded sleep as `page.waitForTimeout(ms)` (already flagged, as an
@@ -289,7 +356,7 @@ const noTimerSleep = {
                             firstArg.name === resolveParam.name;
                         const resolveName = resolveParam?.type === 'Identifier' ? resolveParam.name : undefined;
                         const isWrappedResolve = typeof resolveName === 'string' && callsResolve(firstArg, resolveName);
-                        if (isDirectResolve || isWrappedResolve) {
+                        if ((isDirectResolve || isWrappedResolve) && !isRetryBackoffInHelper(ancestors, i - 1)) {
                             context.report({ node: node, messageId: 'sleep' });
                         }
                     }
@@ -517,8 +584,119 @@ function collectConstBindings(root) {
                 bindings.set(d.id.name, value);
         }
     });
+    // A `const` array is still mutable: `const errors = []; page.on('pageerror',
+    // (e) => errors.push(e)); expect(errors).toEqual([])` is a real assertion
+    // (the listener fills the array), not `expect([]).toEqual([])`. Only keep
+    // an array binding when every reference to it is the plain subject of an
+    // expect(...) call; any other use (method call, passed along, spread,
+    // reassigned element) might mutate it, so it is not a constant.
+    for (const [name, value] of [...bindings]) {
+        if (value.ok && Array.isArray(value.value) && !isOnlyReadAsExpectSubject(root, name)) {
+            bindings.delete(name);
+        }
+    }
     return bindings;
 }
+const MUTATING_METHODS = new Set([
+    'push', 'unshift', 'splice', 'pop', 'shift', 'sort', 'reverse', 'fill', 'copyWithin',
+]);
+/**
+ * True when no reference to `name` under `root` could change the array:
+ * every reference is a declaration, the subject of expect(...), a `.length`
+ * or index read, or the receiver of a non-mutating method. A reference that
+ * is a call argument (it may be handed to code that fills it), the
+ * receiver of a mutating method, an assignment/update target, or any other
+ * use that aliases the array (returned, assigned on, spread, put in an
+ * object) counts as possibly mutating, wherever it sits — including inside
+ * a closure such as a listener. Same-named properties (`obj.name`,
+ * `{ name: 1 }`) are not references. Shadowing is not resolved: a shadowing
+ * binding is read like the outer one, which can only keep a finding quiet.
+ */
+function isOnlyReadAsExpectSubject(root, name) {
+    let ok = true;
+    const visit = (node, stack) => {
+        if (!ok || !node || typeof node !== 'object')
+            return;
+        if (Array.isArray(node)) {
+            for (const item of node)
+                visit(item, stack);
+            return;
+        }
+        const rec = node;
+        if (typeof rec.type !== 'string')
+            return;
+        const n = node;
+        if (n.type === 'Identifier' && n.name === name) {
+            if (referenceMayMutate(n, stack))
+                ok = false;
+            return;
+        }
+        const next = [...stack, n];
+        for (const key of Object.keys(rec)) {
+            if (key === 'parent')
+                continue;
+            const v = rec[key];
+            if (v && typeof v === 'object')
+                visit(v, next);
+        }
+    };
+    visit(root, []);
+    return ok;
+}
+/** Is the member expression `m` itself written, deleted or the receiver of a mutating method? */
+function memberMutates(m, above) {
+    if (above.type === 'AssignmentExpression' && above.left === m)
+        return true;
+    if (above.type === 'UpdateExpression')
+        return true;
+    if (above.type === 'UnaryExpression' && above.operator === 'delete')
+        return true;
+    const prop = m.property;
+    return (!m.computed &&
+        prop?.type === 'Identifier' &&
+        !!prop.name &&
+        MUTATING_METHODS.has(prop.name) &&
+        above.type === 'CallExpression' &&
+        above.callee === m);
+}
+function referenceMayMutate(id, stack) {
+    const parent = stack[stack.length - 1];
+    const grand = stack[stack.length - 2];
+    if (!parent)
+        return true;
+    switch (parent.type) {
+        case 'VariableDeclarator':
+            return parent.id !== id; // `const b = expected` aliases it
+        case 'CallExpression':
+            if (parent.arguments?.[0] === id && isExpectCallNode(parent))
+                return false;
+            return parent.callee !== id || false; // an argument, or the array called
+        case 'MemberExpression': {
+            if (parent.object !== id)
+                return false; // `obj.expected`: a property name, not this binding
+            // Mutation of the member itself (`a.x = 1`, `a.push(1)`), then, for a
+            // computed access chain (`rows[0].push(9)`, `rows[0][1] = 2`), of
+            // the element it reaches: the inner array is part of the asserted one.
+            let member = parent;
+            for (let up = stack.length - 2; up >= 0; up--) {
+                const above = stack[up];
+                if (memberMutates(member, above))
+                    return true;
+                if (!member.computed || above.type !== 'MemberExpression' || above.object !== member)
+                    break;
+                member = above;
+            }
+            return false; // `.length`, `[0]`, `.map(...)`, ... are reads
+        }
+        case 'Property':
+        case 'PropertyDefinition':
+            // Non-computed key position is a name, not a reference; a value (or
+            // shorthand) puts the array inside an object.
+            return !((parent.key === id || false) && !parent.computed && !parent.shorthand);
+        default:
+            return true;
+    }
+}
 /**
  * Climbs from `node` to the body of the nearest enclosing function (the
  * test/hook callback in the common case) — the scope `noTrivialAssertion`
@@ -756,13 +934,72 @@ const noSoftAssertionOnlyTest = {
         };
     },
 };
+const rawRules = {
+    'no-skipped-test-declaration': noSkippedTestDeclaration,
+    'no-timer-sleep': noTimerSleep,
+    'no-coordinate-click': noCoordinateClick,
+    'no-trivial-assertion': noTrivialAssertion,
+    'no-soft-assertion-only-test': noSoftAssertionOnlyTest,
+    'no-unawaited-action': noUnawaitedAction,
+    'no-brittle-selector': noBrittleSelector,
+    'no-shared-mutable-state': noSharedMutableState,
+    'serial-mode-dependency': serialModeDependency,
+    'no-excessive-timeout': noExcessiveTimeout,
+    'no-fixme-test': noFixmeTest,
+    'no-swallowed-assertion': noSwallowedAssertion,
+    'no-weak-assertion': noWeakAssertion,
+    'no-unawaited-expect-value': noUnawaitedExpectValue,
+    'no-self-fulfilling-fallback': noSelfFulfillingFallback,
+};
+/**
+ * Rule crashes are contained: an exception thrown while a rule builds its
+ * listeners or runs one on some unusual syntax must not abort the run for
+ * the whole suite. The rule simply reports nothing for that node. Crashes are
+ * recorded so tests can assert there are none.
+ */
+export const ruleCrashes = [];
+/** Clear the crash log; scorePaths calls this at the start of every run. */
+export function resetRuleCrashes() {
+    ruleCrashes.length = 0;
+}
+/** Crashes of the current run, one entry per rule, in first-crash order. */
+export function summarizeRuleCrashes() {
+    const counts = new Map();
+    for (const c of ruleCrashes)
+        counts.set(c.rule, (counts.get(c.rule) ?? 0) + 1);
+    return [...counts].map(([rule, count]) => ({ rule, count }));
+}
+export function contain(name, rule) {
+    return {
+        ...rule,
+        create(context) {
+            let listeners;
+            try {
+                listeners = rule.create(context);
+            }
+            catch (error) {
+                ruleCrashes.push({ rule: name, error });
+                return {};
+            }
+            const safe = {};
+            for (const [key, fn] of Object.entries(listeners)) {
+                if (typeof fn !== 'function')
+                    continue;
+                safe[key] = (...args) => {
+                    try {
+                        return fn(...args);
+                    }
+                    catch (error) {
+                        ruleCrashes.push({ rule: name, error });
+                        return undefined;
+                    }
+                };
+            }
+            return safe;
+        },
+    };
+}
 export const basePlugin = {
     meta: { name: 'pwscore-base', version: '0.1.0' },
-    rules: {
-        'no-skipped-test-declaration': noSkippedTestDeclaration,
-        'no-timer-sleep': noTimerSleep,
-        'no-coordinate-click': noCoordinateClick,
-        'no-trivial-assertion': noTrivialAssertion,
-        'no-soft-assertion-only-test': noSoftAssertionOnlyTest,
-    },
+    rules: Object.fromEntries(Object.entries(rawRules).map(([name, rule]) => [name, contain(name, rule)])),
 };

package/dist/rules/no-brittle-selector.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+export declare function brittleReason(sel: string): string | undefined;
+export declare const noBrittleSelector: Rule.RuleModule;

package/dist/rules/no-brittle-selector.js

@@ -0,0 +1,150 @@
+import { isPwReceiver, propName, staticString, unwrap } from './rule-util.js';
+/**
+ * `pwscore/no-brittle-selector` (QAG-287). Selector strings that encode
+ * page structure instead of what the user sees. Matches, on the first
+ * argument of `.locator(...)`, `.frameLocator(...)` and the legacy
+ * selector-taking page methods (`page.click('..')`, `page.$('..')`, ...)
+ * when it is a fully static string:
+ *  - XPath: `xpath=...`, or a string starting with `//` or `(//`
+ *  - `:nth-child(` / `:nth-of-type(`
+ *  - a CSS chain with 4 or more combinators (`>`, `+`, `~`, descendant
+ *    space) outside brackets/parentheses/quotes
+ *  - generated class names: `.css-1a2b3c`, `.sc-bdfBwQ`, `.jss123`,
+ *    `.MuiBox-root-12`, `.makeStyles-root-12`
+ * and `.nth(n)` / `.first()` / `.last()` applied directly to a raw
+ * `.locator('<string>')` (a `data-testid`/`role=`/`text=` selector string
+ * is exempt: it names something stable).
+ *
+ * Reported as warning but report-only (evidence, not score): the locators
+ * dimension already counts every raw `.locator()`/legacy selector call in
+ * its native/raw ratio; scoring these as well would charge the same call
+ * twice. The finding says why the raw call is fragile.
+ */
+const SELECTOR_METHODS = new Set(['locator', 'frameLocator']);
+const LEGACY = new Set([
+    'click', 'dblclick', 'fill', 'type', 'press', 'check', 'uncheck', 'hover', 'focus',
+    'selectOption', 'textContent', 'innerText', 'innerHTML', 'getAttribute', 'inputValue',
+    'isVisible', 'isChecked', 'isEnabled', 'isDisabled', 'isHidden', 'waitForSelector', '$', '$$',
+    'setInputFiles', 'dispatchEvent', 'tap',
+]);
+function countCombinators(css) {
+    let depthParen = 0;
+    let depthBracket = 0;
+    let quote = '';
+    let count = 0;
+    let pendingSpace = false;
+    let sawCompound = false;
+    for (let i = 0; i < css.length; i++) {
+        const ch = css[i];
+        if (quote) {
+            if (ch === '\\')
+                i++;
+            else if (ch === quote)
+                quote = '';
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            sawCompound = true;
+            continue;
+        }
+        if (ch === '(') {
+            depthParen++;
+            continue;
+        }
+        if (ch === ')') {
+            depthParen = Math.max(0, depthParen - 1);
+            continue;
+        }
+        if (ch === '[') {
+            depthBracket++;
+            continue;
+        }
+        if (ch === ']') {
+            depthBracket = Math.max(0, depthBracket - 1);
+            continue;
+        }
+        if (depthParen || depthBracket)
+            continue;
+        if (ch === ',')
+            return 0; // selector list: do not guess
+        if (ch === '>' || ch === '+' || ch === '~') {
+            if (sawCompound)
+                count++;
+            sawCompound = false;
+            pendingSpace = false;
+            continue;
+        }
+        if (/\s/.test(ch)) {
+            if (sawCompound)
+                pendingSpace = true;
+            continue;
+        }
+        if (pendingSpace) {
+            count++;
+            pendingSpace = false;
+        }
+        sawCompound = true;
+    }
+    return count;
+}
+export function brittleReason(sel) {
+    const s = sel.trim();
+    if (/^xpath=/i.test(s) || s.startsWith('//') || s.startsWith('(//'))
+        return 'an XPath selector';
+    if (/:nth-(child|of-type|last-child|last-of-type)\(/.test(s))
+        return 'a positional :nth-child/:nth-of-type selector';
+    if (/\.css-(?=[a-z0-9]*\d)[a-z0-9]{5,}\b/.test(s) || /\.sc-(?=[A-Za-z0-9]*[A-Z0-9])[A-Za-z0-9]{5,}/.test(s) ||
+        /\.jss\d+/.test(s) || /\.Mui[A-Za-z]+-[A-Za-z]+-\d+/.test(s) || /\.makeStyles-[A-Za-z]+-\d+/.test(s)) {
+        return 'a generated class name that changes between builds';
+    }
+    // Only plain CSS gets the combinator count (not text=/role=/>> chains).
+    if (!/^[a-z-]+=/i.test(s) || /^css=/i.test(s)) {
+        const css = s.replace(/^css=/i, '');
+        if (!css.includes('>>') && countCombinators(css) >= 4)
+            return 'a long CSS chain (4+ combinators) tied to the page structure';
+    }
+    return undefined;
+}
+export const noBrittleSelector = {
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Disallow selectors that encode page structure' },
+        messages: {
+            brittle: 'Brittle selector: {{reason}}. It breaks when markup is reorganised; prefer getByRole/getByLabel/getByTestId.',
+            positional: '`.{{method}}()` on a raw `.locator(...)` picks an element by its position, which changes with the data or layout. Narrow the locator instead (role, label, test id, filter).',
+        },
+        schema: [],
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                const callee = unwrap(node.callee);
+                if (callee?.type !== 'MemberExpression')
+                    return;
+                const name = propName(callee);
+                if (!name)
+                    return;
+                if (SELECTOR_METHODS.has(name) || (LEGACY.has(name) && isPwReceiver(context, callee.object))) {
+                    const sel = staticString(node.arguments?.[0]);
+                    if (sel !== undefined) {
+                        const reason = brittleReason(sel);
+                        if (reason)
+                            context.report({ node: node, messageId: 'brittle', data: { reason } });
+                    }
+                }
+                if (name === 'first' || name === 'last' || name === 'nth') {
+                    const inner = unwrap(callee.object);
+                    if (inner?.type === 'CallExpression' && inner.callee?.type === 'MemberExpression' && propName(inner.callee) === 'locator') {
+                        const sel = staticString(inner.arguments?.[0]);
+                        if (sel === undefined)
+                            return;
+                        if (/data-(testid|test-id|test|cy|qa|pw)|^role=|^text=|^internal:|^id=|^testid=/i.test(sel.trim()))
+                            return;
+                        context.report({ node: node, messageId: 'positional', data: { method: name } });
+                    }
+                }
+            },
+        };
+    },
+};

package/dist/rules/no-excessive-timeout.d.ts

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