test-inventory 0.6.0 → 0.7.0

package/dist/frameworks/playwright.js

@@ -1,7 +1,7 @@
 import { childNodes, isFunctionNode, propertyKey, propertyName, unwrap } from "../ast.js";
 import { snippet } from "../source.js";
 import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, ModuleFunctions, requiredModule, } from "./bindings.js";
-import { atLeast, findFunction, hookFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, destructuredNames, takesWhole, readCondition, readCount, readOptions, readReason, readStrings, readTitle, refused, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
+import { atLeast, boundMembers, findFunction, hookFunction, isTestName, isTitleLiteral, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, namedFunction, origin, problem, readChain, destructuredNames, takesWhole, readCondition, readCount, readOptions, readReason, readStrings, readTitle, refused, returnedFunction, returnedTestObject, text, unresolvedOption, unresolvedOptions, } from "./common.js";
 const MISMATCHED_SOURCES = new Set(['vitest', '@jest/globals']);
 // Maps rather than object literals, so names such as `constructor` don't match inherited properties.
 const DESCRIBES = new Map([
@@ -297,7 +297,9 @@ export class PlaywrightAdapter {
             const declaration = this.file.values.declarationOf(base.name, scopes);
             const bound = declaration !== null && this.bindings.declarations.has(declaration);
             const local = declaration !== null && this.imports.get(base.name)?.node === declaration;
-            const alias = declaration?.type === 'VariableDeclarator' && !bound && !local ? this.alias(declaration, lookup) : null;
+            const alias = declaration?.type === 'VariableDeclarator' && !bound && !local
+                ? this.alias(declaration, base.name, lookup)
+                : null;
             // The module from `require()` is both the namespace and `test`, so `pw.test(...)` reads as the namespace.
             if (bound && this.bindings.namespaces.has(base.name) && links[0]?.name === 'test' && !links[0].args) {
                 return links.slice(1);
@@ -366,9 +368,14 @@ export class PlaywrightAdapter {
     }
     /**
      * The members of `test` a variable holds: those of a describe function, as in `const serialDescribe =
-     * test.describe.serial`, or none for a test object a function returns.
+     * test.describe.serial`, none for a test object a function returns, and the member `name` takes when it is
+     * destructured, as in `const { beforeEach } = test`. Playwright binds every member to its test object, so a
+     * destructured one works as it does on the object; a test object built with a destructured `extend` is not followed.
      */
-    alias(declarator, lookup) {
+    alias(declarator, name, lookup) {
+        const destructured = boundMembers(declarator.id, name);
+        if (!destructured)
+            return null;
         let members = this.aliases.get(declarator);
         if (members === undefined) {
             // Set first, so a variable defined through itself ends the lookup.
@@ -376,7 +383,7 @@ export class PlaywrightAdapter {
             members = declarator.init ? this.members(declarator.init, lookup) : null;
             this.aliases.set(declarator, members);
         }
-        return members;
+        return members && [...members, ...destructured];
     }
     /** The members of `test` a value holds: none for a test object, or those of a describe function. */
     members(expression, lookup) {
@@ -480,6 +487,7 @@ export class PlaywrightAdapter {
             hashed,
             isParameterized: false,
             caseCount: null,
+            cases: null,
             testContext: null,
             fixtures: destructuredNames(hashed, 0),
             takesAllFixtures: takesWhole(hashed, 0),
@@ -545,6 +553,7 @@ export class PlaywrightAdapter {
             hashed: fn,
             isParameterized: false,
             caseCount: null,
+            cases: null,
             problems,
         };
     }

package/dist/frameworks/vitest.d.ts

@@ -37,7 +37,11 @@ export declare class VitestAdapter implements Adapter {
      */
     private resolve;
     private start;
-    /** The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`. */
+    /**
+     * The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`, with the member `name`
+     * takes when it is destructured, as in `const { beforeEach } = test`. The members Vitest reads through `this`, such as
+     * `each` and `skipIf`, return a test function only when called, so their calls are never read through a variable.
+     */
     private alias;
     private aliasOf;
     /**
@@ -75,10 +79,16 @@ export declare class VitestAdapter implements Adapter {
     /** Vitest's order: `only` wins over `skip`, which wins over `todo`. */
     private states;
     private readDeclarationOptions;
-    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`; the runner ignores an object before. */
+    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`. */
     private retry;
     private meta;
     private caseCount;
+    /**
+     * The cases of a table whose values the scan can work out, as Vitest passes them: `.each` spreads a case that is an
+     * array into the callback's arguments when every case is one, and `.for` passes each case whole. A tagged template
+     * gives one object per row, keyed by the names in its first line.
+     */
+    private tableCases;
     private arrayLength;
     private tagsUsed;
 }

package/dist/frameworks/vitest.js

@@ -1,7 +1,7 @@
 import { childNodes, isFunctionNode, isImportMetaVitest, propertyKey, propertyName, unwrap, } from "../ast.js";
 import { snippet } from "../source.js";
 import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, ModuleFunctions, requiredModule, } from "./bindings.js";
-import { atLeast, hookFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, destructuredNames, takesWhole, readCount, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, refused, text, } from "./common.js";
+import { atLeast, hookFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, boundMembers, destructuredNames, takesWhole, readCount, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, refused, text, } from "./common.js";
 /** What a test function chosen at run time, as in `isCI ? it.skip : it`, is either way: only the links both have. */
 function shared(a, b) {
     if (!a || a.kind !== b?.kind)
@@ -27,6 +27,7 @@ const MODIFIERS = {
 };
 const TABLES = new Set(['each', 'for']);
 const CONDITIONS = new Set(['skipIf', 'runIf']);
+const STATE_FLAGS = ['only', 'todo', 'fails'];
 const DERIVATIONS = new Set(['extend', 'override', 'scoped']);
 /** Hooks, with the position of the test context among their callback's parameters. */
 const HOOKS = new Map([
@@ -401,7 +402,7 @@ export class VitestAdapter {
             this.worthFollowing(base.name, links, args) &&
             this.follow(base.name, !inBody && mayDeclareTests(base.name, links));
         if (!followed && !this.bindings.declarations.has(declaration)) {
-            const alias = declaration.type === 'VariableDeclarator' ? this.alias(declaration, lookup) : null;
+            const alias = declaration.type === 'VariableDeclarator' ? this.alias(declaration, base.name, lookup) : null;
             if (alias)
                 return { kind: alias.kind, index: 0, modifiers: alias.links };
             return this.assumeLocal(declaration, base.name, links, args)
@@ -415,8 +416,15 @@ export class VitestAdapter {
         const kind = this.bindings.kinds.get(base.name);
         return kind ? { kind, index: 0 } : null;
     }
-    /** The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`. */
-    alias(declarator, lookup) {
+    /**
+     * The function and modifiers a variable holds, as in `const skipOnCi = test.skipIf(isCI)`, with the member `name`
+     * takes when it is destructured, as in `const { beforeEach } = test`. The members Vitest reads through `this`, such as
+     * `each` and `skipIf`, return a test function only when called, so their calls are never read through a variable.
+     */
+    alias(declarator, name, lookup) {
+        const destructured = boundMembers(declarator.id, name);
+        if (!destructured)
+            return null;
         let alias = this.aliases.get(declarator);
         if (alias === undefined) {
             // Set first, so a variable defined through itself ends the lookup.
@@ -424,7 +432,8 @@ export class VitestAdapter {
             alias = declarator.init ? this.aliasOf(declarator.init, lookup) : null;
             this.aliases.set(declarator, alias);
         }
-        return alias;
+        const links = destructured.map((member) => ({ name: member, args: null, template: null }));
+        return alias && { kind: alias.kind, links: [...alias.links, ...links] };
     }
     aliasOf(expression, lookup) {
         const node = unwrap(expression);
@@ -634,6 +643,17 @@ export class VitestAdapter {
         const chain = new Set(links.filter((link) => MODIFIERS[kind].has(link.name)).map((link) => link.name));
         const flags = new Set(chain);
         let conditions = links.filter((link) => CONDITIONS.has(link.name)).map((link) => this.linkCondition(link, context));
+        // From Vitest 5.0.5 a test's `skip`, `skipIf` and `runIf` each set its `skip`, so the last of them decides, and a
+        // `skipIf` or `runIf` replaces the skip of a tag or of a describe around. The scan applies that to all of Vitest 5.
+        const lastSkip = links.filter((link) => link.name === 'skip' || CONDITIONS.has(link.name)).at(-1);
+        const skipsByChain = kind === 'test' && lastSkip !== undefined && atLeast(this.file.version, 5, 0);
+        const conditionSetsSkip = skipsByChain && CONDITIONS.has(lastSkip.name);
+        if (skipsByChain) {
+            flags.delete('skip');
+            conditions = conditionSetsSkip ? [this.linkCondition(lastSkip, context)] : [];
+            if (!conditionSetsSkip)
+                flags.add('skip');
+        }
         // A test's own options win over its chain, so `test.skip('title', { skip: false }, fn)` runs. The chain wins for a
         // test's mode, and for everything on a describe.
         for (const [flag, value] of read.flags) {
@@ -653,7 +673,7 @@ export class VitestAdapter {
         // win. A `skip` passed down skips them, and turns todo into skip, as skip goes before todo.
         const line = this.file.source.line(call.start);
         const around = context.passedDown;
-        const passed = read.skip ? null : around;
+        const passed = read.skip || conditionSetsSkip ? null : around;
         const skips = passed?.condition.applies === 'always' && !flags.has('only');
         const table = links.find((link) => TABLES.has(link.name)) ?? null;
         const isTodo = flags.has('todo') || body === undefined;
@@ -683,6 +703,7 @@ export class VitestAdapter {
             hashed: fn ?? namedFunction(this.file, context.scopes, body),
             isParameterized: table !== null,
             caseCount: table ? this.caseCount(call, table, context, problems) : null,
+            cases: table ? this.tableCases(table, context) : null,
             problems,
         };
         let declared;
@@ -704,6 +725,10 @@ export class VitestAdapter {
                 fixtures: fixturesOf(base.hashed, index, this.file.version),
                 takesAllFixtures: takesWhole(base.hashed, index),
                 usesBench: atLeast(this.file.version, 5, 0) && destructuredNames(base.hashed, index).includes('bench'),
+                ownStateOptions: [
+                    ...(read.skip || conditionSetsSkip ? ['skip'] : []),
+                    ...STATE_FLAGS.filter((flag) => read.flags.has(flag)),
+                ],
             };
         }
         return refusal ? refused(call, refusal, context, () => declared) : declared;
@@ -763,8 +788,14 @@ export class VitestAdapter {
             return result;
         const options = readOptions(this.file, context.scopes, node);
         problems.push(...unresolvedOptions(this.file, options, 'its flags, tags and meta are missing'));
+        // From Vitest 5.0.5 an option set to `undefined` replaces nothing; the scan applies that to all of Vitest 5.
+        const given = (key) => {
+            const option = options.values.get(key);
+            const isUndefined = option?.resolved.ok === true && option.resolved.value === undefined;
+            return isUndefined && atLeast(this.file.version, 5, 0) ? undefined : option;
+        };
         for (const flag of ['only', 'todo', 'fails', 'concurrent', 'sequential', 'shuffle']) {
-            const option = options.values.get(flag);
+            const option = given(flag);
             if (option && !option.resolved.ok) {
                 const { importedFrom } = option.resolved;
                 problems.push(unresolvedOption(this.file, flag, option.node, importedFrom, 'it is not applied'));
@@ -776,7 +807,7 @@ export class VitestAdapter {
                 result.flags.set(flag, Boolean(option.resolved.value));
             }
         }
-        const skip = options.values.get('skip');
+        const skip = given('skip');
         if (skip) {
             result.skip = skip.resolved.ok
                 ? { applies: skip.resolved.value ? 'always' : 'never', text: null }
@@ -806,7 +837,7 @@ export class VitestAdapter {
             this.retry(retry, details, context, problems);
         return result;
     }
-    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`; the runner ignores an object before. */
+    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`. */
     retry(option, details, context, problems) {
         const node = unwrap(option.node);
         if (node.type !== 'ObjectExpression') {
@@ -815,8 +846,14 @@ export class VitestAdapter {
                 details.run.retry = { count, delay: null, condition: null };
             return;
         }
-        if (!atLeast(this.file.version, 4, 1))
+        if (!atLeast(this.file.version, 4, 1)) {
+            // Before 4.1 the runner compares the attempt number with the object, so it never runs the test.
+            const source = snippet(text(this.file, node));
+            const message = `Option retry: ${source} is an object, which Vitest reads from 4.1; before, it never runs the test.`;
+            problems.push(problem('unresolved-option', node, message, source));
+            details.run.retry = null;
             return;
+        }
         const values = readOptions(this.file, context.scopes, node);
         problems.push(...unresolvedOptions(this.file, values, 'the retry is not applied'));
         const read = (key) => {
@@ -859,6 +896,43 @@ export class VitestAdapter {
         }
         return count;
     }
+    /**
+     * The cases of a table whose values the scan can work out, as Vitest passes them: `.each` spreads a case that is an
+     * array into the callback's arguments when every case is one, and `.for` passes each case whole. A tagged template
+     * gives one object per row, keyed by the names in its first line.
+     */
+    tableCases(table, context) {
+        let cases;
+        if (table.template) {
+            const values = table.template.expressions.map((item) => this.file.values.resolve(item, context.scopes));
+            if (!values.every((item) => item.ok))
+                return null;
+            const header = templateHeader(table.template);
+            // Without values, Vitest passes the template's strings as the table.
+            cases =
+                values.length === 0
+                    ? table.template.quasis.map((quasi) => quasi.value.cooked ?? undefined)
+                    : Array.from({ length: Math.floor(values.length / header.length) }, (_, row) => Object.fromEntries(header.map((name, column) => [name, values[row * header.length + column].value])));
+        }
+        else {
+            const first = table.args.at(0);
+            const resolved = first && first.type !== 'SpreadElement' ? this.file.values.resolve(first, context.scopes) : null;
+            if (!resolved?.ok || !Array.isArray(resolved.value))
+                return null;
+            cases = resolved.value;
+        }
+        if (table.name === 'for') {
+            return cases.map((item) => ({
+                items: item === null || item === undefined ? [] : Array.isArray(item) ? item : [item],
+                args: [item],
+            }));
+        }
+        const arraysOnly = cases.every((item) => Array.isArray(item));
+        return cases.map((item) => {
+            const items = Array.isArray(item) ? item : [item];
+            return { items, args: arraysOnly ? items : [item] };
+        });
+    }
     arrayLength(node, context) {
         if (node === undefined || node.type === 'SpreadElement')
             return null;
@@ -880,13 +954,24 @@ export class VitestAdapter {
         this.problems.push(problem('config-may-change-state', node, "The file uses Vitest tags, and tags defined in the Vitest config can skip tests or change how they run; the scan can't work out the config's tags."));
     }
 }
-/** Rows in a tagged-template table such as ``each`a | b ${1} | ${2}` ``: values divided by header columns. */
+/**
+ * The column names of a tagged-template table such as ``each`side | qty ${'buy'} | ${100}` ``, as Vitest's
+ * `formatTemplateString` reads them: the text of the template with its spaces taken out, its first line split at `|`.
+ * Outer pipes, as in `| side | qty |`, give empty names too.
+ */
+function templateHeader(template) {
+    // A string with an invalid escape, as in `\xZZ`, has no cooked value, which joins as nothing.
+    const strings = template.quasis.map((quasi) => quasi.value.cooked ?? '');
+    return strings.join('').trim().replace(/ /g, '').split('\n')[0].split('|');
+}
+/**
+ * Rows of a tagged-template table: as many as the values fill, an incomplete last row left out, as Vitest does. A
+ * template without values isn't split, so its text is the one case.
+ */
 function templateRows(template) {
-    const header = (template.quasis[0].value.cooked ?? template.quasis[0].value.raw).trim().split('\n')[0];
-    const columns = header.split('|').filter((column) => column.trim() !== '').length;
-    if (columns === 0 || template.expressions.length % columns !== 0)
-        return null;
-    return template.expressions.length / columns;
+    if (template.expressions.length === 0)
+        return 1;
+    return Math.floor(template.expressions.length / templateHeader(template).length);
 }
 function isMetaValue(value) {
     return value !== undefined;

package/dist/imported-values.d.ts

@@ -0,0 +1,22 @@
+import type { ModuleReader } from './model.ts';
+import { type ImportReader } from './values.ts';
+/**
+ * Works out the values project modules export, for the files of one scan: each module is parsed once and each of its
+ * exports worked out once, however many test files import it. Installed packages are never read, since the reader
+ * only gives project files.
+ */
+export declare class ExportedValues {
+    private readonly modules;
+    private readonly done;
+    /** Results of the current lookup, also those that `done` can't keep, so that each module is read once in it. */
+    private readonly current;
+    private readonly pending;
+    /** How many times a lookup was cut short by a cycle or the depth limit. */
+    private cutShort;
+    /** What a file that reads its imports with `readModule` gets for `import { name } from source`. */
+    reader(readModule: ModuleReader | null): ImportReader | null;
+    /** What `module` exports under `name`; null when it doesn't export it. */
+    private exported;
+    private read;
+    private open;
+}

package/dist/imported-values.js

@@ -0,0 +1,135 @@
+import { ownExport, parseModule, starReexport } from "./frameworks/bindings.js";
+import { Values } from "./values.js";
+const UNRESOLVED = { ok: false, importedFrom: null };
+/** How many modules deep a name is followed through re-exports and imports, as for test objects. */
+const MAX_DEPTH = 16;
+/**
+ * Works out the values project modules export, for the files of one scan: each module is parsed once and each of its
+ * exports worked out once, however many test files import it. Installed packages are never read, since the reader
+ * only gives project files.
+ */
+export class ExportedValues {
+    modules = new WeakMap();
+    done = new Map();
+    /** Results of the current lookup, also those that `done` can't keep, so that each module is read once in it. */
+    current = new Map();
+    pending = new Set();
+    /** How many times a lookup was cut short by a cycle or the depth limit. */
+    cutShort = 0;
+    /** What a file that reads its imports with `readModule` gets for `import { name } from source`. */
+    reader(readModule) {
+        if (!readModule)
+            return null;
+        return (source, name) => {
+            const module = readModule(source);
+            if ('reason' in module)
+                return UNRESOLVED;
+            return this.exported(module, name) ?? UNRESOLVED;
+        };
+    }
+    /** What `module` exports under `name`; null when it doesn't export it. */
+    exported(module, name) {
+        const key = `${module.relativeFilePath}\0${name}`;
+        if (this.done.has(key))
+            return this.done.get(key);
+        if (this.current.has(key)) {
+            // It was worked out on a path that was cut short, so what is built on it depends on that path too.
+            this.cutShort++;
+            return this.current.get(key);
+        }
+        // A path that comes back to a name being worked out, as `export *` modules that re-export each other do, gives
+        // nothing; another path may still give it.
+        if (this.pending.has(key) || this.pending.size >= MAX_DEPTH) {
+            this.cutShort++;
+            return this.pending.has(key) ? null : UNRESOLVED;
+        }
+        const before = this.cutShort;
+        this.pending.add(key);
+        const result = this.read(module, name);
+        this.pending.delete(key);
+        // A result found while a path was cut short depends on where the lookup began, so only this lookup keeps it.
+        if (this.cutShort === before)
+            this.done.set(key, result);
+        else
+            this.current.set(key, result);
+        if (this.pending.size === 0)
+            this.current.clear();
+        return result;
+    }
+    read(module, name) {
+        const opened = this.open(module);
+        if (!opened)
+            return UNRESOLVED;
+        if (opened.json)
+            return jsonExport(opened.json.value, name);
+        const program = opened.program;
+        for (const statement of program.body) {
+            const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : null;
+            if (declaration?.type === 'TSEnumDeclaration' && declaration.id.name === name) {
+                return opened.values.resolveName(name, [program]);
+            }
+        }
+        const own = ownExport(program, name);
+        if (own?.kind === 'default')
+            return opened.values.resolve(own.value, [program]);
+        if (own?.kind === 'function')
+            return UNRESOLVED;
+        if (own?.kind === 'specifier' && own.source !== null) {
+            const from = module.readModule(own.source);
+            return 'reason' in from ? UNRESOLVED : (this.exported(from, own.local) ?? UNRESOLVED);
+        }
+        if (own) {
+            return opened.values.resolveName(own.kind === 'specifier' ? own.local : name, [program]);
+        }
+        // `export *` passes on every name but the default. When two modules export the name with different values, Node
+        // refuses to load the module and Vite's module runner keeps the first, so the value isn't known.
+        if (name === 'default')
+            return null;
+        let found = null;
+        for (const statement of program.body) {
+            const source = starReexport(statement);
+            const from = source === null ? null : module.readModule(source);
+            const result = from && !('reason' in from) ? this.exported(from, name) : null;
+            if (!result)
+                continue;
+            if (found && !(found.ok && result.ok && JSON.stringify(found.value) === JSON.stringify(result.value))) {
+                return UNRESOLVED;
+            }
+            found = result;
+        }
+        return found;
+    }
+    open(module) {
+        if (this.modules.has(module))
+            return this.modules.get(module);
+        let opened = null;
+        if (module.relativeFilePath.endsWith('.json')) {
+            const value = parseJson(module.code);
+            opened = value === undefined ? null : { program: null, json: { value }, values: new Values() };
+        }
+        else if (!module.bytes) {
+            const parsed = parseModule(module);
+            const values = new Values(this.reader(module.readModule));
+            opened = parsed.error ? null : { program: parsed.program, json: null, values };
+        }
+        this.modules.set(module, opened);
+        return opened;
+    }
+}
+function parseJson(code) {
+    try {
+        return JSON.parse(code);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** A JSON module's default export is its value; Vite and Playwright also export its top-level keys by name. */
+function jsonExport(value, name) {
+    if (name === 'default')
+        return { ok: true, value };
+    if (typeof value === 'object' && value !== null && !Array.isArray(value) && Object.hasOwn(value, name)) {
+        return { ok: true, value: value[name] };
+    }
+    return null;
+}

package/dist/model.d.ts

@@ -1,7 +1,10 @@
 import type { CallExpression, Expression, Node } from 'oxc-parser';
 import type { FunctionNode } from './ast.ts';
 import type { Annotation, DiagnosticCode, DiagnosticLevel, HookCounts, MetaValue } from './types.ts';
+import type { Value } from './values.ts';
 export type State = 'skip' | 'fixme' | 'todo' | 'expectedToFail';
+/** The Vitest options that set a test's state. */
+export type StateOption = 'skip' | 'only' | 'todo' | 'fails';
 export type Mode = 'parallel' | 'serial' | 'default';
 /** A state set by a declaration, a describe or a call such as `test.skip(condition)`. */
 export interface StateSetting {
@@ -51,12 +54,15 @@ export interface Details {
 /** Run settings written in one place; a key that is missing is not set there. */
 export interface RunSettings {
     timeout?: number;
-    /** A retry setting replaces the whole `retry` of the describes around, delay and condition included. */
+    /**
+     * A retry setting replaces the whole `retry` of the describes around, delay and condition included; null when it is
+     * set to a value the runner can't use.
+     */
     retry?: {
         count: number;
         delay: number | null;
         condition: string | null;
-    };
+    } | null;
     repeats?: number;
     /** Playwright `test.slow()`: the conditions of the calls, any of which makes the test slow; null when one always does. */
     slow?: {
@@ -77,8 +83,15 @@ interface Declaration {
     isParameterized: boolean;
     /** Number of cases of `.each` or `.for` when the table is written out; null otherwise. */
     caseCount: number | null;
+    /** The cases of `.each` or `.for` when the scan can work out every value in them; null otherwise. */
+    cases: TableCase[] | null;
     problems: Problem[];
 }
+/** One case of a `.each` or `.for` table: the items its title is formatted with, and the arguments its callback gets. */
+export interface TableCase {
+    items: Value[];
+    args: Value[];
+}
 export interface TestDeclaration extends Declaration {
     kind: 'test';
     title: Title;
@@ -90,6 +103,8 @@ export interface TestDeclaration extends Declaration {
     takesAllFixtures: boolean;
     /** Uses Vitest 5's `bench` fixture. */
     usesBench: boolean;
+    /** Vitest: the state options the test sets itself, to `false` too, which replace those of its tags. */
+    ownStateOptions?: StateOption[];
 }
 export interface SuiteDeclaration extends Declaration {
     kind: 'describe';
@@ -186,6 +201,8 @@ export interface Returns {
 /** A module read to see whether it exports a custom `test` object. */
 export interface ModuleSource {
     code: string;
+    /** The file's bytes when it isn't UTF-8 text, such as an image. */
+    bytes?: Uint8Array;
     relativeFilePath: string;
     /** Reads the modules this module imports in turn. */
     readModule: ModuleReader;

package/dist/options.d.ts

@@ -17,6 +17,11 @@ export interface ScanOptions {
     frameworkVersion?: string;
     /** Which tests get the comments above them. Defaults to `non-active`. */
     comments?: CommentsMode;
+    /**
+     * One test or describe per case of a `.each` or `.for` table and per pass of a loop whose values the scan can work
+     * out, each with the title the runner gives it. Defaults to `false`: one record per declaration.
+     */
+    expandCases?: boolean;
 }
 /** @inline */
 export interface ScanSourceOptions {
@@ -28,6 +33,11 @@ export interface ScanSourceOptions {
     frameworkVersion?: string | null;
     /** Which tests get the comments above them. Defaults to `non-active`. */
     comments?: CommentsMode;
+    /**
+     * One test or describe per case of a `.each` or `.for` table and per pass of a loop whose values the scan can work
+     * out, each with the title the runner gives it. Defaults to `false`: one record per declaration.
+     */
+    expandCases?: boolean;
 }
 /** An invalid option, told apart from other errors so that the command line can show it as a usage error. */
 export declare class OptionsError extends TypeError {
@@ -36,6 +46,7 @@ export declare function invalid(option: string, expected: string): OptionsError;
 export declare function checkObject(value: unknown, name: string): Record<string, unknown>;
 export declare function checkFramework(value: unknown, option: string): Framework;
 export declare function checkComments(value: unknown, option: string): CommentsMode;
+export declare function checkFlag(value: unknown, option: string): boolean;
 export declare function checkVersion(value: unknown, option: string): string | null;
 export declare function checkString(value: unknown, option: string): string;
 export declare function checkStrings(value: unknown, option: string, required: boolean): string[];

package/dist/options.js

@@ -25,6 +25,13 @@ export function checkComments(value, option) {
         throw invalid(option, '"all", "non-active" or "none"');
     return value;
 }
+export function checkFlag(value, option) {
+    if (value === undefined)
+        return false;
+    if (typeof value !== 'boolean')
+        throw invalid(option, 'true or false');
+    return value;
+}
 export function checkVersion(value, option) {
     if (value === undefined || value === null)
         return null;

package/dist/parse.d.ts

@@ -15,6 +15,12 @@ export interface ParsedFile {
         end: number;
     } | null;
 }
+/**
+ * The offset of the first bracket nested more than `limit` deep, or null. Parentheses, brackets, braces and template
+ * substitutions count; strings, comments, regular expressions and template text are skipped. A closing bracket closes
+ * up to the one it matches, so a literal read wrongly unbalances only the brackets around it.
+ */
+export declare function tooDeeplyNested(text: string, limit: number): number | null;
 /** The first parser error, located at its first label, or at the start of the file when it has none. */
 export declare function firstError(errors: readonly OxcError[]): ParsedFile['error'];
 export declare function parseFile(fileName: string, code: string): ParsedFile;