@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.2

package/dist/src/conformance-record.js

@@ -2,9 +2,9 @@
 // Regenerate it with `UPDATE_GOLDEN=1 npx vitest --run src/conformance.corpus.test.ts`.
 export const RECORD = {
     conformance: {
-        corpusVersion: "5.2.0",
+        corpusVersion: "6.0.0",
         result: "pass",
-        digest: "sha256:012872542679539ec105f49b5ee502b0a9fa35c6bbd9ef3983b5f6e53af83d8e",
+        digest: "sha256:d65daae4b7c95050c07896b166d0250d233cca71f97de75a6086c1d80fe76232",
     },
     gaps: [],
 };

package/dist/src/convention-rows.js

@@ -10,6 +10,8 @@ const SCRIPT = "{js,jsx,ts,tsx}";
 const MODULE = "{js,mjs,ts,mts}";
 const ANY_MODULE = "{js,mjs,cjs,ts,mts,cts}";
 const VITE_CONFIG = `vite.config.${ANY_MODULE}`;
+/** The legacy configuration files of ESLint that hold JSON or a CommonJS module. */
+const ESLINTRC = [".eslintrc", ".eslintrc.json", ".eslintrc.{js,cjs}"];
 const SVELTEKIT_ROUTE_FILES = "+{page,layout,server,page.server,layout.server,error}";
 /** SvelteKit's entries other than its parameter matchers. */
 const SVELTEKIT_ENTRIES = [
@@ -59,6 +61,29 @@ const ANGULAR_PACKAGE_KEYS = [
     "styles",
     "scripts",
 ].map((key) => ({ key, files: ["angular.json"] }));
+/**
+ * The test runners and the assertion, mock and runner libraries whose import is test
+ * evidence beside each runner a row reads test files for. Each applies whether or not a
+ * manifest declares it, so none is a row.
+ */
+export const TEST_LIBRARIES = [
+    "@jest/globals",
+    "@playwright/test",
+    "ava",
+    "chai",
+    "expect",
+    "jasmine",
+    "jest",
+    "mocha",
+    "msw",
+    "nock",
+    "node:test",
+    "sinon",
+    "tap",
+    "uvu",
+];
+/** The scopes every package of which is a test library. */
+export const TEST_LIBRARY_SCOPES = ["@testing-library/"];
 /** Every row, ordered by name and then by range. */
 export const CONVENTION_ROWS = [
     {
@@ -111,6 +136,25 @@ export const CONVENTION_ROWS = [
             package: "@babel/runtime",
         })),
     },
+    {
+        name: "docusaurus",
+        package: "@docusaurus/core",
+        range: ">=2.0.0 <4.0.0",
+        entries: [`src/pages/**/*.${SCRIPT}`, `src/theme/**/*.${SCRIPT}`],
+        moves: [],
+    },
+    {
+        name: "eslint",
+        package: "eslint",
+        range: ">=4.0.0 <10.0.0",
+        entries: [],
+        moves: [],
+        prefixedNames: [
+            { property: "plugins", files: ESLINTRC, prefix: "eslint-plugin" },
+            { property: "extends", files: ESLINTRC, prefix: "eslint-plugin", marker: "plugin:" },
+            { property: "extends", files: ESLINTRC, prefix: "eslint-config" },
+        ],
+    },
     {
         name: "eslint",
         package: "eslint",
@@ -118,6 +162,13 @@ export const CONVENTION_ROWS = [
         entries: [`**/eslint.config.${ANY_MODULE}`],
         moves: [],
     },
+    {
+        name: "expo",
+        package: "expo",
+        range: ">=44.0.0 <60.0.0",
+        entries: [`{index,App}.${SCRIPT}`],
+        moves: [],
+    },
     {
         name: "expo-router",
         package: "expo-router",
@@ -202,6 +253,28 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        name: "oclif",
+        package: "@oclif/core",
+        range: ">=1.0.0 <5.0.0",
+        entries: [`src/{commands,hooks}/**/*.${SCRIPT}`],
+        moves: [],
+        manifestEntries: [
+            { key: "oclif.commands", directory: true },
+            { key: "oclif.hooks", directory: false },
+        ],
+    },
+    {
+        name: "parcel",
+        package: "parcel",
+        range: ">=2.0.0 <3.0.0",
+        entries: [],
+        moves: [],
+        manifestEntries: [
+            { key: "source", directory: false },
+            { key: "targets.*.source", directory: false },
+        ],
+    },
     {
         name: "prettier",
         package: "prettier",
@@ -493,6 +566,31 @@ export const CONVENTION_ROWS = [
             },
         ],
     },
