test-inventory 0.6.1 → 0.8.0

package/CHANGELOG.md

@@ -1,5 +1,105 @@
 # test-inventory
 
+## 0.8.0
+
+### Minor Changes
+
+- [#75](https://github.com/Huldoser/test-inventory/pull/75) [`f6690bb`](https://github.com/Huldoser/test-inventory/commit/f6690bbe5e49ce048ec4169f21bed23f702942d1) - `--framework` (library: `framework`) is now optional. Without it, the scan takes the runner the project uses: the one
+  whose package a `package.json` in the root or below it lists, or whose config file is there, else one a `package.json`
+  above the root lists. A project with several runners, or none, gets a usage error (a `TypeError` in the library) that
+  names what it found.
+
+- [#75](https://github.com/Huldoser/test-inventory/pull/75) [`f6690bb`](https://github.com/Huldoser/test-inventory/commit/f6690bbe5e49ce048ec4169f21bed23f702942d1) - Jest 29 and 30: `--framework jest` (library: `framework: 'jest'`) lists the tests of Jest files with the same keys as
+  Playwright and Vitest tests. It reads Jest's globals, `fit`, `xit`, `xtest`, `fdescribe` and `xdescribe` among them,
+  imports and `require()` of `@jest/globals`, the chains Jest has, such as `test.concurrent.only.each`, `.failing` as
+  `expectedToFail`, the timeout passed third, `jest.retryTimes()` as `retries` for every test of the file (from 30.5,
+  with `entireDescribe`, of its describe) and `waitBeforeRetry` as `retryDelay`, and `@group` pragmas as tags, as
+  jest-runner-groups reads them. `--expand-cases` titles each case as jest-each 29 and 30 do. Calls Jest refuses, such
+  as `test.only.concurrent`, `test('title')` without a function or an async describe, mark the file's tests `notLoaded`.
+
+  Without globs, the test files come from the Jest config, read as Jest reads it: `jest.config.*`, else `package.json`,
+  with `roots`, `testMatch`, `testRegex`, the ignore patterns, `moduleFileExtensions`, `projects` named by
+  `displayName`, `testTimeout` and `injectGlobals`, also through Jest 30.3's `defineConfig()` and `mergeConfig()`;
+  without any config, Jest's defaults apply. `framework` in the output
+  can now be `jest`, an open set, so `schemaVersion` stays 1.
+
+  The `cases-not-expanded` message no longer names Vitest, as Jest tables can get it too.
+
+### Patch Changes
+
+- [#75](https://github.com/Huldoser/test-inventory/pull/75) [`f6690bb`](https://github.com/Huldoser/test-inventory/commit/f6690bbe5e49ce048ec4169f21bed23f702942d1) - `require()` of a local file is followed as an import is: tables, titles and other values it exports, with
+  `module.exports` or `exports.name`, are read, and helper functions it exports that declare tests are followed. A
+  helper function a shared file imports and exports again, as an `index.js` of helpers does, is followed to where it is
+  written, instead of getting an `unresolved-test-import` error. A helpers file may export a test function it takes from
+  the runner's globals, as `export const pendingTest = xit`, or from the framework's module, with its modifiers.
+
+- [#75](https://github.com/Huldoser/test-inventory/pull/75) [`f6690bb`](https://github.com/Huldoser/test-inventory/commit/f6690bbe5e49ce048ec4169f21bed23f702942d1) - A call the runner refuses, such as `test.only.skip(...)`, that is only reached under a condition no longer marks every
+  test of its file `notLoaded`, as the file loads unless the condition holds; the call is still reported. A test function
+  chosen with `&&`, `||` or `??`, as in `const onCi = process.env.CI && test.skip || test`, is read like one chosen with
+  `?:`. In a config, a list with a spread the scan can't work out keeps the items it can.
+
+- [#75](https://github.com/Huldoser/test-inventory/pull/75) [`f6690bb`](https://github.com/Huldoser/test-inventory/commit/f6690bbe5e49ce048ec4169f21bed23f702942d1) - A config that `require()`s a local file, as a CommonJS config does with a shared base, now reads what that file
+  exports, as an `import` of it already did, and a JSON file, required or imported, is read as its value.
+
+- [#75](https://github.com/Huldoser/test-inventory/pull/75) [`f6690bb`](https://github.com/Huldoser/test-inventory/commit/f6690bbe5e49ce048ec4169f21bed23f702942d1) - A table or loop gets its `caseCount` when its length is known even if one of its values isn't, as in
+  `[NaN, Infinity].forEach(...)` or a table with a call in a row. A test or describe titled by a function or class
+  written in place, as `describe(function OrderBook() {}, ...)`, takes its name, as the runners do. Code the parser
+  fails to hand over, such as a JSX name written as a Unicode escape, gets a `parse-error` instead of an
+  `internal-error`.
+
+- [#75](https://github.com/Huldoser/test-inventory/pull/75) [`f6690bb`](https://github.com/Huldoser/test-inventory/commit/f6690bbe5e49ce048ec4169f21bed23f702942d1) - `dependencyHash` is faster on large projects: the files a test file and its describes reach are put together once for
+  all their tests, and a workspace's packages are found once, not once per folder that imports one. A scan of the Nx
+  repository with 17,571 tests went from 19.4 to 11.9 seconds. Hashes are unchanged.
+
+## 0.7.0
+
+### Minor Changes
+
+- [#72](https://github.com/Huldoser/test-inventory/pull/72) [`cf784f0`](https://github.com/Huldoser/test-inventory/commit/cf784f070e66523df1d68c546f033e1f495f0f49) - `--expand-cases` (library: `expandCases: true`) lists each case of a `.each` or `.for` table and each pass of a loop
+  whose values the scan can work out as its own record, with the title the runner gives it. Vitest's titles follow the
+  rules of the project's Vitest version, 3.0 to 5: `%s`, `%d`, `%i`, `%f`, `%j`, `%o`, `%O`, `%c`, `%#`, `%$` and `$name`,
+  with values quoted and cut as that version does; they match the names Vitest 3.0, 3.1, 3.2, 4.0, 4.1 and 5.0 list.
+  Each case's values are bound in its callback, so titles, tags and conditions built from them are worked out per case,
+  and an `if`, `?:`, `&&`, `||` or `??` that reads nothing but them registers only the branch it takes. Loops in test
+  and hook bodies and loops over a `var` are not expanded, and a file starts expansions up to 1,000 loop passes and
+  describe cases.
+  Suites and tests have a new key, `caseIndex`: the case's index from 0, as `%#` counts, or `null` without the option. A
+  table that can't be expanded stays one record with a new `cases-not-expanded` warning. Without the option the output
+  is as before, apart from `caseIndex: null` on every suite and test.
+
+- [#72](https://github.com/Huldoser/test-inventory/pull/72) [`cf784f0`](https://github.com/Huldoser/test-inventory/commit/cf784f070e66523df1d68c546f033e1f495f0f49) - Values imported from other files of the project are now worked out: a title, tag, annotation, reason, run setting or
+  `.each` table built from a constant, enum or default export of another module, through re-exports, `export *`,
+  `import * as` and JSON files, found the same way as helper functions (relative paths, tsconfig `paths`, `#imports`,
+  workspace packages). Values from installed packages are still not read, and keep their diagnostic.
+
+  A test in a `for...of`, `for...in`, `forEach` or `map` loop over values the scan can work out now has `caseCount`, the
+  number of tests the runner registers, and no `test-in-loop` warning; the warning now marks a loop the scan can't
+  count. Values also work out arithmetic on numbers, as in `30 * 1000`, `?:`, `&&`, `||`, `??`, comparisons,
+  `Object.keys()`, `Object.values()`, `Object.entries()`, `JSON.stringify()`, `String()`, and a string's `toUpperCase()`,
+  `toLowerCase()` and `trim()` and an array's `join()`. A skip condition that works out to a constant, such as
+  `side === 'short'` in a helper called with `'buy'`, now sets the state it gives instead of being kept as a condition.
+
+  Code after an `if` whose branch always returns or throws, as in `if (!strategy.enabled) return;` in a helper, is now
+  under the opposite condition, so its tests have `isInCondition` and a loop around them no count. A tagged-template
+  table is counted as Vitest splits it: outer pipes are columns, an incomplete last row is left out, and a template
+  without values is one case.
+
+  A test whose title was its source text and is now worked out gets a new `id`, once.
+
+### Patch Changes
+
+- [#71](https://github.com/Huldoser/test-inventory/pull/71) [`bf8383f`](https://github.com/Huldoser/test-inventory/commit/bf8383f009a73a026d128cd8e050505cdd63cfb5) - A name destructured from a test object, as in `const { describe, beforeEach } = test`, is now read as that member:
+  `beforeEach(...)` is a hook, `describe(...)` a describe and `skip(...)` a skipped test, for Playwright and Vitest,
+  also nested, as in `const { describe: { serial } } = test`. Every such name was read as `test` itself, so a hook got
+  `test-without-body` and every test of the file `notLoaded`, and the tests inside a describe were left out with
+  `nested-test` warnings.
+
+- [#71](https://github.com/Huldoser/test-inventory/pull/71) [`bf8383f`](https://github.com/Huldoser/test-inventory/commit/bf8383f009a73a026d128cd8e050505cdd63cfb5) - When the root and the folders above it don't have the framework, its version is now read from the shallowest
+  `package.json` below the root that declares it and holds scanned files, as `code/package.json` in a monorepo, with
+  that package's lockfile or installed copy first. The version was `null` there, so the newest rules applied: Vitest
+  5's, which refuse a file that calls `vi.mock` inside a block, made every test of such a file `notLoaded` in a project
+  on Vitest 3.
+
 ## 0.6.1
 
 ### Patch Changes

package/README.md

@@ -2,7 +2,7 @@
 
 Test metadata from source code, not from test results.
 
-test-inventory reads Playwright and Vitest test files and lists every test declaration as JSON: its title, file and
+test-inventory reads Playwright, Vitest and Jest test files and lists every test declaration as JSON: its title, file and
 lines, the describes around it, its tags and annotations, and whether it is active, skipped, fixme, todo, expected
 to fail or in a file the runner refuses to load, with the condition when the state only applies sometimes. It parses
 the code and runs nothing, so it needs no browsers, no build and no runner configuration.
@@ -15,7 +15,7 @@ Documentation: [huldoser.github.io/test-inventory](https://huldoser.github.io/te
 npm install --save-dev test-inventory
 ```
 
-Node.js 22.12 or newer, on Linux, macOS or Windows. Playwright 1.42 or newer, Vitest 3.0 or newer.
+Node.js 22.12 or newer, on Linux, macOS or Windows. Playwright 1.42 or newer, Vitest 3.0 or newer, Jest 29.0 or newer.
 
 ## Command line
 
@@ -25,7 +25,8 @@ Node.js 22.12 or newer, on Linux, macOS or Windows. Playwright 1.42 or newer, Vi
 npx test-inventory "tests/**/*.spec.ts" --framework playwright --output inventory.json
 ```
 
-Without the glob, the test files are those the Playwright or Vitest configs in the project run.
+Without the glob, the test files are those the project's Playwright, Vitest or Jest configs run. Without
+`--framework`, the scan takes the runner the project uses, and asks for `--framework` when it uses several.
 
 For this spec from a trading app's UI tests, `tests/alerts.spec.ts`:
 

package/dist/case-titles.d.ts

@@ -0,0 +1,27 @@
+import type { Value } from './values.ts';
+/**
+ * The title Vitest gives one case of a `.each` or `.for` table, read from Vitest's `formatTitle` in 3.0, 3.1, 4.1
+ * and 5.0: `%#` and `%$` for the case's index, printf placeholders for its items, and `$name` for a key of its object.
+ * Vitest 3 formats the whole title and then replaces `$name`, also inside the values it put in; Vitest 4 and 5 format
+ * each placeholder on its own and replace `$name` only in the text between them. Vitest 3.0 has no `%$`, and reads
+ * `$name` only when the case is an object. Null when the title shows a value the scan doesn't format the way Vitest
+ * does, which is any array or object printed as a whole.
+ *
+ * `version` is Vitest's `[major, minor]`, null for the newest rules. `truncate` is the length Vitest shortens a value to,
+ * 40 unless the config sets `chaiConfig.truncateThreshold` (3 and 4) or `taskTitleValueFormatTruncate` (5); 0 keeps
+ * values whole.
+ */
+export declare function vitestCaseTitle(template: string, items: readonly Value[], index: number, version: readonly [number, number] | null, truncate?: number): string | null;
+/**
+ * The title Jest gives one row of a `.each` table of arrays, or of single values, read from `jest-each` 29.0, 29.7,
+ * 30.0 and 30.5: `%#` and from 30.0 `%$` for the row's index, then one placeholder per item, in order. `%p` shows the
+ * item with pretty-format and the others with Node's `util.format`, which Jest calls too. Items left over are dropped.
+ * Null when an item is an array or object that `util.format` would show, which differs between Node versions.
+ */
+export declare function jestRowTitle(template: string, row: readonly Value[], index: number, version: readonly [number, number] | null): string | null;
+/**
+ * The title Jest gives one case of a `.each` table of objects, or one row of a tagged-template table: `$name` and
+ * `$name.path` for the case's values, and `$#` for its index. `keepsEscapes` is set for a tagged template, where `%%`
+ * stays as written. Null when Jest fails the table, as when a path goes through `null` before 30.0.
+ */
+export declare function jestKeysTitle(template: string, item: Record<string, Value>, index: number, version: readonly [number, number] | null, keepsEscapes: boolean): string | null;

package/dist/case-titles.js

@@ -0,0 +1,329 @@
+import { format } from 'node:util';
+/**
+ * The title Vitest gives one case of a `.each` or `.for` table, read from Vitest's `formatTitle` in 3.0, 3.1, 4.1
+ * and 5.0: `%#` and `%$` for the case's index, printf placeholders for its items, and `$name` for a key of its object.
+ * Vitest 3 formats the whole title and then replaces `$name`, also inside the values it put in; Vitest 4 and 5 format
+ * each placeholder on its own and replace `$name` only in the text between them. Vitest 3.0 has no `%$`, and reads
+ * `$name` only when the case is an object. Null when the title shows a value the scan doesn't format the way Vitest
+ * does, which is any array or object printed as a whole.
+ *
+ * `version` is Vitest's `[major, minor]`, null for the newest rules. `truncate` is the length Vitest shortens a value to,
+ * 40 unless the config sets `chaiConfig.truncateThreshold` (3 and 4) or `taskTitleValueFormatTruncate` (5); 0 keeps
+ * values whole.
+ */
+export function vitestCaseTitle(template, items, index, version, truncate = 40) {
+    const rules = version === null || version[0] >= 5 ? 5 : version[0];
+    const isFirst3 = version !== null && version[0] === 3 && version[1] === 0;
+    let text = template;
+    if (text.includes('%#') || (!isFirst3 && text.includes('%$'))) {
+        text = text.replace(/%%/g, ESCAPED).replace(/%#/g, String(index));
+        if (!isFirst3)
+            text = text.replace(/%\$/g, String(index + 1));
+        text = text.replaceAll(ESCAPED, '%%');
+    }
+    const count = text.split('%').length - 1;
+    if (text.includes('%f'))
+        text = negativeFloats(text, items);
+    const isObjectItem = isObject(items[0]);
+    const attribute = (key) => {
+        const isArrayKey = !isFirst3 && /^\d+$/.test(key);
+        if (!isObjectItem && !isArrayKey)
+            return `$${key}`;
+        const element = isArrayKey ? objectAttr(items, key) : undefined;
+        const value = isObjectItem ? objectAttr(items[0], key, element) : element;
+        if (value === NOT_PLAIN)
+            return null;
+        if (rules === 5)
+            return typeof value === 'string' ? shorten(value, truncate) : prettyFormat(value, truncate);
+        return loupe(value, truncate === 0 ? Infinity : truncate);
+    };
+    if (rules === 3) {
+        const formatted = printf(text, items.slice(0, count), rules, truncate);
+        return formatted === null ? null : replaceAttributes(formatted, ATTRIBUTE_3, attribute);
+    }
+    let output = '';
+    let used = 0;
+    let last = 0;
+    for (const match of text.matchAll(PLACEHOLDER)) {
+        const between = replaceAttributes(text.slice(last, match.index), rules === 5 ? ATTRIBUTE_5 : ATTRIBUTE_3, attribute);
+        if (between === null)
+            return null;
+        output += between;
+        // Each placeholder, `%%` included, takes the next item, also one past the end of the case.
+        const placeholder = printf(match[0], [items[used++]], rules, truncate);
+        if (placeholder === null)
+            return null;
+        output += placeholder;
+        last = match.index + match[0].length;
+    }
+    const rest = replaceAttributes(text.slice(last), rules === 5 ? ATTRIBUTE_5 : ATTRIBUTE_3, attribute);
+    return rest === null ? null : output + rest;
+}
+const ESCAPED = '__vitest_escaped_%__';
+const PLACEHOLDER = /%[sdjifoOc%]/g;
+const ATTRIBUTE_3 = /\$([$\w.]+)/g;
+const ATTRIBUTE_5 = /\$([$\p{ID_Continue}.]+)/gu;
+/** A key that leads to something other than a plain value, such as `toString`, which Vitest would show as a function. */
+const NOT_PLAIN = Symbol('not plain');
+function isPrimitive(value) {
+    return typeof value !== 'object' || value === null;
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Vitest's `objectAttr`: a path such as `order.qty`, `legs[0].side` or `0`, read as `new Object(value)[key]` reads it. */
+function objectAttr(source, path, fallback) {
+    let result = source;
+    for (const key of path.replace(/\[(\d+)\]/g, '.$1').split('.')) {
+        if (result === null || result === undefined)
+            return fallback;
+        const object = Object(result);
+        if (Object.hasOwn(object, key)) {
+            result = object[key];
+        }
+        else if (key in object) {
+            return NOT_PLAIN;
+        }
+        else {
+            return fallback;
+        }
+        if (result === undefined)
+            return fallback;
+    }
+    return result;
+}
+/** `%f` of `-0` shows a minus, which Vitest adds for the item at the same place among the items. */
+function negativeFloats(template, items) {
+    let text = template;
+    template.match(/%f/g).forEach((_, index) => {
+        if (!Object.is(items[index], -0))
+            return;
+        let occurrence = 0;
+        text = text.replace(/%f/g, (match) => (++occurrence === index + 1 ? '-%f' : match));
+    });
+    return text;
+}
+function replaceAttributes(text, pattern, attribute) {
+    let output = '';
+    let last = 0;
+    for (const match of text.matchAll(pattern)) {
+        const value = attribute(match[1]);
+        if (value === null)
+            return null;
+        output += text.slice(last, match.index) + value;
+        last = match.index + match[0].length;
+    }
+    return output + text.slice(last);
+}
+/** Vitest's `format()` for a template and its arguments, for the values it shows the way the scan does. */
+function printf(template, args, rules, truncate) {
+    let used = 0;
+    let output = '';
+    let last = 0;
+    for (const match of template.matchAll(PLACEHOLDER)) {
+        const placeholder = match[0];
+        const formatted = placeholder === '%%'
+            ? '%'
+            : used >= args.length
+                ? placeholder
+                : formatValue(placeholder, args[used++], rules, truncate);
+        if (formatted === null)
+            return null;
+        output += template.slice(last, match.index) + formatted;
+        last = match.index + placeholder.length;
+    }
+    output += template.slice(last);
+    // Arguments beyond the placeholders are appended, as `console.log` does.
+    for (const value of args.slice(used)) {
+        if (!isPrimitive(value))
+            return null;
+        output += ` ${String(value)}`;
+    }
+    return output;
+}
+function formatValue(placeholder, value, rules, truncate) {
+    switch (placeholder) {
+        case '%s':
+            if (!isPrimitive(value))
+                return null;
+            return Object.is(value, -0) ? '-0' : String(value);
+        case '%d':
+            return Number(value).toString();
+        case '%i':
+            return isPrimitive(value) ? Number.parseInt(String(value)).toString() : null;
+        case '%f':
+            return isPrimitive(value) ? Number.parseFloat(String(value)).toString() : null;
+        case '%j':
+            // JSON.stringify(undefined) gives undefined, which the title shows as text.
+            return value === undefined ? 'undefined' : JSON.stringify(value);
+        case '%c':
+            return '';
+        default:
+            // `%o` and `%O` inspect the value: with loupe in Vitest 3 and 4, with pretty-format and the truncate option in 5.
+            if (!isPrimitive(value))
+                return null;
+            return rules === 5 ? prettyFormat(value, truncate) : loupe(value, Infinity);
+    }
+}
+/** A string cut to `length` with an ellipsis, without splitting a surrogate pair; 0 keeps it whole. */
+function shorten(text, length) {
+    if (length === 0 || text.length <= length)
+        return text;
+    let end = length - 1;
+    if (isHighSurrogate(text[end - 1]))
+        end -= 1;
+    return `${text.slice(0, end)}…`;
+}
+function isHighSurrogate(char) {
+    return char !== undefined && char >= '\ud800' && char <= '\udbff';
+}
+/** Vitest 5's `inspect()` of a value, through pretty-format with single quotes. */
+function prettyFormat(value, truncate) {
+    if (!isPrimitive(value))
+        return null;
+    if (typeof value !== 'string')
+        return Object.is(value, -0) ? '-0' : String(value);
+    const quoted = `'${value}'`;
+    if (truncate === 0 || quoted.length <= truncate)
+        return quoted;
+    let end = truncate - 1;
+    if (end > 0 && isHighSurrogate(quoted[end - 1]))
+        end -= 1;
+    return `'${quoted.slice(1, end)}…'`;
+}
+const LOUPE_ESCAPED = new RegExp("['\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]", 'g');
+const LOUPE_ESCAPES = {
+    '\b': '\\b',
+    '\t': '\\t',
+    '\n': '\\n',
+    '\f': '\\f',
+    '\r': '\\r',
+    "'": "\\'",
+};
+/** loupe's `inspect()` of a value, as Vitest 3 and 4 show it, cut to `truncate`. */
+function loupe(value, truncate) {
+    if (!isPrimitive(value))
+        return null;
+    if (typeof value === 'string') {
+        const escaped = value.replace(LOUPE_ESCAPED, (char) => LOUPE_ESCAPES[char] ?? `\\u${`0000${char.charCodeAt(0).toString(16)}`.slice(-4)}`);
+        return `'${loupeTruncate(escaped, truncate - 2)}'`;
+    }
+    if (typeof value !== 'number')
+        return String(value);
+    if (Number.isNaN(value) || !Number.isFinite(value))
+        return String(value);
+    if (value === 0)
+        return Object.is(value, -0) ? '-0' : '+0';
+    return loupeTruncate(String(value), truncate);
+}
+function loupeTruncate(text, length) {
+    if (length < 1 && text.length > 1)
+        return '…';
+    if (text.length <= length || text.length <= 1)
+        return text;
+    let end = length - 1;
+    if (end > 0 && isHighSurrogate(text[end - 1]))
+        end -= 1;
+    return `${text.slice(0, end)}…`;
+}
+/** The text Jest puts in place of `%%` and of `%` in string values while it formats a title. */
+const JEST_ESCAPE = '@@__JEST_EACH_PLACEHOLDER_ESCAPE__@@';
+const JEST_PLACEHOLDER = /%[#Odfijops]/;
+/** The placeholders `util.format` takes an argument for. */
+const NODE_PLACEHOLDER = /%[sdifjoOc]/;
+/**
+ * The title Jest gives one row of a `.each` table of arrays, or of single values, read from `jest-each` 29.0, 29.7,
+ * 30.0 and 30.5: `%#` and from 30.0 `%$` for the row's index, then one placeholder per item, in order. `%p` shows the
+ * item with pretty-format and the others with Node's `util.format`, which Jest calls too. Items left over are dropped.
+ * Null when an item is an array or object that `util.format` would show, which differs between Node versions.
+ */
+export function jestRowTitle(template, row, index, version) {
+    const isJest30 = version === null || version[0] >= 30;
+    const replacesWithFunction = version === null || version[0] > 30 || (version[0] === 30 && version[1] >= 5);
+    let text = template.replaceAll('%%', JEST_ESCAPE).replace('%#', String(index));
+    if (isJest30)
+        text = text.replace('%$', String(index + 1));
+    for (const item of row) {
+        const placeholder = JEST_PLACEHOLDER.exec(text);
+        if (placeholder === null)
+            continue;
+        const value = typeof item === 'string' ? item.replaceAll('%', JEST_ESCAPE) : item;
+        if (placeholder[0] === '%p') {
+            const pretty = prettyFormatMin(value);
+            // Before 30.5, `$&` and the like in the value are read as replacement patterns, as JavaScript's `replace` does.
+            text = replacesWithFunction ? text.replace('%p', () => pretty) : text.replace('%p', pretty);
+        }
+        else if (placeholder[0] === '%j' && replacesWithFunction) {
+            const json = value === undefined ? 'undefined' : JSON.stringify(value);
+            text = text.replace('%j', () => json);
+        }
+        else if (isPrimitive(value) || (placeholder[0] === '%j' && NODE_PLACEHOLDER.exec(text)?.[0] === '%j')) {
+            text = format(text, value);
+        }
+        else {
+            return null;
+        }
+    }
+    return text.replaceAll(JEST_ESCAPE, '%');
+}
+/**
+ * The title Jest gives one case of a `.each` table of objects, or one row of a tagged-template table: `$name` and
+ * `$name.path` for the case's values, and `$#` for its index. `keepsEscapes` is set for a tagged template, where `%%`
+ * stays as written. Null when Jest fails the table, as when a path goes through `null` before 30.0.
+ */
+export function jestKeysTitle(template, item, index, version, keepsEscapes) {
+    let text;
+    try {
+        text = interpolateKeys(template, item, version);
+    }
+    catch {
+        return null;
+    }
+    const title = text.replace('$#', String(index));
+    return keepsEscapes ? title : title.replaceAll('%%', '%');
+}
+/** Jest's `interpolateVariables`, which throws where Jest's does. */
+function interpolateKeys(template, item, version) {
+    const [major, minor] = version ?? [Infinity, 0];
+    const show = (value) => (isPrimitive(value) ? String(value) : prettyFormatMin(value));
+    if (major === 29 && minor < 4) {
+        // Each match of each key is replaced in turn, as text, so a value can hold the next key's match.
+        const matches = Object.keys(item).flatMap((key) => template.match(new RegExp(`\\$${key}[\\.\\w]*`, 'g')) ?? []);
+        return matches.reduce((title, match) => title.replace(match, show(keyPath(item, match, false))), template);
+    }
+    let keys = Object.keys(item);
+    if (major > 30 || (major === 30 && minor >= 5)) {
+        keys = keys.filter((key) => key.length > 0).sort((a, b) => b.length - a.length);
+        if (keys.length === 0)
+            return template;
+        keys = keys.map((key) => key.replaceAll(/[$()*+.?[\\\]^{|}]/g, '\\$&'));
+    }
+    const pattern = new RegExp(`\\$(${keys.join('|')})[.\\w]*`, 'g');
+    return template.replaceAll(pattern, (match) => show(keyPath(item, match, major >= 30)));
+}
+/** The value a `$name.path` match leads to, as Jest's `getPath` reads it; from 30.0 `null` and `undefined` end it. */
+function keyPath(item, match, endsAtNull) {
+    let value = item;
+    for (const key of match.slice(1).split('.')) {
+        if (endsAtNull && (value === null || value === undefined))
+            return String(value);
+        // Throws on `null` and `undefined` before 30.0, as Jest's does.
+        if (!key || !Object.prototype.hasOwnProperty.call(value, key))
+            return value;
+        value = value[key];
+    }
+    return endsAtNull && (value === null || value === undefined) ? String(value) : value;
+}
+/** pretty-format with `{ min: true, maxDepth: 1 }`, as Jest shows a value in a title. */
+function prettyFormatMin(value, depth = 0) {
+    if (typeof value === 'string')
+        return `"${value.replaceAll(/"|\\/g, '\\$&')}"`;
+    if (isPrimitive(value))
+        return Object.is(value, -0) ? '-0' : String(value);
+    if (depth >= 1)
+        return Array.isArray(value) ? '[Array]' : '[Object]';
+    if (Array.isArray(value))
+        return `[${value.map((item) => prettyFormatMin(item, depth + 1)).join(', ')}]`;
+    const keys = Object.keys(value).sort();
+    return `{${keys.map((key) => `${prettyFormatMin(key)}: ${prettyFormatMin(value[key], depth + 1)}`).join(', ')}}`;
+}

package/dist/cli.d.ts

@@ -6,6 +6,6 @@ export interface Io {
     /** Read for `--related -`. */
     stdin?: Readable;
 }
-export declare const HELP = "Usage: test-inventory [glob...] --framework <playwright|vitest> [options]\n\nLists the tests in the matching files as JSON, read from the source code without running them. Without globs, the\ntest files are those the Playwright or Vitest configs in the root and the folders below it run.\n\nOptions:\n  --framework <name>           playwright or vitest (required)\n  --root <dir>                 project root; paths in the output are relative to it (default: current directory)\n  --ignore <glob>              leave out matching files; can be repeated (node_modules is always left out)\n  --framework-version <x.y.z>  apply the rules of this framework version instead of the one in the project\n  --comments <mode>            comments above tests: all, non-active or none (default: non-active)\n  --state <state>              keep tests in this state, such as skip or fixme; can be repeated\n  --tag <tag>                  keep tests with this tag, such as @smoke; can be repeated\n  --grep <regex>               keep tests whose full name matches, ignoring case\n  --only                       keep tests that use .only, or are inside a describe that does\n  --without-reason             keep tests that don't run and give no reason\n  --related <file>             keep tests a change to this file can affect; can be repeated; - reads files, one per\n                               line, from standard input, as git diff --name-only writes them\n  --fields <keys>              write only these keys of each test, separated by commas; id is always kept\n  --format <format>            json or jsonl, one record per line (default: json)\n  -o, --output <file>          write to a file instead of standard output\n  --pretty                     indent the JSON\n  -h, --help                   show this help\n  -v, --version                show the version\n\nExit codes: 0 when the scan finishes, even with diagnostics; 2 for invalid arguments, an output that cannot be\nwritten, or a crash. 1 is reserved for a future release.\n\nExamples:\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --output inventory.json\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --state skip --fields fullName,reason\n";
+export declare const HELP = "Usage: test-inventory [glob...] [options]\n\nLists the tests in the matching files as JSON, read from the source code without running them. Without globs, the\ntest files are those the Playwright, Vitest or Jest configs in the root and the folders below it run.\n\nOptions:\n  --framework <name>           playwright, vitest or jest (default: the one the project uses)\n  --root <dir>                 project root; paths in the output are relative to it (default: current directory)\n  --ignore <glob>              leave out matching files; can be repeated (node_modules is always left out)\n  --framework-version <x.y.z>  apply the rules of this framework version instead of the one in the project\n  --comments <mode>            comments above tests: all, non-active or none (default: non-active)\n  --expand-cases               one record per case of a .each or .for table and per pass of a loop, with its title\n  --state <state>              keep tests in this state, such as skip or fixme; can be repeated\n  --tag <tag>                  keep tests with this tag, such as @smoke; can be repeated\n  --grep <regex>               keep tests whose full name matches, ignoring case\n  --only                       keep tests that use .only, or are inside a describe that does\n  --without-reason             keep tests that don't run and give no reason\n  --related <file>             keep tests a change to this file can affect; can be repeated; - reads files, one per\n                               line, from standard input, as git diff --name-only writes them\n  --fields <keys>              write only these keys of each test, separated by commas; id is always kept\n  --format <format>            json or jsonl, one record per line (default: json)\n  -o, --output <file>          write to a file instead of standard output\n  --pretty                     indent the JSON\n  -h, --help                   show this help\n  -v, --version                show the version\n\nExit codes: 0 when the scan finishes, even with diagnostics; 2 for invalid arguments, an output that cannot be\nwritten, or a crash. 1 is reserved for a future release.\n\nExamples:\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --output inventory.json\n  test-inventory \"tests/**/*.spec.ts\" --framework playwright --state skip --fields fullName,reason\n";
 /** Runs the command line with the given arguments and streams. Resolves to the exit code. */
 export declare function run(argv: string[], io: Io): Promise<number>;

package/dist/cli.js

@@ -8,17 +8,18 @@ import { writeInventory, writeInventoryLines } from "./json.js";
 import { OptionsError, toPosixPath } from "./options.js";
 import { scan } from "./scan.js";
 import { toolVersion } from "./version.js";
-export const HELP = `Usage: test-inventory [glob...] --framework <playwright|vitest> [options]
+export const HELP = `Usage: test-inventory [glob...] [options]
 
 Lists the tests in the matching files as JSON, read from the source code without running them. Without globs, the
-test files are those the Playwright or Vitest configs in the root and the folders below it run.
+test files are those the Playwright, Vitest or Jest configs in the root and the folders below it run.
 
 Options:
-  --framework <name>           playwright or vitest (required)
+  --framework <name>           playwright, vitest or jest (default: the one the project uses)
   --root <dir>                 project root; paths in the output are relative to it (default: current directory)
   --ignore <glob>              leave out matching files; can be repeated (node_modules is always left out)
   --framework-version <x.y.z>  apply the rules of this framework version instead of the one in the project
   --comments <mode>            comments above tests: all, non-active or none (default: non-active)
+  --expand-cases               one record per case of a .each or .for table and per pass of a loop, with its title
   --state <state>              keep tests in this state, such as skip or fixme; can be repeated
   --tag <tag>                  keep tests with this tag, such as @smoke; can be repeated
   --grep <regex>               keep tests whose full name matches, ignoring case
@@ -114,6 +115,7 @@ export async function run(argv, io) {
                 ignore: { type: 'string', multiple: true },
                 'framework-version': { type: 'string' },
                 comments: { type: 'string' },
+                'expand-cases': { type: 'boolean' },
                 state: { type: 'string', multiple: true },
                 tag: { type: 'string', multiple: true },
                 grep: { type: 'string' },
@@ -141,8 +143,6 @@ export async function run(argv, io) {
         io.stdout.write(`${toolVersion}\n`);
         return FINISHED;
     }
-    if (values.framework === undefined)
-        return fail('--framework is required: playwright or vitest.');
     const format = values.format ?? 'json';
     if (!FORMATS.includes(format))
         return fail('--format must be json or jsonl.');
@@ -180,6 +180,7 @@ export async function run(argv, io) {
             ignore: values.ignore ?? [],
             frameworkVersion: values['framework-version'],
             comments: values.comments,
+            expandCases: values['expand-cases'],
         });
         const filtered = filterInventory(inventory, filter);
         result = fields === undefined ? filtered : pickTestFields(filtered, fields);

package/dist/config-dependencies.js

@@ -16,6 +16,7 @@ const SNAPSHOT_KEYS = {
         ['test', 'browser', 'expect', 'toMatchScreenshot', 'resolveScreenshotPath'],
         ['test', 'browser', 'expect', 'toMatchScreenshot', 'screenshotDirectory'],
     ],
+    jest: [['snapshotResolver']],
 };
 /** The keys of a config that name setup files, by framework; Vitest's are a project's own. */
 const SETUP_KEYS = {
@@ -24,6 +25,7 @@ const SETUP_KEYS = {
         ['test', 'setupFiles'],
         ['test', 'globalSetup'],
     ],
+    jest: [['setupFiles'], ['setupFilesAfterEnv'], ['globalSetup'], ['globalTeardown']],
 };
 const UNKNOWN_PROJECTS = "The projects that run the file can't be worked out, so dependencyHash doesn't cover their setup.";
 /**
@@ -86,7 +88,9 @@ export class ConfigDependencies {
             const found = written(settings, keys);
             for (const item of found ? listOf(found.setting) : []) {
                 if (item.kind === 'value' && typeof item.value === 'string') {
-                    const read = this.setupFile(root, item.value);
+                    // Jest's `<rootDir>` at the start of a path is the project's root.
+                    const file = item.value.startsWith('<rootDir>') ? `.${item.value.slice(9)}` : item.value;
+                    const read = this.setupFile(root, file);
                     if (read && !('reason' in read))
                         modules.add(read);
                     else if (read) {
@@ -124,13 +128,14 @@ export class ConfigDependencies {
                 ? projects
                 : [{ settings: placement.settings, root: folder, container: null }];
             // Vitest runs the global setup of the config it starts with for every project, extending it or not.
-            setup(own, config.settings, folder, ['test', 'globalSetup']);
+            if (this.framework === 'vitest')
+                setup(own, config.settings, folder, ['test', 'globalSetup']);
             for (const project of running) {
                 // A file several projects run may be run by one from another config, which the file runs with too; the config
                 // reader has read that config, so it can be read.
                 const written = 'config' in project ? this.module(project.config.file) : own;
                 modules.add(written);
-                for (const keys of SETUP_KEYS.vitest)
+                for (const keys of SETUP_KEYS[this.framework])
                     setup(written, project.settings, project.root, keys);
                 const { container } = project;
                 const outer = container && this.module(container.file);

package/dist/config-runs.d.ts

@@ -58,6 +58,8 @@ 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;
     /** 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);
@@ -107,10 +109,30 @@ 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