test-inventory 0.6.1 → 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;
     /**
@@ -79,6 +83,12 @@ export declare class VitestAdapter implements Adapter {
     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)
@@ -402,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)
@@ -416,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.
@@ -425,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);
@@ -695,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;
@@ -887,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;
@@ -908,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,6 +1,7 @@
 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';
@@ -82,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;

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/records.js

@@ -305,6 +305,7 @@ class RecordBuilder {
             isSerial: scope.mode === 'serial',
             isShuffled: declaration.isShuffled,
             isParameterized: declaration.isParameterized,
+            caseIndex: pending.caseIndex,
             tags: unique(scope.details.tags),
             annotations: scope.details.annotations,
             locks: unique(scope.details.locks),
@@ -389,8 +390,9 @@ class RecordBuilder {
         }
         if (declaration.isOnly)
             this.forbidOnly(located, pending.site ? null : pending.call);
-        if (pending.isInLoop) {
-            this.diagnostics.push(this.diagnostic(problem('test-in-loop', located, 'The test is declared in a loop; it is listed once, while the runner creates one test per iteration.'), id));
+        // A loop the scan counts is described by caseCount, as a table is.
+        if (pending.loops.includes(null)) {
+            this.diagnostics.push(this.diagnostic(problem('test-in-loop', located, "The test is declared in a loop the scan can't count; it is listed once, while the runner creates one test per pass."), id));
         }
         if ((declaration.isOnly || fromTags?.only === true) &&
             chosen &&
@@ -455,7 +457,10 @@ class RecordBuilder {
             steps: pending.steps,
             isBenchmark: this.options.isBenchmarkFile || declaration.usesBench,
             isParameterized: tables.length > 0,
-            caseCount: tables.length > 0 ? repetitions(tables.map((item) => item.caseCount)) : null,
+            caseCount: tables.length > 0 || pending.isInLoop
+                ? repetitions([...tables.map((item) => item.caseCount), ...pending.loops])
+                : null,
+            caseIndex: pending.caseIndex,
             isInLoop: pending.isInLoop,
             isInCondition: pending.isInCondition,
             isInFunction: pending.isInFunction,
@@ -482,7 +487,9 @@ class RecordBuilder {
             const describes = outward(test.scope).filter((scope) => scope.kind === 'describe');
             const titles = describes.flatMap((scope) => suiteOf(scope).declaration.title?.text ?? []).reverse();
             // In a loop, a title path that never changes is registered again on each pass.
-            const repeated = playwright && test.isInLoop && describes.every((scope) => !suiteOf(scope).declaration.title?.isDynamic);
+            const repeated = playwright &&
+                test.passes.some((passes) => passes === null || passes > 1) &&
+                describes.every((scope) => !suiteOf(scope).declaration.title?.isDynamic);
             if (repeated) {
                 const message = 'The test is declared in a loop with the same title on each pass, so Playwright fails to load the file and runs no tests at all.';
                 const item = problem('duplicate-title', test.site ?? test.call, message, test.declaration.title.text);

package/dist/scan-file.d.ts

@@ -1,5 +1,6 @@
 import type { RunsWith } from './config-dependencies.ts';
 import { DependencyGraph, type SnapshotFiles } from './dependency-hash.ts';
+import { ExportedValues } from './imported-values.ts';
 import type { ModuleReader } from './model.ts';
 import { type CommentsMode, type FileConfig, type FileRecords } from './records.ts';
 import type { Framework } from './types.ts';
@@ -8,6 +9,8 @@ export interface FileSettings {
     /** `[major, minor]` of the framework version; null applies the newest rules. */
     version: [number, number] | null;
     comments: CommentsMode;
+    /** One test or describe per case of a table and per pass of a loop whose values the scan can work out. */
+    expandCases?: boolean;
     readModule: ModuleReader | null;
     /** The project root, left out of error messages so that the output has no absolute paths. */
     root: string | null;
