test-inventory 0.2.1 → 0.4.0

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, requiredModule, } from "./bindings.js";
-import { atLeast, findFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, readOptions, readStrings, isTitleLiteral, readReason, namedFunction, unresolvedOption, unresolvedOptions, readTitle, text, } from "./common.js";
+import { allDeclarators, bindAll, exportName, followImport, followModule, moduleImports, ModuleFunctions, requiredModule, } from "./bindings.js";
+import { atLeast, findFunction, isTestName, localTestObject, looksLikeDeclaration, mayDeclareTests, mayHoldTestObject, origin, problem, readChain, readCondition, returnedFunction, returnedTestObject, destructuredNames, 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)
@@ -37,6 +37,11 @@ const HOOKS = new Map([
     ['afterAll', null],
     ['aroundAll', null],
 ]);
+function isHook(name) {
+    return HOOKS.has(name);
+}
+/** First members of chains that never declare a test, even when Vitest refuses the rest of the chain. */
+const NOT_DECLARING = new Set([...HOOKS.keys(), ...DERIVATIONS]);
 /** First members that show a name imported from a local file is used as Vitest's `test`. */
 const TEST_MEMBERS = new Set([...MODIFIERS.test, ...MODIFIERS.describe, ...TABLES, ...CONDITIONS, ...KINDS.keys()]);
 /** Calls Vitest moves to the top of the file before running it: `vi.mock`, `vi.unmock` and `vi.hoisted`. */
@@ -89,6 +94,23 @@ function hoistedValue(call, parents) {
     const parent = parents.at(-1);
     return parent?.type === 'AwaitExpression' ? parent : call;
 }
