eslint-plugin-test-governance 0.3.0 → 0.4.0

package/dist/utils/constants.d.ts

@@ -2,9 +2,11 @@
 export declare const MARKER_RE: RegExp;
 /** A tag as written in options: `@` followed by letters, digits, `-` and `_`. */
 export declare const TAG_RE: RegExp;
-export declare const BUILTIN_STATE_NAMES: readonly ["skip", "fixme", "fail", "slow", "new", "unstable"];
+export declare const BUILTIN_STATE_NAMES: readonly ["skip", "fixme", "fail", "slow", "todo", "new", "unstable"];
 export type BuiltinStateName = (typeof BUILTIN_STATE_NAMES)[number];
+/** The test frameworks the rules understand. */
+export declare const FRAMEWORK_NAMES: readonly ["playwright", "jest", "vitest"];
+export type FrameworkName = (typeof FRAMEWORK_NAMES)[number];
 export declare const TICKET_PRESETS: readonly ["any", "jira", "github", "gitlab", "linear", "azure-devops", "numeric", "pattern"];
-/** Comment keywords that must reference a ticket by default (`// TODO: WEB-123`). */
+/** Comment keywords that must reference a ticket by default (`// TODO: TRADE-123`). */
 export declare const DEFAULT_COMMENT_KEYWORDS: string[];
-//# sourceMappingURL=constants.d.ts.map

package/dist/utils/constants.js

@@ -2,7 +2,9 @@
 export const MARKER_RE = /^[A-Z][A-Z0-9_-]*$/;
 /** A tag as written in options: `@` followed by letters, digits, `-` and `_`. */
 export const TAG_RE = /^@[\w-]+$/;
