eslint-plugin-test-governance 0.3.1 → 0.5.0

package/dist/index.js

@@ -4,6 +4,8 @@ import noConflictingStates from "./rules/no-conflicting-states.js";
 import noOrphanedMarker from "./rules/no-orphaned-marker.js";
 import requireTicketInComments from "./rules/require-ticket-in-comments.js";
 import requireTicket from "./rules/require-ticket.js";
+import { FRAMEWORK_NAMES } from "./utils/constants.js";
+import { ConfigError } from "./utils/errors.js";
 import { compileOptions, SETTINGS_KEY } from "./utils/options.js";
 const PLUGIN_NAME = 'test-governance';
 // Read at load time so the reported version always matches the published package.
@@ -17,7 +19,8 @@ const ruleModules = {
 };
 // Public types come from `eslint` itself, so users don't need typescript-eslint installed.
 export const rules = ruleModules;
-const recommendedRules = Object.fromEntries(Object.keys(ruleModules).map((name) => [
+// Every framework config turns on all the rules, at the severity in each rule's `meta.docs.recommended`.
+const configRules = Object.fromEntries(Object.keys(ruleModules).map((name) => [
     `${PLUGIN_NAME}/${name}`,
     ruleModules[name].meta.docs.recommended,
 ]));
@@ -28,27 +31,38 @@ const plugin = {
     configure,
 };
 /**
- * Returns the recommended config with shared options in `settings['test-governance']`,
+ * Returns the config of `options.framework` with shared options in `settings['test-governance']`,
  * so all rules read the same ticket formats and states.
  */
-export function configure(options = {}) {
+export function configure(options) {
     compileOptions(options); // fail on a bad config at load time, not on the first lint
     return {
-        name: `${PLUGIN_NAME}/recommended`,
+        name: `${PLUGIN_NAME}/${options.framework}`,
         plugins: { [PLUGIN_NAME]: plugin },
-        rules: { ...recommendedRules },
+        rules: { ...configRules },
         settings: { [SETTINGS_KEY]: options },
     };
 }
-plugin.configs.recommended = {
-    name: `${PLUGIN_NAME}/recommended`,
-    plugins: { [PLUGIN_NAME]: plugin },
-    rules: { ...recommendedRules },
-};
+// Each sets its framework, so it wins over a `configure()` that applies to all files when listed after it.
+for (const framework of FRAMEWORK_NAMES) {
+    plugin.configs[framework] = configure({ framework });
+}
+// `configs.recommended` was removed in 0.5.0. Reading it throws, so `...configs.recommended` fails with this
+// message instead of spreading nothing and turning the rules off without a word. It isn't enumerable, so
+// tools that list the configs don't see it.
+Object.defineProperty(plugin.configs, 'recommended', {
+    get() {
+        throw new ConfigError('configs.recommended was removed in 0.5.0. Use the config for your framework: configs.playwright, configs.jest or configs.vitest. See https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/upgrading.md');
+    },
+});
 export const configs = plugin.configs;
 export default plugin;
-// Makes `require('eslint-plugin-test-governance')` return the plugin itself rather than the module
-// namespace. With the namespace, a CommonJS config that registers the plugin next to
-// `configs.recommended` fails with "Cannot redefine plugin".
+/**
+ * Makes `require('eslint-plugin-test-governance')` return the plugin itself rather than the module
+ * namespace. With the namespace, a CommonJS config that registers the plugin next to
+ * `configs.playwright` fails with "Cannot redefine plugin".
+ *
+ * @internal Left out of the type declarations: TypeScript before 5.6 can't parse a string export
+ * name, so it would reject the whole file.
+ */
 export { plugin as 'module.exports' };
-//# sourceMappingURL=index.js.map

package/dist/rules/marker-matches-state.d.ts

@@ -1,3 +1,2 @@
 declare const _default: import("../utils/create-rule.ts").Rule<"wrongMarker" | "sharedMarker" | "renameMarker" | "addMarker">;
 export default _default;
-//# sourceMappingURL=marker-matches-state.d.ts.map

package/dist/rules/marker-matches-state.js

@@ -2,14 +2,15 @@ import { appliesTo, describeSubject, isStateMarker, missingStates, strayMarkers
 import { createRule } from "../utils/create-rule.js";
 import { indentOf, keywordRange } from "../utils/fix.js";
 export default createRule({
-    name: 'marker-matches-state',
     meta: {
         type: 'problem',
-        hasSuggestions: true,
         docs: {
             description: "Require the marker keyword to match the test's state",
             recommended: 'error',
+            url: 'https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/rules/marker-matches-state.md',
         },
+        hasSuggestions: true,
+        schema: [],
         messages: {
             wrongMarker: "`{{found}}:` doesn't match this code: {{subject}} is in the '{{state}}' state, so the marker should be `{{expected}}:`.",
             sharedMarker: "`{{found}}:` covers only the '{{foundState}}' state. {{subject}} is also in the '{{state}}' state, which needs its own `// {{expected}}: <ticket>` marker.",
@@ -17,7 +18,7 @@ export default createRule({
             addMarker: 'Add `// {{expected}}: {{tickets}}` with the same ticket.',
         },
     },
-    check(context, analysis, options) {
+    create(context, analysis, options) {
         const { sourceCode } = context;
         for (const subject of analysis.subjects) {
             const missing = missingStates(subject);
@@ -78,4 +79,3 @@ export default createRule({
         }
     },
 });
-//# sourceMappingURL=marker-matches-state.js.map

package/dist/rules/no-conflicting-states.d.ts

@@ -1,3 +1,2 @@
 declare const _default: import("../utils/create-rule.ts").Rule<"newAndUnstable" | "newSkipped" | "tagCase" | "tagTypo">;
 export default _default;
-//# sourceMappingURL=no-conflicting-states.d.ts.map

package/dist/rules/no-conflicting-states.js

@@ -2,16 +2,16 @@ import { headLoc } from "../utils/analyze.js";
 import { createRule } from "../utils/create-rule.js";
 import { isTagState } from "../utils/options.js";
 import { editDistance, typoThreshold } from "../utils/distance.js";
-import { tagRange } from "../utils/fix.js";
 export default createRule({
-    name: 'no-conflicting-states',
     meta: {
         type: 'problem',
-        fixable: 'code',
         docs: {
             description: 'Disallow state tags that contradict each other, differ in case or look like typos',
             recommended: 'warn',
+            url: 'https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/rules/no-conflicting-states.md',
         },
+        fixable: 'code',
+        schema: [],
         messages: {
             newAndUnstable: '`{{new}}` and `{{unstable}}` are separate stages; a test should be in only one of them.',
             newSkipped: "`{{new}}` on a skipped test: a new test that doesn't run can't be promoted. Fix the test or drop the tag.",
@@ -19,19 +19,13 @@ export default createRule({
             tagTypo: '`{{found}}` looks like a typo of `{{expected}}`.',
         },
     },
-    check(context, analysis, options) {
-        const { sourceCode } = context;
+    create(context, analysis, options) {
         const tagStates = options.states.filter(isTagState);
         const newTag = options.states.find((s) => s.name === 'new')?.tag;
         const unstableTag = options.states.find((s) => s.name === 'unstable')?.tag;
         for (const subject of analysis.subjects) {
-            const ownIndex = new Map();
-            for (const occurrence of subject.tags) {
-                const key = `${occurrence.tag}\0${occurrence.node.range[0]}`;
-                const index = ownIndex.get(key) ?? 0;
-                ownIndex.set(key, index + 1);
-                checkSpelling(occurrence, index);
-            }
+            for (const occurrence of subject.tags)
+                checkSpelling(occurrence);
             if (newTag === undefined)
                 continue;
             const own = (tag) => subject.tags.find((t) => t.tag === tag);
@@ -55,19 +49,20 @@ export default createRule({
                 });
             }
         }
-        function checkSpelling(occurrence, index) {
-            const { tag } = occurrence;
+        function checkSpelling(occurrence) {
+            const { tag, range } = occurrence;
+            // A Vitest tag name is written without its `@`, so show it, and fix it, the same way.
+            const written = (name) => (occurrence.plain ? name.slice(1) : name);
             if (tagStates.some((s) => s.tag === tag))
                 return;
             const lower = tag.toLowerCase();
             const sameLetters = tagStates.find((s) => s.tag.toLowerCase() === lower);
             if (sameLetters) {
-                const range = tagRange(sourceCode, occurrence.node, tag, index);
                 context.report({
                     node: occurrence.node,
                     messageId: 'tagCase',
-                    data: { found: tag, expected: sameLetters.tag },
-                    fix: range && ((fixer) => fixer.replaceTextRange(range, sameLetters.tag)),
+                    data: { found: written(tag), expected: written(sameLetters.tag) },
+                    fix: range && ((fixer) => fixer.replaceTextRange(range, written(sameLetters.tag))),
                 });
                 return;
             }
@@ -79,9 +74,12 @@ export default createRule({
                     editDistance(lower, expected) <= typoThreshold(expected.length - 1));
             });
             if (near) {
-                context.report({ node: occurrence.node, messageId: 'tagTypo', data: { found: tag, expected: near.tag } });
+                context.report({
+                    node: occurrence.node,
+                    messageId: 'tagTypo',
+                    data: { found: written(tag), expected: written(near.tag) },
+                });
             }
         }
     },
 });
-//# sourceMappingURL=no-conflicting-states.js.map

package/dist/rules/no-orphaned-marker.d.ts

@@ -1,3 +1,2 @@
 declare const _default: import("../utils/create-rule.ts").Rule<"orphaned" | "detached" | "removeMarker">;
 export default _default;
-//# sourceMappingURL=no-orphaned-marker.d.ts.map

package/dist/rules/no-orphaned-marker.js

@@ -2,28 +2,29 @@ import { describeSubject, isProse, missingStates, strayMarkers } from "../utils/
 import { createRule } from "../utils/create-rule.js";
 import { removeComment } from "../utils/fix.js";
 export default createRule({
-    name: 'no-orphaned-marker',
     meta: {
         type: 'problem',
-        hasSuggestions: true,
         docs: {
             description: 'Disallow marker comments that no longer match a test state',
             recommended: 'error',
+            url: 'https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/rules/no-orphaned-marker.md',
         },
+        hasSuggestions: true,
+        schema: [],
         messages: {
             orphaned: "`{{marker}}:` is left over: {{subject}} is not in the '{{state}}' state.",
             detached: '`{{marker}}:` is not directly above a test, describe or skip call, so it has no effect.',
             removeMarker: 'Remove this comment.',
         },
     },
-    check(context, analysis, options) {
-        // Files without Playwright tests, such as application code, have no markers to check.
+    create(context, analysis, options) {
+        // Files without tests, such as application code, have no markers to check.
         if (!analysis.isTestFile)
             return;
         const { sourceCode } = context;
         const markers = [];
         for (const marker of analysis.detachedMarkers) {
-            // `// FIXME: WEB-12` above a helper is a tracked work comment, checked by require-ticket-in-comments.
+            // `// FIXME: TRADE-12` above a helper is a tracked work comment, checked by require-ticket-in-comments.
             if (options.workCommentKeywords.has(marker.keyword))
                 continue;
             markers.push({ marker, messageId: 'detached', subject: '' });
@@ -33,8 +34,13 @@ export default createRule({
             if (missingStates(subject).length > 0)
                 continue;
             const name = describeSubject(subject).replace(/^This/, 'this');
-            for (const marker of strayMarkers(subject, options))
+            for (const marker of strayMarkers(subject, options)) {
+                // TODO is the everyday work-comment keyword, so `// TODO: TRADE-12` above a test that isn't a todo
+                // is a tracked note about it far more often than a todo test's forgotten marker.
+                if (marker.state.name === 'todo' && options.workCommentKeywords.has(marker.keyword.toUpperCase()))
+                    continue;
                 markers.push({ marker, messageId: 'orphaned', subject: name });
+            }
         }
         for (const { marker, messageId, subject } of markers) {
             // `// SKIP: this is flaky` is prose, not a leftover ticket.
@@ -49,4 +55,3 @@ export default createRule({
         }
     },
 });
-//# sourceMappingURL=no-orphaned-marker.js.map

package/dist/rules/require-ticket-in-comments.d.ts

@@ -1,3 +1,2 @@
 declare const _default: import("../utils/create-rule.ts").Rule<"missingTicket" | "invalidTicket" | "placeholderTicket" | "extraText" | "removeExtraText">;
 export default _default;
-//# sourceMappingURL=require-ticket-in-comments.d.ts.map

package/dist/rules/require-ticket-in-comments.js

@@ -1,4 +1,4 @@
-import { appliesTo, isStateMarker, parseTickets } from "../utils/analyze.js";
+import { appliesTo, commentLines, isStateMarker, parseTickets } from "../utils/analyze.js";
 import { createRule } from "../utils/create-rule.js";
 import { compileTicketSpec } from "../utils/tickets.js";
 /** Recognises anything shaped like a ticket, to tell a wrong-format ticket from plain prose. */
@@ -7,14 +7,15 @@ function escapeRegExp(text) {
     return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 export default createRule({
-    name: 'require-ticket-in-comments',
     meta: {
         type: 'suggestion',
-        hasSuggestions: true,
         docs: {
             description: 'Require FIXME and TODO comments in test files to start with a ticket',
             recommended: 'error',
+            url: 'https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/rules/require-ticket-in-comments.md',
         },
+        hasSuggestions: true,
+        schema: [],
         messages: {
             missingTicket: '`{{keyword}}` comments must start with a ticket, e.g. `// {{upper}}: {{example}}`. Put the details in the ticket.',
             invalidTicket: "'{{ticket}}' is not a valid ticket. Expected {{expected}}.",
@@ -23,7 +24,7 @@ export default createRule({
             removeExtraText: 'Remove `{{text}}`.',
         },
     },
-    check(context, analysis, options) {
+    create(context, analysis, options) {
         const keywords = options.commentKeywords;
         if (keywords.length === 0 || !analysis.isTestFile)
             return;
@@ -39,12 +40,12 @@ export default createRule({
         }
         // `TODO`/`FIXME` in capitals counts with or without a colon. Other casings need the colon, so a
         // sentence that happens to start with "Todo" is not mistaken for a work comment. The keyword can
-        // carry its ticket in parentheses, `TODO(WEB-123): ...`, a common style that tools also use for
+        // carry its ticket in parentheses, `TODO(TRADE-123): ...`, a common style that tools also use for
         // a name, `TODO(alice)`, which is not a ticket. Some teams put a space before the parenthesis.
         const alternatives = keywords.map(escapeRegExp).join('|');
         const keywordRe = new RegExp(`^(\\s*\\*?\\s*)(${alternatives})(?:\\s*\\(([^)]*)\\))?(?:\\s*:|(?=\\s|$))`, 'i');
         /**
-         * `TODO(WEB-1, WEB-2): text`: the tickets are in the parentheses, and anything after them, from the
+         * `TODO(TRADE-1, TRADE-2): text`: the tickets are in the parentheses, and anything after them, from the
          * closing parenthesis on, is a note.
          */
         function parseParenthesized(line, start, open, inParens) {
@@ -61,12 +62,7 @@ export default createRule({
         for (const comment of sourceCode.getAllComments()) {
             if (owned.has(comment))
                 continue;
-            // `//` and `/*` are both two characters, so the comment's value starts two characters in.
-            let lineStart = comment.range[0] + 2;
-            for (const rawLine of comment.value.split('\n')) {
-                const line = rawLine.replace(/\r$/, '');
-                const start = lineStart;
-                lineStart += rawLine.length + 1;
+            for (const { text: line, start } of commentLines(comment)) {
                 const match = keywordRe.exec(line);
                 if (!match)
                     continue;
@@ -114,4 +110,3 @@ export default createRule({
         }
     },
 });
-//# sourceMappingURL=require-ticket-in-comments.js.map

package/dist/rules/require-ticket.d.ts

@@ -1,3 +1,2 @@
-declare const _default: import("../utils/create-rule.ts").Rule<"missingTicket" | "invalidTicket" | "placeholderTicket" | "extraText" | "removeExtraText" | "missingMarker" | "markerCase" | "dynamicTitle">;
+declare const _default: import("../utils/create-rule.ts").Rule<"missingTicket" | "invalidTicket" | "placeholderTicket" | "extraText" | "removeExtraText" | "missingMarker" | "markerCase" | "dynamicTitle" | "dynamicTags">;
 export default _default;
-//# sourceMappingURL=require-ticket.d.ts.map

package/dist/rules/require-ticket.js

@@ -1,14 +1,15 @@
 import { appliesTo, describeSubject, evaluate, headLoc } from "../utils/analyze.js";
 import { createRule } from "../utils/create-rule.js";
 export default createRule({
-    name: 'require-ticket',
     meta: {
         type: 'problem',
-        hasSuggestions: true,
         docs: {
             description: 'Require a ticket marker comment above skipped, fixme and tagged tests',
             recommended: 'error',
+            url: 'https://github.com/Huldoser/eslint-plugin-test-governance/blob/main/docs/rules/require-ticket.md',
         },
+        hasSuggestions: true,
+        schema: [],
         messages: {
             missingMarker: "{{subject}} is in the '{{state}}' state but has no `// {{marker}}: <ticket>` comment directly above it, e.g. `// {{marker}}: {{example}}`.",
             missingTicket: '`{{marker}}:` needs a ticket right after the colon, e.g. `// {{marker}}: {{example}}`.',
@@ -18,16 +19,20 @@ export default createRule({
             extraText: 'Only ticket IDs are allowed after `{{marker}}:`, separated by commas. Put details in the ticket instead of `{{text}}`.',
             removeExtraText: 'Remove `{{text}}`.',
             dynamicTitle: "This title isn't static text, so its tags can't be checked. Use a string or template literal.",
+            dynamicTags: "These tags can't be read in this file, so they can't be checked. Use strings, or constants declared in this file.",
         },
     },
-    check(context, analysis, options) {
+    create(context, analysis, options) {
         const hasTagStates = options.states.some((s) => s.tag !== undefined);
         // A broken marker on a describe can be reached from several tests; report it once.
         const reported = new Set();
         const reportOnce = (key) => !reported.has(key) && Boolean(reported.add(key));
         for (const subject of analysis.subjects) {
-            if (subject.dynamicTitle && options.reportDynamicTitles && hasTagStates) {
-                context.report({ node: subject.node.arguments[0], messageId: 'dynamicTitle' });
+            if (options.reportUnreadableTags && hasTagStates) {
+                if (subject.dynamicTitle)
+                    context.report({ node: subject.node.arguments[0], messageId: 'dynamicTitle' });
+                for (const node of subject.unreadTags)
+                    context.report({ node, messageId: 'dynamicTags' });
             }
             for (const { state, required } of subject.states) {
                 if (!required)
@@ -38,7 +43,6 @@ export default createRule({
                     !reportOnce(`${result.marker.comment.range[0]}:${state.name}`)) {
                     continue;
                 }
-                const data = { state: state.name, marker: state.marker, example: state.ticket.example };
                 switch (result.kind) {
                     case 'ok':
                         break;
@@ -46,7 +50,12 @@ export default createRule({
                         context.report({
                             loc: headLoc(subject),
                             messageId: 'missingMarker',
-                            data: { ...data, subject: describeSubject(subject) },
+                            data: {
+                                subject: describeSubject(subject),
+                                state: state.name,
+                                marker: state.marker,
+                                example: state.ticket.example,
+                            },
                         });
                         break;
                     case 'case':
@@ -57,13 +66,17 @@ export default createRule({
                         });
                         break;
                     case 'no-ticket':
-                        context.report({ loc: result.marker.comment.loc, messageId: 'missingTicket', data });
+                        context.report({
+                            loc: result.marker.comment.loc,
+                            messageId: 'missingTicket',
+                            data: { marker: state.marker, example: state.ticket.example },
+                        });
                         break;
                     case 'bad-ticket':
                         context.report({
                             loc: result.marker.comment.loc,
                             messageId: result.ticket.result === 'placeholder' ? 'placeholderTicket' : 'invalidTicket',
-                            data: { ...data, ticket: result.ticket.text, expected: state.ticket.expected },
+                            data: { ticket: result.ticket.text, state: state.name, expected: state.ticket.expected },
                         });
                         break;
                 }
@@ -97,4 +110,3 @@ export default createRule({
         }
     },
 });
-//# sourceMappingURL=require-ticket.js.map

package/dist/utils/analyze.d.ts

@@ -4,7 +4,7 @@ import type { TicketCheck, TicketMatcher } from './tickets.ts';
 type Node = TSESTree.Node;
 type Comment = TSESTree.Comment;
 type SourceCode = Readonly<TSESLint.SourceCode>;
-export interface MarkerTicket {
+interface MarkerTicket {
     text: string;
     result: TicketCheck;
 }
@@ -30,15 +30,23 @@ export type StateMarker = Marker & {
 export declare function isStateMarker(marker: Marker): marker is StateMarker;
 export interface TagOccurrence {
     tag: string;
-    node: TSESTree.Literal | TSESTree.TemplateLiteral;
+    /** Where to report the tag: the text it is written in, or the name it comes from, as `Tags.NEW`. */
+    node: Node;
+    /**
+     * Where the tag is written in the source. Unset when it comes from a constant, or when an escape such
+     * as `\u002D` comes before the tag or inside it, since the source then no longer lines up with the title.
+     */
+    range?: TSESTree.Range;
+    /** Set for a Vitest tag name such as `'flaky'` in `tags`, which is written without its `@`. */
+    plain?: true;
 }
-export interface StateSource {
+interface StateSource {
     state: StateDef;
     /** False for conditional skips unless `requireTicketForConditional` is set. */
     required: boolean;
 }
 export interface Subject {
-    kind: 'test' | 'describe' | 'runtime';
+    kind: 'test' | 'describe' | 'step' | 'runtime';
     node: TSESTree.CallExpression;
     /** The node the marker comment block sits above. */
     anchor: Node;
@@ -53,6 +61,13 @@ export interface Subject {
     tags: TagOccurrence[];
     /** Tags this node inherits from enclosing describes. */
     inheritedTags: Set<string>;
+    /** Tag values, or a whole details object, on this node that can't be read, as `{ tag: TAGS.NEW }` with `TAGS` imported. */
+    unreadTags: Node[];
+    /**
+     * States this node may be in without the code showing it: tag states when tags can't be read, and
+     * Vitest's option states when its options object can't. Includes those of enclosing describes.
+     */
+    unknownStates: Set<string>;
     /** True when this node is skipped or fixme'd by any means, whether or not those states are on. */
     skipped: boolean;
     ownSkip: boolean;
@@ -63,7 +78,7 @@ export interface Analysis {
     subjects: Subject[];
     /** Markers that are not in the comment block of any test, describe or runtime call. */
     detachedMarkers: StateMarker[];
-    /** Whether the file uses Playwright at all: a Playwright import or a call to a test function. */
+    /** Whether the file uses the test framework at all: an import from it or a call to a test function. */
     isTestFile: boolean;
 }
 export type Evaluation = {
@@ -86,6 +101,11 @@ export type Evaluation = {
  * of `text[0]`. Anything after the last ticket, including a trailing comma, is returned as `extra`.
  */
 export declare function parseTickets(text: string, offset: number, matcher: TicketMatcher): Pick<Marker, 'tickets' | 'extra'>;
+/** The lines of a comment and where each starts in the source, split at every line break JavaScript has. */
+export declare function commentLines(comment: Comment): {
+    text: string;
+    start: number;
+}[];
 export declare function analyze(sourceCode: SourceCode, options: ResolvedOptions): Analysis;
 /** Whether `subject` is in `stateName` at all, required or not, including inherited and runtime states. */
 export declare function appliesTo(subject: Subject, stateName: string): boolean;
@@ -99,19 +119,16 @@ export declare function missingStates(subject: Subject): StateDef[];
  */
 export declare function isProse(marker: Marker): boolean;
 /**
- * Whether a marker is really an ordinary work comment such as `// FIXME: refactor this`: its keyword
- * is also a work-comment keyword and it doesn't start with a valid ticket. `require-ticket-in-comments`
- * reports those; the marker rules leave them alone.
+ * Markers in the subject's own block for states that don't apply to it, leaving out work comments and
+ * states its code may hide, such as a tag from a constant imported from another file. A marker in the
+ * wrong case, as `// skip: TRADE-1`, counts when it starts with a valid ticket.
  */
-export declare function isWorkComment(marker: Marker, options: ResolvedOptions): boolean;
-/** Markers in the subject's own block for states that don't apply to it, leaving out work comments. */
 export declare function strayMarkers(subject: Subject, options: ResolvedOptions): StateMarker[];
 /**
  * Where to report a problem with a test or describe: from the callee to the end of the title
- * (`test.skip('pays with PayPal'`), so editors underline the declaration rather than the whole body.
+ * (`test.skip('places a limit order'`), so editors underline the declaration rather than the whole body.
  * Runtime calls such as `test.skip()` are short, so they are reported whole.
  */
 export declare function headLoc(subject: Subject): TSESTree.SourceLocation;
 export declare function describeSubject(subject: Subject): string;
 export {};
-//# sourceMappingURL=analyze.d.ts.map