test-inventory 0.6.0 → 0.6.1

package/dist/config.js

@@ -140,6 +140,68 @@ function spread(base, over, at) {
         return { kind: 'object', keys: new Map(over.keys), rest: over.rest };
     return { kind: 'object', keys: new Map([...base.keys, ...over.keys]), rest: base.rest };
 }
+/** `{ ...a, ...b }` of two objects either of which may be unset, as Playwright merges `use` and `expect`. */
+function assign(a, b, at) {
+    return [a, b].reduce((merged, over) => (over ? spread(merged, over, at) : merged), emptyObject());
+}
+/**
+ * Playwright's `defineConfig(base, over)`: `over`'s keys replace `base`'s, but `expect`, `use` and `build` merge key by
+ * key, and `projects` by name. `webServer`, whose lists Playwright joins, isn't read.
+ */
+function playwrightMerge(base, over, at) {
+    const merged = spread(base, over, at);
+    if (over.kind !== 'object' || over.rest)
+        return merged;
+    for (const key of ['expect', 'use', 'build']) {
+        if (merged.keys.has(key))
+            merged.keys.set(key, assign(child(base, key), child(over, key), at));
+    }
+    const overrides = child(over, 'projects');
+    // Without projects of its own, `over` keeps those of `base`; with `projects: undefined`, it drops them.
+    if (overrides === null || isNullish(overrides))
+        return merged;
+    const projects = child(base, 'projects');
+    const items = projects === null || isNullish(projects) ? [] : projects.kind === 'list' ? projects.items : null;
+    const isKnown = items !== null && overrides.kind === 'list';
+    merged.keys.set('projects', isKnown ? mergeProjects(items, overrides.items, at) : unknown(at));
+    return merged;
+}
+/**
+ * Playwright's projects of a config with those of a config over it merged in by name, with their `use` key by key; the
+ * others are added after, the last of each name. Unknown when the scan can't tell a project's name.
+ */
+function mergeProjects(base, overrides, at) {
+    const byName = new Map();
+    for (const project of overrides) {
+        const name = projectName(project);
+        if (name === null)
+            return unknown(at);
+        byName.set(name, project);
+    }
+    const projects = [];
+    for (const project of base) {
+        const name = projectName(project);
+        if (name === null)
+            return unknown(at);
+        const override = byName.get(name);
+        byName.delete(name);
+        if (!override) {
+            projects.push(project);
+            continue;
+        }
+        const merged = spread(spread(emptyObject(), project, at), override, at);
+        merged.keys.set('use', assign(child(project, 'use'), child(override, 'use'), at));
+        projects.push(merged);
+    }
+    return { kind: 'list', items: [...projects, ...byName.values()] };
+}
+/** The name Playwright merges a project by: undefined when unset, null when the scan can't tell. */
+function projectName(project) {
+    const name = child(project, 'name');
+    if (name === null || (name.kind === 'value' && name.value === undefined))
+        return undefined;
+    return name.kind === 'value' && typeof name.value === 'string' ? name.value : null;
+}
 /**
  * One of two settings, as the two sides of a condition: what both agree on is known, and the rest is unknown at `at`,
  * where the condition is written. Null is a setting neither side sets.
@@ -479,9 +541,9 @@ class ConfigCode {
             // Vitest's defineConfig() and defineProject() return the config they are given, or the one a function returns.
             return isFunctionNode(args[0]) ? this.returned(args[0], frame, scopes) : this.evaluate(args[0], frame, scopes);
         }
-        // Playwright's defineConfig() merges the configs it is given, each over the ones before it. It also merges their
-        // `use`, `expect`, `build`, `webServer` and `projects`, which the scan doesn't read yet.
-        return args.reduce((merged, arg) => spread(merged, this.evaluate(arg, frame, scopes), { frame, node: arg }), emptyObject());
+        // Playwright's defineConfig() merges the configs it is given, each over the ones before it.
+        const [first, ...others] = args;
+        return others.reduce((merged, arg) => playwrightMerge(merged, this.evaluate(arg, frame, scopes), { frame, node: arg }), spread(emptyObject(), this.evaluate(first, frame, scopes), { frame, node: first }));
     }
     /**
      * Where a function a config calls comes from: `name` of `import { name } from 'module'` or

package/dist/dependency-hash.d.ts

@@ -2,17 +2,20 @@ import { type Node } from 'oxc-parser';
 import type { ConfigGap, RunsWith } from './config-dependencies.ts';
 import type { Extraction, Frame, PendingTest } from './extract.ts';
 import type { ModuleReader, ModuleSource, Problem, Span } from './model.ts';
-import type { ParsedFile } from './parse.ts';
+import { type ParsedFile } from './parse.ts';
 import { type SourceText } from './source.ts';
 import type { Framework } from './types.ts';
 import { Values } from './values.ts';
 /** A file whose code a test can run: the scanned file, a module it imports, or a data file such as JSON. */
 interface Module {
     relativeFilePath: string;
-    /** Null for a file that isn't JavaScript or TypeScript, which is taken by its text. */
+    /** Null for a file that isn't JavaScript or TypeScript, which is taken by its text; for a component, its scripts. */
     parsed: ParsedFile | null;
-    /** The file's text with line endings read as `\n`, for a file that isn't code. */
-    text: string | null;
+    /**
+     * The file's text with line endings read as `\n`, for a file that isn't code or a component; its bytes when it isn't
+     * UTF-8 text, such as an image.
+     */
+    text: string | Uint8Array | null;
     values: Values;
     readModule: ModuleReader | null;
     /** Its top-level code that runs when it is imported, and the modules it imports, which run then too. */
@@ -191,6 +194,11 @@ export declare class DependencyGraph {
      * takes the whole module, so that nothing it may run is left out.
      */
     private exported;
+    /**
+     * A name a module passes on from another, as `export { quote } from './nasdaq'` does, with the re-export itself: which
+     * module the name comes from is code too, so the barrel is among the files a change to which affects the test.
+     */
+    private passedOn;
     /** What `export * from source` gives for a name; null when the module behind it doesn't export it. */
     private reexported;
     /**

package/dist/dependency-hash.js

@@ -4,6 +4,7 @@ import { childNodes, isFunctionNode, propertyKey, unwrap } from "./ast.js";
 import { exportName, parseModule } from "./frameworks/bindings.js";
 import { destructuredNames, problem, takesWhole } from "./frameworks/common.js";
 import { shortHash, hashNodes } from "./hash.js";
+import { parseFile } from "./parse.js";
 import { snippet } from "./source.js";
 import { bindingNames, isScopeNode, Values } from "./values.js";
 /** Statements that only declare something, unless code in them runs while they are evaluated. */
@@ -157,6 +158,50 @@ function isAutoOption(property) {
         property.value.value === true);
 }
 const CODE_FILE = /\.[cm]?[jt]sx?$/;
+/** A Vue or Svelte single-file component: markup with its code in `<script>` blocks. */
+const COMPONENT_FILE = /\.(?:vue|svelte)$/;
+/**
+ * A comment, which may hold a `<script>` that isn't one, or a script block with its attributes and code. An attribute
+ * may hold `>`, as Svelte's `generics="T extends Record<string, number>"` does. Both end where HTML ends them: a
+ * comment also at `--!>`, a script at `</script` with anything before its `>`.
+ */
+const COMPONENT_BLOCK = /<!--[\s\S]*?--!?>|<script\b((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*?)<\/script(?:[\s/][^>]*)?>/gi;
+/**
+ * A file's bytes with line endings as `\n`, as git may check out a text file with either; one git takes for binary, with
+ * a NUL byte in its first 8,000, stays as it is.
+ */
+function withLineFeeds(bytes) {
+    if (bytes.subarray(0, 8000).includes(0))
+        return bytes;
+    // Latin-1 maps each byte to one character and back, so only the line endings change.
+    return Buffer.from(Buffer.from(bytes).toString('latin1').replace(/\r\n?/g, '\n'), 'latin1');
+}
+/** Whether a script block holds code: one with a `type` other than a JavaScript one, as JSON-LD, holds data. */
+function isScriptCode(attributes) {
+    const type = /(?:^|\s)type\s*=\s*["']?([^"'\s>]*)/i.exec(attributes)?.[1] ?? '';
+    return /^(?:module|(?:text|application)\/(?:java|ecma)script)?$/i.test(type);
+}
+/**
+ * A component's script blocks as one module, the rest of the file blanked so that offsets stay those of the file, and
+ * a file name for the language they are in: `lang="ts"` is TypeScript, no `lang` JavaScript.
+ */
+function componentScript(code) {
+    // A byte order mark stays, for the parser to leave out as it does from any file.
+    const blank = (text) => text.replace(/[^\r\n\uFEFF]/g, ' ');
+    let script = '';
+    let end = 0;
+    let lang = 'js';
+    for (const match of code.matchAll(COMPONENT_BLOCK)) {
+        const [whole, attributes, body] = match;
+        if (whole.startsWith('<!--') || !isScriptCode(attributes))
+            continue;
+        const start = match.index + '<script'.length + attributes.length + 1;
+        script += blank(code.slice(end, start)) + body;
+        end = start + body.length;
+        lang = /(?:^|\s)lang\s*=\s*["']?(\w+)/.exec(attributes)?.[1] ?? lang;
+    }
+    return { fileName: `component.${lang}`, code: script + blank(code.slice(end)) };
+}
 const DECLARATION_FILE = /\.d\.[cm]?ts$/;
 /**
  * What an import being looked up stands for while the lookup leads back to it, through re-exports: nothing found
@@ -469,7 +514,8 @@ export class DependencyGraph {
     hashOf(unit) {
         if (unit.hash === undefined) {
             if (unit.module.text !== null) {
-                unit.hash = shortHash(unit.module.text);
+                // Counted once, through the unit of all of it, however many of a component's units a test reaches.
+                unit.hash = unit.module.whole.includes(unit) ? shortHash(unit.module.text) : null;
             }
             else {
                 const cut = [...unit.cut].map(([start, end]) => ({ start, end }));
@@ -490,7 +536,12 @@ export class DependencyGraph {
                 this.modules.set(parsed, module);
             }
             else {
-                module = this.newModule(source.relativeFilePath, null, source.code.replace(/\r\n?/g, '\n'), new Values(), null);
+                const text = source.bytes ? withLineFeeds(source.bytes) : source.code.replace(/\r\n?/g, '\n');
+                // A component's markup and styles shape what it renders, so it is taken by its text, and its scripts are
+                // followed for the modules they import.
+                const script = COMPONENT_FILE.test(source.relativeFilePath) ? componentScript(source.code) : null;
+                const parsed = script && parseFile(script.fileName, script.code);
+                module = this.newModule(source.relativeFilePath, parsed, text, new Values(), parsed && source.readModule);
             }
             this.modules.set(source, module);
         }
@@ -572,7 +623,7 @@ export class DependencyGraph {
     importUnit(module, statement, specifier) {
         let unit = this.imports.get(specifier);
         if (!unit) {
-            const roots = [statement.source, specifier].map((node) => ({ node, scopes: [] }));
+            const roots = [...new Set([statement.source, specifier])].map((node) => ({ node, scopes: [] }));
             unit = this.newUnit(module, roots, new Map(), false);
             unit.edges = new Set();
             this.imports.set(specifier, unit);
@@ -682,8 +733,12 @@ export class DependencyGraph {
             ];
         }
         if (module.parsed.error) {
-            return [this.placeUnit(from, at, `'${specifier}' could not be parsed, so dependencyHash doesn't cover it.`)];
+            const place = this.placeUnit(from, at, `'${specifier}' could not be parsed, so dependencyHash doesn't cover it.`);
+            return module.text === null ? [place] : [this.textUnit(module), place];
         }
+        // A component's markup may use anything its scripts declare or import, its types included.
+        if (module.text !== null)
+            return [this.wholeUnit(module, false)];
         return name === '' ? [this.loadUnit(module, types)] : this.exported(module, name, types, new Set());
     }
     /**
@@ -711,7 +766,7 @@ export class DependencyGraph {
                     : [this.declarationUnit(module, declaration, types)];
             }
             if (statement.type === 'ExportAllDeclaration' && statement.exported && exportName(statement.exported) === name) {
-                return this.imported(module, statement.source.value, '*', types, statement);
+                return this.passedOn(module, statement, statement.source, statement.exported, '*', types);
             }
             if (statement.type !== 'ExportNamedDeclaration')
                 continue;
@@ -735,7 +790,7 @@ export class DependencyGraph {
                 continue;
             const localName = exportName(specifier.local);
             return statement.source
-                ? this.imported(module, statement.source.value, localName, types, statement)
+                ? this.passedOn(module, statement, statement.source, specifier, localName, types)
                 : local(localName);
         }
         // `export *` passes on every name but `default`, and only when the module doesn't export the name itself.
@@ -745,11 +800,19 @@ export class DependencyGraph {
                     continue;
                 const found = this.reexported(module, statement.source.value, name, types, searched);
                 if (found)
-                    return found;
+                    return [...found, this.importUnit(module, statement, statement.source)];
             }
         }
         return [this.wholeUnit(module, types)];
     }
+    /**
+     * A name a module passes on from another, as `export { quote } from './nasdaq'` does, with the re-export itself: which
+     * module the name comes from is code too, so the barrel is among the files a change to which affects the test.
+     */
+    passedOn(module, statement, source, specifier, name, types) {
+        const units = this.imported(module, source.value, name, types, statement);
+        return units === IN_PROGRESS ? units : [...units, this.importUnit(module, { source }, specifier)];
+    }
     /** What `export * from source` gives for a name; null when the module behind it doesn't export it. */
     reexported(from, source, name, types, searched) {
         const read = this.read(from, source);
@@ -1161,10 +1224,22 @@ export class DependencyGraph {
                     }
                     break;
                 }
-                case 'ImportDeclaration':
-                    if (node.importKind !== 'type' || types)
-                        add(this.imported(module, node.source.value, '', types, node));
+                case 'ImportDeclaration': {
+                    if (module.text === null) {
+                        if (node.importKind !== 'type' || types)
+                            add(this.imported(module, node.source.value, '', types, node));
+                        return;
+                    }
+                    // A component's markup uses what its scripts import, where the scan doesn't look, and Vue builds the props
+                    // of `defineProps<Props>()` from the types, so every import counts, types with their types.
+                    const isType = node.importKind === 'type';
+                    add(this.imported(module, node.source.value, '', isType, node));
+                    for (const specifier of node.specifiers) {
+                        const isTypeName = isType || (specifier.type === 'ImportSpecifier' && specifier.importKind === 'type');
+                        add(this.toDeclaration(module, specifier, specifier.local.name, null, isTypeName));
+                    }
                     return;
+                }
                 case 'TSImportEqualsDeclaration':
                     if (node.moduleReference.type !== 'TSExternalModuleReference')
                         break;

package/dist/extract.js

@@ -753,13 +753,16 @@ class Walker {
             mergeRun(call.target.hookRun, settings);
         }
     }
-    /** Counts `expect()`, `expect.soft()` and `expect.poll()`, and reads `expect.assertions(n)` and `expect.hasAssertions()`. */
+    /**
+     * Counts `expect()`, `expect.soft()`, `expect.poll()` and `expect.element()`, and reads `expect.assertions(n)` and
+     * `expect.hasAssertions()`.
+     */
     expectCall(call, test) {
         const callee = unwrap(call.callee);
         const [root, member] = callee.type === 'MemberExpression' ? [unwrap(callee.object), propertyName(callee)] : [callee, 'call'];
         if (root.type !== 'Identifier' || root.name !== 'expect')
             return;
-        if (member === 'call' || member === 'soft' || member === 'poll')
+        if (member === 'call' || member === 'soft' || member === 'poll' || member === 'element')
             test.expectCount += 1;
         if (member === 'hasAssertions')
             test.expectsAssertions = true;

package/dist/frameworks/vitest.d.ts

@@ -75,7 +75,7 @@ export declare class VitestAdapter implements Adapter {
     /** Vitest's order: `only` wins over `skip`, which wins over `todo`. */
     private states;
     private readDeclarationOptions;
-    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`; the runner ignores an object before. */
+    /** `retry` as a number, or since Vitest 4.1 as `{ count, delay, condition }`. */
     private retry;
     private meta;
     private caseCount;

package/dist/frameworks/vitest.js

@@ -27,6 +27,7 @@ const MODIFIERS = {
 };
 const TABLES = new Set(['each', 'for']);
 const CONDITIONS = new Set(['skipIf', 'runIf']);
+const STATE_FLAGS = ['only', 'todo', 'fails'];
 const DERIVATIONS = new Set(['extend', 'override', 'scoped']);
 /** Hooks, with the position of the test context among their callback's parameters. */
 const HOOKS = new Map([
@@ -634,6 +635,17 @@ export class VitestAdapter {
         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));
+        // From Vitest 5.0.5 a test's `skip`, `skipIf` and `runIf` each set its `skip`, so the last of them decides, and a
+        // `skipIf` or `runIf` replaces the skip of a tag or of a describe around. The scan applies that to all of Vitest 5.
+        const lastSkip = links.filter((link) => link.name === 'skip' || CONDITIONS.has(link.name)).at(-1);
+        const skipsByChain = kind === 'test' && lastSkip !== undefined && atLeast(this.file.version, 5, 0);
+        const conditionSetsSkip = skipsByChain && CONDITIONS.has(lastSkip.name);
+        if (skipsByChain) {
+            flags.delete('skip');
+            conditions = conditionSetsSkip ? [this.linkCondition(lastSkip, context)] : [];
+            if (!conditionSetsSkip)
+                flags.add('skip');
+        }
         // 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) {
@@ -653,7 +665,7 @@ export class VitestAdapter {
         // 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 passed = read.skip || conditionSetsSkip ? 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;
@@ -704,6 +716,10 @@ export class VitestAdapter {
                 fixtures: fixturesOf(base.hashed, index, this.file.version),
                 takesAllFixtures: takesWhole(base.hashed, index),
                 usesBench: atLeast(this.file.version, 5, 0) && destructuredNames(base.hashed, index).includes('bench'),
+                ownStateOptions: [
+                    ...(read.skip || conditionSetsSkip ? ['skip'] : []),
+                    ...STATE_FLAGS.filter((flag) => read.flags.has(flag)),
+                ],
             };
         }
         return refusal ? refused(call, refusal, context, () => declared) : declared;
@@ -763,8 +779,14 @@ export class VitestAdapter {
             return result;
         const options = readOptions(this.file, context.scopes, node);
         problems.push(...unresolvedOptions(this.file, options, 'its flags, tags and meta are missing'));
+        // From Vitest 5.0.5 an option set to `undefined` replaces nothing; the scan applies that to all of Vitest 5.
+        const given = (key) => {
+            const option = options.values.get(key);
+            const isUndefined = option?.resolved.ok === true && option.resolved.value === undefined;
+            return isUndefined && atLeast(this.file.version, 5, 0) ? undefined : option;
+        };
         for (const flag of ['only', 'todo', 'fails', 'concurrent', 'sequential', 'shuffle']) {
-            const option = options.values.get(flag);
+            const option = given(flag);
             if (option && !option.resolved.ok) {
                 const { importedFrom } = option.resolved;
                 problems.push(unresolvedOption(this.file, flag, option.node, importedFrom, 'it is not applied'));
@@ -776,7 +798,7 @@ export class VitestAdapter {
                 result.flags.set(flag, Boolean(option.resolved.value));
             }
         }
-        const skip = options.values.get('skip');
+        const skip = given('skip');
         if (skip) {
             result.skip = skip.resolved.ok
                 ? { applies: skip.resolved.value ? 'always' : 'never', text: null }
@@ -806,7 +828,7 @@ export class VitestAdapter {
             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` as a number, or since Vitest 4.1 as `{ count, delay, condition }`. */
     retry(option, details, context, problems) {
         const node = unwrap(option.node);
         if (node.type !== 'ObjectExpression') {
@@ -815,8 +837,14 @@ export class VitestAdapter {
                 details.run.retry = { count, delay: null, condition: null };
             return;
         }
-        if (!atLeast(this.file.version, 4, 1))
+        if (!atLeast(this.file.version, 4, 1)) {
+            // Before 4.1 the runner compares the attempt number with the object, so it never runs the test.
+            const source = snippet(text(this.file, node));
+            const message = `Option retry: ${source} is an object, which Vitest reads from 4.1; before, it never runs the test.`;
+            problems.push(problem('unresolved-option', node, message, source));
+            details.run.retry = null;
             return;
+        }
         const values = readOptions(this.file, context.scopes, node);
         problems.push(...unresolvedOptions(this.file, values, 'the retry is not applied'));
         const read = (key) => {

package/dist/model.d.ts

@@ -2,6 +2,8 @@ import type { CallExpression, Expression, Node } from 'oxc-parser';
 import type { FunctionNode } from './ast.ts';
 import type { Annotation, DiagnosticCode, DiagnosticLevel, HookCounts, MetaValue } from './types.ts';
 export type State = 'skip' | 'fixme' | 'todo' | 'expectedToFail';
+/** The Vitest options that set a test's state. */
+export type StateOption = 'skip' | 'only' | 'todo' | 'fails';
 export type Mode = 'parallel' | 'serial' | 'default';
 /** A state set by a declaration, a describe or a call such as `test.skip(condition)`. */
 export interface StateSetting {
@@ -51,12 +53,15 @@ export interface Details {
 /** Run settings written in one place; a key that is missing is not set there. */
 export interface RunSettings {
     timeout?: number;
-    /** A retry setting replaces the whole `retry` of the describes around, delay and condition included. */
+    /**
+     * A retry setting replaces the whole `retry` of the describes around, delay and condition included; null when it is
+     * set to a value the runner can't use.
+     */
     retry?: {
         count: number;
         delay: number | null;
         condition: string | null;
-    };
+    } | null;
     repeats?: number;
     /** Playwright `test.slow()`: the conditions of the calls, any of which makes the test slow; null when one always does. */
     slow?: {
@@ -90,6 +95,8 @@ export interface TestDeclaration extends Declaration {
     takesAllFixtures: boolean;
     /** Uses Vitest 5's `bench` fixture. */
     usesBench: boolean;
+    /** Vitest: the state options the test sets itself, to `false` too, which replace those of its tags. */
+    ownStateOptions?: StateOption[];
 }
 export interface SuiteDeclaration extends Declaration {
     kind: 'describe';
@@ -186,6 +193,8 @@ export interface Returns {
 /** A module read to see whether it exports a custom `test` object. */
 export interface ModuleSource {
     code: string;
+    /** The file's bytes when it isn't UTF-8 text, such as an image. */
+    bytes?: Uint8Array;
     relativeFilePath: string;
     /** Reads the modules this module imports in turn. */
     readModule: ModuleReader;

package/dist/parse.d.ts

@@ -15,6 +15,12 @@ export interface ParsedFile {
         end: number;
     } | null;
 }
+/**
+ * The offset of the first bracket nested more than `limit` deep, or null. Parentheses, brackets, braces and template
+ * substitutions count; strings, comments, regular expressions and template text are skipped. A closing bracket closes
+ * up to the one it matches, so a literal read wrongly unbalances only the brackets around it.
+ */
+export declare function tooDeeplyNested(text: string, limit: number): number | null;
 /** The first parser error, located at its first label, or at the start of the file when it has none. */
 export declare function firstError(errors: readonly OxcError[]): ParsedFile['error'];
 export declare function parseFile(fileName: string, code: string): ParsedFile;