test-inventory 0.6.0 → 0.7.0

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

@@ -7,6 +7,7 @@ export const LEVELS = {
     'unresolved-tag': 'warning',
     'unresolved-annotation': 'warning',
     'unresolved-cases': 'warning',
+    'cases-not-expanded': 'warning',
     'test-in-loop': 'warning',
     'dynamic-title': 'warning',
     'duplicate-title': 'warning',

package/dist/extract.d.ts

@@ -48,6 +48,8 @@ export interface PendingSuite {
     /** Declared under a condition, or in a function: it may not run while the file loads. */
     isInCondition: boolean;
     isInFunction: boolean;
+    /** With `expandCases`, the index of the case of a table or pass of a loop this describe is; null otherwise. */
+    caseIndex: number | null;
 }
 export interface PendingTest {
     scope: Scope;
@@ -66,8 +68,17 @@ export interface PendingTest {
     states: StateSetting[];
     annotations: Annotation[];
     isInLoop: boolean;
+    /**
+     * How many times each loop around the test registers it, outermost first; null for a loop the scan can't count, or
+     * one that registers it under a condition.
+     */
+    loops: (number | null)[];
+    /** How many passes each loop around the test makes, whether or not it registers the test on each. */
+    passes: (number | null)[];
     isInCondition: boolean;
     isInFunction: boolean;
+    /** With `expandCases`, the index of the case of a table or pass of a loop this test is; null otherwise. */
+    caseIndex: number | null;
     comments: string[];
     /** Run settings from calls in the body, which win over everything around the test. */
     run: RunSettings;
@@ -85,6 +96,13 @@ export interface Frame {
     readModule: ModuleReader | null;
     relativeFilePath: string;
 }
+/** How the walk lists tables and loops. */
+export interface ExtractOptions {
+    /** One test or describe per case of a table and per pass of a loop whose values the scan can work out. */
+    expandCases: boolean;
+    /** Vitest's `[major, minor]`, whose rules give each case its title; null for the newest rules. */
+    version: readonly [number, number] | null;
+}
 /** Reads a module a helper is imported from as a frame; null when it can't be parsed. */
 export type OpenModule = (module: ModuleSource) => Frame | null;
 export interface Extraction {
@@ -112,4 +130,4 @@ export declare function anySlow(slows: NonNullable<RunSettings['slow']>[]): NonN
 export declare function eitherCondition(parts: string[]): string;
 export declare function noHooks(): HookCounts;
 /** Walks the scanned file; `openModule` reads the modules of imported helpers that the file calls. */
-export declare function extract(main: Frame, openModule: OpenModule): Extraction;
+export declare function extract(main: Frame, openModule: OpenModule, options?: ExtractOptions): Extraction;