+/** Keys of the test context that Vitest provides itself, with the version that added each; they are not fixtures. */
+const CONTEXT_KEYS = new Map([
+    ['task', [3, 0]],
+    ['expect', [3, 0]],
+    ['skip', [3, 0]],
+    ['onTestFailed', [3, 0]],
+    ['onTestFinished', [3, 0]],
+    ['annotate', [3, 2]],
+    ['signal', [3, 2]],
+    ['bench', [5, 0]],
+]);
+function fixturesOf(fn, index, version) {
+    return destructuredNames(fn, index).filter((name) => {
+        const since = CONTEXT_KEYS.get(name);
+        return !since || !atLeast(version, ...since);
+    });
+}
 /** The names a file binds to Vitest's `test`, `describe`, hooks and namespace. */
 class VitestBindings {
     kinds = new Map();
@@ -102,9 +124,12 @@ class VitestBindings {
     /** Names imported from other modules, which may be test objects there. */
     imported;
     follow;
+    /** The module's functions and the variables they may build test objects in; see `ModuleFunctions`. */
+    functions;
     constructor(program, version, follow) {
         this.imported = moduleImports(program, (source) => source === 'vitest' || MISMATCHED_SOURCES.has(source));
         this.follow = follow;
+        this.functions = new ModuleFunctions(program, this.imported, follow);
         for (const statement of program.body) {
             if (statement.type !== 'ImportDeclaration' || statement.importKind === 'type')
                 continue;
@@ -139,30 +164,49 @@ class VitestBindings {
                 this.declarations.add(declarator);
             return bound;
         });
+        this.functions.keep(declarators.filter((declarator) => !this.declarations.has(declarator)));
     }
     isTestName(name) {
-        return this.kinds.has(name) || this.importsTestObject(name);
+        return this.kinds.has(name) || this.importsTestObject(name) || this.holdsTestObject(name);
     }
-    isTestObject(expression) {
+    /**
+     * `followsCalls` is cleared where a call is not followed to what it returns: while the names are bound, so that only
+     * a value asked about is followed, as following reads other modules, and in the scanned file, whose calls the walk
+     * follows in their scopes.
+     */
+    isTestObject(expression, followsCalls = true) {
         const node = unwrap(expression);
-        if (node.type === 'Identifier')
-            return this.kinds.get(node.name) === 'test' || this.importsTestObject(node.name);
+        if (node.type === 'Identifier') {
+            const { name } = node;
+            return (this.kinds.get(name) === 'test' || this.importsTestObject(name) || (followsCalls && this.holdsTestObject(name)));
+        }
         if (node.type === 'MemberExpression') {
             return KINDS.get(propertyName(node) ?? '') === 'test' && this.isNamespace(node.object);
         }
         // `process.env.CI ? vitestTest : skippedTest` is a test object either way.
         if (node.type === 'ConditionalExpression') {
-            return this.isTestObject(node.consequent) || this.isTestObject(node.alternate);
+            return this.isTestObject(node.consequent, followsCalls) || this.isTestObject(node.alternate, followsCalls);
         }
         if (node.type !== 'CallExpression')
             return false;
         const callee = unwrap(node.callee);
+        // `defineBrokerTest()`, a function that returns a test object.
+        if (callee.type === 'Identifier')
+            return followsCalls && this.returnsTestObject(callee.name);
         return (callee.type === 'MemberExpression' &&
             DERIVATIONS.has(propertyName(callee) ?? '') &&
-            this.isTestObject(callee.object));
+            this.isTestObject(callee.object, followsCalls));
+    }
+    returnsTestObject(name) {
+        return this.functions.returnsTestObject(name, (expression) => this.isTestObject(expression));
+    }
+    holdsTestObject(name) {
+        return this.functions.holdsTestObject(name, (expression) => this.isTestObject(expression));
     }
-    reexports(source, imported) {
-        return source === 'vitest' ? KINDS.has(imported) : this.follow(source, imported);
+    reexports(source, imported, exported) {
+        if (source !== 'vitest')
+            return this.follow(source, imported, exported);
+        return exported === 'test object' && KINDS.has(imported);
     }
     /** Whether a name is imported from another module that exports it as a test object, as `base` from './base'. */
     importsTestObject(name) {
@@ -178,7 +222,7 @@ class VitestBindings {
         if (kind) {
             this.kinds.set(local, kind);
         }
-        else if (HOOKS.has(imported)) {
+        else if (isHook(imported)) {
             this.hooks.set(local, imported);
         }
         else if (imported === 'bench' && atLeast(version, 5, 0)) {
@@ -189,7 +233,7 @@ class VitestBindings {
         const { id, init } = declarator;
         if (!init)
             return false;
-        if (id.type === 'Identifier' && this.isTestObject(init)) {
+        if (id.type === 'Identifier' && this.isTestObject(init, false)) {
             this.kinds.set(id.name, 'test');
             return true;
         }
@@ -203,7 +247,7 @@ class VitestBindings {
             const kind = KINDS.get(key ?? '');
             if (kind)
                 this.kinds.set(property.value.name, kind);
-            if (key !== null && HOOKS.has(key))
+            if (key !== null && isHook(key))
                 this.hooks.set(property.value.name, key);
         }
         return true;
@@ -231,10 +275,11 @@ export class VitestAdapter {
         // A test object the file builds from an imported one, as in `const it = base.extend({...})`, is followed quietly:
         // a call through the import itself is what reports an import that can't be followed.
         const followed = new Map();
-        this.bindings = new VitestBindings(parsed.program, file.version, (source, imported) => {
-            const key = `${source}\0${imported}`;
-            if (!followed.has(key))
-                followed.set(key, followModule(source, imported, readModule, this.framework()).exported);
+        this.bindings = new VitestBindings(parsed.program, file.version, (source, imported, exported = 'test object') => {
+            const key = `${source}\0${exported}\0${imported}`;
+            if (!followed.has(key)) {
+                followed.set(key, followModule(source, imported, readModule, this.framework(), exported).exported);
+            }
             return followed.get(key) === true;
         });
         this.problems = [...this.bindings.problems];
@@ -259,8 +304,8 @@ export class VitestAdapter {
             this.contextSkip(call, context) ??
             this.chainCall(call, context));
     }
-    testFunction(expression, scopes) {
-        return this.aliasOf(expression, { scopes, inBody: false, returnsOf: null });
+    testFunction(expression, scopes, returnsOf) {
+        return this.aliasOf(expression, { scopes, inBody: false, returnsOf });
     }
     /** A call to `bench` imported from Vitest 5, which is undefined there, so the call throws. */
     benchCall(call, context) {
@@ -282,7 +327,7 @@ export class VitestAdapter {
         if (!resolved)
             return null;
         const { kind, links } = resolved;
-        if (kind === 'test' && links.length === 1 && HOOKS.has(links[0].name))
+        if (kind === 'test' && links.length === 1 && isHook(links[0].name))
             return this.hook(call, links[0].name);
         if (links.length === 1 && DERIVATIONS.has(links[0].name))
             return { kind: 'other' };
@@ -290,29 +335,24 @@ export class VitestAdapter {
         if (last && (TABLES.has(last.name) || CONDITIONS.has(last.name)) && !last.args && !last.template) {
             return { kind: 'other' };
         }
-        for (const link of links) {
+        const callee = snippet(text(this.file, call.callee));
+        const removed = (link) => link.name === 'sequential' && atLeast(this.file.version, 5, 0);
+        const valid = (link) => {
             const called = link.args !== null || link.template !== null;
-            const valid = MODIFIERS[kind].has(link.name)
-                ? !called
-                : TABLES.has(link.name)
-                    ? called
-                    : CONDITIONS.has(link.name) && link.args !== null;
-            if (!valid) {
-                const callee = snippet(text(this.file, call.callee));
-                return {
-                    kind: 'invalid',
-                    problem: problem('invalid-chain', call, `${callee} is not part of Vitest's API.`, callee),
-                };
-            }
-            if (link.name === 'sequential' && atLeast(this.file.version, 5, 0)) {
-                const callee = snippet(text(this.file, call.callee));
-                return {
-                    kind: 'invalid',
-                    problem: problem('removed-api', call, `sequential was removed in Vitest 5; ${callee}(...) fails.`, callee),
-                };
-            }
-        }
-        return this.declaration(call, kind, links, context);
+            if (MODIFIERS[kind].has(link.name))
+                return !called && !removed(link);
+            return TABLES.has(link.name) ? called : CONDITIONS.has(link.name) && link.args !== null;
+        };
+        const invalid = links.find((link) => !valid(link));
+        if (!invalid)
+            return this.declaration(call, kind, links, context);
+        const refusal = removed(invalid)
+            ? problem('removed-api', call, `sequential was removed in Vitest 5; ${callee}(...) fails.`, callee)
+            : problem('invalid-chain', call, `${callee} is not part of Vitest's API.`, callee);
+        if (NOT_DECLARING.has(links[0].name))
+            return { kind: 'invalid', problem: refusal };
+        // Which of its parts the chain means is not known, so it declares a plain test or describe.
+        return refused(call, refusal, context, () => this.declaration(call, kind, [], context));
     }
     /**
      * The function a chain calls and the links after it, or null when it isn't one of Vitest's. An import that can't be
@@ -402,7 +442,7 @@ export class VitestAdapter {
      */
     returned(call, links, args, lookup) {
         const callee = unwrap(call.callee);
-        if (callee.type !== 'Identifier' || !lookup.returnsOf)
+        if (callee.type !== 'Identifier')
             return null;
         const returns = lookup.returnsOf(callee.name, lookup.scopes);
         if (returns)
@@ -472,27 +512,28 @@ export class VitestAdapter {
             return null;
         const declaration = this.file.values.declarationOf(callee.name, context.scopes);
         const hook = declaration === null
-            ? HOOKS.has(callee.name) && callee.name
+            ? isHook(callee.name) && callee.name
             : this.bindings.declarations.has(declaration) && this.bindings.hooks.get(callee.name);
         return hook ? this.hook(call, hook) : null;
     }
     hook(call, name) {
         const fn = findFunction(call.arguments);
         const index = HOOKS.get(name);
-        return { kind: 'hook', fn, testContext: index === null ? null : skipNames(fn, index) };
+        return {
+            kind: 'hook',
+            name,
+            fn,
+            testContext: index === null ? null : contextNames(fn, index),
+            fixtures: fixturesOf(fn, index, this.file.version),
+        };
     }
     contextSkip(call, context) {
         const names = context.testContext;
         if (!names)
             return null;
-        const callee = unwrap(call.callee);
-        const isSkip = callee.type === 'Identifier'
-            ? names.functions.has(callee.name)
-            : callee.type === 'MemberExpression' &&
-                propertyName(callee) === 'skip' &&
-                callee.object.type === 'Identifier' &&
-                names.objects.has(callee.object.name);
-        if (!isSkip)
+        if (atLeast(this.file.version, 3, 2) && callsContext(call, names, 'annotate'))
+            return this.annotate(call, context);
+        if (!callsContext(call, names, 'skip'))
             return null;
         const [first, second] = call.arguments;
         // skip(), skip(note) or skip(condition, note); before Vitest 3.1 the first argument is always the note.
@@ -507,6 +548,29 @@ export class VitestAdapter {
             problems: reason.problem ? [reason.problem] : [],
         };
     }
+    /**
+     * `annotate(message, type?)` from the test context (3.2), as an annotation of type `notice` when no type is given; the
+     * second argument may also be an attachment.
+     */
+    annotate(call, context) {
+        const args = call.arguments.map((arg) => arg.type === 'SpreadElement' ? null : this.file.values.resolve(arg, context.scopes));
+        const [message, second] = args;
+        // A second argument that isn't a string is an attachment, given in place of the type.
+        let type = 'notice';
+        if (args.length > 1 && !second?.ok)
+            type = null;
+        else if (second?.ok && typeof second.value === 'string')
+            type = second.value;
+        if (message?.ok && typeof message.value === 'string' && type !== null) {
+            const annotation = { type, description: message.value, lineStart: this.file.source.line(call.start) };
+            return { kind: 'annotations', items: [annotation], problems: [] };
+        }
+        const source = snippet(text(this.file, call));
+        const unresolved = [message, second].find((item) => item && !item.ok);
+        const from = unresolved && !unresolved.ok ? unresolved.importedFrom : null;
+        const missing = problem('unresolved-annotation', call, `Annotation ${source}${origin(from)} could not be worked out; it is missing.`, source);
+        return { kind: 'annotations', items: [], problems: [missing] };
+    }
     declaration(call, kind, links, context) {
         const args = call.arguments;
         const callee = snippet(text(this.file, call.callee));
@@ -528,6 +592,8 @@ export class VitestAdapter {
         // (title, fn, timeout), (title, options, fn) or the removed (title, fn, options)
         let options;
         let body;
+        let timeout;
+        let refusal = null;
         const [second, third] = [args.at(1), args.at(2)];
         if (args.some((arg) => arg.type === 'SpreadElement')) {
             // With spread arguments, as in test(...args), the function and options are unknown.
@@ -540,29 +606,63 @@ export class VitestAdapter {
             body = second;
             if (third !== undefined && this.isOptions(third, undefined, context)) {
                 if (atLeast(this.file.version, 4, 0)) {
-                    return {
-                        kind: 'invalid',
-                        problem: problem('removed-api', third, `${callee}() takes options as its second argument since Vitest 4; with options third the call fails.`, snippet(text(this.file, third))),
-                    };
+                    refusal = problem('removed-api', third, `${callee}() takes options as its second argument since Vitest 4; with options third the call fails.`, snippet(text(this.file, third)));
                 }
                 options = third;
             }
+            else if (third === undefined ||
+                isFunctionNode(second) ||
+                namedFunction(this.file, context.scopes, second) ||
+                this.file.values.resolve(third, context.scopes).ok) {
+                // With imported options and a body passed by name, either could be the body, so the third is no timeout.
+                timeout = third;
+            }
         }
         const fn = isFunctionNode(body) ? body : null;
         const read = this.readDeclarationOptions(options, context, problems);
-        const flags = new Set([
-            ...links.filter((link) => MODIFIERS[kind].has(link.name)).map((link) => link.name),
-            ...read.flags,
-        ]);
-        const conditions = [
-            ...links.filter((link) => CONDITIONS.has(link.name)).map((link) => this.linkCondition(link, context)),
-            ...read.conditions,
-        ];
+        if (timeout) {
+            const node = timeout;
+            const option = { node, resolved: this.file.values.resolve(node, context.scopes) };
+            const value = readCount(this.file, 'timeout', option, problems);
+            if (value !== null)
+                read.details.run.timeout = value;
+        }
+        const chain = new Set(links.filter((link) => MODIFIERS[kind].has(link.name)).map((link) => link.name));
+        const flags = new Set(chain);
+        let conditions = links.filter((link) => CONDITIONS.has(link.name)).map((link) => this.linkCondition(link, context));
+        // A test's own options win over its chain, so `test.skip('title', { skip: false }, fn)` runs. The chain wins for a
+        // test's mode, and for everything on a describe.
+        for (const [flag, value] of read.flags) {
+            if (value)
+                flags.add(flag);
+            else if (kind === 'test' && flag !== 'sequential')
+                flags.delete(flag);
+        }
+        if (read.skip && kind === 'test') {
+            flags.delete('skip');
+            conditions = [read.skip];
+        }
+        else if (read.skip) {
+            conditions.push(read.skip);
+        }
+        // Vitest passes a describe's options down to the tests and describes inside, where their own options and `only`
+        // win. A `skip` passed down skips them, and turns todo into skip, as skip goes before todo.
+        const line = this.file.source.line(call.start);
+        const around = context.passedDown;
+        const passed = read.skip ? null : around;
+        const skips = passed?.condition.applies === 'always' && !flags.has('only');
         const table = links.find((link) => TABLES.has(link.name)) ?? null;
         const isTodo = flags.has('todo') || body === undefined;
-        const states = this.states(flags, conditions, isTodo, this.file.source.line(call.start));
-        // `{ concurrent: false }` is how Vitest 5 turns parallel off, in place of `sequential`.
-        const parallel = read.concurrent ?? flags.has('concurrent');
+        const states = this.states(flags, conditions, isTodo && !skips, line);
+        const skipped = () => states.some((setting) => setting.state === 'skip' && !setting.condition);
+        // The skip is set where the describe that passes it down sets it. A skipped describe around already skips what is
+        // inside, as it does when its own `only` beats its skip; a todo describe gets the skip itself.
+        if (skips && !skipped() && (!passed.covered || (kind === 'describe' && isTodo))) {
+            states.push({ state: 'skip', condition: null, reason: null, hasDynamicReason: false, line: passed.line });
+        }
+        // The chain's mode wins over the options'. `{ concurrent: false }` is how Vitest 5 turns parallel off, in place of
+        // `sequential`.
+        const parallel = chain.has('concurrent') || (!chain.has('sequential') && read.concurrent === true);
         const mode = parallel
             ? 'parallel'
             : flags.has('sequential') || read.concurrent === false
@@ -580,18 +680,27 @@ export class VitestAdapter {
             caseCount: table ? this.caseCount(call, table, context, problems) : null,
             problems,
         };
+        let declared;
         if (kind === 'describe') {
             // A table's cases are passed instead.
             const first = table ? null : fn?.params.at(0);
             if (fn && first?.type === 'Identifier')
                 this.suiteParameters.set(fn, first.name);
-            return { kind: 'describe', ...base, isShuffled: flags.has('shuffle') };
+            const own = read.skip ? { condition: read.skip, line } : around;
+            const passesDown = own && { ...own, covered: (around?.covered ?? false) || skipped() };
+            declared = { kind: 'describe', ...base, isShuffled: flags.has('shuffle'), passesDown };
         }
-        return {
-            kind: 'test',
-            ...base,
-            testContext: skipNames(fn, table?.name === 'for' ? 1 : table ? null : 0),
-        };
+        else {
+            const index = table?.name === 'for' ? 1 : table ? null : 0;
+            declared = {
+                kind: 'test',
+                ...base,
+                testContext: contextNames(base.hashed, index),
+                fixtures: fixturesOf(base.hashed, index, this.file.version),
+                usesBench: atLeast(this.file.version, 5, 0) && destructuredNames(base.hashed, index).includes('bench'),
+            };
+        }
+        return refusal ? refused(call, refusal, context, () => declared) : declared;
     }
     /** Whether an argument holds options: an object, a name for one, or anything but a function before the body. */
     isOptions(node, next, context) {
@@ -637,11 +746,11 @@ export class VitestAdapter {
         return fails;
     }
     readDeclarationOptions(node, context, problems) {
-        const details = { tags: [], annotations: [], locks: [], meta: null };
+        const details = { tags: [], annotations: [], locks: [], meta: null, run: {} };
         const result = {
-            flags: [],
+            flags: new Map(),
             concurrent: null,
-            conditions: [],
+            skip: null,
             details,
         };
         if (!node)
@@ -657,15 +766,15 @@ export class VitestAdapter {
             else if (option?.resolved.ok && flag === 'concurrent') {
                 result.concurrent = Boolean(option.resolved.value);
             }
-            else if (option?.resolved.ok && option.resolved.value) {
-                result.flags.push(flag);
+            else if (option?.resolved.ok) {
+                result.flags.set(flag, Boolean(option.resolved.value));
             }
         }
         const skip = options.values.get('skip');
         if (skip) {
-            result.conditions.push(skip.resolved.ok
+            result.skip = skip.resolved.ok
                 ? { applies: skip.resolved.value ? 'always' : 'never', text: null }
-                : { applies: 'sometimes', text: snippet(text(this.file, skip.node)) });
+                : { applies: 'sometimes', text: snippet(text(this.file, skip.node)) };
         }
         const tags = options.values.get('tags');
         if (tags && atLeast(this.file.version, 4, 1)) {
@@ -680,8 +789,46 @@ export class VitestAdapter {
         const meta = options.values.get('meta');
         if (meta)
             details.meta = this.meta(meta, context, problems);
+        for (const key of ['timeout', 'repeats']) {
+            const option = options.values.get(key);
+            const value = option ? readCount(this.file, key, option, problems) : null;
+            if (value !== null)
+                details.run[key] = value;
+        }
+        const retry = options.values.get('retry');
+        if (retry)
+            this.retry(retry, details, context, problems);
         return result;
     }
+    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`; the runner ignores an object before. */
+    retry(option, details, context, problems) {
+        const node = unwrap(option.node);
+        if (node.type !== 'ObjectExpression') {
+            const count = readCount(this.file, 'retry', option, problems);
+            if (count !== null)
+                details.run.retry = { count, delay: null, condition: null };
+            return;
+        }
+        if (!atLeast(this.file.version, 4, 1))
+            return;
+        const values = readOptions(this.file, context.scopes, node);
+        problems.push(...unresolvedOptions(this.file, values, 'the retry is not applied'));
+        const read = (key) => {
+            const value = values.values.get(key);
+            return value ? readCount(this.file, `retry.${key}`, value, problems) : undefined;
+        };
+        const count = read('count');
+        const delay = read('delay');
+        if (count === null)
+            return;
+        const condition = values.values.get('condition');
+        details.run.retry = {
+            // Vitest retries 0 times when the object has no count.
+            count: count ?? 0,
+            delay: delay ?? null,
+            condition: condition ? snippet(text(this.file, condition.node)) : null,
+        };
+    }
     meta(option, context, problems) {
         const entries = readOptions(this.file, context.scopes, option.node);
         problems.push(...unresolvedOptions(this.file, entries, 'its meta values are missing'));
@@ -738,19 +885,32 @@ function templateRows(template) {
 function isMetaValue(value) {
     return value !== undefined;
 }
-function skipNames(fn, index) {
+function contextNames(fn, index) {
     const parameter = index === null ? undefined : fn?.params[index];
     if (!parameter)
         return null;
-    const names = { objects: new Set(), functions: new Set() };
+    const names = { objects: new Set(), skip: new Set(), annotate: new Set() };
     if (parameter.type === 'Identifier')
         names.objects.add(parameter.name);
     if (parameter.type === 'ObjectPattern') {
         for (const property of parameter.properties) {
-            if (property.type === 'Property' && propertyKey(property) === 'skip' && property.value.type === 'Identifier') {
-                names.functions.add(property.value.name);
+            const key = property.type === 'Property' ? propertyKey(property) : null;
+            if ((key === 'skip' || key === 'annotate') &&
+                property.type === 'Property' &&
+                property.value.type === 'Identifier') {
+                names[key].add(property.value.name);
             }
         }
     }
     return names;
 }
+/** Whether a call is `name(...)` for a context function taken out of the context, or `context.name(...)`. */
+function callsContext(call, names, member) {
+    const callee = unwrap(call.callee);
+    return callee.type === 'Identifier'
+        ? names[member].has(callee.name)
+        : callee.type === 'MemberExpression' &&
+            propertyName(callee) === member &&
+            callee.object.type === 'Identifier' &&
+            names.objects.has(callee.object.name);
+}

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { scan } from './scan.ts';
 export { scanSource } from './scan-source.ts';
+export { filterInventory, pickTestFields } from './filter.ts';
+export type { InventoryFilter, PickedInventory } from './filter.ts';
 export type { CommentsMode, ScanOptions, ScanSourceOptions } from './options.ts';
-export type { Annotation, DeclaredAt, Diagnostic, DiagnosticCode, DiagnosticLevel, Framework, Inventory, MetaValue, StateSource, SuiteRecord, Summary, TestRecord, TestState, Tool, } from './types.ts';
+export type { Annotation, DeclaredAt, Diagnostic, DiagnosticCode, DiagnosticLevel, FileRecord, Framework, HookCounts, Inventory, InventoryLine, MetaValue, StateSource, SuiteRecord, Summary, TestRecord, TestState, Tool, } from './types.ts';

package/dist/index.js

@@ -1,2 +1,3 @@
 export { scan } from "./scan.js";
 export { scanSource } from "./scan-source.js";
+export { filterInventory, pickTestFields } from "./filter.js";

package/dist/inventory.js

@@ -10,6 +10,7 @@ export function createInventory(framework, frameworkVersion, fileCount, files, p
         framework,
         frameworkVersion,
         summary: summarize(fileCount, suites, tests, diagnostics),
+        files: files.map((file) => file.file),
         suites,
         tests,
         diagnostics,

package/dist/json.d.ts

@@ -1,6 +1,12 @@
 import type { Inventory } from './types.ts';
+/** An inventory as the command line writes it, with every key of the test records or only the picked ones. */
+export type Output = Omit<Inventory, 'tests'> & {
+    tests: object[];
+};
 /**
  * Writes an inventory as JSON one record at a time, so a large inventory never becomes one huge string.
  * The text is exactly what `JSON.stringify(inventory, null, pretty ? 2 : undefined)` returns.
  */
-export declare function writeInventory(inventory: Inventory, pretty: boolean, write: (chunk: string) => Promise<void>): Promise<void>;
+export declare function writeInventory(inventory: Output, pretty: boolean, write: (chunk: string) => Promise<void>): Promise<void>;
+/** Writes an inventory as JSON Lines: one line per record, each marked by `type`, as `InventoryLine` describes. */
+export declare function writeInventoryLines(inventory: Output, write: (chunk: string) => Promise<void>): Promise<void>;

package/dist/json.js

@@ -1,18 +1,24 @@
 /** Collects small pieces into larger chunks, so a stream gets few writes. */
 const CHUNK_SIZE = 64 * 1024;
+function chunked(write) {
+    let buffer = '';
+    return {
+        emit: async (text) => {
+            buffer += text;
+            if (buffer.length >= CHUNK_SIZE) {
+                await write(buffer);
+                buffer = '';
+            }
+        },
+        flush: () => write(buffer),
+    };
+}
 /**
  * Writes an inventory as JSON one record at a time, so a large inventory never becomes one huge string.
  * The text is exactly what `JSON.stringify(inventory, null, pretty ? 2 : undefined)` returns.
  */
 export async function writeInventory(inventory, pretty, write) {
-    let buffer = '';
-    const emit = async (text) => {
-        buffer += text;
-        if (buffer.length >= CHUNK_SIZE) {
-            await write(buffer);
-            buffer = '';
-        }
-    };
+    const { emit, flush } = chunked(write);
     const stringify = (value, depth) => {
         const json = JSON.stringify(value, null, pretty ? 2 : undefined);
         return pretty ? json.replaceAll('\n', `\n${'  '.repeat(depth)}`) : json;
@@ -34,5 +40,22 @@ export async function writeInventory(inventory, pretty, write) {
         }
     }
     await emit(`${newline(0)}}`);
-    await write(buffer);
+    await flush();
+}
+/** Writes an inventory as JSON Lines: one line per record, each marked by `type`, as `InventoryLine` describes. */
+export async function writeInventoryLines(inventory, write) {
+    const { emit, flush } = chunked(write);
+    const line = (type, record) => emit(`${JSON.stringify({ type, ...record })}\n`);
+    const { schemaVersion, tool, framework, frameworkVersion } = inventory;
+    await line('inventory', { schemaVersion, tool, framework, frameworkVersion });
+    for (const file of inventory.files)
+        await line('file', file);
+    for (const suite of inventory.suites)
+        await line('suite', suite);
+    for (const test of inventory.tests)
+        await line('test', test);
+    for (const diagnostic of inventory.diagnostics)
+        await line('diagnostic', diagnostic);
+    await line('summary', inventory.summary);
+    await flush();
 }