test-inventory 0.6.1 → 0.8.0

package/dist/imported-values.js

@@ -0,0 +1,149 @@
+import { commonJsExport, commonJsNames, 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]);
+        }
+        const commonJs = commonJsExport(program, name);
+        if (commonJs)
+            return opened.values.resolve(commonJs, [program]);
+        // What `require()` gives for a module that exports its names one by one: an object of them.
+        const names = name === 'default' ? commonJsNames(program) : [];
+        if (names.length > 0) {
+            const entries = names.map((item) => [item, opened.values.resolve(commonJsExport(program, item), [program])]);
+            if (!entries.every(([, value]) => value.ok))
+                return UNRESOLVED;
+            return {
+                ok: true,
+                value: Object.fromEntries(entries.map(([key, value]) => [key, value.value])),
+            };
+        }
+        // `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,16 @@ 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 title the runner gives it, and the arguments its callback gets. */
+export interface TableCase {
+    /** Null when the scan can't format it the way the runner does, as for a title that shows an object. */
+    title: string | null;
+    args: Value[];
+}
 export interface TestDeclaration extends Declaration {
     kind: 'test';
     title: Title;
@@ -131,6 +140,8 @@ export type ApiCall = TestDeclaration | SuiteDeclaration | {
     settings: RunSettings;
     /** Source text of the first argument. */ argument: string | null;
     problems: Problem[];
+    /** Jest's `jest.retryTimes()`, which applies to every test of the file; a later call replaces it. */
+    fileWide?: boolean;
 } | {
     kind: 'hook';
     name: keyof HookCounts;

package/dist/options.d.ts

@@ -8,7 +8,11 @@ export interface ScanOptions {
      * a dot too. Without them, the test files are those the configs in the root and the folders below it run.
      */
     patterns?: string[];
-    framework: Framework;
+    /**
+     * The runner whose tests are listed. Without it, the one the project uses: whose package a package.json lists, or
+     * whose config is in the root or below. With none of them or several, the scan throws a `TypeError` that names them.
+     */
+    framework?: Framework;
     /** The project root. Paths in the output are relative to it. Defaults to the current directory. */
     root?: string;
     /** Glob patterns to leave out, in addition to `node_modules` and `.git`. */
@@ -17,6 +21,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 +37,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 +50,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

@@ -1,4 +1,4 @@
-const FRAMEWORKS = ['playwright', 'vitest'];
+const FRAMEWORKS = ['playwright', 'vitest', 'jest'];
 const COMMENTS = ['all', 'non-active', 'none'];
 // A prerelease and build metadata each appear once, so a long input can't make the match backtrack for long.
 const VERSION = /^v?(\d+)\.(\d+)(?:\.\d+)?(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -15,7 +15,7 @@ export function checkObject(value, name) {
 }
 export function checkFramework(value, option) {
     if (!FRAMEWORKS.includes(value))
-        throw invalid(option, '"playwright" or "vitest"');
+        throw invalid(option, '"playwright", "vitest" or "jest"');
     return value;
 }
 export function checkComments(value, option) {
@@ -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.js

@@ -222,10 +222,25 @@ export function parseFile(fileName, code) {
             error: { message, start: tooDeep, end: tooDeep + 1 },
         };
     }
-    const result = parseSync(fileName, text, parserOptions(fileName));
+    let result;
+    let program;
+    try {
+        result = parseSync(fileName, text, parserOptions(fileName));
+        // The tree is handed over when it is first read.
+        program = result.program;
+    }
+    catch (error) {
+        // The parser can fail to hand over the tree of invalid code, as for a JSX name written as a Unicode escape.
+        return {
+            source: new SourceText(text),
+            program: parseSync(fileName, '', parserOptions(fileName)).program,
+            comments: [],
+            error: { message: error.message, start: 0, end: 0 },
+        };
+    }
     return {
         source: new SourceText(text),
-        program: result.program,
+        program,
         comments: result.comments,
         error: firstError(result.errors),
     };

package/dist/records.js

@@ -1,4 +1,4 @@
-import { REJECTS_FILE, toDiagnostic } from "./diagnostics.js";
+import { LEVELS, REJECTS_FILE, toDiagnostic } from "./diagnostics.js";
 import { anySlow, eitherCondition, noHooks, } from "./extract.js";
 import { problem } from "./frameworks/common.js";
 import { hashNodes, shortHash } from "./hash.js";
@@ -187,6 +187,8 @@ class RecordBuilder {
     diagnostics = [];
     /** The line of the first problem for which the runner refuses the file; null when it loads. */
     rejectedAt = null;
+    /** Jest: the describes with a test of their own that uses `.only`, which then keep their mode from their others. */
+    focused = new Set();
     constructor(parsed, options) {
         this.parsed = parsed;
         this.options = options;
@@ -203,12 +205,17 @@ class RecordBuilder {
             ...extraction.problems.filter((item) => tags === null || isTagMissing || item.code !== 'config-may-change-state'),
             ...undefinedUses.map((use) => use.problem),
         ];
-        const rejecting = [...problems, ...testProblems, ...duplicates.map((item) => item.problem)].filter((item) => REJECTS_FILE[this.options.framework].has(item.code) && item.code !== 'undefined-tag' && item.afterLoad !== true);
+        const rejecting = [...problems, ...testProblems, ...duplicates.map((item) => item.problem)].filter((item) => REJECTS_FILE[this.options.framework].has(item.code) &&
+            item.code !== 'undefined-tag' &&
+            item.afterLoad !== true &&
+            // A warning of a code that rejects files, as for Jest's .each without a body, leaves the file loading.
+            (item.level ?? LEVELS[item.code]) === 'error');
         // Each of these problems points at the code that causes it. Vitest meets the tags in the order they are listed.
         const firstTag = undefinedUses.find((use) => use.isSure)?.problem;
         const lines = [...rejecting, ...(firstTag ? [firstTag] : [])].map((item) => this.parsed.source.line(item.node.start));
         if (lines.length > 0)
             this.rejectedAt = Math.min(...lines);
+        this.focused = new Set(extraction.tests.filter((test) => test.declaration.isOnly).map((test) => test.scope));
         const suites = extraction.suites.map((suite) => this.suite(suite));
         const tests = extraction.tests.map((test) => this.test(test, suites));
         for (const item of problems) {
@@ -305,6 +312,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),
@@ -335,6 +343,29 @@ class RecordBuilder {
             merged[option] = undefined;
         return merged;
     }
+    /**
+     * A Jest test's state, as jest-circus decides it: a describe takes its own `.only` or `.skip`, else the mode around
+     * it; a test without a mode of its own takes its describe's, unless that describe is `.only` and has a test of its
+     * own that uses `.only`. A skipped describe skips every test in it, a todo or a `.only` too, and a `.only` there
+     * focuses nothing.
+     */
+    jestState(pending, scopes) {
+        const { declaration } = pending;
+        const marked = scopes.find((scope) => scope.isOnly || scope.states.some((setting) => setting.state === 'skip'));
+        const skippedBy = marked && !marked.isOnly ? marked.states.find((setting) => setting.state === 'skip') : undefined;
+        const own = (state) => declaration.states.find((setting) => setting.state === state);
+        const passesOnly = marked?.isOnly === true && !this.focused.has(pending.scope);
+        if (skippedBy) {
+            return {
+                chosen: own('skip')
+                    ? { setting: own('skip'), source: 'test' }
+                    : { setting: skippedBy, source: 'suite' },
+                isOnly: false,
+            };
+        }
+        const setting = own('skip') ?? own('todo') ?? own('expectedToFail');
+        return { chosen: setting ? { setting, source: 'test' } : null, isOnly: declaration.isOnly || passesOnly };
+    }
     test(pending, suites) {
         const { declaration } = pending;
         const dependencies = this.options.dependencies(pending);
@@ -355,14 +386,17 @@ class RecordBuilder {
         // In Vitest 5 the options of a test's tags win over those the describes pass down; before, the describes' win.
         const tagsFirst = this.options.config?.tags?.beatsDescribes ?? true;
         const tagged = (own, tag, around) => tagsFirst ? [...own, ...tag, ...around] : [...own, ...around, ...tag];
-        const chosen = chooseState([
-            ...declaredStates(pending.states.slice(0, declaration.states.length), fromTags, declaration),
-            ...pending.states.slice(declaration.states.length).map((setting) => ({ setting, source: 'test' })),
-            ...scopes.flatMap((scope) => scope.states.map((setting) => ({
-                setting,
-                source: scope.kind === 'file' ? 'file' : 'suite',
-            }))),
-        ]);
+        const jest = this.options.framework === 'jest' ? this.jestState(pending, scopes) : null;
+        const chosen = jest
+            ? jest.chosen
+            : chooseState([
+                ...declaredStates(pending.states.slice(0, declaration.states.length), fromTags, declaration),
+                ...pending.states.slice(declaration.states.length).map((setting) => ({ setting, source: 'test' })),
+                ...scopes.flatMap((scope) => scope.states.map((setting) => ({
+                    setting,
+                    source: scope.kind === 'file' ? 'file' : 'suite',
+                }))),
+            ]);
         // When the runner refuses the file, no test in it runs, whatever else is written.
         const rejected = this.rejectedAt !== null;
         const state = rejected ? 'notLoaded' : (chosen?.setting.state ?? 'active');
@@ -375,7 +409,9 @@ class RecordBuilder {
         for (const values of [fromTags?.meta, ...describes.map((scope) => scope.details.meta), declaration.details.meta]) {
             Object.assign(meta, values);
         }
-        const isOnly = declaration.isOnly || scopes.some((scope) => scope.isOnly) || fromTags?.only === true;
+        const isOnly = jest
+            ? jest.isOnly
+            : declaration.isOnly || scopes.some((scope) => scope.isOnly) || fromTags?.only === true;
         const comments = this.options.comments === 'all' || (this.options.comments === 'non-active' && state !== 'active')
             ? pending.comments
             : [];
@@ -389,8 +425,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 +492,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 +522,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/resolve.js

@@ -272,39 +272,35 @@ function pnpmWorkspacePatterns(text) {
     }
     return patterns;
 }
-/** The folder of each package in the workspace a folder belongs to, by name; empty outside a workspace. */
-function workspacePackages(directory) {
-    for (let folder = directory;; folder = path.dirname(folder)) {
-        const workspaces = readJson(path.join(folder, 'package.json'))?.workspaces;
-        const fromManifest = Array.isArray(workspaces) ? workspaces : record(workspaces)?.packages;
-        const pnpm = readText(path.join(folder, 'pnpm-workspace.yaml'));
-        // pnpm reads only pnpm-workspace.yaml, and npm, Yarn and Bun only package.json, so a repository that moved to
-        // pnpm may still have an old list there. Packages from both are found.
-        const lists = [Array.isArray(fromManifest) ? fromManifest : null, pnpm ? pnpmWorkspacePatterns(pnpm) : null];
-        const patterns = lists.some((list) => list !== null)
-            ? lists.flat().filter((item) => typeof item === 'string')
-            : null;
-        if (patterns) {
-            // Packages are inside the workspace. A pattern or a link that leads out of its folder could send the search through
-            // the whole disk, so neither is followed.
-            const inside = patterns.filter((item) => !path.isAbsolute(item.replace(/^!/, '')) && !/(^|\/)\.\.(\/|$)/.test(item));
-            const manifests = globSync(inside.filter((item) => !item.startsWith('!')).map((item) => `${item.replace(/\/+$/, '')}/package.json`), {
-                cwd: folder,
-                absolute: true,
-                followSymbolicLinks: false,
-                ignore: ['**/node_modules/**', ...inside.filter((item) => item.startsWith('!')).map((item) => item.slice(1))],
-            });
-            const packages = new Map();
-            for (const manifest of manifests) {
-                const name = readJson(manifest)?.name;
-                if (typeof name === 'string')
-                    packages.set(name, path.dirname(manifest));
-            }
-            return packages;
-        }
-        if (path.dirname(folder) === folder)
-            return new Map();
+/** The folder of each package of the workspace a folder is the root of, by name; null when it isn't one. */
+function workspaceAt(folder) {
+    const workspaces = readJson(path.join(folder, 'package.json'))?.workspaces;
+    const fromManifest = Array.isArray(workspaces) ? workspaces : record(workspaces)?.packages;
+    const pnpm = readText(path.join(folder, 'pnpm-workspace.yaml'));
+    // pnpm reads only pnpm-workspace.yaml, and npm, Yarn and Bun only package.json, so a repository that moved to
+    // pnpm may still have an old list there. Packages from both are found.
+    const lists = [Array.isArray(fromManifest) ? fromManifest : null, pnpm ? pnpmWorkspacePatterns(pnpm) : null];
+    const patterns = lists.some((list) => list !== null)
+        ? lists.flat().filter((item) => typeof item === 'string')
+        : null;
+    if (!patterns)
+        return null;
+    // Packages are inside the workspace. A pattern or a link that leads out of its folder could send the search through
+    // the whole disk, so neither is followed.
+    const inside = patterns.filter((item) => !path.isAbsolute(item.replace(/^!/, '')) && !/(^|\/)\.\.(\/|$)/.test(item));
+    const manifests = globSync(inside.filter((item) => !item.startsWith('!')).map((item) => `${item.replace(/\/+$/, '')}/package.json`), {
+        cwd: folder,
+        absolute: true,
+        followSymbolicLinks: false,
+        ignore: ['**/node_modules/**', ...inside.filter((item) => item.startsWith('!')).map((item) => item.slice(1))],
+    });
+    const packages = new Map();
+    for (const manifest of manifests) {
+        const name = readJson(manifest)?.name;
+        if (typeof name === 'string')
+            packages.set(name, path.dirname(manifest));
     }
+    return packages;
 }
 /**
  * A workspace package followed to its TypeScript source: through its link in node_modules, or, before an install, from
@@ -351,12 +347,19 @@ export function moduleResolver(root) {
         }
         return options;
     };
+    // The packages of the workspace a folder belongs to, empty outside one; each folder on the way up is looked at once.
     const packagesOf = (directory) => {
-        let packages = workspaces.get(directory);
-        if (!packages) {
-            packages = workspacePackages(directory);
-            workspaces.set(directory, packages);
+        const passed = [];
+        let packages;
+        for (let folder = directory; !packages; folder = path.dirname(folder)) {
+            packages = workspaces.get(folder);
+            if (packages)
+                break;
+            passed.push(folder);
+            packages = workspaceAt(folder) ?? (path.dirname(folder) === folder ? new Map() : null);
         }
+        for (const folder of passed)
+            workspaces.set(folder, packages);
         return packages;
     };
     const reader = (fromFile) => (specifier) => {

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,21 +2,27 @@ 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";
+import { JestAdapter } from "./frameworks/jest.js";
 import { parseFile } from "./parse.js";
 import { buildRecords, fileRecord } from "./records.js";
 import { snippet } from "./source.js";
 import { Values } from "./values.js";
 const TYPE_TEST = /\.(test|spec)-d\.[cm]?[jt]sx?$/;
 const BENCHMARK = /\.(bench|benchmark)\.[cm]?[jt]sx?$/;
+const ADAPTERS = {
+    playwright: (parsed, file, readModule) => new PlaywrightAdapter(parsed.program, file, readModule),
+    vitest: (parsed, file, readModule) => new VitestAdapter(parsed, file, readModule),
+    jest: (parsed, file, readModule) => new JestAdapter(parsed, file, readModule),
+};
 /** 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 };
-    const adapter = settings.framework === 'playwright'
-        ? new PlaywrightAdapter(parsed.program, file, readModule)
-        : new VitestAdapter(parsed, file, readModule);
+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 = ADAPTERS[settings.framework](parsed, file, readModule);
     return { parsed, adapter, values: file.values, readModule, relativeFilePath };
 }
 /** The records of a file the scan read no tests from. */
@@ -35,11 +41,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,
     });