-export const BUILTIN_STATE_NAMES = ['skip', 'fixme', 'fail', 'slow', 'new', 'unstable'];
+export const BUILTIN_STATE_NAMES = ['skip', 'fixme', 'fail', 'slow', 'todo', 'new', 'unstable'];
+/** The test frameworks the rules understand. */
+export const FRAMEWORK_NAMES = ['playwright', 'jest', 'vitest'];
 export const TICKET_PRESETS = [
     'any',
     'jira',
@@ -13,6 +15,5 @@ export const TICKET_PRESETS = [
     'numeric',
     'pattern',
 ];
-/** Comment keywords that must reference a ticket by default (`// TODO: WEB-123`). */
+/** Comment keywords that must reference a ticket by default (`// TODO: TRADE-123`). */
 export const DEFAULT_COMMENT_KEYWORDS = ['FIXME', 'TODO'];
-//# sourceMappingURL=constants.js.map

package/dist/utils/create-rule.d.ts

@@ -1,10 +1,9 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-import { type Analysis } from './analyze.js';
-import { type ResolvedOptions } from './options.js';
-export declare const REPO_URL = "https://github.com/Huldoser/eslint-plugin-test-governance";
+import { type Analysis } from './analyze.ts';
+import { type ResolvedOptions } from './options.ts';
 /** Rules take no options of their own: everything is shared through `settings['test-governance']`. */
-export type RuleOptions = [];
-export interface RuleDocs {
+type RuleOptions = [];
+interface RuleDocs {
     description: string;
     recommended: 'error' | 'warn';
     url: string;
@@ -15,15 +14,15 @@ export type Rule<MessageIds extends string> = TSESLint.RuleModule<MessageIds, Ru
     };
 };
 export interface RuleDefinition<MessageIds extends string> {
-    name: string;
     meta: Omit<TSESLint.RuleMetaData<MessageIds, RuleDocs>, 'docs' | 'schema' | 'defaultOptions'> & {
-        docs: Omit<RuleDocs, 'url'>;
+        docs: RuleDocs;
+        schema: [];
     };
-    check(context: Readonly<TSESLint.RuleContext<MessageIds, RuleOptions>>, analysis: Analysis, options: ResolvedOptions): void;
+    create(context: Readonly<TSESLint.RuleContext<MessageIds, RuleOptions>>, analysis: Analysis, options: ResolvedOptions): void;
 }
 /**
  * Builds a rule that reads its options from `settings['test-governance']`.
- * `check` runs once per file with the shared analysis.
+ * `create` runs once per file, at the end, with the shared analysis.
  */
 export declare function createRule<MessageIds extends string>(definition: RuleDefinition<MessageIds>): Rule<MessageIds>;
-//# sourceMappingURL=create-rule.d.ts.map
+export {};

package/dist/utils/create-rule.js

@@ -1,26 +1,20 @@
-import { analyze } from './analyze.js';
-import { resolveOptions } from './options.js';
-export const REPO_URL = 'https://github.com/Huldoser/eslint-plugin-test-governance';
+import { analyze } from "./analyze.js";
+import { resolveOptions } from "./options.js";
 /**
  * Builds a rule that reads its options from `settings['test-governance']`.
- * `check` runs once per file with the shared analysis.
+ * `create` runs once per file, at the end, with the shared analysis.
  */
 export function createRule(definition) {
     return {
-        meta: {
-            ...definition.meta,
-            docs: { ...definition.meta.docs, url: `${REPO_URL}/blob/main/docs/rules/${definition.name}.md` },
-            schema: [],
-        },
+        meta: definition.meta,
         defaultOptions: [],
         create(context) {
             const options = resolveOptions(context.settings);
             return {
                 'Program:exit'() {
-                    definition.check(context, analyze(context.sourceCode, options), options);
+                    definition.create(context, analyze(context.sourceCode, options), options);
                 },
             };
         },
     };
 }
-//# sourceMappingURL=create-rule.js.map

package/dist/utils/distance.d.ts

@@ -2,4 +2,3 @@
 export declare function editDistance(a: string, b: string): number;
 /** How many edits still count as a typo for a tag of this length (without the `@`). */
 export declare function typoThreshold(length: number): number;
-//# sourceMappingURL=distance.d.ts.map

package/dist/utils/distance.js

@@ -20,4 +20,3 @@ export function typoThreshold(length) {
         return 2;
     return length >= 5 ? 1 : 0;
 }
-//# sourceMappingURL=distance.js.map

package/dist/utils/errors.d.ts

@@ -2,4 +2,3 @@
 export declare class ConfigError extends Error {
     constructor(message: string);
 }
-//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.js

@@ -5,4 +5,3 @@ export class ConfigError extends Error {
         this.name = 'ConfigError';
     }
 }
-//# sourceMappingURL=errors.js.map

package/dist/utils/fix.d.ts

