test-inventory 0.6.0 → 0.6.1

package/dist/parse.js

@@ -7,6 +7,200 @@ function parserOptions(fileName) {
     const sourceType = extension.startsWith('.c') ? 'commonjs' : extension.startsWith('.m') ? 'module' : 'unambiguous';
     return { lang, sourceType, preserveParens: false };
 }
+/**
+ * How deep brackets may nest. oxc-parser recurses on the native stack, which no catch can stop: brackets about 2,400
+ * deep crash a worker thread's 4 MB stack and 4,800 the main thread's 8 MB. Of the 10,000 files in this package's
+ * development dependencies, minified bundles included, the deepest nests 34.
+ */
+const MAX_NESTING = 500;
+/** Words after which a `/` starts a regular expression rather than a division. */
+const BEFORE_REGEX = new Set([
+    'return',
+    'typeof',
+    'instanceof',
+    'in',
+    'of',
+    'new',
+    'delete',
+    'void',
+    'throw',
+    'case',
+    'do',
+    'else',
+    'yield',
+    'await',
+]);
+const Char = {
+    Tab: 9,
+    LineFeed: 10,
+    CarriageReturn: 13,
+    Space: 32,
+    DoubleQuote: 34,
+    Dollar: 36,
+    SingleQuote: 39,
+    OpenParen: 40,
+    CloseParen: 41,
+    Star: 42,
+    Slash: 47,
+    LessThan: 60,
+    GreaterThan: 62,
+    OpenBracket: 91,
+    Backslash: 92,
+    CloseBracket: 93,
+    Backtick: 96,
+    OpenBrace: 123,
+    CloseBrace: 125,
+};
+/** Letters, digits, `_`, `$` and anything outside ASCII, as identifiers and numbers use. */
+function isWordChar(code) {
+    return ((code >= 97 && code <= 122) ||
+        (code >= 65 && code <= 90) ||
+        (code >= 48 && code <= 57) ||
+        code === 95 ||
+        code === Char.Dollar ||
+        code > 127);
+}
+/** Whether the code right before `end` is a word after which a `/` starts a regular expression. */
+function afterKeyword(text, end) {
+    let wordEnd = end;
+    while (wordEnd > 0 && /\s/.test(text[wordEnd - 1]))
+        wordEnd--;
+    let wordStart = wordEnd;
+    while (wordStart > 0 && isWordChar(text.charCodeAt(wordStart - 1)))
+        wordStart--;
+    return BEFORE_REGEX.has(text.slice(wordStart, wordEnd));
+}
+/**
+ * Whether the slash at `at` ends a JSX tag, as in `</ul>` or `<OrderLeg leg={leg} />`, where a regular expression
+ * could otherwise start and run on over the brackets after it.
+ */
+function endsJsxTag(text, at) {
+    if (text.charCodeAt(at - 1) === Char.LessThan)
+        return true;
+    if (text.charCodeAt(at + 1) !== Char.GreaterThan)
+        return false;
+    let before = at - 1;
+    while (before > 0 && /\s/.test(text[before]))
+        before--;
+    return text.charCodeAt(before) === Char.CloseBrace;
+}
+/**
+ * The offset of the first bracket nested more than `limit` deep, or null. Parentheses, brackets, braces and template
+ * substitutions count; strings, comments, regular expressions and template text are skipped. A closing bracket closes
+ * up to the one it matches, so a literal read wrongly unbalances only the brackets around it.
+ */
+export function tooDeeplyNested(text, limit) {
+    // Open brackets by their character; a substitution is kept as its backtick.
+    const open = [];
+    const counts = new Uint32Array(128);
+    let regexAllowed = true;
+    let index = 0;
+    const push = (code) => {
+        open.push(code);
+        counts[code]++;
+        return open.length > limit;
+    };
+    // Reads template text up to its end or a substitution; true when the substitution is one too deep.
+    const templateText = () => {
+        while (index < text.length) {
+            const code = text.charCodeAt(index);
+            if (code === Char.Backslash)
+                index += 2;
+            else if (code === Char.Backtick) {
+                index++;
+                regexAllowed = false;
+                return false;
+            }
+            else if (code === Char.Dollar && text.charCodeAt(index + 1) === Char.OpenBrace) {
+                if (push(Char.Backtick))
+                    return true;
+                index += 2;
+                regexAllowed = true;
+                return false;
+            }
+            else
+                index++;
+        }
+        return false;
+    };
+    // Skips a string or regular expression; neither goes past the end of the line.
+    const literal = (end) => {
+        let inClass = false;
+        while (index < text.length) {
+            const code = text.charCodeAt(index);
+            if (code === Char.LineFeed)
+                return;
+            index += code === Char.Backslash ? 2 : 1;
+            if (end === Char.Slash && code === Char.OpenBracket)
+                inClass = true;
+            else if (code === Char.CloseBracket)
+                inClass = false;
+            else if (code === end && !inClass)
+                return;
+        }
+    };
+    while (index < text.length) {
+        const code = text.charCodeAt(index);
+        const next = text.charCodeAt(index + 1);
+        const start = index;
+        if (code === Char.Space || code === Char.LineFeed || code === Char.Tab || code === Char.CarriageReturn) {
+            index++;
+        }
+        else if (code === Char.Slash && next === Char.Slash) {
+            const end = text.indexOf('\n', index);
+            index = end === -1 ? text.length : end;
+        }
+        else if (code === Char.Slash && next === Char.Star) {
+            const end = text.indexOf('*/', index + 2);
+            index = end === -1 ? text.length : end + 2;
+        }
+        else if (code === Char.SingleQuote ||
+            code === Char.DoubleQuote ||
+            (code === Char.Slash && (regexAllowed || afterKeyword(text, start)) && !endsJsxTag(text, start))) {
+            index++;
+            literal(code);
+            regexAllowed = false;
+        }
+        else if (code === Char.Backtick) {
+            index++;
+            if (templateText())
+                return index;
+        }
+        else if (isWordChar(code)) {
+            while (index < text.length && isWordChar(text.charCodeAt(index)))
+                index++;
+            regexAllowed = false;
+        }
+        else if (code === Char.OpenParen || code === Char.OpenBracket || code === Char.OpenBrace) {
+            if (push(code))
+                return start;
+            index++;
+            regexAllowed = true;
+        }
+        else if (code === Char.CloseParen || code === Char.CloseBracket || code === Char.CloseBrace) {
+            index++;
+            // A block can end right before a regular expression; a value in parentheses or brackets is divided.
+            regexAllowed = code === Char.CloseBrace;
+            const opener = code === Char.CloseParen ? Char.OpenParen : code === Char.CloseBracket ? Char.OpenBracket : Char.OpenBrace;
+            const closesSubstitution = code === Char.CloseBrace && counts[Char.Backtick] !== 0;
+            if (counts[opener] === 0 && !closesSubstitution)
+                continue;
+            let closed;
+            do {
+                closed = open.pop();
+                counts[closed]--;
+            } while (closed !== opener && !(closed === Char.Backtick && code === Char.CloseBrace));
+            // A substitution after this one is as deep as the one it closed, so it is never the first too deep.
+            if (closed === Char.Backtick)
+                templateText();
+        }
+        else {
+            index++;
+            regexAllowed = true;
+        }
+    }
+    return null;
+}
 /** The first parser error, located at its first label, or at the start of the file when it has none. */
 export function firstError(errors) {
     const first = errors.at(0);
@@ -18,6 +212,16 @@ export function firstError(errors) {
 export function parseFile(fileName, code) {
     // A byte order mark is not part of the code, and editors don't count it as a column.
     const text = code.charCodeAt(0) === 0xfeff ? code.slice(1) : code;
+    const tooDeep = tooDeeplyNested(text, MAX_NESTING);
+    if (tooDeep !== null) {
+        const message = `Brackets are nested more than ${MAX_NESTING} deep, too deep to parse safely`;
+        return {
+            source: new SourceText(text),
+            program: parseSync(fileName, '', parserOptions(fileName)).program,
+            comments: [],
+            error: { message, start: tooDeep, end: tooDeep + 1 },
+        };
+    }
     const result = parseSync(fileName, text, parserOptions(fileName));
     return {
         source: new SourceText(text),

package/dist/records.d.ts

@@ -61,6 +61,8 @@ export interface FileConfig {
     };
     /** Vitest's tags; null when the scan can't work them out, or the projects that run the file define different ones. */
     tags: VitestTags | null;
+    /** The tags Playwright's config `tag` gives every test, before the test's own. */
+    configTags: string[];
 }
 interface RecordOptions {
     relativeFilePath: string;

package/dist/records.js

@@ -314,7 +314,7 @@ class RecordBuilder {
         };
     }
     /** What the config's Vitest tags set on a test with `tags`, merged as Vitest merges them; null when none applies. */
-    tagOptions(tags) {
+    tagOptions(tags, ownStateOptions) {
         const definitions = this.options.config?.tags?.definitions ?? [];
         const applied = tags.flatMap((name) => definitions.filter((definition) => definition.name === name));
         if (applied.length === 0)
@@ -330,6 +330,9 @@ class RecordBuilder {
             if (meta)
                 merged.meta = { ...merged.meta, ...meta };
         }
+        // Vitest merges the test's own options over its tags', so `skip: false` runs a test whose tag skips it.
+        for (const option of ownStateOptions)
+            merged[option] = undefined;
         return merged;
     }
     test(pending, suites) {
@@ -343,11 +346,12 @@ class RecordBuilder {
         const id = this.id([this.describeTitles(describes), title.withoutTags]);
         const fileScope = scopes[scopes.length - 1];
         const tags = unique([
+            ...(this.options.config?.configTags ?? []),
             ...fileScope.details.tags,
             ...describes.flatMap((scope) => scope.details.tags),
             ...declaration.details.tags,
         ]);
-        const fromTags = this.tagOptions(tags);
+        const fromTags = this.tagOptions(tags, declaration.ownStateOptions ?? []);
         // In Vitest 5 the options of a test's tags win over those the describes pass down; before, the describes' win.
         const tagsFirst = this.options.config?.tags?.beatsDescribes ?? true;
         const tagged = (own, tag, around) => tagsFirst ? [...own, ...tag, ...around] : [...own, ...around, ...tag];

package/dist/resolve.js

@@ -1,3 +1,4 @@
+import { isUtf8 } from 'node:buffer';
 import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import path from 'node:path';
 import { globSync } from 'tinyglobby';
@@ -8,7 +9,7 @@ function isFile(file) {
 }
 /** The file a path refers to, found the way TypeScript and Node do: as is, with an extension, or a folder's index. */
 function findFile(base) {
-    const stripped = base.replace(/\.[cm]?js$/, '');
+    const stripped = base.replace(/\.(?:[cm]?js|jsx)$/, '');
     const candidates = [
         base,
         ...EXTENSIONS.map((extension) => stripped + extension),
@@ -42,6 +43,16 @@ function readText(file) {
         return null;
     }
 }
+/** A file's text, with its bytes too when it isn't UTF-8 text, as an image isn't; null when it can't be read. */
+function readContent(file) {
+    try {
+        const bytes = readFileSync(file);
+        return isUtf8(bytes) ? { code: bytes.toString('utf8') } : { code: bytes.toString('utf8'), bytes };
+    }
+    catch {
+        return null;
+    }
+}
 function readJson(file) {
     const text = isFile(file) ? readText(file) : null;
     return text === null ? null : record(parseJsonc(text));
@@ -362,17 +373,24 @@ export function moduleResolver(root) {
         }
         else {
             const options = optionsFor(directory);
-            const aliased = options ? aliasFiles(specifier, options) : null;
+            const targets = options ? aliasFiles(specifier, options) : null;
+            const aliased = targets?.find((file) => findFile(file) !== null);
             if (aliased) {
-                candidates = aliased;
+                candidates = [aliased];
             }
             else {
-                // `baseUrl` turns any name into a path, so a name not found there may still be a workspace package.
+                // TypeScript goes on to the usual lookup when no file of a matching alias exists. `baseUrl` turns any name
+                // into a path, so a name not found there may still be a workspace package.
                 const fromBaseUrl = options?.baseUrl ? findFile(path.resolve(options.baseUrl, specifier)) : null;
                 const workspace = fromBaseUrl ? null : workspaceSource(specifier, directory, packagesOf);
                 if (workspace && 'reason' in workspace)
                     return workspace;
                 const file = fromBaseUrl ?? workspace?.file;
+                // No package name starts with `@/` or `~/`, so these are aliases, as Vite's `resolve.alias` sets them; any
+                // other name with no file may still be a package or a built-in module, as TypeScript takes it to be.
+                if (!file && /^[@~]\//.test(specifier)) {
+                    return { reason: targets ? 'could not be read' : 'is a path alias that no tsconfig paths define' };
+                }
                 if (!file)
                     return { reason: 'is not a local file, a path alias or a workspace package' };
                 candidates = [file];
@@ -382,10 +400,12 @@ export function moduleResolver(root) {
         if (!found)
             return { reason: 'could not be read' };
         if (!modules.has(found)) {
-            const code = readText(found);
-            modules.set(found, code === null
-                ? null
-                : { code, relativeFilePath: path.relative(root, found).replaceAll('\\', '/'), readModule: reader(found) });
+            const content = readContent(found);
+            modules.set(found, content && {
+                ...content,
+                relativeFilePath: path.relative(root, found).replaceAll('\\', '/'),
+                readModule: reader(found),
+            });
         }
         return modules.get(found) ?? { reason: 'could not be read' };
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-inventory",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Test metadata from source code, not from test results.",
   "keywords": [
     "testing",