+    {
+        name: "tanstack-router",
+        package: "@tanstack/router-plugin",
+        range: ">=1.0.0 <2.0.0",
+        entries: [`<routes>/**/*.${SCRIPT}`],
+        moves: [
+            {
+                id: "routes",
+                defaults: ["src/routes"],
+                readings: [
+                    { property: "routesDirectory", files: ["tsr.config.json"] },
+                    {
+                        property: "routesDirectory",
+                        files: [VITE_CONFIG],
+                        call: { module: "@tanstack/router-plugin/vite", export: "tanstackRouter" },
+                    },
+                    {
+                        property: "routesDirectory",
+                        files: [VITE_CONFIG],
+                        call: { module: "@tanstack/router-plugin/vite", export: "TanStackRouterVite" },
+                    },
+                ],
+            },
+        ],
+    },
     {
         name: "vite",
         package: "vite",

package/dist/src/conventions.js

@@ -471,6 +471,40 @@ function manifestKeyUses(manifest, keys) {
     const strings = keys.flatMap((key) => documentStrings(manifest[key]));
     return declared.filter((name) => strings.some((text) => text === name || text.startsWith(`${name}/`)));
 }
+/** The extensions an entry a manifest entry key names without one may carry. */
+const ENTRY_EXTENSIONS = "{js,jsx,mjs,cjs,ts,tsx,mts,cts}";
+/** The characters that make a manifest string a pattern rather than a directory's name. */
+const PATTERN = /[*?{}[\]]/u;
+/**
+ * The entry globs one applied row's manifest entry keys write, below the manifest's
+ * directory: a directory's every module, or a file with or without an extension. A string
+ * that leaves the directory names nothing.
+ */
+function manifestEntryGlobs(manifest, keys) {
+    const at = (value, path) => {
+        const [key, ...rest] = path;
+        if (key === undefined) {
+            return [value];
+        }
+        if (!isRecord(value)) {
+            return [];
+        }
+        const next = key === "*" ? Object.values(value) : Object.hasOwn(value, key) ? [value[key]] : [];
+        return next.flatMap((one) => at(one, rest));
+    };
+    return keys.flatMap(({ key, directory }) => at(manifest, key.split(".")).flatMap((value) => documentStrings(value).flatMap((text) => {
+        const path = normalizePath(text)
+            .replace(/^(?:\.\/)+/u, "")
+            .replace(/\/+$/u, "");
+        if (path === "" || path === ".." || path.startsWith("../") || path.startsWith("/")) {
+            return [];
+        }
+        if (!directory) {
+            return [path, `${path}.${ENTRY_EXTENSIONS}`];
+        }
+        return PATTERN.test(path) ? [] : [`${path}/**/*.${ENTRY_EXTENSIONS}`];
+    })));
+}
 /**
  * Every value one file writes at one property's path inside the object it is read from:
  * the options argument of every call `call` names, or the file's default export. A string
@@ -620,6 +654,57 @@ function shortNameUses(host, parse, dir, manifest, readings) {
     }
     return [...used].filter((name) => declared.has(name)).sort(compare);
 }
+/**
+ * The package one value of a prefixed-name reading names, or none: ESLint's own naming,
+ * https://github.com/eslint/eslintrc/blob/main/lib/shared/naming.js
+ */
+function prefixedPackage(value, reading) {
+    const { prefix, marker } = reading;
+    let name;
+    if (marker === undefined) {
+        if (value.includes(":") || value.startsWith(".") || value.startsWith("/")) {
+            return undefined;
+        }
+        const parts = value.split("/");
+        name = (value.startsWith("@") ? parts.slice(0, 2) : parts.slice(0, 1)).join("/");
+    }
+    else {
+        if (!value.startsWith(marker) || !value.includes("/", marker.length)) {
+            return undefined;
+        }
+        name = value.slice(marker.length, value.lastIndexOf("/"));
+    }
+    if (name === "") {
+        return undefined;
+    }
+    if (!name.startsWith("@")) {
+        return name.startsWith(`${prefix}-`) ? name : `${prefix}-${name}`;
+    }
+    const [scope, rest] = name.split("/");
+    if (rest === undefined || rest === "" || rest === prefix) {
+        return `${scope ?? name}/${prefix}`;
+    }
+    return rest.startsWith(`${prefix}-`) ? name : `${scope ?? name}/${prefix}-${rest}`;
+}
+/** The declared dependencies an applied row's prefixed names use. */
+function prefixedNameUses(host, parse, dir, manifest, readings) {
+    const declared = new Set(DEPENDENCY_SECTIONS.flatMap((section) => {
+        const held = isRecord(manifest) ? manifest[section] : undefined;
+        return isRecord(held) ? Object.keys(held) : [];
+    }));
+    const used = new Set();
+    for (const reading of readings) {
+        for (const { file } of readingFiles(host, parse, dir, reading.files)) {
+            for (const value of readProperty(file, reading.property, reading.call, true).values) {
+                const named = prefixedPackage(value, reading);
+                if (named !== undefined && declared.has(named)) {
+                    used.add(named);
+                }
+            }
+        }
+    }
+    return [...used].sort(compare);
+}
 /** The declared dependencies an applied row's helper settings use. */
 function helperUses(host, parse, dir, manifest, readings) {
     const declared = new Set(DEPENDENCY_SECTIONS.flatMap((section) => {
@@ -756,6 +841,10 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             for (const name of shortNameUses(host, parse, manifest.dir, declared, row.shortNames ?? [])) {
                 uses.add(name);
             }
+            const prefixed = row.prefixedNames ?? [];
+            for (const name of prefixedNameUses(host, parse, manifest.dir, declared, prefixed)) {
+                uses.add(name);
+            }
             const keys = row.packageKeys ?? [];
             for (const name of packageKeyUses(host, parse, manifest.dir, declared, keys)) {
                 uses.add(name);
@@ -774,7 +863,11 @@ export function readConventions(host, parse, manifests, disabled, rows = CONVENT
             for (const below of new Set((row.generated ?? []).flatMap((one) => expand(one, resolved)))) {
                 generated.push({ dir: manifest.dir, row: row.name, below });
             }
-            for (const glob of new Set(row.entries.flatMap((entry) => expand(entry, resolved)))) {
+            const written = [
+                ...row.entries.flatMap((entry) => expand(entry, resolved)),
+                ...manifestEntryGlobs(declared, row.manifestEntries ?? []),
+            ];
+            for (const glob of new Set(written)) {
                 globs.push({
                     dir: manifest.dir,
                     row: row.name,
@@ -819,10 +912,13 @@ export function conventionEntries(conventions, files) {
     const found = new Map();
     for (const glob of conventions.globs) {
         for (const file of files.byName.values()) {
-            const path = relativePath(glob.dir, file.fileName);
-            if (path !== undefined &&
-                glob.expression.test(path) &&
-                !glob.excludes.some((one) => one.test(path))) {
+            const matched = [file.fileName, ...files.writtenAs(file)].some((name) => {
+                const path = relativePath(glob.dir, name);
+                return (path !== undefined &&
+                    glob.expression.test(path) &&
+                    !glob.excludes.some((one) => one.test(path)));
+            });
+            if (matched) {
                 found.set(`${file.fileName}\u0000${glob.row}`, { file, row: glob.row });
             }
         }

package/dist/src/decorator.js

@@ -1,14 +1,10 @@
 /**
- * The decorator class: a member a decorator expression is attached to, and every
- * member of a class a decorator expression is attached to, is held back, because the
- * decorator receives the member or the class when the class is defined and may reach
- * the member by its name.
- *
- * The rule is read from the tree alone: a decorator is attached where it is written.
- * The use the decorator itself makes of what it decorates is the reference pass's,
- * which records it as a `decorator` reference; this class records only that the
- * declaration is held back, and the member set of a decorated class is every member
- * the inventory holds for the class, static members included.
+ * The decorator class: a member a decorator expression is attached to, and every member
+ * of a class one is attached to but the member a parameter property declares, is held
+ * back, because the decorator may reach the member by its name. The rule is read from
+ * the tree alone. The decorator's own use of what it decorates is the reference pass's
+ * `decorator` reference; this class records only that the declaration is held back,
+ * static members of a decorated class included.
  */
 import { decoratorsOf, spelledDecorator } from "./calls.js";
 import { isParameterProperty, nodeKey, } from "./inventory.js";
@@ -34,25 +30,32 @@ export function decorator(input) {
             }
         }
     }
-    const found = [];
+    const decorated = [];
+    // A decorated class's container passes each constructor argument, which keeps the
+    // parameter, not the member a parameter property stores it in.
+    const parameterMembers = new Set();
     for (const file of project.ownSourceFiles()) {
         const visit = (node) => {
             const id = held.declarations.get(nodeKey(file, node));
             const symbol = id === undefined ? undefined : byId.get(id);
+            if (id !== undefined && isParameterProperty(node)) {
+                parameterMembers.add(id);
+            }
             // A parameter property's decorator is attached to its parameter, and to no member.
             if (symbol !== undefined && DECORATED.has(symbol.kind) && !isParameterProperty(node)) {
                 for (const attached of decoratorsOf(node)) {
-                    const detail = `decorated by ${spelledDecorator(attached)}`;
-                    const site = renderPosition(file, targetRoot, attached.getStart());
-                    const reached = symbol.kind === "class" ? (membersOf.get(symbol.id) ?? []) : [symbol];
-                    for (const member of reached) {
-                        found.push({ id: member.id, detail, site });
-                    }
+                    decorated.push({
+                        symbol,
+                        detail: `decorated by ${spelledDecorator(attached)}`,
+                        site: renderPosition(file, targetRoot, attached.getStart()),
+                    });
                 }
             }
             node.forEachChild(visit);
         };
         file.forEachChild(visit);
     }
-    return found;
+    return decorated.flatMap(({ symbol, detail, site }) => (symbol.kind === "class"
+        ? (membersOf.get(symbol.id) ?? []).filter((member) => !parameterMembers.has(member.id))
+        : [symbol]).map((member) => ({ id: member.id, detail, site })));
 }