test-inventory 0.4.1 → 0.6.0

package/dist/scan.js

@@ -1,11 +1,16 @@
-import { existsSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 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 { DependencyGraph } from "./dependency-hash.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, } from "./options.js";
+import { checkComments, 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";
@@ -46,14 +51,66 @@ function folderHint(root, patterns, framework) {
     const example = `${folder.slice(0, end)}/**/*.${framework === 'playwright' ? 'spec' : 'test'}.ts`;
     return ` "${folder}" is a folder; to scan the test files in it, use a pattern such as "${example}".`;
 }
+/** The JavaScript and TypeScript files the runners read, which the configs choose the test files from. */
+const SCRIPT_FILES = '**/*.{js,jsx,ts,tsx,mjs,mjsx,mts,mtsx,cjs,cjsx,cts,ctsx}';
+/** Whether an error says a file or folder isn't there, as a snapshot isn't before a test first writes it. */
+function isMissing(error) {
+    return error.code === 'ENOENT';
+}
+/**
+ * The files in a folder of the project and the folders in it, linked files too, as paths in the folder with `/`;
+ * none for no folder.
+ */
+function filesIn(root, folder) {
+    const base = path.join(root, folder);
+    try {
+        return readdirSync(base, { recursive: true, withFileTypes: true })
+            .filter((entry) => entry.isFile() || (entry.isSymbolicLink() && isFile(path.join(entry.parentPath, entry.name))))
+            .map((entry) => toPosixPath(path.relative(base, path.join(entry.parentPath, entry.name))))
+            .sort();
+    }
+    catch (error) {
+        return isMissing(error) ? [] : 'unreadable';
+    }
+}
+function isFile(file) {
+    try {
+        return statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** A file's bytes, from the project root; null when there is none. */
+function bytesOf(root, file) {
+    try {
+        return readFileSync(path.join(root, file));
+    }
+    catch (error) {
+        return isMissing(error) ? null : 'unreadable';
+    }
+}
+/** Why a scan found no test files: what the patterns matched, or whether there is a config to find them from. */
+function noFiles(root, patterns, framework, placements) {
+    if (patterns) {
+        const list = patterns.map((pattern) => `"${pattern}"`).join(', ');
+        return `No test files match ${list} in the root.${folderHint(root, patterns, framework)}`;
+    }
+    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';
+    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.`;
+}
 /**
- * Scans the test files that match `patterns` under `root`, one file at a time.
+ * Scans the test files that match `patterns` under `root`, or without patterns those the configs run, one file at a
+ * time.
  *
  * Throws a `TypeError` for invalid options. Problems with files and code are reported as diagnostics.
  */
 export async function scan(options) {
     const checked = checkObject(options, 'options');
-    const patterns = checkStrings(checked.patterns, 'options.patterns', true);
+    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');
@@ -73,45 +130,101 @@ export async function scan(options) {
         : majorMinor(frameworkVersion);
     const source = override === null ? (detected?.source ?? 'package.json') : '.';
     const projectDiagnostics = versionDiagnostics(framework, frameworkVersion, source, range);
-    const found = await findFiles(root, patterns, ignore, framework);
+    // 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);
-    if (found.files.length === 0) {
-        const list = patterns.map((pattern) => `"${pattern}"`).join(', ');
-        const message = `No test files match ${list} in the root.${folderHint(root, patterns, framework)}`;
-        projectDiagnostics.push(fileDiagnostic('no-files-matched', '.', message));
-    }
     const readerFor = moduleResolver(root);
+    const graph = new DependencyGraph();
+    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)]));
+    const files = patterns ? found.files : found.files.filter((file) => placements.get(file.absolutePath)?.runs);
+    // A setup project's files may be outside the patterns, or ignored for the scan, so they are looked for in its testDir.
+    const setupDirs = new Set();
+    for (const { config, projects } of placements.values()) {
+        const seen = new Set();
+        const names = (projects ?? []).flatMap((project) => project.dependencies);
+        for (let name = names.pop(); config && name !== undefined; name = names.pop()) {
+            const project = seen.has(name) ? null : runs.projectNamed(config, name);
+            seen.add(name);
+            if (!project)
+                continue;
+            setupDirs.add(project.about.testDir);
+            names.push(...project.about.dependencies);
+        }
+    }
+    // Searched from the folder itself, as a folder named like `(auth)` would be read as a glob in a pattern.
+    const setupFiles = await Promise.all([...setupDirs].map((folder) => glob(SCRIPT_FILES, { cwd: folder, absolute: true, ignore: ['**/node_modules/**'] })));
+    const candidates = setupFiles.flat().map((file) => path.resolve(file));
+    const configDependencies = new ConfigDependencies(framework, runs, readerFor, candidates);
+    // Many tests of a file compare against one folder, so each is listed once.
+    const listed = new Map();
+    const list = (folder) => {
+        if (!listed.has(folder))
+            listed.set(folder, filesIn(root, folder));
+        return listed.get(folder);
+    };
+    const snapshotFiles = { framework, list, read: (file) => bytesOf(root, file) };
+    const notRun = [];
     const results = [];
     const globalsFiles = [];
-    for (const { absolutePath, relativeFilePath } of found.files) {
+    for (const { absolutePath, relativeFilePath } of files) {
+        const placement = placements.get(absolutePath);
+        if (placement.config)
+            configs.use(placement.config);
+        const config = placement.config?.record.relativeFilePath ?? null;
         let code;
         try {
             code = await readFile(absolutePath, 'utf8');
         }
         catch (error) {
+            const records = noRecords(relativeFilePath);
             results.push({
-                ...noRecords(relativeFilePath),
+                ...records,
+                file: { ...records.file, config },
                 diagnostics: [
                     fileDiagnostic('read-error', relativeFilePath, `The file could not be read: ${readFailure(error)}.`),
                 ],
             });
             continue;
         }
+        const runsWith = configDependencies.of(placement);
         const result = scanFile(code, relativeFilePath, {
             framework,
             version: rules,
             comments,
             readModule: readerFor(absolutePath),
             root,
+            isBenchmarkFile: placement.runs === null ? null : placement.runs === 'benchmark',
+            config: fileConfig(placement, framework, rules, absolutePath),
+            graph,
+            runsWith,
+            snapshotFiles: { ...snapshotFiles, moved: runsWith.moved },
         });
         if (result.usesGlobals)
             globalsFiles.push({ absolutePath, relativeFilePath });
-        results.push(result);
+        // A file without tests that no config runs, such as a source file a broad pattern matches, misses nothing.
+        if (placement.runs === false && result.tests.length > 0) {
+            const message = `The file has tests, but no config in its folder or above runs it, so the runner doesn't collect them; the nearest config is ${config}.`;
+            notRun.push(fileDiagnostic('file-not-run', relativeFilePath, message));
+        }
+        results.push({ ...result, file: { ...result.file, config } });
+    }
+    const missingGlobals = globalsCheck(root, configs, (file) => placements.get(file));
+    let globals = null;
+    for (const { absolutePath, relativeFilePath } of globalsFiles) {
+        const message = missingGlobals(absolutePath);
+        if (message === null)
+            continue;
+        globals = fileDiagnostic('globals-not-enabled', relativeFilePath, message);
+        break;
     }
-    const enabled = globalsCheck(root);
-    const globalsFile = globalsFiles.find((file) => !enabled(file.absolutePath))?.relativeFilePath;
-    if (globalsFile !== undefined) {
-        projectDiagnostics.push(fileDiagnostic('globals-not-enabled', globalsFile, "The file uses Vitest's global test functions, but no Vitest or Vite config with globals: true and no tsconfig with vitest/globals was found."));
+    projectDiagnostics.push(...configs.diagnostics, ...notRun, ...(globals ? [globals] : []));
+    // After the config warnings, which may say why no file was found.
+    if (files.length === 0) {
+        projectDiagnostics.push(fileDiagnostic('no-files-matched', '.', noFiles(root, patterns, framework, placements)));
     }
-    return createInventory(framework, frameworkVersion, found.files.length, results, projectDiagnostics);
+    const fileCount = files.length;
+    const records = configs.records((config) => runs.projectsIn(config));
+    return createInventory(framework, frameworkVersion, fileCount, results, projectDiagnostics, records);
 }

package/dist/types.d.ts

@@ -20,18 +20,25 @@ export type Framework = 'playwright' | 'vitest';
  */
 export type TestState = 'active' | 'skip' | 'fixme' | 'todo' | 'expectedToFail' | 'notLoaded';
 /**
- * Where a test's state is set: on the test, on a describe around it, or at file level.
+ * Where a test's state is set: on the test, on a describe around it, at file level, or by a Vitest tag the config
+ * defines.
  *
  * @inline
  */
-export type StateSource = 'test' | 'suite' | 'file';
+export type StateSource = 'test' | 'suite' | 'file' | 'config';
+/**
+ * Where a test's run setting comes from: the test, a describe around it, the file, or the config its file uses.
+ *
+ * @inline
+ */
+export type SettingSource = 'test' | 'suite' | 'file' | 'config';
 /**
  * `error`: tests may be missing from the output. `warning`: a value is missing or approximate.
  *
  * @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' | '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';
+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 MetaValue = string | number | boolean | null | MetaValue[] | {
     [key: string]: MetaValue;
 };
@@ -45,6 +52,8 @@ export interface Inventory {
     /** Read from the project, or given with `--framework-version`; null when unknown. */
     frameworkVersion: string | null;
     summary: Summary;
+    /** The configs the scanned files use, sorted by path. */
+    configs: ConfigRecord[];
     /** One per scanned file, in the order the files were scanned. */
     files: FileRecord[];
     suites: SuiteRecord[];
@@ -53,12 +62,14 @@ export interface Inventory {
 }
 /**
  * One line of the JSON Lines output (`--format jsonl`): the inventory with each record on its own line, marked by
- * `type`. The `inventory` line comes first, then the files, suites, tests and diagnostics in the order of the JSON
- * output, and the `summary` line last.
+ * `type`. The `inventory` line comes first, then the configs, files, suites, tests and diagnostics in the order of the
+ * JSON output, and the `summary` line last.
  */
 export type InventoryLine = ({
     type: 'inventory';
 } & Pick<Inventory, 'schemaVersion' | 'tool' | 'framework' | 'frameworkVersion'>) | ({
+    type: 'config';
+} & ConfigRecord) | ({
     type: 'file';
 } & FileRecord) | ({
     type: 'suite';
@@ -103,11 +114,40 @@ export interface Summary {
     /** Tests per annotation type. */
     annotationCounts: Record<string, Count>;
 }
+/**
+ * A Playwright or Vitest config that scanned files use: the nearest one in a file's folder or a folder above it, up to
+ * the root, as the runner started in that folder would. Read as code, never run.
+ */
+export interface ConfigRecord {
+    /** Path from the project root, with `/` separators. */
+    relativeFilePath: string;
+    /** Files the config takes settings from through imports, such as a shared base config, in the order read. */
+    extends: string[];
+    /**
+     * The projects the config runs tests in: Playwright's `projects`, or one for a config without them; Vitest's, with
+     * each browser instance as one. Null when the scan can't work them out.
+     */
+    projects: ProjectRecord[] | null;
+}
+/** @inline */
+export interface ProjectRecord {
+    /** As the runner names it: `''` for a project without a name. */
+    name: string;
+    /** The folder the project's test files are found in, from the project root: Playwright's `testDir`, Vitest's `dir`. */
+    testDir: string;
+    /** Playwright's projects that run before this one; `[]` for Vitest. */
+    dependencies: string[];
+}
 /** A scanned file, also one that has no tests or could not be read. */
 export interface FileRecord {
     /** Path from the project root, with `/` separators. */
     relativeFilePath: string;
     fileName: string;
+    /**
+     * The config the file uses, from the project root: the outermost config at or above it that runs it, as the runner
+     * started at the root would, else the nearest. Null when there is none.
+     */
+    config: string | null;
     /** Hooks at the top level of the file, which run around every test in it. */
     hooks: HookCounts;
     suiteCount: Count;
@@ -210,6 +250,16 @@ export interface TestRecord {
     id: Hash;
     /** Hash of the test body, ignoring whitespace and comments; null when the test has no body. */
     bodyHash: Hash | null;
+    /**
+     * Hash of everything the test runs in the project: its call, the hooks, options and code of the file and of every
+     * describe around it, and the functions, classes, constants and modules these use, followed through imports. Ignores
+     * whitespace and comments. Installed packages are not in it.
+     */
+    dependencyHash: Hash;
+    /** The files that went into `dependencyHash`, the test's own included, sorted, with `/` separators. */
+    dependencies: string[];
+    /** Something the test reaches couldn't be followed, so a change there doesn't change `dependencyHash`. */
+    hasUnfollowedDependencies: boolean;
     /** The nearest describe; null outside any describe. */
     suiteId: Hash | null;
     /** Titles of the describes around the test, outermost first. */
@@ -275,7 +325,7 @@ export interface TestRecord {
     hooks: HookCounts;
     /**
      * In milliseconds: the last `test.setTimeout()` in the body or a `beforeEach`, otherwise the nearest describe or file
-     * that sets one. Null when the file sets none, so the config's timeout applies.
+     * that sets one, otherwise the config. Null when none sets it, so the runner's default applies.
      */
     timeout: Count | null;
     /** Playwright `test.slow()` applies: the runner triples the timeout. */
@@ -288,8 +338,29 @@ export interface TestRecord {
     retryDelay: Count | null;
     /** Vitest only: source text of the `retry` object's `condition`, a RegExp or a function. */
     retryCondition: string | null;
-    /** Vitest only: how many times the runner runs the test again after the first run. */
+    /**
+     * How many times the runner runs the test again after the first run: Vitest's `repeats`, or Playwright's `repeatEach`
+     * from the config less one.
+     */
     repeats: Count | null;
+    /**
+     * Where `timeout` comes from; null when nothing sets it. A null `timeout` from the config means the config sets it, but
+     * its projects set different values or the value depends on a condition, as in `process.env.CI ? 2 : 0`.
+     */
+    timeoutSource: SettingSource | null;
+    /** Where `retries`, `retryDelay` and `retryCondition` come from, read as `timeoutSource` is. */
+    retriesSource: SettingSource | null;
+    /** Where `repeats` comes from, read as `timeoutSource` is. */
+    repeatsSource: SettingSource | null;
+    /**
+     * The config's source text for `timeout` when the config sets it under a condition, as in
+     * `process.env.CI ? 60_000 : 30_000`, shortened when long; null otherwise.
+     */
+    timeoutConfigText: string | null;
+    /** The config's source text for `retries`, read as `timeoutConfigText` is. */
+    retriesConfigText: string | null;
+    /** The config's source text for `repeats`, Playwright's `repeatEach`, read as `timeoutConfigText` is. */
+    repeatsConfigText: string | null;
     /**
      * Names the test function takes from its context, then those of the `beforeEach`, `afterEach` and `aroundEach` hooks
      * around it, once each. Vitest's own context keys, such as `expect` and `task`, are left out.
@@ -320,6 +391,11 @@ export interface TestRecord {
     isInCondition: boolean;
     /** Declared inside a plain function. */
     isInFunction: boolean;
+    /**
+     * Names of the projects that run the test, of the config its file uses, after each project's files and Playwright's
+     * `grep` and `grepInvert`. `[]` when no project runs it; null when there is no config, or the scan can't tell.
+     */
+    projects: string[] | null;
 }
 /** @inline */
 export interface Step {

package/dist/values.d.ts

@@ -36,6 +36,11 @@ export declare class Values {
      * the file does not declare it, as with globals.
      */
     declarationOf(name: string, scopes: readonly Node[]): Node | null;
+    /** The value a `const` name is declared with, and the scopes around that declaration; null for any other name. */
+    constantOf(name: string, scopes: readonly Node[]): {
+        init: Expression;
+        scopes: readonly Node[];
+    } | 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 function or class declared in the file. */

package/dist/values.js

@@ -208,6 +208,11 @@ export class Values {
     declarationOf(name, scopes) {
         return this.lookup(name, scopes)?.binding.declaration ?? null;
     }
+    /** The value a `const` name is declared with, and the scopes around that declaration; null for any other name. */
+    constantOf(name, scopes) {
+        const binding = this.lookup(name, scopes)?.binding;
+        return binding?.kind === 'const' ? { init: binding.init, scopes: binding.scopes } : 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;

package/dist/vitest-config.d.ts

@@ -1,6 +1,8 @@
+import type { Placement } from './config-runs.ts';
+import { type Configs } from './config.ts';
 /**
- * Returns a check of whether Vitest's globals are turned on for a file, by a config in its folder or any folder
- * above it up to the root, as in a monorepo where each package has its own config. Config files are read as code and
- * never run.
+ * Returns a check of whether Vitest's globals are turned on for a file: by the project of the config it uses, or by a
+ * tsconfig in its folder or any folder above it up to the root. The check gives the message to report when they are
+ * not, and null when they are or may be. Config files are read as code, never run.
  */
-export declare function globalsCheck(root: string): (file: string) => boolean;
+export declare function globalsCheck(root: string, configs: Configs, placementOf: (file: string) => Placement): (file: string) => string | null;

package/dist/vitest-config.js

@@ -1,19 +1,6 @@
 import { readdirSync, readFileSync } from 'node:fs';
 import path from 'node:path';
-import { childNodes } from "./ast.js";
-import { parseFile } from "./parse.js";
-const CONFIG_FILES = ['vitest.config', 'vite.config'].flatMap((name) => ['.ts', '.mts', '.cts', '.js', '.mjs', '.cjs'].map((extension) => name + extension));
-function setsGlobals(node) {
-    if (node.type === 'Property' &&
-        !node.computed &&
-        ((node.key.type === 'Identifier' && node.key.name === 'globals') ||
-            (node.key.type === 'Literal' && node.key.value === 'globals')) &&
-        node.value.type === 'Literal' &&
-        node.value.value === true) {
-        return true;
-    }
-    return childNodes(node).some(setsGlobals);
-}
+import { settingAt } from "./config.js";
 /** A file's text, or null when it is missing or can't be read. */
 function readText(file) {
     try {
@@ -23,13 +10,8 @@ function readText(file) {
         return null;
     }
 }
-/** Whether a folder has a Vitest or Vite config with `globals: true`, or a tsconfig with `vitest/globals`. */
-function enablesGlobals(directory) {
-    for (const name of CONFIG_FILES) {
-        const code = readText(path.join(directory, name));
-        if (code !== null && setsGlobals(parseFile(name, code).program))
-            return true;
-    }
+/** Whether a folder has a tsconfig with `vitest/globals` in its types. */
+function typesGlobals(directory) {
     let names;
     try {
         names = readdirSync(directory);
@@ -39,21 +21,43 @@ function enablesGlobals(directory) {
     }
     return names.some((name) => /^tsconfig.*\.json$/.test(name) && (readText(path.join(directory, name)) ?? '').includes('"vitest/globals"'));
 }
+const ASSUMED = "files that use Vitest's global test functions are taken to have them";
+/** Whether a project's settings turn Vitest's globals on; null when the scan can't tell. */
+function turnsOnGlobals(settings, configs) {
+    // A project the scan can't work out was reported where its files were asked for.
+    if (settings.kind === 'unknown')
+        return null;
+    const globals = settingAt(settings, ['test', 'globals']);
+    if (globals?.kind !== 'unknown')
+        return globals?.kind === 'value' && globals.value === true;
+    configs.reportUnknown(globals, 'test.globals', ASSUMED);
+    return null;
+}
 /**
- * Returns a check of whether Vitest's globals are turned on for a file, by a config in its folder or any folder
- * above it up to the root, as in a monorepo where each package has its own config. Config files are read as code and
- * never run.
+ * Returns a check of whether Vitest's globals are turned on for a file: by the project of the config it uses, or by a
+ * tsconfig in its folder or any folder above it up to the root. The check gives the message to report when they are
+ * not, and null when they are or may be. Config files are read as code, never run.
  */
-export function globalsCheck(root) {
+export function globalsCheck(root, configs, placementOf) {
     const known = new Map();
-    const enabled = (directory) => {
+    const typed = (directory) => {
         let result = known.get(directory);
         if (result === undefined) {
             const parent = path.dirname(directory);
-            result = enablesGlobals(directory) || (directory !== root && parent !== directory && enabled(parent));
+            result = typesGlobals(directory) || (directory !== root && parent !== directory && typed(parent));
             known.set(directory, result);
         }
         return result;
     };
-    return (file) => enabled(path.dirname(file));
+    return (file) => {
+        if (typed(path.dirname(file)))
+            return null;
+        const { config, settings } = placementOf(file);
+        if (config && settings && turnsOnGlobals(settings, configs) !== false)
+            return null;
+        const why = config
+            ? `${config.record.relativeFilePath} doesn't set test.globals to true for it`
+            : 'no Vitest or Vite config was found';
+        return `The file uses Vitest's global test functions, but ${why} and no tsconfig has vitest/globals in its types.`;
+    };
 }

package/dist/vitest-defaults.d.ts

@@ -0,0 +1,6 @@
+/** Vitest's default file settings, as `configDefaults` in `vitest/config` holds them. */
+export declare const VITEST_INCLUDE: string[];
+export declare const VITEST_TYPECHECK_INCLUDE: string[];
+export declare const VITEST_BENCHMARK_INCLUDE: string[];
+/** Vitest's default `exclude`: Vitest 4 left out the folders and tool configs that Vitest 3 excludes. */
+export declare function vitestExclude(version: [number, number] | null): string[];

package/dist/vitest-defaults.js

@@ -0,0 +1,16 @@
+/** Vitest's default file settings, as `configDefaults` in `vitest/config` holds them. */
+export const VITEST_INCLUDE = ['**/*.{test,spec}.?(c|m)[jt]s?(x)'];
+export const VITEST_TYPECHECK_INCLUDE = ['**/*.{test,spec}-d.?(c|m)[jt]s?(x)'];
+export const VITEST_BENCHMARK_INCLUDE = ['**/*.{bench,benchmark}.?(c|m)[jt]s?(x)'];
+/** Vitest's default `exclude`: Vitest 4 left out the folders and tool configs that Vitest 3 excludes. */
+export function vitestExclude(version) {
+    if (version === null || version[0] >= 4)
+        return ['**/node_modules/**', '**/.git/**'];
+    return [
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/cypress/**',
+        '**/.{idea,git,cache,output,temp}/**',
+        '**/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*',
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-inventory",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "Test metadata from source code, not from test results.",
   "keywords": [
     "testing",
@@ -79,7 +79,8 @@
     "changeset": "changeset"
   },
   "dependencies": {
-    "oxc-parser": "0.154.0",
+    "oxc-parser": "0.156.0",
+    "picomatch": "^4.0.7",
     "tinyglobby": "^0.2.17"
   },
   "devDependencies": {
@@ -87,19 +88,20 @@
     "@changesets/changelog-github": "^1.0.1",
     "@changesets/cli": "^3.0.3",
     "@types/node": "~22.12.0",
-    "@vitest/coverage-v8": "5.0.4",
+    "@types/picomatch": "^4.0.3",
+    "@vitest/coverage-v8": "5.0.5",
     "ajv": "^8.20.0",
-    "eslint": "~10.12.0",
+    "eslint": "~10.13.0",
     "prettier": "3.9.10",
     "publint": "^0.3.25",
     "ts-json-schema-generator": "2.9.0",
     "typedoc": "^0.28.20",
-    "typedoc-plugin-markdown": "^4.13.1",
+    "typedoc-plugin-markdown": "^4.14.1",
     "typedoc-vitepress-theme": "^1.1.4",
     "typescript": "~6.0.3",
-    "typescript-eslint": "~8.71.2",
-    "vitepress": "2.0.0-alpha.20",
+    "typescript-eslint": "~8.72.1",
+    "vitepress": "2.0.0-alpha.21",
     "vitepress-plugin-llms": "^1.14.0",
-    "vitest": "5.0.4"
+    "vitest": "5.0.5"
   }
 }