@@ -6,7 +6,4 @@ export declare function keywordRange(sourceCode: SourceCode, comment: TSESTree.C
 export declare function removeComment(sourceCode: SourceCode, comment: TSESTree.Comment): TSESLint.RuleFix;
 /** Indentation of the line `comment` starts on. */
 export declare function indentOf(sourceCode: SourceCode, comment: TSESTree.Comment): string;
-/** Range of the `index`-th occurrence of `tag` in the source text of `node`. */
-export declare function tagRange(sourceCode: SourceCode, node: TSESTree.Node, tag: string, index: number): TSESTree.Range | undefined;
 export {};
-//# sourceMappingURL=fix.d.ts.map

package/dist/utils/fix.js

@@ -24,11 +24,3 @@ export function indentOf(sourceCode, comment) {
     const line = sourceCode.lines[comment.loc.start.line - 1];
     return line.slice(0, line.length - line.trimStart().length);
 }
-/** Range of the `index`-th occurrence of `tag` in the source text of `node`. */
-export function tagRange(sourceCode, node, tag, index) {
-    const text = sourceCode.getText(node);
-    const re = new RegExp(`(?<![\\w@])${escapeRegExp(tag)}(?![\\w-])`, 'g');
-    const match = [...text.matchAll(re)].at(index);
-    return match === undefined ? undefined : [node.range[0] + match.index, node.range[0] + match.index + tag.length];
-}
-//# sourceMappingURL=fix.js.map

package/dist/utils/frameworks.d.ts

@@ -0,0 +1,59 @@
+import type { BuiltinStateName, FrameworkName } from './constants.ts';
+/** A state a test enters through its own code, as opposed to a tag. */
+export type Modifier = 'skip' | 'fixme' | 'fail' | 'slow' | 'todo';
+/** What a name from a framework stands for: `xit` is a test with `skip`, `suite` a describe block. */
+export interface Root {
+    kind: 'test' | 'describe';
+    modifiers: readonly string[];
+}
+/** The state a member puts a test in. A conditional one, like Vitest's `skipIf(...)`, may not apply. */
+interface Effect {
+    modifier: Modifier;
+    conditional: boolean;
+}
+/** How a test framework declares tests and puts them in states. */
+export interface Framework {
+    name: FrameworkName;
+    /** Whether `source` is one of the framework's own modules. */
+    ownsModule(source: string): boolean;
+    /** Test functions the framework's modules export, by exported name. */
+    exports: ReadonlyMap<string, Root>;
+    /** What a default import from the framework's module is. */
+    defaultExport?: Root;
+    /** Test functions that exist without an import, besides `testFunctions`. */
+    globals: ReadonlyMap<string, Root>;
+    /** The default `testFunctions`. */
+    testFunctions: readonly string[];
+    /**
+     * Members a test or describe call may have, as in `test.skip(...)`. A member that is called to build
+     * the function, as in `test.each(table)('buys %s', fn)`, is written with parentheses: `each()`.
+     */
+    testMembers: ReadonlySet<string>;
+    describeMembers: ReadonlySet<string>;
+    /** Members that are called to build the function that declares the tests. */
+    factories: ReadonlySet<string>;
+    /** The state each member puts a test in. */
+    effects: ReadonlyMap<string, Effect>;
+    /** Keys of an options object that put a test in a state, as in Vitest's `{ skip: true }`. */
+    optionEffects: ReadonlyMap<string, Modifier>;
+    /** The key of the details or options object that holds tags. */
+    tagKey?: string;
+    /**
+     * The parameter of a test's body that can change its state at runtime, such as Playwright's
+     * `testInfo` or Vitest's test context, and the methods it has for that.
+     */
+    info?: {
+        param: number;
+        methods: ReadonlySet<string>;
+    };
+    /** Built-in states a test can be put in with this framework. */
+    states: ReadonlySet<BuiltinStateName>;
+    /** Playwright's own API on `test`: `test.describe`, `test.step`, `test.info()` and runtime `test.skip()`. */
+    playwright: boolean;
+}
+/** Methods on `testInfo` and on `test` itself that change a test's state at runtime. */
+export declare const RUNTIME_MODIFIERS: ReadonlySet<string>;
+export declare const FRAMEWORKS: Record<FrameworkName, Framework>;
+/** Whether `source` belongs to a test runner other than `framework`, so its names are never tests here. */
+export declare function isOtherRunner(framework: Framework, source: string): boolean;
+export {};

package/dist/utils/frameworks.js

@@ -0,0 +1,102 @@
+const TEST = { kind: 'test', modifiers: [] };
+const DESCRIBE = { kind: 'describe', modifiers: [] };
+const PLAYWRIGHT_MODULES = new Set(['@playwright/test', 'playwright/test']);
+/** Test runners besides Playwright. A name imported from one of them belongs to that runner. */
+const OTHER_RUNNERS = new Set(['vitest', '@jest/globals', 'node:test', 'bun:test', 'mocha', 'ava', 'tap', 'uvu']);
+/** `@playwright/test` and the component-testing packages such as `@playwright/experimental-ct-react`. */
+function isPlaywrightModule(source) {
+    return PLAYWRIGHT_MODULES.has(source) || source.startsWith('@playwright/experimental-ct-');
+}
+/** Methods on `testInfo` and on `test` itself that change a test's state at runtime. */
+export const RUNTIME_MODIFIERS = new Set(['skip', 'fixme', 'fail', 'slow']);
+const effects = (entries) => new Map(entries.map(([member, modifier, conditional = false]) => [member, { modifier, conditional }]));
+const playwright = {
+    name: 'playwright',
+    ownsModule: isPlaywrightModule,
+    exports: new Map([['test', TEST]]),
+    defaultExport: TEST,
+    globals: new Map(),
+    testFunctions: ['test'],
+    testMembers: new Set(['only', 'skip', 'fixme', 'fail', 'slow']),
+    describeMembers: new Set(['only', 'skip', 'fixme', 'serial', 'parallel']),
+    factories: new Set(),
+    effects: effects([
+        ['skip', 'skip'],
+        ['fixme', 'fixme'],
+        ['fail', 'fail'],
+        ['slow', 'slow'],
+    ]),
+    optionEffects: new Map(),
+    tagKey: 'tag',
+    info: { param: 1, methods: RUNTIME_MODIFIERS },
+    states: new Set(['skip', 'fixme', 'fail', 'slow', 'new', 'unstable']),
+    playwright: true,
+};
+const JEST_FUNCTIONS = new Map([
+    ['test', TEST],
+    ['it', TEST],
+    ['xtest', { kind: 'test', modifiers: ['skip'] }],
+    ['xit', { kind: 'test', modifiers: ['skip'] }],
+    ['fit', { kind: 'test', modifiers: ['only'] }],
+    ['describe', DESCRIBE],
+    ['xdescribe', { kind: 'describe', modifiers: ['skip'] }],
+    ['fdescribe', { kind: 'describe', modifiers: ['only'] }],
+]);
+const jest = {
+    name: 'jest',
+    ownsModule: (source) => source === '@jest/globals',
+    exports: JEST_FUNCTIONS,
+    globals: new Map([...JEST_FUNCTIONS].filter(([name]) => name !== 'test' && name !== 'it')),
+    testFunctions: ['test', 'it'],
+    testMembers: new Set(['only', 'skip', 'todo', 'failing', 'concurrent', 'each()']),
+    describeMembers: new Set(['only', 'skip', 'each()']),
+    factories: new Set(['each']),
+    effects: effects([
+        ['skip', 'skip'],
+        ['todo', 'todo'],
+        ['failing', 'fail'],
+    ]),
+    optionEffects: new Map(),
+    states: new Set(['skip', 'todo', 'fail', 'new', 'unstable']),
+    playwright: false,
+};
+const VITEST_FACTORIES = ['each()', 'for()', 'skipIf()', 'runIf()'];
+const vitest = {
+    name: 'vitest',
+    ownsModule: (source) => source === 'vitest',
+    exports: new Map([
+        ['test', TEST],
+        ['it', TEST],
+        ['describe', DESCRIBE],
+        ['suite', DESCRIBE],
+    ]),
+    globals: new Map([
+        ['describe', DESCRIBE],
+        ['suite', DESCRIBE],
+    ]),
+    testFunctions: ['test', 'it'],
+    testMembers: new Set(['only', 'skip', 'todo', 'fails', 'concurrent', 'sequential', ...VITEST_FACTORIES]),
+    describeMembers: new Set(['only', 'skip', 'todo', 'concurrent', 'sequential', 'shuffle', ...VITEST_FACTORIES]),
+    factories: new Set(['each', 'for', 'skipIf', 'runIf']),
+    effects: effects([
+        ['skip', 'skip'],
+        ['todo', 'todo'],
+        ['fails', 'fail'],
+        ['skipIf()', 'skip', true],
+        ['runIf()', 'skip', true],
+    ]),
+    optionEffects: new Map([
+        ['skip', 'skip'],
+        ['todo', 'todo'],
+        ['fails', 'fail'],
+    ]),
+    tagKey: 'tags',
+    info: { param: 0, methods: new Set(['skip']) },
+    states: new Set(['skip', 'todo', 'fail', 'new', 'unstable']),
+    playwright: false,
+};
+export const FRAMEWORKS = { playwright, jest, vitest };
+/** Whether `source` belongs to a test runner other than `framework`, so its names are never tests here. */
+export function isOtherRunner(framework, source) {
+    return (isPlaywrightModule(source) || OTHER_RUNNERS.has(source)) && !framework.ownsModule(source);
+}

package/dist/utils/options.d.ts

@@ -1,5 +1,6 @@
-import { type BuiltinStateName } from './constants.js';
-import { type TicketMatcher, type TicketSpec } from './tickets.js';
+import { type BuiltinStateName, type FrameworkName } from './constants.ts';
+import { type Framework, type Modifier } from './frameworks.ts';
+import { type TicketMatcher, type TicketSpec } from './tickets.ts';
 export declare const SETTINGS_KEY = "test-governance";
 /** A state override in `states`. `false` turns a state off, `true` turns it on. */
 export interface StateOverride {
@@ -14,36 +15,50 @@ export interface CustomState {
     marker: string;
     ticket?: TicketSpec | TicketSpec[];
 }
-export type { BuiltinStateName } from './constants.js';
 /** Options shared by every rule. Set them once in `settings['test-governance']`. */
 export interface GovernanceOptions {
-    /** Names that are treated as the Playwright `test` function. Defaults to `['test']`. */
+    /** The test framework of the files the config applies to. Defaults to `'playwright'`. */
+    framework?: FrameworkName;
+    /**
+     * Names that are treated as the framework's `test` function. Defaults to `['test']` for Playwright and
+     * `['test', 'it']` for Jest and Vitest. Your list replaces the default one, so include those names if
+     * you still need them.
+     */
     testFunctions?: string[];
     /** Accepted ticket formats. Defaults to `{ preset: 'any' }`. */
     ticket?: TicketSpec | TicketSpec[];
-    /** Tickets that are rejected as placeholders. `*` matches any characters. */
+    /**
+     * Tickets that are rejected as placeholders. `*` matches any characters. Your list replaces the default
+     * one (`TODO`, `TBD`, `XXX-*`, ...); tickets numbered 0 are always rejected.
+     */
     placeholders?: string[];
     /** Turns on the `@new` and `@unstable` states. */
     lifecycleTags?: boolean;
+    /**
+     * Turns built-in states on or off, renames their marker or gives them their own ticket format. `skip`,
+     * `fixme` and `todo` are on by default, `fail` and `slow` off; a setting for `new` or `unstable` wins over
+     * `lifecycleTags`. `fixme` and `slow` exist only in Playwright and `todo` only in Jest and Vitest.
+     */
     states?: Partial<Record<BuiltinStateName, boolean | StateOverride>>;
+    /** Adds a state for a tag, e.g. `{ quarantine: { when: '@quarantine', marker: 'QUARANTINE' } }`. */
     customStates?: Record<string, CustomState>;
     /** Require a ticket for conditional skips such as `test.skip(browserName === 'webkit')`. */
     requireTicketForConditional?: boolean;
     /** Let blank lines separate a marker from the test it belongs to. */
     allowBlankLine?: boolean;
     /**
-     * Comment keywords that must start with a ticket anywhere in a test file, e.g. `// TODO: WEB-123`.
-     * Defaults to `{ keywords: ['FIXME', 'TODO'] }`; `false` allows free-form comments.
+     * Comment keywords that must start with a ticket anywhere in a test file, e.g. `// TODO: TRADE-123`.
+     * Defaults to `{ keywords: ['FIXME', 'TODO'] }`, and your keywords replace those; `false` allows free-form
+     * comments.
      */
     comments?: false | {
         keywords?: string[];
     };
-    /** Allow free text after the tickets, e.g. `// SKIP: WEB-1 flaky on CI`. Off by default: details belong in the ticket. */
+    /** Allow free text after the tickets, e.g. `// SKIP: TRADE-1 flaky on CI`. Off by default: details belong in the ticket. */
     allowNotes?: boolean;
     /** Report titles that aren't static text when a tag state is on, because their tags can't be read. */
     reportDynamicTitles?: boolean;
 }
-export type Modifier = 'skip' | 'fixme' | 'fail' | 'slow';
 interface StateBase {
     name: string;
     marker: string;
@@ -62,6 +77,7 @@ export type TagStateDef = Extract<StateDef, {
 }>;
 export declare function isTagState(state: StateDef): state is TagStateDef;
 export interface ResolvedOptions {
+    framework: Framework;
     testFunctions: Set<string>;
     states: StateDef[];
     requireTicketForConditional: boolean;
@@ -78,11 +94,10 @@ export interface ResolvedOptions {
     /** Ticket format for comments: the shared default format. */
     commentTicket: TicketMatcher;
 }
-export { ConfigError } from './errors.js';
+export { ConfigError } from './errors.ts';
 /**
  * Compiles `settings['test-governance']`. Every rule reads the same settings, so they always agree,
  * and the result is cached per settings object, so the rules share one compile.
  */
 export declare function resolveOptions(settings: unknown): ResolvedOptions;
 export declare function compileOptions(options: GovernanceOptions): ResolvedOptions;
-//# sourceMappingURL=options.d.ts.map

package/dist/utils/options.js

@@ -1,8 +1,9 @@
-import { BUILTIN_STATE_NAMES, DEFAULT_COMMENT_KEYWORDS } from './constants.js';
-import { ConfigError } from './errors.js';
-import { optionsSchema } from './schema.js';
-import { compileTicketSpec, DEFAULT_PLACEHOLDERS } from './tickets.js';
-import { validate } from './validate.js';
+import { BUILTIN_STATE_NAMES, DEFAULT_COMMENT_KEYWORDS, } from "./constants.js";
+import { ConfigError } from "./errors.js";
+import { FRAMEWORKS } from "./frameworks.js";
+import { optionsSchema } from "./schema.js";
+import { compileTicketSpec, DEFAULT_PLACEHOLDERS } from "./tickets.js";
+import { validate } from "./validate.js";
 export const SETTINGS_KEY = 'test-governance';
 export function isTagState(state) {
     return state.tag !== undefined;
@@ -12,10 +13,11 @@ const BUILTIN_STATES = {
     fixme: { marker: 'FIXME', modifier: 'fixme', enabled: true },
     fail: { marker: 'FAIL', modifier: 'fail', enabled: false },
     slow: { marker: 'SLOW', modifier: 'slow', enabled: false },
+    todo: { marker: 'TODO', modifier: 'todo', enabled: true },
     new: { marker: 'NEW', tag: '@new', lifecycle: true, enabled: false },
     unstable: { marker: 'UNSTABLE', tag: '@unstable', lifecycle: true, enabled: false },
 };
-export { ConfigError } from './errors.js';
+export { ConfigError } from "./errors.js";
 function toSpecs(spec) {
     return Array.isArray(spec) ? spec : [spec];
 }
@@ -82,6 +84,7 @@ export function compileOptions(options) {
     if (problems.length > 0) {
         throw new ConfigError(`invalid options:\n${problems.map((problem) => `  - ${problem}`).join('\n')}`);
     }
+    const framework = FRAMEWORKS[options.framework ?? 'playwright'];
     const placeholders = options.placeholders ?? DEFAULT_PLACEHOLDERS;
     const defaultTicket = toSpecs(options.ticket ?? { preset: 'any' });
     const compile = (spec) => compileTicketSpec(spec === undefined ? defaultTicket : toSpecs(spec), placeholders);
@@ -92,7 +95,8 @@ export function compileOptions(options) {
         const raw = overrides[name];
         const override = typeof raw === 'boolean' ? { enabled: raw } : (raw ?? {});
         const enabled = override.enabled ?? (def.lifecycle ? (options.lifecycleTags ?? def.enabled) : def.enabled);
-        if (!enabled)
+        // A state the framework has no way to enter, such as `fixme` in Jest, stays off.
+        if (!enabled || !framework.states.has(name))
             continue;
         const base = {
             name,
@@ -123,7 +127,8 @@ export function compileOptions(options) {
     }
     const commentKeywords = options.comments === false ? [] : (options.comments?.keywords ?? DEFAULT_COMMENT_KEYWORDS);
     return {
-        testFunctions: new Set(options.testFunctions ?? ['test']),
+        framework,
+        testFunctions: new Set(options.testFunctions ?? framework.testFunctions),
         states,
         requireTicketForConditional: options.requireTicketForConditional ?? false,
         allowBlankLine: options.allowBlankLine ?? false,
@@ -134,4 +139,3 @@ export function compileOptions(options) {
         commentTicket: defaultMatcher,
     };
 }
-//# sourceMappingURL=options.js.map

package/dist/utils/schema.d.ts

@@ -1,4 +1,3 @@
-import type { Schema } from './validate.js';
+import type { Schema } from './validate.ts';
 /** The shape of `settings['test-governance']`, the options of `configure()`. */
 export declare const optionsSchema: Schema;
-//# sourceMappingURL=schema.d.ts.map

package/dist/utils/schema.js

@@ -1,4 +1,4 @@
-import { BUILTIN_STATE_NAMES, MARKER_RE, TAG_RE, TICKET_PRESETS } from './constants.js';
+import { BUILTIN_STATE_NAMES, FRAMEWORK_NAMES, MARKER_RE, TAG_RE, TICKET_PRESETS } from "./constants.js";
 const MARKER_HINT = 'an uppercase keyword such as NEEDS-DATA (letters, digits, "-" and "_")';
 const TAG_HINT = 'a tag such as @needs-data';
 /** Jira project and Linear team keys, as they appear in tickets: `WEB` in `WEB-123`. */
@@ -40,6 +40,7 @@ const stateOverrideSchema = {
 export const optionsSchema = {
     type: 'object',
     properties: {
+        framework: { type: 'string', enum: [...FRAMEWORK_NAMES] },
         testFunctions: { type: 'array', items: { type: 'string' } },
         ticket: ticketSchema,
         placeholders: { type: 'array', items: { type: 'string' } },
@@ -81,4 +82,3 @@ export const optionsSchema = {
     },
     additionalProperties: false,
 };
-//# sourceMappingURL=schema.js.map

package/dist/utils/tickets.d.ts

@@ -35,4 +35,3 @@ export interface TicketMatcher {
 }
 export declare const DEFAULT_PLACEHOLDERS: string[];
 export declare function compileTicketSpec(specs: TicketSpec[], placeholders: string[]): TicketMatcher;
-//# sourceMappingURL=tickets.d.ts.map

package/dist/utils/tickets.js

@@ -1,5 +1,5 @@
-import { ConfigError } from './errors.js';
-export const DEFAULT_PLACEHOLDERS = ['TODO', 'TBD', 'XXX-*', '0', '123', '1234', '12345'];
+import { ConfigError } from "./errors.js";
+export const DEFAULT_PLACEHOLDERS = ['TODO', 'TBD', 'XXX-*', '0'];
 // Every pattern below is anchored and has no nested or overlapping quantifiers, so matching is
 // linear in the token length. URLs are parsed with `new URL` rather than a regex.
 const KEY_RE = /^([A-Z][A-Z0-9_]+)-\d+$/;
@@ -8,7 +8,8 @@ const GITHUB_REF_RE = /^[A-Za-z0-9][A-Za-z0-9-]*\/[\w.-]+#\d+$/;
 const GITLAB_REF_RE = /^[\w.-]+(?:\/[\w.-]+)+#\d+$/;
 const AZURE_REF_RE = /^AB#\d+$/;
 const DIGITS_RE = /^\d+$/;
-const JIRA_PATH_RE = /^\/browse\/([A-Z][A-Z0-9_]+-\d+)\/?$/;
+// Jira Server and Data Center can run under a path, as in https://issues.example.com/jira/browse/TRADE-1.
+const JIRA_PATH_RE = /\/browse\/([A-Z][A-Z0-9_]+-\d+)\/?$/;
 const GITHUB_PATH_RE = /^\/[^/]+\/[^/]+\/(?:issues|pull)\/\d+\/?$/;
 const GITLAB_PATH_RE = /\/-\/(?:issues|merge_requests|work_items)\/\d+\/?$/;
 const LINEAR_PATH_RE = /^\/[^/]+\/issue\/([A-Z][A-Z0-9]*-\d+)(?:\/[^/]*)?$/;
@@ -171,4 +172,3 @@ export function compileTicketSpec(specs, placeholders) {
         example: presets[0].example,
     };
 }
-//# sourceMappingURL=tickets.js.map

package/dist/utils/validate.d.ts

@@ -18,4 +18,3 @@ export interface Schema {
  * readable problems such as `ticket.preset must be one of "any", "jira", … (got "jria")`.
  */
 export declare function validate(value: unknown, schema: Schema, path?: string): string[];
-//# sourceMappingURL=validate.d.ts.map

package/dist/utils/validate.js

@@ -1,4 +1,4 @@
-import { editDistance } from './distance.js';
+import { editDistance } from "./distance.js";
 function kindOf(value) {
     if (value === null)
         return 'null';
@@ -29,7 +29,8 @@ const toJson = JSON.stringify;
 function show(value) {
     if (typeof value === 'function')
         return 'a function';
-    const text = toJson(value) ?? String(value);
+    // JSON shows a regex as `{}`.
+    const text = value instanceof RegExp ? String(value) : (toJson(value) ?? String(value));
     return text.length > 40 ? `${text.slice(0, 37)}...` : text;
 }
 function join(path, key) {
@@ -119,4 +120,3 @@ export function validate(value, schema, path = '') {
     }
     return [];
 }
-//# sourceMappingURL=validate.js.map

package/docs/rules/marker-matches-state.md

@@ -22,15 +22,15 @@ Incorrect:
 <!-- example: invalid -->
 
 ```js
-// SKIP: WEB-500
-test.fixme('splits shipping', async () => {});
+// SKIP: TRADE-500
+test.fixme('shows the unfilled quantity of a partly filled order', async () => {});
 ```
 
 <!-- example: invalid settings={"lifecycleTags":true} -->
 
 ```js
-// SKIP: WEB-500
-test.skip('splits shipping @unstable', async () => {});
+// SKIP: TRADE-500
+test.skip('shows the unfilled quantity of a partly filled order @unstable', async () => {});
 ```
 
 Correct:
@@ -38,18 +38,26 @@ Correct:
 <!-- example: valid -->
 
 ```js
-// FIXME: WEB-500
-test.fixme('splits shipping', async () => {});
+// FIXME: TRADE-500
+test.fixme('shows the unfilled quantity of a partly filled order', async () => {});
 ```
 
 <!-- example: valid settings={"lifecycleTags":true} -->
 
 ```js
-// SKIP: WEB-500
-// UNSTABLE: WEB-500
-test.skip('splits shipping @unstable', async () => {});
+// SKIP: TRADE-500
+// UNSTABLE: TRADE-500
+test.skip('shows the unfilled quantity of a partly filled order @unstable', async () => {});
 ```
 
 ## Options
 
-Uses the shared options described in the [README](../../README.md#options).
+This rule has no options of its own. It reads the shared options described in the
+[README](../../README.md#options). These change what it reports:
+
+- `lifecycleTags`, `states` and `customStates`: which states are on, and the marker keyword each
+  one expects.
+- `requireTicketForConditional`: conditional skips such as `test.skip(browserName === 'webkit')`
+  need a marker only when this is set, so only then is a wrong marker above one reported.
+- `allowBlankLine`: whether a marker separated from its test by a blank line still belongs to it.
+- `framework` and `testFunctions`: which functions count as the framework's `test`.