test-inventory 0.7.0 → 0.8.0

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) {
@@ -336,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);
@@ -356,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');
@@ -376,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
             : [];

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

@@ -6,19 +6,23 @@ 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, 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);
+    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. */

package/dist/scan.js

@@ -4,19 +4,19 @@ import path from 'node:path';
 import { glob } from 'tinyglobby';
 import { ConfigDependencies } from "./config-dependencies.js";
 import { ConfigRuns, fileConfig } from "./config-runs.js";
-import { Configs } from "./config.js";
+import { Configs, settingAt } 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 { detectFramework, detectFrameworkVersion, FRAMEWORK_NAMES, OLDEST } from "./framework-version.js";
 import { createInventory } from "./inventory.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";
 function versionDiagnostics(framework, version, source, range) {
-    const name = framework === 'playwright' ? 'Playwright' : 'Vitest';
+    const name = FRAMEWORK_NAMES[framework];
     if (version === null) {
         return [
             fileDiagnostic('unknown-framework-version', source, `The ${name} version could not be read from the project, so the rules of the newest supported version apply.`),
@@ -37,6 +37,17 @@ function versionDiagnostics(framework, version, source, range) {
         fileDiagnostic('approximate-framework-version', source, `Only the range "${range}" was found for ${name}, so the rules of the newest ${major}.x release apply.`),
     ];
 }
+/** Why Jest gives a file that uses its globals none: a project that runs it sets `injectGlobals` to false. */
+function jestGlobals(placement) {
+    const off = placement.projects?.find(({ settings }) => {
+        const setting = settingAt(settings, ['injectGlobals']);
+        return setting?.kind === 'value' && setting.value === false;
+    });
+    if (!off)
+        return null;
+    const config = off.config.record.relativeFilePath;
+    return `The file uses describe, it or test without importing them, but ${config} sets injectGlobals to false, so Jest doesn't define them; import them from '@jest/globals'.`;
+}
 /** For a pattern that names a folder, which matches no file, a pattern that matches the test files in it. */
 function folderHint(root, patterns, framework) {
     const folder = patterns.find((pattern) => {
@@ -100,7 +111,7 @@ function noFiles(root, patterns, framework, placements) {
     if ([...placements.values()].some((placement) => placement.config)) {
         return 'No test files were found from the configs in the root.';
     }
-    const name = framework === 'playwright' ? 'Playwright' : 'Vitest';
+    const name = FRAMEWORK_NAMES[framework];
     return `No patterns were given, and no ${name} config is in the root or a folder below it, so there are no test files to find.`;
 }
 /**
@@ -112,7 +123,6 @@ function noFiles(root, patterns, framework, placements) {
 export async function scan(options) {
     const checked = checkObject(options, 'options');
     const patterns = checked.patterns === undefined ? null : checkStrings(checked.patterns, 'options.patterns', true);
-    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');
@@ -123,6 +133,9 @@ 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 framework = checked.framework === undefined
+        ? detectFramework(root, ignore)
+        : checkFramework(checked.framework, 'options.framework');
     // 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);
@@ -216,7 +229,9 @@ export async function scan(options) {
         }
         results.push({ ...result, file: { ...result.file, config } });
     }
-    const missingGlobals = globalsCheck(root, configs, (file) => placements.get(file));
+    const missingGlobals = framework === 'jest'
+        ? (file) => jestGlobals(placements.get(file))
+        : globalsCheck(root, configs, (file) => placements.get(file));
     let globals = null;
     for (const { absolutePath, relativeFilePath } of globalsFiles) {
         const message = missingGlobals(absolutePath);

package/dist/types.d.ts

@@ -11,7 +11,7 @@ type Position = number;
 /** @pattern ^[0-9a-f]{16}$ */
 type Hash = string;
 /** @inline */
-export type Framework = 'playwright' | 'vitest';
+export type Framework = 'playwright' | 'vitest' | 'jest';
 /**
  * The state the runner applies to a test, after describes and file-level calls are taken into account. `notLoaded`:
  * the runner refuses to load the file, so none of its tests run.
@@ -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' | '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 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' | 'describe-throws' | '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;
 };
@@ -242,7 +242,10 @@ export interface SuiteRecord {
     /** Source text of the `test.slow()` condition; null when unconditional or not slow. */
     slowCondition: string | null;
     retries: Count | null;
-    /** Vitest only: milliseconds between retries, from the `retry` object (4.1). */
+    /**
+     * Milliseconds between retries: Vitest's from the `retry` object (4.1), Jest's from `waitBeforeRetry` of
+     * `jest.retryTimes()` (30.0); null otherwise.
+     */
     retryDelay: Count | null;
     /** Vitest only: source text of the `retry` object's `condition`, a RegExp or a function. */
     retryCondition: string | null;
@@ -339,7 +342,10 @@ export interface TestRecord {
     slowCondition: string | null;
     /** How many times the runner retries the test when it fails; null when the file sets none. */
     retries: Count | null;
-    /** Vitest only: milliseconds between retries, from the `retry` object (4.1). */
+    /**
+     * Milliseconds between retries: Vitest's from the `retry` object (4.1), Jest's from `waitBeforeRetry` of
+     * `jest.retryTimes()` (30.0); null otherwise.
+     */
     retryDelay: Count | null;
     /** Vitest only: source text of the `retry` object's `condition`, a RegExp or a function. */
     retryCondition: string | null;

package/dist/values.d.ts

@@ -60,6 +60,8 @@ export declare class Values {
         init: Expression;
         scopes: readonly Node[];
     } | null;
+    /** The name a module exports that a name imported from it stands for, `default` for a default import; null otherwise. */
+    importedName(name: string, scopes: readonly Node[]): string | 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;
     /**
@@ -81,6 +83,14 @@ export declare class Values {
     /** `data.name` where `data` is `import * as data`: what the module exports as `name`; null for any other member. */
     private namespaceMember;
     private imported;
+    /**
+     * How many items a list has when not all its values are known, as `[NaN, Infinity]`: a list written out, its spreads
+     * included, held in a constant the module doesn't change, or the keys, values or entries of an object written out;
+     * null otherwise. `seen` stops at a constant defined through itself.
+     */
+    lengthOf(node: Expression, scopes: readonly Node[], seen?: Set<string>): number | null;
+    /** How many keys an object written out has, held in a constant the module doesn't change; null otherwise. */
+    private keyCount;
     /** 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. */

package/dist/values.js

@@ -1,4 +1,4 @@
-import { childNodes, isFunctionNode, propertyName, unwrap } from "./ast.js";
+import { childNodes, isFunctionNode, propertyKey, propertyName, unwrap } from "./ast.js";
 const UNRESOLVED = { ok: false, importedFrom: null };
 function isPrimitive(value) {
     return typeof value !== 'object' || value === null;
@@ -314,6 +314,11 @@ export class Values {
         const binding = this.lookup(name, scopes)?.binding;
         return binding?.kind === 'const' ? { init: binding.init, scopes: binding.scopes } : null;
     }
+    /** The name a module exports that a name imported from it stands for, `default` for a default import; null otherwise. */
+    importedName(name, scopes) {
+        const binding = this.lookup(name, scopes)?.binding;
+        return binding?.kind === 'import' ? binding.imported : null;
+    }
     /** The module a name is imported from where it is used; null when it isn't an import. */
     importSource(name, scopes) {
         const binding = this.lookup(name, scopes)?.binding;
@@ -421,6 +426,61 @@ export class Values {
         const resolved = name !== null && this.imports ? this.imports(source, name) : UNRESOLVED;
         return resolved.ok ? resolved : { ok: false, importedFrom: source };
     }
+    /**
+     * How many items a list has when not all its values are known, as `[NaN, Infinity]`: a list written out, its spreads
+     * included, held in a constant the module doesn't change, or the keys, values or entries of an object written out;
+     * null otherwise. `seen` stops at a constant defined through itself.
+     */
+    lengthOf(node, scopes, seen = new Set()) {
+        const resolved = this.resolve(node, scopes);
+        if (resolved.ok)
+            return Array.isArray(resolved.value) ? resolved.value.length : null;
+        const expression = unwrap(node);
+        if (expression.type === 'Identifier') {
+            const binding = this.lookup(expression.name, scopes)?.binding;
+            if (binding?.kind !== 'const' || seen.has(expression.name))
+                return null;
+            if (this.changedAtLoad(binding.scopes[0]).has(expression.name))
+                return null;
+            return this.lengthOf(binding.init, binding.scopes, new Set([...seen, expression.name]));
+        }
+        if (expression.type === 'CallExpression' && isObjectListing(expression)) {
+            const target = expression.arguments[0];
+            return this.keyCount(target, scopes, seen);
+        }
+        if (expression.type !== 'ArrayExpression')
+            return null;
+        let length = 0;
+        for (const element of expression.elements) {
+            const inner = element?.type === 'SpreadElement' ? this.lengthOf(element.argument, scopes, seen) : 1;
+            if (inner === null)
+                return null;
+            length += inner;
+        }
+        return length;
+    }
+    /** How many keys an object written out has, held in a constant the module doesn't change; null otherwise. */
+    keyCount(node, scopes, seen) {
+        const expression = unwrap(node);
+        if (expression.type === 'Identifier') {
+            const binding = this.lookup(expression.name, scopes)?.binding;
+            if (binding?.kind !== 'const' || seen.has(expression.name))
+                return null;
+            if (this.changedAtLoad(binding.scopes[0]).has(expression.name))
+                return null;
+            return this.keyCount(binding.init, binding.scopes, new Set([...seen, expression.name]));
+        }
+        if (expression.type !== 'ObjectExpression')
+            return null;
+        const keys = new Set();
+        for (const property of expression.properties) {
+            const key = property.type === 'Property' ? propertyKey(property) : null;
+            if (key === null)
+                return null;
+            keys.add(key);
+        }
+        return keys.size;
+    }
     /** What a name refers to where it is used; `scopes` lists the scope nodes around the use, outermost first. */
     resolveName(name, scopes) {
         const found = this.lookup(name, scopes);
@@ -716,7 +776,33 @@ function collectBindings(scope, scopes) {
                 if (statement.declare)
                     break;
                 for (const declarator of statement.declarations) {
-                    if (statement.kind === 'const' && declarator.id.type === 'Identifier' && declarator.init) {
+                    const required = declarator.init ? localRequire(declarator.init) : null;
+                    if (required !== null && declarator.id.type === 'Identifier') {
+                        // `const symbols = require('./symbols')` stands for what the module exports, as a default import does.
+                        bindings.set(declarator.id.name, {
+                            kind: 'import',
+                            source: required,
+                            imported: 'default',
+                            declaration: declarator,
+                        });
+                    }
+                    else if (required !== null && declarator.id.type === 'ObjectPattern') {
+                        for (const property of declarator.id.properties) {
+                            const key = property.type === 'Property' ? propertyKey(property) : null;
+                            if (key !== null && property.type === 'Property' && property.value.type === 'Identifier') {
+                                bindings.set(property.value.name, {
+                                    kind: 'import',
+                                    source: required,
+                                    imported: key,
+                                    declaration: declarator,
+                                });
+                            }
+                            else {
+                                other(bindingNames(property.type === 'Property' ? property.value : property), declarator);
+                            }
+                        }
+                    }
+                    else if (statement.kind === 'const' && declarator.id.type === 'Identifier' && declarator.init) {
                         bindings.set(declarator.id.name, { kind: 'const', init: declarator.init, scopes, declaration: declarator });
                     }
                     else {
@@ -783,3 +869,22 @@ function collectBindings(scope, scopes) {
     }
     return bindings;
 }
+/** `Object.keys(x)`, `Object.values(x)` or `Object.entries(x)`, which list as many items as `x` has keys. */
+function isObjectListing(call) {
+    const callee = unwrap(call.callee);
+    return (callee.type === 'MemberExpression' &&
+        callee.object.type === 'Identifier' &&
+        callee.object.name === 'Object' &&
+        ['keys', 'values', 'entries'].includes(propertyName(callee)) &&
+        call.arguments.length === 1 &&
+        call.arguments[0].type !== 'SpreadElement');
+}
+/** The local file `require('./symbols')` loads, as an import of it; null for a package or any other expression. */
+function localRequire(expression) {
+    const node = unwrap(expression);
+    if (node.type !== 'CallExpression' || node.callee.type !== 'Identifier' || node.callee.name !== 'require')
+        return null;
+    const [argument] = node.arguments;
+    const isLocal = argument.type === 'Literal' && typeof argument.value === 'string' && /^\.\.?\//.test(argument.value);
+    return isLocal ? argument.value : null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-inventory",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Test metadata from source code, not from test results.",
   "keywords": [
     "testing",

package/schema/v1.json

@@ -98,7 +98,8 @@
           "type": "string",
           "enum": [
             "playwright",
-            "vitest"
+            "vitest",
+            "jest"
           ]
         },
         {
@@ -607,7 +608,7 @@
               "type": "null"
             }
           ],
-          "description": "Vitest only: milliseconds between retries, from the `retry` object (4.1)."
+          "description": "Milliseconds between retries: Vitest's from the `retry` object (4.1), Jest's from `waitBeforeRetry` of `jest.retryTimes()` (30.0); null otherwise."
         },
         "retryCondition": {
           "type": [
@@ -1025,7 +1026,7 @@
               "type": "null"
             }
           ],
-          "description": "Vitest only: milliseconds between retries, from the `retry` object (4.1)."
+          "description": "Milliseconds between retries: Vitest's from the `retry` object (4.1), Jest's from `waitBeforeRetry` of `jest.retryTimes()` (30.0); null otherwise."
         },
         "retryCondition": {
           "type": [
@@ -1449,6 +1450,7 @@
             "test-without-body",
             "describe-not-called",
             "async-describe",
+            "describe-throws",
             "nested-test",
             "tag-without-at",
             "removed-api",