@@ -17,6 +20,8 @@ export interface FileSettings {
     config?: FileConfig | null;
     /** Shared by the files of one scan, so that code many tests reach is read once. */
     graph?: DependencyGraph;
+    /** Shared by the files of one scan, so that each module's exported values are worked out once. */
+    exports?: ExportedValues;
     /** What the file's config runs with each of its tests: the config, setup files and setup projects. */
     runsWith?: RunsWith;
     /** Reads the snapshot files tests compare against; none when one file's code is scanned. */

package/dist/scan-file.js

@@ -2,6 +2,7 @@ import { DependencyGraph, fileDependencies } from "./dependency-hash.js";
 import { fileDiagnostic, toDiagnostic } from "./diagnostics.js";
 import { extract, noHooks } from "./extract.js";
 import { parseModule } from "./frameworks/bindings.js";
+import { ExportedValues } from "./imported-values.js";
 import { atLeast, problem } from "./frameworks/common.js";
 import { PlaywrightAdapter } from "./frameworks/playwright.js";
 import { VitestAdapter } from "./frameworks/vitest.js";
@@ -12,8 +13,9 @@ import { Values } from "./values.js";
 const TYPE_TEST = /\.(test|spec)-d\.[cm]?[jt]sx?$/;
 const BENCHMARK = /\.(bench|benchmark)\.[cm]?[jt]sx?$/;
 /** A file read for the scan: the scanned file, or a module a helper function is imported from. */
-function frame(parsed, relativeFilePath, settings, readModule) {
-    const file = { source: parsed.source, values: new Values(), version: settings.version };
+function frame(parsed, relativeFilePath, settings, readModule, exports) {
+    const values = new Values(exports.reader(readModule));
+    const file = { source: parsed.source, values, version: settings.version };
     const adapter = settings.framework === 'playwright'
         ? new PlaywrightAdapter(parsed.program, file, readModule)
         : new VitestAdapter(parsed, file, readModule);
@@ -35,11 +37,12 @@ export function scanFile(code, relativeFilePath, settings) {
             if (parsed.program.body.length === 0)
                 return { ...noRecords(relativeFilePath), diagnostics, usesGlobals: false };
         }
-        const main = frame(parsed, relativeFilePath, settings, settings.readModule);
+        const exports = settings.exports ?? new ExportedValues();
+        const main = frame(parsed, relativeFilePath, settings, settings.readModule, exports);
         const extraction = extract(main, (module) => {
             const helper = parseModule(module);
-            return helper.error ? null : frame(helper, module.relativeFilePath, settings, module.readModule);
-        });
+            return helper.error ? null : frame(helper, module.relativeFilePath, settings, module.readModule, exports);
+        }, { expandCases: settings.expandCases ?? false, version: settings.version });
         const isTypeTest = settings.framework === 'vitest' && TYPE_TEST.test(relativeFilePath);
         const unfollowed = [];
         const dependencies = fileDependencies(settings.graph ?? new DependencyGraph(), main, extraction, isTypeTest, (place) => unfollowed.push(place), settings.runsWith, settings.snapshotFiles);

package/dist/scan-source.js

@@ -1,5 +1,5 @@
 import { createInventory } from "./inventory.js";
-import { checkComments, checkFramework, checkObject, checkString, checkVersion, invalid, majorMinor, toPosixPath, } from "./options.js";
+import { checkComments, checkFlag, checkFramework, checkObject, checkString, checkVersion, invalid, majorMinor, toPosixPath, } from "./options.js";
 import { scanFile } from "./scan-file.js";
 /**
  * Scans the code of one test file, without reading anything from disk.
@@ -15,10 +15,12 @@ export function scanSource(options) {
     const framework = checkFramework(checked.framework, 'options.framework');
     const frameworkVersion = checkVersion(checked.frameworkVersion, 'options.frameworkVersion');
     const comments = checkComments(checked.comments, 'options.comments');
+    const expandCases = checkFlag(checked.expandCases, 'options.expandCases');
     const result = scanFile(checked.code, relativeFilePath, {
         framework,
         version: majorMinor(frameworkVersion),
         comments,
+        expandCases,
         readModule: null,
         root: null,
     });

package/dist/scan.js

@@ -6,11 +6,12 @@ import { ConfigDependencies } from "./config-dependencies.js";
 import { ConfigRuns, fileConfig } from "./config-runs.js";
 import { Configs } from "./config.js";
 import { DependencyGraph } from "./dependency-hash.js";
+import { ExportedValues } from "./imported-values.js";
 import { fileDiagnostic } from "./diagnostics.js";
 import { findFiles, normalizePattern, readFailure } from "./files.js";
 import { detectFrameworkVersion, OLDEST } from "./framework-version.js";
 import { createInventory } from "./inventory.js";
-import { checkComments, checkFramework, checkObject, checkStrings, checkVersion, invalid, majorMinor, toPosixPath, } from "./options.js";
+import { checkComments, checkFlag, checkFramework, checkObject, checkStrings, checkVersion, invalid, majorMinor, toPosixPath, } from "./options.js";
 import { moduleResolver } from "./resolve.js";
 import { noRecords, scanFile } from "./scan-file.js";
 import { globalsCheck } from "./vitest-config.js";
@@ -114,6 +115,7 @@ export async function scan(options) {
     const framework = checkFramework(checked.framework, 'options.framework');
     const ignore = checkStrings(checked.ignore, 'options.ignore', false);
     const comments = checkComments(checked.comments, 'options.comments');
+    const expandCases = checkFlag(checked.expandCases, 'options.expandCases');
     const override = checkVersion(checked.frameworkVersion, 'options.frameworkVersion');
     if (checked.root !== undefined && (typeof checked.root !== 'string' || checked.root === '')) {
         throw invalid('options.root', 'a non-empty string');
@@ -121,7 +123,10 @@ export async function scan(options) {
     const root = path.resolve(checked.root ?? process.cwd());
     if (!existsSync(root) || !statSync(root).isDirectory())
         throw invalid('options.root', `a directory, and ${root} is not one`);
-    const detected = override === null ? detectFrameworkVersion(root, framework) : null;
+    // Without patterns, the configs choose among all JavaScript and TypeScript files.
+    const found = await findFiles(root, patterns ?? [SCRIPT_FILES], ignore, framework);
+    const scanned = found.files.map((file) => file.relativeFilePath);
+    const detected = override === null ? detectFrameworkVersion(root, framework, scanned) : null;
     const frameworkVersion = override ?? detected?.version ?? null;
     const range = detected?.range ?? null;
     // With only a range, the newest rules of its major apply, as the newest release in it is the likeliest installed.
@@ -130,11 +135,10 @@ export async function scan(options) {
         : majorMinor(frameworkVersion);
     const source = override === null ? (detected?.source ?? 'package.json') : '.';
     const projectDiagnostics = versionDiagnostics(framework, frameworkVersion, source, range);
-    // Without patterns, the configs choose among all JavaScript and TypeScript files.
-    const found = await findFiles(root, patterns ?? [SCRIPT_FILES], ignore, framework);
     projectDiagnostics.push(...found.diagnostics);
     const readerFor = moduleResolver(root);
     const graph = new DependencyGraph();
+    const exports = new ExportedValues();
     const configs = new Configs(root, framework, readerFor, rules);
     const runs = new ConfigRuns(configs, framework, rules, patterns === null);
     const placements = new Map(found.files.map((file) => [file.absolutePath, runs.placementOf(file.absolutePath)]));
@@ -193,11 +197,13 @@ export async function scan(options) {
             framework,
             version: rules,
             comments,
+            expandCases,
             readModule: readerFor(absolutePath),
             root,
             isBenchmarkFile: placement.runs === null ? null : placement.runs === 'benchmark',
             config: fileConfig(placement, framework, rules, absolutePath),
             graph,
+            exports,
             runsWith,
             snapshotFiles: { ...snapshotFiles, moved: runsWith.moved },
         });