@cplieger/deadset-ts 8.0.0-dev.15 → 8.0.0-dev.17

package/dist/src/{workflow-steps.js → entries/workflow-steps.js}

@@ -4,11 +4,11 @@
  * it runs in. A workflow or hook manager file is read by `text/yaml.ts`, and one it does not
  * read gives no command; each command is read by `commands/read.ts`.
  */
-import { pathsNamed, readCommands } from "./commands/read.js";
-import { isRecord } from "./json-document.js";
-import { joinPath, resolvePath } from "./paths.js";
-import { filesIn } from "./fs/tree.js";
-import { yamlDocument } from "./text/yaml.js";
+import { pathsNamed, readCommands } from "../commands/read.js";
+import { isRecord } from "../json-document.js";
+import { joinPath, resolvePath } from "../paths.js";
+import { filesIn } from "../fs/tree.js";
+import { yamlDocument } from "../text/yaml.js";
 const WORKFLOWS = ".github/workflows";
 /** The directories whose every file is a git hook script, run as the shell runs it. */
 const HOOK_DIRS = [".husky", ".githooks"];
@@ -144,14 +144,24 @@ export function commandFileTexts(host, targetRoot) {
         ...[makefileAt(host, root) ?? []].flat(),
     ].flatMap((path) => readText(host, path) ?? []);
 }
+/** Reads the target root's workflow steps, git hooks, hook managers and makefile. */
+export function readWorkflows(host, targetRoot) {
+    return {
+        readings: workflowCommands(host, targetRoot).map(({ text, dir, writtenDirectory }) => {
+            const reading = readCommands(text, dir);
+            return { ...reading, held: [reading.held, writtenDirectory ?? ""].join("\n") };
+        }),
+        texts: commandFileTexts(host, targetRoot),
+    };
+}
 /**
  * The own files the target root's workflow steps, git hooks and recipes run or name, as
  * `pathsNamed` reads each command.
  */
