test-inventory 0.6.0 → 0.7.0

package/dist/parse.js

@@ -7,6 +7,200 @@ function parserOptions(fileName) {
     const sourceType = extension.startsWith('.c') ? 'commonjs' : extension.startsWith('.m') ? 'module' : 'unambiguous';
     return { lang, sourceType, preserveParens: false };
 }
+/**
+ * How deep brackets may nest. oxc-parser recurses on the native stack, which no catch can stop: brackets about 2,400
+ * deep crash a worker thread's 4 MB stack and 4,800 the main thread's 8 MB. Of the 10,000 files in this package's
+ * development dependencies, minified bundles included, the deepest nests 34.
+ */
+const MAX_NESTING = 500;
+/** Words after which a `/` starts a regular expression rather than a division. */
+const BEFORE_REGEX = new Set([
+    'return',
+    'typeof',
+    'instanceof',
+    'in',
+    'of',
+    'new',
+    'delete',
+    'void',
+    'throw',
+    'case',
+    'do',
+    'else',
+    'yield',
+    'await',
+]);
+const Char = {
+    Tab: 9,
+    LineFeed: 10,
+    CarriageReturn: 13,
+    Space: 32,
+    DoubleQuote: 34,
+    Dollar: 36,
+    SingleQuote: 39,
+    OpenParen: 40,
+    CloseParen: 41,
+    Star: 42,
+    Slash: 47,
+    LessThan: 60,
+    GreaterThan: 62,
+    OpenBracket: 91,
+    Backslash: 92,
+    CloseBracket: 93,
+    Backtick: 96,
+    OpenBrace: 123,
+    CloseBrace: 125,
+};
+/** Letters, digits, `_`, `$` and anything outside ASCII, as identifiers and numbers use. */
+function isWordChar(code) {
+    return ((code >= 97 && code <= 122) ||
+        (code >= 65 && code <= 90) ||
+        (code >= 48 && code <= 57) ||
+        code === 95 ||
+        code === Char.Dollar ||
+        code > 127);
+}
+/** Whether the code right before `end` is a word after which a `/` starts a regular expression. */
+function afterKeyword(text, end) {
+    let wordEnd = end;
+    while (wordEnd > 0 && /\s/.test(text[wordEnd - 1]))
+        wordEnd--;
+    let wordStart = wordEnd;
+    while (wordStart > 0 && isWordChar(text.charCodeAt(wordStart - 1)))
+        wordStart--;
+    return BEFORE_REGEX.has(text.slice(wordStart, wordEnd));
+}
+/**
+ * Whether the slash at `at` ends a JSX tag, as in `</ul>` or `<OrderLeg leg={leg} />`, where a regular expression
+ * could otherwise start and run on over the brackets after it.
+ */
+function endsJsxTag(text, at) {
+    if (text.charCodeAt(at - 1) === Char.LessThan)
+        return true;
+    if (text.charCodeAt(at + 1) !== Char.GreaterThan)
+        return false;
+    let before = at - 1;
+    while (before > 0 && /\s/.test(text[before]))
+        before--;
+    return text.charCodeAt(before) === Char.CloseBrace;
+}
+/**
+ * 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 function tooDeeplyNested(text, limit) {
+    // Open brackets by their character; a substitution is kept as its backtick.
+    const open = [];
+    const counts = new Uint32Array(128);
+    let regexAllowed = true;
+    let index = 0;
+    const push = (code) => {
+        open.push(code);
+        counts[code]++;
+        return open.length > limit;
+    };
+    // Reads template text up to its end or a substitution; true when the substitution is one too deep.
+    const templateText = () => {
+        while (index < text.length) {
+            const code = text.charCodeAt(index);
+            if (code === Char.Backslash)
+                index += 2;
+            else if (code === Char.Backtick) {
+                index++;
+                regexAllowed = false;
+                return false;
+            }
+            else if (code === Char.Dollar && text.charCodeAt(index + 1) === Char.OpenBrace) {
+                if (push(Char.Backtick))
+                    return true;
+                index += 2;
+                regexAllowed = true;
+                return false;
+            }
+            else
+                index++;
+        }
+        return false;
+    };
+    // Skips a string or regular expression; neither goes past the end of the line.
+    const literal = (end) => {
+        let inClass = false;
+        while (index < text.length) {
+            const code = text.charCodeAt(index);
+            if (code === Char.LineFeed)
+                return;
+            index += code === Char.Backslash ? 2 : 1;
+            if (end === Char.Slash && code === Char.OpenBracket)
+                inClass = true;
+            else if (code === Char.CloseBracket)
+                inClass = false;
+            else if (code === end && !inClass)
+                return;
+        }
+    };
+    while (index < text.length) {
+        const code = text.charCodeAt(index);
+        const next = text.charCodeAt(index + 1);
+        const start = index;
+        if (code === Char.Space || code === Char.LineFeed || code === Char.Tab || code === Char.CarriageReturn) {
+            index++;
+        }
+        else if (code === Char.Slash && next === Char.Slash) {
+            const end = text.indexOf('\n', index);
+            index = end === -1 ? text.length : end;
+        }
+        else if (code === Char.Slash && next === Char.Star) {
+            const end = text.indexOf('*/', index + 2);
+            index = end === -1 ? text.length : end + 2;
+        }
+        else if (code === Char.SingleQuote ||
+            code === Char.DoubleQuote ||
+            (code === Char.Slash && (regexAllowed || afterKeyword(text, start)) && !endsJsxTag(text, start))) {
+            index++;
+            literal(code);
+            regexAllowed = false;
+        }
+        else if (code === Char.Backtick) {
+            index++;
+            if (templateText())
+                return index;
+        }
+        else if (isWordChar(code)) {
+            while (index < text.length && isWordChar(text.charCodeAt(index)))
+                index++;
+            regexAllowed = false;
+        }
+        else if (code === Char.OpenParen || code === Char.OpenBracket || code === Char.OpenBrace) {
+            if (push(code))
+                return start;
+            index++;
+            regexAllowed = true;
+        }
+        else if (code === Char.CloseParen || code === Char.CloseBracket || code === Char.CloseBrace) {
+            index++;
+            // A block can end right before a regular expression; a value in parentheses or brackets is divided.
+            regexAllowed = code === Char.CloseBrace;
+            const opener = code === Char.CloseParen ? Char.OpenParen : code === Char.CloseBracket ? Char.OpenBracket : Char.OpenBrace;
+            const closesSubstitution = code === Char.CloseBrace && counts[Char.Backtick] !== 0;
+            if (counts[opener] === 0 && !closesSubstitution)
+                continue;
+            let closed;
+            do {
+                closed = open.pop();
+                counts[closed]--;
+            } while (closed !== opener && !(closed === Char.Backtick && code === Char.CloseBrace));
+            // A substitution after this one is as deep as the one it closed, so it is never the first too deep.
+            if (closed === Char.Backtick)
+                templateText();
+        }
+        else {
+            index++;
+            regexAllowed = true;
+        }
+    }
+    return null;
+}
 /** The first parser error, located at its first label, or at the start of the file when it has none. */
 export function firstError(errors) {
     const first = errors.at(0);
@@ -18,6 +212,16 @@ export function firstError(errors) {
 export function parseFile(fileName, code) {
     // A byte order mark is not part of the code, and editors don't count it as a column.
     const text = code.charCodeAt(0) === 0xfeff ? code.slice(1) : code;
+    const tooDeep = tooDeeplyNested(text, MAX_NESTING);
+    if (tooDeep !== null) {
+        const message = `Brackets are nested more than ${MAX_NESTING} deep, too deep to parse safely`;
+        return {
+            source: new SourceText(text),
+            program: parseSync(fileName, '', parserOptions(fileName)).program,
+            comments: [],
+            error: { message, start: tooDeep, end: tooDeep + 1 },
+        };
+    }
     const result = parseSync(fileName, text, parserOptions(fileName));
     return {
         source: new SourceText(text),

package/dist/records.d.ts

@@ -61,6 +61,8 @@ export interface FileConfig {
     };
     /** Vitest's tags; null when the scan can't work them out, or the projects that run the file define different ones. */
     tags: VitestTags | null;
+    /** The tags Playwright's config `tag` gives every test, before the test's own. */
+    configTags: string[];
 }
 interface RecordOptions {
     relativeFilePath: string;

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),
@@ -314,7 +315,7 @@ class RecordBuilder {
         };
     }
     /** What the config's Vitest tags set on a test with `tags`, merged as Vitest merges them; null when none applies. */
-    tagOptions(tags) {
+    tagOptions(tags, ownStateOptions) {
         const definitions = this.options.config?.tags?.definitions ?? [];
         const applied = tags.flatMap((name) => definitions.filter((definition) => definition.name === name));
         if (applied.length === 0)
@@ -330,6 +331,9 @@ class RecordBuilder {
             if (meta)
                 merged.meta = { ...merged.meta, ...meta };
         }
+        // Vitest merges the test's own options over its tags', so `skip: false` runs a test whose tag skips it.
+        for (const option of ownStateOptions)
+            merged[option] = undefined;
         return merged;
     }
     test(pending, suites) {
@@ -343,11 +347,12 @@ class RecordBuilder {
         const id = this.id([this.describeTitles(describes), title.withoutTags]);
         const fileScope = scopes[scopes.length - 1];
         const tags = unique([
+            ...(this.options.config?.configTags ?? []),
             ...fileScope.details.tags,
             ...describes.flatMap((scope) => scope.details.tags),
             ...declaration.details.tags,
         ]);
-        const fromTags = this.tagOptions(tags);
+        const fromTags = this.tagOptions(tags, declaration.ownStateOptions ?? []);
         // 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];
@@ -385,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 &&
@@ -451,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,
@@ -478,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/resolve.js

@@ -1,3 +1,4 @@
+import { isUtf8 } from 'node:buffer';
 import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { globSync } from 'tinyglobby';
@@ -8,7 +9,7 @@ function isFile(file) {
 }
 /** The file a path refers to, found the way TypeScript and Node do: as is, with an extension, or a folder's index. */
 function findFile(base) {
-    const stripped = base.replace(/\.[cm]?js$/, '');
+    const stripped = base.replace(/\.(?:[cm]?js|jsx)$/, '');
     const candidates = [
         base,
         ...EXTENSIONS.map((extension) => stripped + extension),
@@ -42,6 +43,16 @@ function readText(file) {
         return null;
     }
 }
+/** A file's text, with its bytes too when it isn't UTF-8 text, as an image isn't; null when it can't be read. */
+function readContent(file) {
+    try {
+        const bytes = readFileSync(file);
+        return isUtf8(bytes) ? { code: bytes.toString('utf8') } : { code: bytes.toString('utf8'), bytes };
+    }
+    catch {
+        return null;
+    }
+}
 function readJson(file) {
     const text = isFile(file) ? readText(file) : null;
     return text === null ? null : record(parseJsonc(text));
@@ -362,17 +373,24 @@ export function moduleResolver(root) {
         }
         else {
             const options = optionsFor(directory);
-            const aliased = options ? aliasFiles(specifier, options) : null;
+            const targets = options ? aliasFiles(specifier, options) : null;
+            const aliased = targets?.find((file) => findFile(file) !== null);
             if (aliased) {
-                candidates = aliased;
+                candidates = [aliased];
             }
             else {
-                // `baseUrl` turns any name into a path, so a name not found there may still be a workspace package.
+                // TypeScript goes on to the usual lookup when no file of a matching alias exists. `baseUrl` turns any name
+                // into a path, so a name not found there may still be a workspace package.
                 const fromBaseUrl = options?.baseUrl ? findFile(path.resolve(options.baseUrl, specifier)) : null;
                 const workspace = fromBaseUrl ? null : workspaceSource(specifier, directory, packagesOf);
                 if (workspace && 'reason' in workspace)
                     return workspace;
                 const file = fromBaseUrl ?? workspace?.file;
+                // No package name starts with `@/` or `~/`, so these are aliases, as Vite's `resolve.alias` sets them; any
+                // other name with no file may still be a package or a built-in module, as TypeScript takes it to be.
+                if (!file && /^[@~]\//.test(specifier)) {
+                    return { reason: targets ? 'could not be read' : 'is a path alias that no tsconfig paths define' };
+                }
                 if (!file)
                     return { reason: 'is not a local file, a path alias or a workspace package' };
                 candidates = [file];
@@ -382,10 +400,12 @@ export function moduleResolver(root) {
         if (!found)
             return { reason: 'could not be read' };
         if (!modules.has(found)) {
-            const code = readText(found);
-            modules.set(found, code === null
-                ? null
-                : { code, relativeFilePath: path.relative(root, found).replaceAll('\\', '/'), readModule: reader(found) });
+            const content = readContent(found);
+            modules.set(found, content && {
+                ...content,
+                relativeFilePath: path.relative(root, found).replaceAll('\\', '/'),
+                readModule: reader(found),
+            });
         }
         return modules.get(found) ?? { reason: 'could not be read' };
     };

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 },
         });

package/dist/types.d.ts

@@ -38,7 +38,7 @@ export type SettingSource = 'test' | 'suite' | 'file' | 'config';
  * @inline
  */
 export type DiagnosticLevel = 'error' | 'warning';
-export type DiagnosticCode = 'unresolved-test-import' | 'parse-error' | 'read-error' | 'framework-mismatch' | 'unresolved-tag' | 'unresolved-annotation' | 'unresolved-cases' | 'test-in-loop' | 'dynamic-title' | 'duplicate-title' | 'duplicate-id' | 'internal-error' | 'invalid-chain' | 'skip-without-body' | 'test-without-body' | 'describe-not-called' | 'async-describe' | 'nested-test' | 'tag-without-at' | 'removed-api' | 'only-in-skipped-describe' | 'config-may-change-state' | 'undefined-tag' | 'symlink-ignored' | 'invalid-import' | 'globals-not-enabled' | 'unknown-framework-version' | 'unsupported-framework-version' | 'local-test-object' | 'state-in-helper' | 'unresolved-option' | 'dynamic-reason' | 'no-files-matched' | 'unsupported-file' | 'approximate-framework-version' | 'test-in-function' | 'empty-title' | 'bench-outside-benchmark-file' | 'config-value-unknown' | 'file-not-run' | 'forbidden-only' | 'dependency-not-followed';
+export type DiagnosticCode = 'unresolved-test-import' | 'parse-error' | 'read-error' | 'framework-mismatch' | 'unresolved-tag' | 'unresolved-annotation' | 'unresolved-cases' | 'cases-not-expanded' | 'test-in-loop' | 'dynamic-title' | 'duplicate-title' | 'duplicate-id' | 'internal-error' | 'invalid-chain' | 'skip-without-body' | 'test-without-body' | 'describe-not-called' | 'async-describe' | 'nested-test' | 'tag-without-at' | 'removed-api' | 'only-in-skipped-describe' | 'config-may-change-state' | 'undefined-tag' | 'symlink-ignored' | 'invalid-import' | 'globals-not-enabled' | 'unknown-framework-version' | 'unsupported-framework-version' | 'local-test-object' | 'state-in-helper' | 'unresolved-option' | 'dynamic-reason' | 'no-files-matched' | 'unsupported-file' | 'approximate-framework-version' | 'test-in-function' | 'empty-title' | 'bench-outside-benchmark-file' | 'config-value-unknown' | 'file-not-run' | 'forbidden-only' | 'dependency-not-followed';
 export type MetaValue = string | number | boolean | null | MetaValue[] | {
     [key: string]: MetaValue;
 };
@@ -222,6 +222,11 @@ export interface SuiteRecord {
     isShuffled: boolean;
     /** Declared with `.each` or `.for`. */
     isParameterized: boolean;
+    /**
+     * With `expandCases`, which case of its table or pass of its loop the describe is, from 0, as Vitest's `%#` counts;
+     * null without `expandCases`, or when the describe isn't one of several.
+     */
+    caseIndex: Count | null;
     tags: string[];
     annotations: Annotation[];
     /** Playwright only. */
@@ -381,10 +386,17 @@ export interface TestRecord {
     /** Declared with `.each` or `.for`, or inside a describe declared with them, so the runner repeats it. */
     isParameterized: boolean;
     /**
-     * How many times the runner repeats the test: the cases of its own table times those of each describe table around
-     * it. Null when a table is not written out in the file, or the test is not parameterized.
+     * How many times the runner repeats the test: the cases of its own table times those of each describe table and the
+     * passes of each loop around it. Null when the scan can't work out a table or a loop's values, or the test is neither
+     * parameterized nor in a loop.
      */
     caseCount: Count | null;
+    /**
+     * With `expandCases`, which case of its own table, or pass of the innermost loop around it inside its describe, the
+     * test is, from 0, as Vitest's `%#` counts; null without `expandCases`, or when the test isn't one of several. The
+     * case of a describe table or loop around the describe is the describe's `caseIndex`.
+     */
+    caseIndex: Count | null;
     /** Declared inside a loop, `forEach` or `map`. */
     isInLoop: boolean;
     /** Declared inside `if`, `?:`, `&&`, `switch` or a `catch` block. */

package/dist/values.d.ts

@@ -11,6 +11,8 @@ export type Resolved = {
     ok: false;
     importedFrom: string | null;
 };
+/** What another module exports under a name, `default` included, for an import of the file. */
+export type ImportReader = (source: string, name: string) => Resolved;
 /** Whether a value can be used as a property name. */
 export declare function isKey(value: Value): value is string | number;
 export declare function isScopeNode(node: Node): boolean;
@@ -22,6 +24,11 @@ export declare class Values {
     private readonly pending;
     /** The functions being read at one of their calls, innermost last. */
     private readonly calls;
+    private readonly imports;
+    private readonly assigned;
+    private readonly changed;
+    /** Without `imports`, a value imported from another module is not worked out. */
+    constructor(imports?: ImportReader | null);
     /**
      * Runs `read` with a function's parameters bound to the arguments of one call, worked out where the call is, so that
      * titles and values built from them resolve, as in `test(\`${side} rejects a zero quantity\`)` inside
@@ -29,6 +36,18 @@ export declare class Values {
      * takes the parameter's default value, worked out in `scopes`, the scopes around the function.
      */
     withArguments<T>(fn: FunctionNode, args: readonly Resolved[], scopes: readonly Node[], read: () => T): T;
+    /**
+     * Runs `read` with the names a loop declares bound to one of the values it goes over, as in
+     * `for (const [tier, bps] of Object.entries(FEES))`. `declarator` is the loop's variable declarator.
+     */
+    withLoopValue<T>(declarator: Node, pattern: Node, value: Resolved, body: Node, scopes: readonly Node[], read: () => T): T;
+    private assignedIn;
+    private withBound;
+    /**
+     * Binds the names of a parameter or a loop variable to the parts of `value` they take, as destructuring does. A
+     * missing `value`, after a spread argument, leaves them unknown, unless a default gives them one.
+     */
+    private bind;
     /** `scopes` lists the scope nodes around the expression, outermost first. */
     resolve(node: Expression, scopes: readonly Node[]): Resolved;
     /**
@@ -43,12 +62,31 @@ export declare class Values {
     } | null;
     /** The module a name is imported from where it is used; null when it isn't an import. */
     importSource(name: string, scopes: readonly Node[]): string | null;
+    /**
+     * Whether a name refers to a parameter or loop variable bound to a value where it is used: an argument of the helper
+     * call being walked, or a value of the case or pass of an expansion.
+     */
+    isBound(name: string, scopes: readonly Node[]): boolean;
     /** Whether a name refers to a function or class declared in the file. */
     isFunction(name: string, scopes: readonly Node[]): boolean;
     private propertyKey;
-    private resolveName;
+    /**
+     * The calls titles are often built with, all of them pure: `Object.keys()`, `Object.values()`, `Object.entries()`,
+     * `JSON.stringify()` with one argument, `String()`, and a string's `toUpperCase()`, `toLowerCase()` and `trim()` and
+     * an array's `join()`.
+     */
+    private call;
+    /** Whether a name refers to a global, as no scope around the use declares it. */
+    private isGlobal;
+    /** `data.name` where `data` is `import * as data`: what the module exports as `name`; null for any other member. */
+    private namespaceMember;
+    private imported;
+    /** What a name refers to where it is used; `scopes` lists the scope nodes around the use, outermost first. */
+    resolveName(name: string, scopes: readonly Node[]): Resolved;
     /** A parameter of a function read at one of its calls: the argument given there. */
     private resolveParameter;
+    /** Names the module changes while it loads, as in `WATCHED.push('MSFT')`, whose declared value isn't the one used. */
+    private changedAtLoad;
     private resolveConstant;
     private enumMembers;
     private lookup;