test-inventory 0.4.1 → 0.6.0

package/dist/config-runs.d.ts

@@ -0,0 +1,113 @@
+import { type ConfigFile, type Configs, type Setting } from './config.ts';
+import type { FileConfig, VitestTags } from './records.ts';
+import type { Framework, ProjectRecord } from './types.ts';
+/** What makes a file run: as a test, or as a Vitest benchmark, which plain `vitest` doesn't run. */
+type Run = 'test' | 'benchmark';
+/**
+ * What the output says of a project: its name, the folder its test files are found from and Playwright's
+ * `dependencies`. `grep` is Playwright's filter of its test titles, which start from the path in `grepRoot`.
+ */
+export interface ProjectAbout {
+    name: string;
+    testDir: string;
+    dependencies: string[];
+    /** The project's settings, which its setup files are read from. */
+    settings: Setting;
+    /** The folder its setup files are found from: Vitest's root, or the config's folder. */
+    root: string;
+    /** For a Vitest project from a config another config lists, the outermost one, whose global setup runs too. */
+    container: ConfigFile | null;
+    /** The config the project is written in. */
+    config: ConfigFile;
+    grep: ((title: string) => boolean) | null;
+    grepRoot: string;
+    defaults: ProjectDefaults;
+}
+/**
+ * The settings a project gives its tests, as written; null when unset. Playwright's `timeout`, `retries`, `repeatEach`
+ * and `fullyParallel`; Vitest's `testTimeout`, `retry`, `repeats` and `sequence.concurrent`, and the tags it defines.
+ */
+interface ProjectDefaults {
+    timeout: Setting | null;
+    retry: Setting | null;
+    repeatEach: Setting | null;
+    repeats: Setting | null;
+    parallel: Setting | null;
+    tags: VitestTags | null;
+}
+/** The config a file uses, the settings of its project, and how that config runs it. */
+export interface Placement {
+    config: ConfigFile | null;
+    settings: Setting | null;
+    /** False when no config runs the file; null when there is no config, or one can't tell. */
+    runs: Run | false | null;
+    /** The projects of the config that run the file, which a Playwright `grep` may narrow per test; null when unknown. */
+    projects: ProjectAbout[] | null;
+}
+/** Finds the configs a file is under and decides which one runs it, as the runner started at the root would. */
+export declare class ConfigRuns {
+    private readonly configs;
+    private readonly framework;
+    private readonly version;
+    /** Whether the configs find the test files, as in a scan without patterns, rather than the patterns. */
+    private readonly findsFiles;
+    private readonly projects;
+    private readonly ignoreRules;
+    private readonly folderStates;
+    /** The Vitest configs whose projects are being found, to stop at one whose projects name itself. */
+    private readonly expanding;
+    constructor(configs: Configs, framework: Framework, version: [number, number] | null, findsFiles: boolean);
+    /**
+     * The config a file uses, as the runner started at the root would: the outermost config at or above it that runs it,
+     * with the project that does; else the outermost one whose files the scan can't work out, reported then; else the
+     * nearest config.
+     */
+    placementOf(file: string): Placement;
+    /** The projects of a config the output lists; null when the scan can't work them out. */
+    projectsIn(config: ConfigFile): ProjectRecord[] | null;
+    /**
+     * A config's project, named as the runner names it, with the files it runs; null when there is none, or the scan
+     * can't tell which files it runs.
+     */
+    projectNamed(config: ConfigFile, name: string): {
+        about: ProjectAbout;
+        runs: (file: string) => unknown;
+    } | null;
+    private projectsOf;
+    /** Vitest's `retry`: before 4.1, which reads only a count, an object is one the scan can't work out. */
+    private vitestRetry;
+    /** A project whose files can't be worked out, because of `setting` under `key`: it may run any file. */
+    private unknownProject;
+    private playwrightProjects;
+    /** A Playwright project: its own settings, else the config's, else Playwright's defaults. */
+    private playwrightProject;
+    /**
+     * Whether `.gitignore` files in a project's test folder, and the folders below it on the way to the file, leave the
+     * file out, as Playwright reads them.
+     */
+    private isGitIgnored;
+    /** A folder's status and the rules inside it, worked out once per project folder however many files it holds. */
+    private folderState;
+    private rulesIn;
+    private vitestProjects;
+    /** A project written in `test.projects`, which inherits the root config as each version of Vitest decides. */
+    private vitestEntry;
+    /**
+     * The projects of a config file or folder `test.projects` names: the config's own, also the projects it lists in
+     * Vitest 5, or a project with Vitest's defaults for a folder without a config.
+     */
+    private vitestPath;
+    /**
+     * A Vitest project: its files are found from `test.dir`, else `test.root` or `root`, else its folder. With browser
+     * mode on, each of `browser.instances` is a project of its own, named as Vitest names it.
+     */
+    private vitestProject;
+    /** The files a Vitest project runs and its settings; `ownTags`, when set, in place of the tags in `settings`. */
+    private vitestFiles;
+}
+/**
+ * What the config a file uses gives it: Playwright's `forbidOnly`, read from the top level only, as Playwright reads
+ * it, and for each test, the projects that run it and what they set; null without a config.
+ */
+export declare function fileConfig(placement: Placement, framework: Framework, version: [number, number] | null, file: string): FileConfig | null;
+export {};