-export function workflowEntries(host, targetRoot, files) {
+export function workflowEntries(workflows, files) {
     const found = [];
-    for (const { text, dir } of workflowCommands(host, targetRoot)) {
-        for (const { path, written } of pathsNamed(readCommands(text, dir))) {
+    for (const reading of workflows.readings) {
+        for (const { path, written } of pathsNamed(reading)) {
             for (const file of files.named(path)) {
                 found.push({ file, source: written });
             }

package/dist/src/extensions.js

@@ -0,0 +1,37 @@
+/** The extension lists the analysis reads files by, each written once. */
+/**
+ * The extensions tried, in order, after a path written without one: a relative specifier
+ * of a configuration file (`roots.5`) and a path a command runs or loads (`roots.13`).
+ */
+export const APPENDED_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+];
+/** The extensions of a module a tool runs or loads as its configuration (`roots.2`). */
+export const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"];
+/** The extensions of a file a build writes from a source file. */
+export const OUTPUT_EXTENSIONS = [
+    ".js",
+    ".mjs",
+    ".cjs",
+    ".jsx",
+    ".d.ts",
+    ".d.mts",
+    ".d.cts",
+];
+/** One list as a glob's brace list, its dots dropped: `{js,mjs}`. */
+export function braced(extensions) {
+    return `{${extensions.map((one) => one.slice(1)).join(",")}}`;
+}
+/** The extension of one list a name ends with, the longest where several do. */
+export function extensionOf(name, extensions) {
+    return extensions
+        .filter((one) => name.endsWith(one))
+        .reduce((longest, one) => (one.length > (longest?.length ?? 0) ? one : longest), undefined);
+}

package/dist/src/facts.js

@@ -0,0 +1,38 @@
+/**
+ * The facts document `--facts` writes, `bindings.1` and `bindings.2`: the run's generated
+ * files under the one decision the generated-file class reads, and the binding identities
+ * they publish. No binding state is computed, so it states `evaluated: false` (`bindings.10`).
+ */
+import { FACTS_VERSION } from "./contract/contract.generated.js";
+import { LANGUAGE, PRODUCT } from "./product.js";
+import { bytewise } from "./text/compare.js";
+/** The facts document of one run, as the text written to the path `--facts` names. */
+export function factsDocument(version, generated, bindings) {
+    const document = {
+        facts_version: FACTS_VERSION,
+        analyzer: { name: PRODUCT, version },
+        language: LANGUAGE,
+        evaluated: false,
+        generated: [...generated]
+            .sort(([a], [b]) => bytewise(a, b))
+            .map(([path, fact]) => ({
+            path,
+            line: fact.line,
+            evidence: fact.evidence,
+            detail: fact.detail,
+            ...(fact.generator === undefined
+                ? {}
+                : {
+                    generator: {
+                        row: fact.generator.row,
+                        ...(fact.generator.version === undefined
+                            ? {}
+                            : { version: fact.generator.version }),
+                    },
+                    schema_files: fact.generator.schemaFiles,
+                }),
+        })),
+        bindings,
+    };
+    return `${JSON.stringify(document, null, 2)}\n`;
+}

package/dist/src/findings/completion.js

@@ -79,12 +79,13 @@ function testedByIn(input) {
  * published API, a public member of a published type included, is `certain` where the
  * run loaded every consumer the scope declared and declared one, `probable` where one did
  * not load, and `possible` where it declared none, whatever the configuration says of the
- * consumer set. A member an `in` expression tests by name, and one a function outside the
- * analysis fills, is `possible`.
+ * consumer set. A member an `in` expression tests by name, one a function outside the
+ * analysis fills, and one {@link possiblyLoaded} names, is `possible`.
  */
 function reachabilityClasses(input) {
     const tested = testedByIn(input);
     const filled = input.boundary.filledOutside ?? new Set();
+    const possible = possiblyLoaded(input);
     const published = publishedIds(input.swept.matrix.union);
     const { declared } = input.boundary.consumers;
     const outside = declared.length === 0
@@ -93,7 +94,7 @@ function reachabilityClasses(input) {
             ? "certain"
             : "probable";
     return (id) => {
-        if (tested.has(id) || filled.has(id)) {
+        if (tested.has(id) || filled.has(id) || possible.has(id)) {
             return "possible";
         }
         return published.has(id) ? outside : "certain";
@@ -137,6 +138,35 @@ function testCeilings(input, classOf) {
         ? testTargets(union, id).reduce((lowest, target) => capped(lowest, classOf(target)), "certain")
         : "certain";
 }
+/**
+ * What only a bundler's retry of an import Node leaves unresolved names (program.38), and each
+ * dead declaration that reaches through dead declarations, as confidence.20 reads what only
+ * tests reach: each is dead only while no loader the analysis does not see loads the file.
+ */
+function possiblyLoaded(input) {
+    const seeds = input.boundary.possiblyLoaded ?? new Set();
+    if (seeds.size === 0) {
+        return seeds;
+    }
+    const union = input.swept.matrix.union;
+    const dead = new Set(input.swept.sweep.candidates.map((one) => one.id));
+    const reached = new Set();
+    const pending = union.symbols.flatMap((symbol, at) => (seeds.has(symbol.id) ? [at] : []));
+    for (let at = pending.pop(); at !== undefined; at = pending.pop()) {
+        const symbol = union.symbols[at];
+        if (symbol === undefined || reached.has(symbol.id)) {
+            continue;
+        }
+        reached.add(symbol.id);
+        for (const edge of union.out[at] ?? []) {
+            const to = union.symbols[edge.to];
+            if (to !== undefined && dead.has(to.id)) {
+                pending.push(edge.to);
+            }
+        }
+    }
+    return reached;
+}
 /**
  * The subjects dead only because production code only tests use is: each declaration the
  * sweep marks test-used, each `DS1602` file of such code, and each test of dead code every
@@ -281,6 +311,7 @@ export function completed(input, findings, kinds = KINDS) {
     const union = swept.matrix.union;
     const positions = new Map(union.symbols.map((symbol, at) => [declarationKey(symbol.ref, symbol.position.path), at]));
     const candidates = new Map(swept.sweep.candidates.map((candidate) => [candidate.id, candidate]));
+    const fileIds = new Map(union.symbols.flatMap((one) => (one.kind === "file" ? [[one.position.path, one.id]] : [])));
     const classOf = reachabilityClasses(input);
     const ceilingOf = testCeilings(input, classOf);
     const testUsed = testUsedSubjects(input);
@@ -365,7 +396,12 @@ export function completed(input, findings, kinds = KINDS) {
         const counts = candidate === undefined
             ? union.made[at]
             : { production: candidate.productionRefs, test: candidate.testRefs };
-        const ownClass = judged === undefined ? (finding.reachabilityClass ?? "certain") : classOf(judged.id);
+        const ownClass = judged !== undefined
+            ? classOf(judged.id)
+            : (finding.reachabilityClass ??
+                (finding.code === CODE.fileNeverImported
+                    ? classOf(fileIds.get(finding.position.path) ?? "")
+                    : "certain"));
         const used = judged !== undefined
             ? candidate !== undefined && testUsed.declarations.has(judged.id)
             : finding.code === CODE.fileNeverImported && testUsed.files.has(finding.position.path);

package/dist/src/findings/emitters.js

@@ -96,16 +96,13 @@ function atPossible(input) {
  */
 function dialledOver(input, suppressed, found, unmarked) {
     const would = [...unmarked, ...found];
-    const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked));
     const unanswered = heldKeys(input);
+    const heldIds = new Set(input.swept.heldByUnanswered);
+    const keyOf = (finding) => declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
+    const held = (finding) => unanswered.has(keyOf(finding)) || insideSkipped(input.swept.skipped, finding.position);
+    const ledger = ledgerOf(suppressed.records, would, dialsOver(input, found, suppressed, unmarked), { withholds: held, holdsRecord: (record) => heldIds.has(record.bound) });
     const markup = markupKeys(input);
-    const candidates = found.filter((finding) => {
-        const key = declarationKey(finding.symbol.holder ?? finding.symbol.ref, finding.position.path);
-        return (!ledger.withheld(finding) &&
-            !unanswered.has(key) &&
-            !markup.has(key) &&
-            !insideSkipped(input.swept.skipped, finding.position));
-    });
+    const candidates = found.filter((finding) => !ledger.withheld(finding) && !held(finding) && !markup.has(keyOf(finding)));
     const kept = reportable(input, candidates);
     const evaluated = evaluateEdges(kept, input.boundary.edges, input.swept.matrix.union.symbols);
     return {

package/dist/src/{implementations.js → findings/implementations.js}

@@ -7,9 +7,9 @@
  */
 import { isClassDeclaration, isHeritageClause, isInterfaceDeclaration, isMethodDeclaration, SyntaxKind, } from "@typescript/native/ast";
 import { SymbolFlags } from "@typescript/native/sync";
-import { aliasChains } from "./alias-chain.js";
-import { nodeKey } from "./inventory.js";
-import { must, Unanswerable } from "./query.js";
+import { aliasChains } from "../alias-chain.js";
+import { nodeKey } from "../inventory.js";
+import { must, Unanswerable } from "../query.js";
 /** The interfaces, the classes and the `implements` entries of one project's own files. */
 function walk(project, held) {
     const interfaces = [];

package/dist/src/{in-operands.js → findings/in-operands.js}

@@ -4,8 +4,8 @@
  * links the read to a declaration, so only a text match can tell which member it reads.
  */
 import { isBinaryExpression, isNoSubstitutionTemplateLiteral, isStringLiteral, SyntaxKind, } from "@typescript/native/ast";
-import { sourceFilesOf } from "./source-files.js";
-import { bytewise } from "./text/compare.js";
+import { sourceFilesOf } from "../source-files.js";
+import { bytewise } from "../text/compare.js";
 /**
  * The text of each string literal, or template literal with no substitution, written as
  * the left operand of an `in` expression in a file of the project that is no test file.

package/dist/src/findings/self-check.js

@@ -1,7 +1,7 @@
-import { CODE } from "../contract/contract.generated.js";
+import { CODE, REMEDIES } from "../contract/contract.generated.js";
 import { REPOSITORY_DOCUMENT } from "../config.js";
 import { FIXED_SEVERITY_CODES } from "../kinds.js";
-import { isDependencyCode, isUnsuppressibleCode, } from "../suppress.js";
+import { names, subjectOfCode, } from "../suppress.js";
 import { bytewise } from "../text/compare.js";
 /** The subject kind of a finding about a configured declaration. */
 const DECLARATION_SUBJECT = "configured-declaration";
@@ -24,6 +24,39 @@ export function fileRefsOf(symbols) {
         .map((symbol) => [symbol.position.path, symbol.ref]));
     return (path) => byPath.get(path);
 }
+/**
+ * Why a record of `mechanism` naming `codes` can match nothing, one clause per subject whose
+ * findings kinds.json's remedies table lets no record of that mechanism name, in subject order.
+ */
+function unnameable(codes, mechanism) {
+    return Object.keys(REMEDIES).flatMap((subject) => {
+        const named = codes.filter((code) => subjectOfCode(code) === subject);
+        if (named.length === 0 || names(subject, mechanism)) {
+            return [];
+        }
+        const { names: what, suppressions } = REMEDIES[subject];
+        const reports = `${spelled(named)} ${named.length === 1 ? "reports" : "each report"} ${what}`;
+        if (suppressions.length > 0) {
+            const records = suppressions.map((one) => articled(WRITTEN[one]));
+            return [`${reports}, which only ${spelledOr(records)} can name`];
+        }
+        const settable = named.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
+        const remedy = settable.length === 0
+            ? "fix what the finding names instead"
+            : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
+        return [`${reports}, which no suppression can name; ${remedy}`];
+    });
+}
+/** A record's written name with its indefinite article. */
+function articled(name) {
+    return `${/^[aeiou]/u.test(name) ? "an" : "a"} ${name}`;
+}
+/** A list as a sentence names alternatives. */
+function spelledOr(items) {
+    return items.length < 2
+        ? items.join("")
+        : `${items.slice(0, -1).join(", ")} or ${items.at(-1) ?? ""}`;
+}
 /** A list of codes as a sentence names them. */
 function spelled(codes) {
     if (codes.length < 2) {
@@ -85,25 +118,8 @@ export function staleSuppressions(stale, files) {
         const reports = [...new Set(records.flatMap((one) => one.reports))]
             .filter((code) => !codes.includes(code))
             .sort(bytewise);
-        const rows = codes.filter(isUnsuppressibleCode);
-        const dependencies = first.mechanism === "inline" ? codes.filter(isDependencyCode) : [];
-        const settable = rows.filter((code) => !FIXED_SEVERITY_CODES.includes(code));
-        const remedy = settable.length === 0
-            ? "fix what the finding names instead"
-            : `fix what the finding names or set the severity of ${spelled(settable)} instead`;
         const declared = reports.length === 0 ? "" : `its declaration reports ${spelled(reports)}`;
-        const because = [
-            ...(rows.length > 0
-                ? [
-                    `${spelled(rows)} ${rows.length === 1 ? "reports a row" : "report rows"} of a document, which no suppression can name; ${remedy}`,
-                ]
-                : []),
-            ...(dependencies.length > 0
-                ? [
-                    `${spelled(dependencies)} ${dependencies.length === 1 ? "reports a dependency row" : "report dependency rows"}, which only an ignore entry or a baseline row can name`,
-                ]
-                : []),
-        ];
+        const because = unnameable(codes, first.mechanism);
         const instead = because.length > 0
             ? `, because ${because.join("; ")}${declared === "" ? "" : `; ${declared}`}`
             : declared === ""

package/dist/src/findings-pass.js

@@ -7,7 +7,7 @@ import { EXIT_CLEAN, EXIT_FINDINGS, EXIT_PENDING } from "./contract/contract.gen
 import { fails } from "./config.js";
 import { decidedFindings } from "./findings/emitters.js";
 import { fileRefsOf, staleSuppressions, } from "./findings/self-check.js";
-import { isDependencySubject, isRowSubject, pairs, suppressionCounts, } from "./suppress.js";
+import { namesKind, pairs, suppressionCounts } from "./suppress.js";
 import { bytewise } from "./text/compare.js";
 import { PRODUCT } from "./product.js";
 /** The canonical order: path, line, column, code, then the symbol reference. */
@@ -71,15 +71,14 @@ export function verdictOf(result, config) {
 }
 /**
  * The rows one round of a baseline write records from its findings, in their order. A
- * finding about a row of a document other than a dependency row is not recorded: no record
- * withholds one, so a row recording it would be stale on the first read back. Two findings
- * that would record the same row, two parts of one declaration under one code, record it
- * once.
+ * finding no baseline row can name is not recorded: a row recording it would be stale on
+ * the first read back. Two findings that would record the same row, two parts of one
+ * declaration under one code, record it once.
  */
 export function recordedFindings(findings) {
     const rows = new Map();
     for (const finding of findings) {
-        if (isRowSubject(finding.symbol.kind) && !isDependencySubject(finding.symbol.kind)) {
+        if (!namesKind(finding.symbol.kind, "baseline")) {
             continue;
         }
         const row = { code: finding.code, symbol: finding.symbol.ref, path: finding.position.path };

package/dist/src/framework-lifecycle.js

@@ -1,18 +1,42 @@
 /**
- * The framework-lifecycle class: a member a `ts.lifecycle_contracts` entry lists is held
- * back on each class that is the entry's component, being a class a decorator or a call
- * the entry's `components` name is attached to or passes, or one extending, directly or
- * through a chain, a class its `bases` name. A component's members are its type's, so a
- * member a base class declares answers for every subclass.
+ * The framework-lifecycle class: a member a lifecycle contract lists is held back on each
+ * class that is the contract's component, being a class a decorator or a call the
+ * contract's `components` name is attached to or passes, or one extending, directly or
+ * through a chain, a class its `bases` name. The contracts are the platform's custom
+ * elements and each `ts.lifecycle_contracts` entry. A component's members are its type's,
+ * so a member a base class declares answers for every subclass.
  */
 import { isClassDeclaration, isClassExpression, isHeritageClause, SyntaxKind, } from "@typescript/native/ast";
 import { aliasChains } from "./alias-chain.js";
 import { calleeName, callsOf, classesPassed, decoratedClasses, decoratorCallee } from "./calls.js";
 import { classMembers, memberComponent, typesAt } from "./class-members.js";
-import { entriesAt, names, namesADeclaration, resolveEntries, spelledEntry, } from "./configured-declarations.js";
+import { entriesAt, names, namesADeclaration, resolveEntries, spelledEntry, } from "./roots/configured-declarations.js";
 import { nodeKey } from "./inventory.js";
 import { renderPosition } from "./position.js";
 import { must } from "./query.js";
+/**
+ * The platform's own contract (references-ts.38): `CustomElementRegistry.define` reads
+ * these members off the class it registers, its constructor's and its prototype's
+ * (https://html.spec.whatwg.org/multipage/custom-elements.html#dom-customelementregistry-define),
+ * and calls each callback as a custom element reaction.
+ */
+const CUSTOM_ELEMENTS = {
+    components: [{ global: "CustomElementRegistry.define" }],
+    members: [
+        "observedAttributes:static",
+        "disabledFeatures:static",
+        "formAssociated:static",
+        "connectedCallback",
+        "disconnectedCallback",
+        "connectedMoveCallback",
+        "adoptedCallback",
+        "attributeChangedCallback",
+        "formAssociatedCallback",
+        "formResetCallback",
+        "formDisabledCallback",
+        "formStateRestoreCallback",
+    ],
+};
 /** Every contract's components and bases, resolved in one pass over the entries. */
 function resolveContracts(project, held, contracts) {
     const entries = contracts.flatMap((contract) => [
@@ -155,16 +179,17 @@ function byBases(project, held, chains, contracts) {
 }
 /**
  * The framework-lifecycle detector: each member a contract lists, on each class that
- * is a component of that contract's framework, recorded where the class was found to
- * be one.
+ * is a component of that contract's framework, recorded once per place where the class
+ * was found to be one.
  */
 export function frameworkLifecycle(input) {
     const { project, held, targetRoot } = input;
-    if (input.ts.lifecycle_contracts.length === 0) {
+    const declared = [CUSTOM_ELEMENTS, ...input.ts.lifecycle_contracts];
+    const contracts = resolveContracts(project, held, declared);
+    if (contracts.every((one) => one.components.length === 0 && one.bases.length === 0)) {
         return [];
     }
     const chains = aliasChains(project, held);
-    const contracts = resolveContracts(project, held, input.ts.lifecycle_contracts);
     const components = [
         ...byComponents(project, held, chains, contracts),
         ...byBases(project, held, chains, contracts),
@@ -173,22 +198,24 @@ export function frameworkLifecycle(input) {
         return [];
     }
     const ids = new Set(components.map((one) => one.id));
-    const sides = input.ts.lifecycle_contracts.some((contract) => contract.members.some((name) => name.endsWith(":static")))
+    const sides = declared.some((contract) => contract.members.some((name) => name.endsWith(":static")))
         ? ["instance", "static"]
         : ["instance"];
     const members = sides.map((side) => classMembers(project, held, ids, side));
     const byId = new Map(held.symbols.map((symbol) => [symbol.id, symbol]));
-    const found = [];
+    const found = new Map();
     for (const component of components) {
         const listed = new Set(component.contract.members);
         const site = renderPosition(component.site.getSourceFile(), targetRoot, component.site.getStart());
         for (const member of members.flatMap((side) => side.get(component.id) ?? [])) {
             const symbol = byId.get(member.id);
             const spelled = symbol === undefined ? undefined : memberComponent(symbol, byId);
-            if (spelled !== undefined && listed.has(spelled)) {
-                found.push({ id: member.id, detail: component.detail, site });
+            // A configured contract may name the platform's registry too; one record answers both.
+            const key = `${member.id}\0${component.detail}\0${site.path}:${String(site.line)}:${String(site.column)}`;
+            if (spelled !== undefined && listed.has(spelled) && !found.has(key)) {
+                found.set(key, { id: member.id, detail: component.detail, site });
             }
         }
     }
-    return found;
+    return [...found.values()];
 }

package/dist/src/fs/manifest.js

@@ -16,22 +16,27 @@ export const DEPENDENCY_SECTIONS = [
 export function inInstalledPackages(path) {
     return path.split("/").includes(INSTALLED_PACKAGES);
 }
-/** One JSON file's text and decoded value, or undefined where it cannot be read or parsed. */
-export function readDocument(host, path) {
+/** One JSON file, read and parsed, as {@link JSONRead} tells its states apart. */
+export function readJSONFile(host, path) {
     let text;
     try {
         text = host.readFile(path);
     }
-    catch {
-        return undefined;
+    catch (error) {
+        return { kind: "unread", reason: message(error) };
     }
     try {
-        return { text, value: JSON.parse(text) };
+        return { kind: "read", text, value: JSON.parse(text) };
     }
     catch {
-        return undefined;
+        return { kind: "malformed" };
     }
 }
+/** One JSON file's text and decoded value, or undefined where it cannot be read or parsed. */
+export function readDocument(host, path) {
+    const read = readJSONFile(host, path);
+    return read.kind === "read" ? { text: read.text, value: read.value } : undefined;
+}
 /** One JSON file's decoded value, or undefined where it cannot be read or parsed. */
 export function readJSON(host, path) {
     return readDocument(host, path)?.value;
@@ -50,21 +55,11 @@ export function readManifestAt(host, dir) {
     if (!holdsManifest(host, dir)) {
         return { kind: "absent" };
     }
-    let text;
-    try {
-        text = host.readFile(joinPath(dir, MANIFEST));
-    }
-    catch (error) {
-        return { kind: "unread", reason: message(error) };
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        return { kind: "malformed" };
+    const read = readJSONFile(host, joinPath(dir, MANIFEST));
+    if (read.kind !== "read") {
+        return read;
     }
-    return isRecord(value) ? { kind: "read", manifest: value } : { kind: "malformed" };
+    return isRecord(read.value) ? { kind: "read", manifest: read.value } : { kind: "malformed" };
 }
 /** Whether one directory holds a manifest file. */
 export function holdsManifest(host, dir) {