test-inventory 0.7.0 → 0.9.0

package/dist/config-runs.d.ts

@@ -1,4 +1,7 @@
 import { type ConfigFile, type Configs, type Setting } from './config.ts';
+import { type MochaInterface } from './frameworks/mocha.ts';
+import type { WebdriverIOFramework } from './frameworks/webdriverio.ts';
+import type { ImportMap } from './resolve.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. */
@@ -58,6 +61,11 @@ export declare class ConfigRuns {
     private readonly projects;
     private readonly ignoreRules;
     private readonly folderStates;
+    /** The project Jest runs with when no config is found up to the root. */
+    private jestDefaults;
+    private mochaDefaults;
+    private nodeRuns;
+    private bunFiles;
     /** The Vitest configs whose projects are being found, with their names, to stop at one whose projects name itself. */
     private readonly expanding;
     constructor(configs: Configs, framework: Framework, version: [number, number] | null, findsFiles: boolean);
@@ -84,6 +92,66 @@ export declare class ConfigRuns {
         about: ProjectAbout;
         runs: (file: string) => unknown;
     } | null;
+    /** Mocha runs one set of files, from the config it starts with, or its defaults without one. */
+    private placeMocha;
+    /**
+     * The files Mocha runs, as it looks them up from the root, the folder it starts in, wherever its config is: each
+     * `spec` entry a glob, a file, a file without its extension, or a folder whose files with one of the `extension`s it
+     * takes, also in folders below with `recursive`, less those `ignore` matches; and the `file` entries, loaded first.
+     * With globs, every file they match, less `ignore`. A timeout may be written as `'2s'`.
+     */
+    private mochaProject;
+    /**
+     * Jasmine runs one set of files, from its config. Without one it runs none, unless it is given files: Karma and
+     * Angular projects give it theirs from their own configs, which the scan doesn't read, so their globs decide.
+     */
+    private placeJasmine;
+    /**
+     * The files Jasmine runs: those under `spec_dir`, from the root, that a `spec_files` glob matches, less those a glob
+     * starting with `!` matches. With globs, every file they match, as files given to Jasmine replace `spec_files`.
+     */
+    private jasmineProject;
+    /**
+     * Cypress runs a file in its e2e project, or in its component project when the config sets up component testing.
+     * Without a config it runs nothing, unless it is given files.
+     */
+    private placeCypress;
+    /**
+     * Cypress's testing types as projects: `e2e`, and `component` when the config has it. Each runs the files under the
+     * config's folder that its `specPattern` matches, dot files left out, without those its `excludeSpecPattern` matches,
+     * dot files included, and those in `node_modules` unless a `specPattern` names it; component testing also leaves out
+     * the files e2e's `specPattern` matches. `cypress run` matches each pattern against the whole path, as globby does.
+     */
+    private cypressProjects;
+    /** `bun test` runs the files of `bunFilesOf`, with the settings of the `bunfig.toml` in the root, when there is one. */
+    private placeBun;
+    /**
+     * The files `bun test` runs: those under `[test] root`, the root by default, whose name without its extension ends
+     * with `.test`, `_test`, `.spec` or `_spec`, with a JavaScript or TypeScript extension, outside dot folders and
+     * `node_modules`, and from Bun 1.3.11 outside the folders and files a `pathIgnorePatterns` glob matches. `[test] retry`
+     * applies to every test, and the tests of the files a `concurrentTestGlob` glob matches run at once.
+     */
+    private bunFilesOf;
+    /** `node --test` runs the files its arguments name, or without any, those its default patterns match; see `nodeFiles`. */
+    private placeNode;
+    /**
+     * The files `node --test` runs from the root, outside dot folders and `node_modules`: those the arguments of the
+     * package.json script that runs it give, the `test` script first, each a glob or a path, and from Node.js 26.8 a folder
+     * for the default patterns inside it; without arguments, the default patterns. They take TypeScript files too from
+     * Node.js 22.18, which strips types by default.
+     */
+    private nodeFiles;
+    /** WebdriverIO runs the files of the config in the root; without one, it runs nothing, unless it is given files. */
+    private placeWebdriverIO;
+    /**
+     * The files `wdio` runs: those under `rootDir`, the config's folder by default, that a `specs` glob matches, also in
+     * the nested lists that group files into one worker, less those `exclude` leaves out. A capability's own `specs` replace the config's for it, and its `exclude` adds to the config's. Globs leave out
+     * dot files and folders, and one without a `/` matches a file's name at any depth. When every `exclude` entry holds a
+     * `/`, `\` or `*`, they are globs too; otherwise each one leaves out every file whose URL contains it. Files given
+     * with `--spec` replace `specs`, so scanned with globs, every file they match counts as run, less the excludes. The
+     * config's `mochaOpts.timeout` and `retries`, or `jasmineOpts.defaultTimeoutInterval`, apply to every test.
+     */
+    private webdriverioProject;
     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;
@@ -107,16 +175,41 @@ export declare class ConfigRuns {
     /** A folder's status and the rules inside it, worked out once per project folder however many files it holds. */
     private folderState;
     private rulesIn;
+    /** A config for the defaults of a runner started where no config is found. */
+    private noConfig;
+    /**
+     * Jest's projects: the config itself, or the entries of its `projects`. A path or glob there names a folder, whose
+     * config is the one Jest finds from it, or a config file; an object is a project whose `rootDir` defaults to the
+     * config's folder. The config's own test files then count only when an entry names its folder.
+     */
+    private jestProjects;
+    /**
+     * The files a Jest project runs, as Jest's SearchSource picks them: under one of `roots`, with an extension in
+     * `moduleFileExtensions`, not left out by `modulePathIgnorePatterns`, matching `testMatch` or `testRegex`, and not
+     * `testPathIgnorePatterns`. Paths and patterns are matched with `/`, and `<rootDir>` stands for `rootDir`. `global`
+     * is the config Jest is started with, whose `testTimeout` applies to every project in Jest 29.
+     */
+    private jestProject;
     /**
      * The projects of a Vitest config, the one the runner starts with or, in Vitest 5, a config another lists, whose name
      * then goes around the names of its projects.
      */
+    /**
+     * A project's settings over those of its `preset` when that is a local file, as `'../../jest.preset.js'`, which Jest
+     * finds from `rootDir`: the project's own settings win, as Jest merges them. A preset that is a package isn't read.
+     */
+    private withPreset;
     private vitestProjects;
     /**
      * A project written in `test.projects`, which inherits the root config as each version of Vitest decides, named
      * after `index` when it has no name of its own.
      */
     private vitestEntry;
+    /**
+     * The folder an inline project runs from. Without a root of its own, every version runs it from the config's root;
+     * Vitest 5 also resolves its own root from there, where older versions resolve it from the config's folder.
+     */
+    private inlineRoot;
     /**
      * 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. Without a name, a project is named
@@ -125,15 +218,36 @@ export declare class ConfigRuns {
     private vitestPath;
     /**
      * A Vitest project, with the name Vitest gives it: 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.
+     * else its folder; with `isRoot`, `folder` is its root already. 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.
+ * What the config a file uses gives it: Playwright's `forbidOnly` or Vitest's `allowOnly`, read from the top level
+ * only, as the runners read them, 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;
+/**
+ * The interface Mocha's `ui` gives a file's tests: BDD by default, or TDD. Another one, QUnit, exports or a package,
+ * declares tests in a way the scan doesn't read, which is reported on the config, and the file is read as BDD.
+ */
+export declare function mochaInterface(placement: Placement, configs: Configs): MochaInterface;
+/** The interface WebdriverIO's `mochaOpts.ui` gives a file's tests, read as Mocha's `ui`. */
+export declare function webdriverioInterface(placement: Placement, configs: Configs): MochaInterface | undefined;
+/**
+ * The framework a WebdriverIO config runs the specs with: Mocha by default, or Jasmine. Cucumber runs feature files,
+ * which the scan doesn't read; that and a value the scan can't work out are reported on the config when `configs` is
+ * given, and the files are read as Mocha's.
+ */
+export declare function webdriverioFramework(placement: Placement, configs: Configs | null): WebdriverIOFramework;
+/**
+ * How the config a file runs with maps its imports, for its dependencies: Vite's `resolve.alias` and Vitest's
+ * `test.alias`, from the project and from the config file, and Jest's `moduleNameMapper`, `modulePaths` and
+ * `moduleDirectories` other than `node_modules`, with `<rootDir>` in them. Null for the other runners, without a
+ * config, or when it maps nothing.
+ */
+export declare function importMap(placement: Placement, framework: Framework): ImportMap | null;
 export {};