@describe-me/vitest 0.3.0 → 0.5.0-next.0

package/dist/reporter.js

@@ -1,33 +1,55 @@
 /**
  * Node-side Vitest reporter. Collects frames from task.meta and writes
- * `.describe-me/manifest.json` plus one file per snapshot.
+ * `.describe-me/`: `manifest.json`, `snapshots/`, `styles/` and `assets/`.
  */
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join, relative, resolve } from 'node:path';
+import { join, relative, resolve, sep } from 'node:path';
 import { META_KEY, } from '@describe-me/core/types';
+import { AssetStore } from './asset-store.js';
 import { collectComponentDocsSafely } from './collect-component-docs-safely.js';
+import { compileGlobs } from './compile-globs.js';
 import { componentEntries } from './component-entries.js';
+import { fileFilter } from './file-filter.js';
+import { isRecordedTest } from './is-recorded-test.js';
+import { printDiagnostics } from './print-diagnostics.js';
 import { SnapshotStore } from './snapshot-store.js';
+import { StyleStore } from './style-store.js';
 import { testPath } from './test-path.js';
+function recordOf(tc) {
+    return tc.meta()[META_KEY];
+}
 export default class DescribeMeReporter {
     outDirOption;
+    isRecordedFile;
     root = process.cwd();
     outDir = '';
     snapshots;
+    assets;
+    styles;
     modules = new Map();
     constructor(options = {}) {
         this.outDirOption = options.outDir ?? '.describe-me';
+        this.isRecordedFile = fileFilter({
+            include: compileGlobs(options.include),
+            exclude: compileGlobs(options.exclude),
+        });
     }
     onInit(vitest) {
         this.root = vitest.config.root;
         this.outDir = resolve(this.root, this.outDirOption);
         this.snapshots = new SnapshotStore(this.outDir);
+        this.assets = new AssetStore(this.outDir, this.root);
+        this.styles = new StyleStore(this.outDir);
         this.seedFromPreviousRun();
     }
+    onTestRunStart() {
+        this.assets.startRun();
+    }
     /**
      * A filtered run (`vitest run Button.test.tsx`) must not wipe the other
      * modules from the manifest, so start from whatever the last run wrote.
-     * Modules whose file no longer exists are dropped.
+     * Modules whose file is gone or no longer selected by `include` / `exclude`
+     * are dropped, and so are the empty tests that 0.4 still wrote.
      */
     seedFromPreviousRun() {
         const file = join(this.outDir, 'manifest.json');
@@ -37,8 +59,11 @@ export default class DescribeMeReporter {
         try {
             const previous = JSON.parse(readFileSync(file, 'utf8'));
             for (const mod of previous.modules ?? []) {
-                if (existsSync(resolve(this.root, mod.id))) {
-                    this.modules.set(mod.id, mod);
+                const tests = mod.tests.filter((test) => isRecordedTest(test));
+                if (tests.length > 0 &&
+                    this.isRecordedModule(mod.id) &&
+                    existsSync(resolve(this.root, mod.id))) {
+                    this.modules.set(mod.id, { ...mod, tests });
                 }
             }
         }
@@ -46,34 +71,75 @@ export default class DescribeMeReporter {
             // corrupt or incompatible manifest: start fresh
         }
     }
+    /**
+     * A test skipped in this run keeps its previous entry, so a filtered run does
+     * not erase documentation.
+     */
     onTestModuleEnd(module) {
         const id = relative(this.root, module.moduleId);
-        const tests = Array.from(module.children.allTests()).map((tc) => this.toManifestTest(tc));
+        if (!this.isRecordedModule(id)) {
+            this.modules.delete(id);
+            return;
+        }
+        const previous = this.modules.get(id);
+        const tests = [];
+        for (const tc of module.children.allTests()) {
+            const test = this.manifestTestOf(tc, previous);
+            if (test) {
+                tests.push(test);
+            }
+        }
+        if (tests.length === 0) {
+            this.modules.delete(id);
+            return;
+        }
         this.modules.set(id, { id, tests });
     }
     async onTestRunEnd() {
         const modules = Array.from(this.modules.values()).sort((left, right) => left.id.localeCompare(right.id));
         const components = await collectComponentDocsSafely(this.root, componentEntries(modules, this.root));
+        // Only what this run found: a filtered run does not know which of the
+        // previous run's missing assets belonged to the modules it skipped.
+        const assetsMissing = this.assets.missing();
         const manifest = {
             version: 1,
             generatedAt: new Date().toISOString(),
             root: this.root,
             modules,
             components,
+            assetsMissing,
         };
-        this.snapshots.collectGarbage(manifest.modules.flatMap((mod) => mod.tests.flatMap((test) => test.frames.map((frame) => frame.snapshot))));
+        const snapshotFiles = manifest.modules.flatMap((mod) => mod.tests.flatMap((test) => test.frames.map((frame) => frame.snapshot)));
+        this.snapshots.collectGarbage(snapshotFiles);
+        const styleFiles = this.styles.collectGarbage(snapshotFiles);
+        this.assets.collectGarbage([...snapshotFiles, ...styleFiles]);
         writeFileSync(join(this.outDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+        printDiagnostics(manifest);
+    }
+    /** Module ids use the platform's separators. Globs expect posix ones. */
+    isRecordedModule(id) {
+        return this.isRecordedFile(id.split(sep).join('/'));
+    }
+    /** Decided before any snapshot is written, so a dropped test writes no file. */
+    manifestTestOf(tc, previous) {
+        const record = recordOf(tc);
+        if (record && isRecordedTest(record)) {
+            return this.toManifestTest(tc, record);
+        }
+        if (tc.result().state !== 'skipped') {
+            return undefined;
+        }
+        return previous?.tests.find((test) => test.id === tc.id && test.fullName === tc.fullName && isRecordedTest(test));
     }
-    toManifestTest(tc) {
-        const record = tc.meta()[META_KEY];
+    toManifestTest(tc, record) {
         const result = tc.result();
-        const frames = (record?.frames ?? []).map((frame) => ({
+        const frames = record.frames.map((frame) => ({
             id: frame.id,
             kind: frame.kind,
             label: frame.label,
             at: frame.at,
             meta: frame.meta,
-            snapshot: this.snapshots.write(frame.snapshot),
+            snapshot: this.writeSnapshot(frame.snapshot, record.origin),
         }));
         return {
             id: tc.id,
@@ -83,8 +149,18 @@ export default class DescribeMeReporter {
             state: result.state ?? 'pending',
             duration: tc.diagnostic()?.duration,
             errors: result.errors?.map((error) => ({ message: error.message, stack: error.stack })),
-            component: record?.component,
+            component: record.component,
             frames,
         };
     }
+    /**
+     * Store one frame's DOM, with asset URLs pointing into the asset store and
+     * long stylesheets moved to the style store. Assets go first, so stored CSS
+     * carries asset URLs too.
+     */
+    writeSnapshot(snapshot, origin) {
+        // A mixed install, where an older core created the global recorder, still hands over objects.
+        const json = typeof snapshot === 'string' ? snapshot : JSON.stringify(snapshot);
+        return this.snapshots.write(this.styles.extract(this.assets.rewrite(json, origin)));
+    }
 }

package/dist/runtime-options.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Travels from the plugin to the setup files through Vitest's `provide` /
+ * `inject`. Keep it plain JSON: the browser receives it serialized, so a
+ * RegExp would not survive. The test runtime imports this file, so it imports
+ * nothing itself.
+ */
+export interface CompiledGlob {
+    source: string;
+    flags: string;
+}
+export interface RuntimeOptions {
+    /** Empty means every test file. */
+    include: CompiledGlob[];
+    /** Wins over `include`. */
+    exclude: CompiledGlob[];
+}
+export declare const RUNTIME_OPTIONS_KEY: "describe-me";
+declare module 'vitest' {
+    interface ProvidedContext {
+        'describe-me': RuntimeOptions;
+    }
+}

package/dist/runtime-options.js

@@ -0,0 +1,7 @@
+/**
+ * Travels from the plugin to the setup files through Vitest's `provide` /
+ * `inject`. Keep it plain JSON: the browser receives it serialized, so a
+ * RegExp would not survive. The test runtime imports this file, so it imports
+ * nothing itself.
+ */
+export const RUNTIME_OPTIONS_KEY = 'describe-me';

package/dist/setup-dom.js

@@ -1,11 +1,15 @@
 /**
  * Vitest setup file for DOM environments such as jsdom:
  * `setupFiles: ['@describe-me/vitest/setup-dom']`. Patches Testing Library's
- * userEvent so every interaction records a frame, and registers the
- * recording hooks. Never imports `vitest/browser`, which only exists in
- * browser mode.
+ * userEvent, when it is installed, so every interaction records a frame, sets
+ * React's act flag where Testing Library would, and registers the recording
+ * hooks. Which test files are recorded (`include` / `exclude`) comes from the
+ * plugin. Never imports `vitest/browser`, which only exists in browser mode.
  */
+import { mirrorReactActEnvironment } from './mirror-react-act-environment.js';
 import { patchTestingLibraryUserEvent } from './patch-testing-library-user-event.js';
+import { readRuntimeOptions } from './read-runtime-options.js';
 import { registerRecordingHooks } from './register-recording-hooks.js';
-patchTestingLibraryUserEvent();
-registerRecordingHooks();
+await patchTestingLibraryUserEvent();
+mirrorReactActEnvironment();
+registerRecordingHooks(readRuntimeOptions());

package/dist/setup.js

@@ -1,11 +1,13 @@
 /**
  * Vitest setup file for browser mode: `setupFiles: ['@describe-me/vitest/setup']`.
  * Patches Vitest's locators and userEvent so every interaction records a
- * frame, and registers the recording hooks. For jsdom use `./setup-dom`.
+ * frame, and registers the recording hooks. Which test files are recorded
+ * (`include` / `exclude`) comes from the plugin. For jsdom use `./setup-dom`.
  */
 import { patchLocators } from './patch-locators.js';
 import { patchUserEvent } from './patch-user-event.js';
+import { readRuntimeOptions } from './read-runtime-options.js';
 import { registerRecordingHooks } from './register-recording-hooks.js';
 patchLocators();
 patchUserEvent();
-registerRecordingHooks();
+registerRecordingHooks(readRuntimeOptions());

package/dist/snapshot-store.d.ts

@@ -5,8 +5,8 @@
 export declare class SnapshotStore {
     private readonly dir;
     constructor(outDir: string);
-    /** Write one snapshot and return its path relative to the manifest. */
-    write(snapshot: unknown): string;
+    /** Write one serialized snapshot and return its path relative to the manifest. */
+    write(json: string): string;
     /** Drop the files no manifest frame points at any more. */
     collectGarbage(referenced: Iterable<string>): void;
 }

package/dist/snapshot-store.js

@@ -11,9 +11,8 @@ export class SnapshotStore {
         this.dir = join(outDir, 'snapshots');
         mkdirSync(this.dir, { recursive: true });
     }
-    /** Write one snapshot and return its path relative to the manifest. */
-    write(snapshot) {
-        const json = JSON.stringify(snapshot);
+    /** Write one serialized snapshot and return its path relative to the manifest. */
+    write(json) {
         const hash = createHash('sha1').update(json).digest('hex').slice(0, 16);
         const file = `${hash}.json`;
         const abs = join(this.dir, file);

package/dist/split-stylesheet.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Split a stylesheet into chunks of about 4 KB, cut between top-level rules
+ * where their content decides, so a sheet that grows from test to test keeps
+ * most of its chunks. `chunks.join('')` is always the input, even for
+ * malformed CSS.
+ */
+export declare function splitStylesheet(css: string): string[];

package/dist/split-stylesheet.js

@@ -0,0 +1,114 @@
+/** A chunk is never closed below this length, so small rules do not end up in tiny files. */
+const MIN_CHUNK = 1024;
+/**
+ * A chunk is closed once it reaches this length. Only its last rule can take it
+ * past the limit, because a rule is never split.
+ */
+const MAX_CHUNK = 16384;
+/**
+ * Past `MIN_CHUNK`, a rule of `n` characters ends its chunk with a probability
+ * of about `n / BOUNDARY_SPACING`, decided by a hash of its text. Chunks then
+ * average about 4 KB, and where they end depends on content, not on offsets.
+ */
+const BOUNDARY_SPACING = 3072;
+/** Boundaries only need a cheap, stable hash, not sha1. */
+function fnv1a32(text) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < text.length; i++) {
+        hash = Math.imul(hash ^ text.charCodeAt(i), 0x01000193);
+    }
+    return hash >>> 0;
+}
+function isBoundary(piece) {
+    return fnv1a32(piece) % BOUNDARY_SPACING < piece.length;
+}
+function endOfComment(css, start) {
+    const close = css.indexOf('*/', start + 2);
+    return close === -1 ? css.length : close + 2;
+}
+function endOfString(css, start) {
+    const quote = css[start];
+    let i = start + 1;
+    while (i < css.length) {
+        if (css[i] === '\\') {
+            i += 2;
+        }
+        else if (css[i] === quote) {
+            return i + 1;
+        }
+        else {
+            i++;
+        }
+    }
+    return css.length;
+}
+/**
+ * Cut a stylesheet after every top-level rule: after the `}` that closes a
+ * top-level block, or after a semicolon at depth 0 (`@import`). Strings,
+ * comments and escapes are skipped and nothing in parentheses counts, so
+ * `content: "}"` or an unquoted font URL with semicolons never ends a rule.
+ */
+function topLevelPieces(css) {
+    const pieces = [];
+    let start = 0;
+    let braces = 0;
+    let parens = 0;
+    let i = 0;
+    while (i < css.length) {
+        const char = css[i];
+        if (char === '\\') {
+            i += 2;
+            continue;
+        }
+        if (char === '/' && css[i + 1] === '*') {
+            i = endOfComment(css, i);
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            i = endOfString(css, i);
+            continue;
+        }
+        if (char === '(') {
+            parens++;
+        }
+        else if (char === ')') {
+            parens = Math.max(0, parens - 1);
+        }
+        else if (parens === 0 && char === '{') {
+            braces++;
+        }
+        else if (parens === 0 && char === '}') {
+            braces = Math.max(0, braces - 1);
+        }
+        i++;
+        if (parens === 0 && braces === 0 && (char === '}' || char === ';')) {
+            pieces.push(css.slice(start, i));
+            start = i;
+        }
+    }
+    if (start < css.length) {
+        pieces.push(css.slice(start));
+    }
+    return pieces;
+}
+/**
+ * Split a stylesheet into chunks of about 4 KB, cut between top-level rules
+ * where their content decides, so a sheet that grows from test to test keeps
+ * most of its chunks. `chunks.join('')` is always the input, even for
+ * malformed CSS.
+ */
+export function splitStylesheet(css) {
+    const chunks = [];
+    let current = '';
+    for (const piece of topLevelPieces(css)) {
+        current += piece;
+        if (current.length >= MAX_CHUNK || (current.length >= MIN_CHUNK && isBoundary(piece))) {
+            chunks.push(current);
+            current = '';
+        }
+    }
+    if (current !== '') {
+        chunks.push(current);
+    }
+    return chunks;
+}

package/dist/style-store.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Content-addressed store for the stylesheets rrweb copies into every capture,
+ * living in `<outDir>/styles`. A sheet is stored once, in chunks, so one that
+ * grows from test to test shares most of them.
+ */
+export declare class StyleStore {
+    private readonly outDir;
+    private readonly dir;
+    /** Snapshots are content-addressed, so a cached entry never goes stale. */
+    private readonly referencesBySnapshot;
+    constructor(outDir: string);
+    /**
+     * Replace each long `_cssText` in a serialized snapshot with a reference to
+     * its chunks, writing the ones not stored yet. Idempotent.
+     */
+    extract(json: string): string;
+    /**
+     * Drop the chunks no kept snapshot refers to, and return the kept ones as
+     * sorted `styles/<hash>.css` paths for the asset store. Paths are relative to
+     * the output directory, as the manifest stores them.
+     */
+    collectGarbage(snapshotFiles: Iterable<string>): string[];
+    private write;
+    private referencesIn;
+}

package/dist/style-store.js

@@ -0,0 +1,90 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { join } from 'node:path';
+import { STYLE_URL_PREFIX } from '@describe-me/core/types';
+import { splitStylesheet } from './split-stylesheet.js';
+/** Shorter sheets stay inline, where they cost less than a reference and a file of their own. */
+const MIN_EXTRACTED_LENGTH = 256;
+/**
+ * Inside a JSON string every `"` is escaped, so only a real `_cssText` key
+ * matches. Unrolled, because `(?:[^"\\]|\\.)*` is much slower on
+ * megabyte-long sheets.
+ */
+const CSS_TEXT_MEMBER = /"_cssText":"([^"\\]*(?:\\.[^"\\]*)*)"/g;
+const STYLE_REFERENCE = new RegExp(`${STYLE_URL_PREFIX}([0-9a-f]{16}(?:\\+[0-9a-f]{16})*)`, 'g');
+/**
+ * Content-addressed store for the stylesheets rrweb copies into every capture,
+ * living in `<outDir>/styles`. A sheet is stored once, in chunks, so one that
+ * grows from test to test shares most of them.
+ */
+export class StyleStore {
+    outDir;
+    dir;
+    /** Snapshots are content-addressed, so a cached entry never goes stale. */
+    referencesBySnapshot = new Map();
+    constructor(outDir) {
+        this.outDir = outDir;
+        this.dir = join(outDir, 'styles');
+        mkdirSync(this.dir, { recursive: true });
+    }
+    /**
+     * Replace each long `_cssText` in a serialized snapshot with a reference to
+     * its chunks, writing the ones not stored yet. Idempotent.
+     */
+    extract(json) {
+        return json.replace(CSS_TEXT_MEMBER, (member, escaped) => {
+            const css = JSON.parse(`"${escaped}"`);
+            if (css.length < MIN_EXTRACTED_LENGTH || css.startsWith(STYLE_URL_PREFIX)) {
+                return member;
+            }
+            const hashes = splitStylesheet(css).map((chunk) => this.write(chunk));
+            return `"_cssText":"${STYLE_URL_PREFIX}${hashes.join('+')}"`;
+        });
+    }
+    /**
+     * Drop the chunks no kept snapshot refers to, and return the kept ones as
+     * sorted `styles/<hash>.css` paths for the asset store. Paths are relative to
+     * the output directory, as the manifest stores them.
+     */
+    collectGarbage(snapshotFiles) {
+        const keep = new Set();
+        for (const snapshotFile of snapshotFiles) {
+            for (const hash of this.referencesIn(snapshotFile)) {
+                keep.add(`${hash}.css`);
+            }
+        }
+        const kept = [];
+        for (const file of readdirSync(this.dir)) {
+            if (keep.has(file)) {
+                kept.push(`styles/${file}`);
+            }
+            else {
+                rmSync(join(this.dir, file), { force: true });
+            }
+        }
+        return kept.sort();
+    }
+    write(chunk) {
+        const hash = createHash('sha1').update(chunk).digest('hex').slice(0, 16);
+        const file = join(this.dir, `${hash}.css`);
+        // Not remembered in memory: in watch mode, GC can delete the file between runs.
+        if (!existsSync(file)) {
+            writeFileSync(file, chunk);
+        }
+        return hash;
+    }
+    referencesIn(snapshotFile) {
+        const cached = this.referencesBySnapshot.get(snapshotFile);
+        if (cached) {
+            return cached;
+        }
+        const path = join(this.outDir, snapshotFile);
+        if (!statSync(path, { throwIfNoEntry: false })?.isFile()) {
+            return [];
+        }
+        const json = readFileSync(path, 'utf8');
+        const hashes = Array.from(json.matchAll(STYLE_REFERENCE), (match) => match[1].split('+')).flat();
+        this.referencesBySnapshot.set(snapshotFile, hashes);
+        return hashes;
+    }
+}

package/dist/styled-components-browser-build.d.ts

@@ -0,0 +1,15 @@
+import type { ViteUserConfig } from 'vitest/config';
+/**
+ * The Vite and Vitest config that makes a DOM environment load the browser
+ * build of styled-components, or undefined when the project does not use
+ * styled-components 5 or later.
+ *
+ * Vitest resolves the Node build, whose `createGlobalStyle` never inserts its
+ * CSS on the client, so global resets and fonts would be missing from every
+ * snapshot. The alias points `styled-components` at the browser ESM file. The
+ * optimizer is needed as well: jest-styled-components `require`s
+ * styled-components through Node, which ignores the alias, and would get a
+ * second instance whose styles its serializer cannot see. Bundling both
+ * together gives them one.
+ */
+export declare function styledComponentsBrowserBuild(root: string): ViteUserConfig | undefined;

package/dist/styled-components-browser-build.js

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, resolve } from 'node:path';
+function resolverFor(root) {
+    // createRequire wants an absolute file inside the directory; it does not have to exist.
+    const requireFromRoot = createRequire(join(resolve(root), 'package.json'));
+    return (id) => {
+        try {
+            return requireFromRoot.resolve(id);
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
+function withoutDotSlash(path) {
+    return path.replace(/^\.\//, '');
+}
+/** The file the package's `browser` map swaps its `module` entry for, relative to the package. */
+function browserModule(pkg) {
+    if (!pkg.module || !pkg.browser || typeof pkg.browser === 'string') {
+        return undefined;
+    }
+    const moduleEntry = withoutDotSlash(pkg.module);
+    for (const [from, to] of Object.entries(pkg.browser)) {
+        if (withoutDotSlash(from) === moduleEntry && typeof to === 'string') {
+            return to;
+        }
+    }
+    return undefined;
+}
+/**
+ * The Vite and Vitest config that makes a DOM environment load the browser
+ * build of styled-components, or undefined when the project does not use
+ * styled-components 5 or later.
+ *
+ * Vitest resolves the Node build, whose `createGlobalStyle` never inserts its
+ * CSS on the client, so global resets and fonts would be missing from every
+ * snapshot. The alias points `styled-components` at the browser ESM file. The
+ * optimizer is needed as well: jest-styled-components `require`s
+ * styled-components through Node, which ignores the alias, and would get a
+ * second instance whose styles its serializer cannot see. Bundling both
+ * together gives them one.
+ */
+export function styledComponentsBrowserBuild(root) {
+    const resolveFromRoot = resolverFor(root);
+    const manifest = resolveFromRoot('styled-components/package.json');
+    if (!manifest) {
+        return undefined;
+    }
+    const pkg = JSON.parse(readFileSync(manifest, 'utf8'));
+    const major = Number.parseInt(pkg.version ?? '', 10);
+    const browserFile = browserModule(pkg);
+    if (Number.isNaN(major) || major < 5 || !browserFile) {
+        return undefined;
+    }
+    const replacement = join(dirname(manifest), browserFile);
+    if (!existsSync(replacement)) {
+        return undefined;
+    }
+    const include = ['styled-components'];
+    if (resolveFromRoot('jest-styled-components')) {
+        include.push('jest-styled-components');
+    }
+    return {
+        resolve: { alias: [{ find: /^styled-components$/, replacement }] },
+        test: { deps: { optimizer: { client: { enabled: true, include } } } },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@describe-me/vitest",
-  "version": "0.3.0",
+  "version": "0.5.0-next.0",
   "description": "Vitest integration for describe-me: plugin, setup file and reporter",
   "keywords": [
     "vitest",
@@ -58,12 +58,13 @@
     "./dist/setup-dom.js"
   ],
   "dependencies": {
-    "@describe-me/core": "^0.3.0"
+    "picomatch": "^4.0.3",
+    "@describe-me/core": "^0.5.0-next.0"
   },
   "peerDependencies": {
-    "vitest": ">=4",
-    "typescript": ">=5.0",
-    "@testing-library/user-event": ">=14"
+    "vitest": "^4.0.0 || ^5.0.0",
+    "typescript": "^5.0.0 || ^6.0.0",
+    "@testing-library/user-event": "^14.0.0"
   },
   "peerDependenciesMeta": {
     "typescript": {
@@ -78,7 +79,8 @@
     "@types/node": "^22",
     "typescript": "^6",
     "@testing-library/user-event": "^14.6.1",
-    "@testing-library/dom": "^10.4.0"
+    "@testing-library/dom": "^10.4.0",
+    "@types/picomatch": "^4.0.3"
   },
   "scripts": {
     "build": "rimraf dist && tsc -p tsconfig.json"

package/dist/element-label.d.ts

@@ -1,6 +0,0 @@
-/**
- * A readable target for a frame label, e.g. `button "show details"`.
- * Testing Library hands interactions a real `Element` rather than a Vitest
- * locator, so the label is read off the element instead of a selector string.
- */
-export declare function elementLabel(target: unknown): string | undefined;