@cplieger/deadset-ts 3.12.0 → 3.13.0

package/dist/src/findings/unused-declarations.js

@@ -111,7 +111,15 @@ function messageOf(code, judged) {
     return `${subject} has no reference in the target`;
 }
 /** The findings of the unused-declarations family, `DS1000` to `DS1099`. */
-export const unusedDeclarations = (input) => {
+export const unusedDeclarations = (input) => familyFindings(input, false);
+/**
+ * The finding each member of a dead container would carry were its container live: what
+ * a record on such a member is matched against, since the report carries the container's
+ * finding rather than one of the member's own.
+ */
+export const fallenMembers = (input) => familyFindings(input, true);
+/** The family's findings, or, where `fallen` is set, its dead containers' members' alone. */
+function familyFindings(input, fallen) {
     const union = input.swept.matrix.union;
     const dead = new Set(input.swept.sweep.candidates.map((candidate) => candidate.id));
     const unreachable = unreachableExports(input);
@@ -122,11 +130,15 @@ export const unusedDeclarations = (input) => {
         if (symbol === undefined) {
             continue;
         }
+        const containerDead = dead.has(symbol.parent);
+        if (fallen !== containerDead) {
+            continue;
+        }
         const judged = {
             candidate,
             symbol,
             test: union.test[at] === true,
-            containerDead: dead.has(symbol.parent),
+            containerDead: containerDead && !fallen,
             deprecated: input.deprecated.has(symbol.id),
             unreachable: unreachable.has(symbol.id),
         };
@@ -148,4 +160,4 @@ export const unusedDeclarations = (input) => {
         });
     }
     return found;
-};
+}

package/dist/src/findings-pass.js

@@ -76,18 +76,25 @@ export function verdictOf(result, config) {
     return failing ? EXIT_FINDINGS : EXIT_CLEAN;
 }
 /**
- * The findings of a report as a baseline records them, in report order. A finding about a
- * row of a document is not recorded: no record withholds one, so a row recording it would
- * be stale on the first read back.
+ * The rows one round of a baseline write records from its findings, in their order. A
+ * finding about a row of a document 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.
  */
-export function recordedFindings(result) {
-    return result.findings
-        .filter((finding) => !isRowSubject(finding.symbol.kind))
-        .map((finding) => ({
-        code: finding.code,
-        symbol: finding.symbol.ref,
-        path: finding.position.path,
-    }));
+export function recordedFindings(findings) {
+    const rows = new Map();
+    for (const finding of findings) {
+        if (isRowSubject(finding.symbol.kind)) {
+            continue;
+        }
+        const row = { code: finding.code, symbol: finding.symbol.ref, path: finding.position.path };
+        rows.set(rowKey(row), rows.get(rowKey(row)) ?? row);
+    }
+    return [...rows.values()];
+}
+/** One row's identity: its code, its symbol and its path. */
+export function rowKey(row) {
+    return `${row.code}\u0000${row.symbol}\u0000${row.path}`;
 }
 /** The analyzer identity a baseline this analyzer writes names as its rows' provenance. */
 export function analyzerProvenance(version) {

package/dist/src/graph.js

@@ -32,15 +32,15 @@ const SWEPT = {
 };
 /**
  * Whether a root of each kind names a caller, which holds it live under both relations: a
- * tool reads the configuration it loads, a runtime runs a test file, a setup file and a
- * worker, and a configured root asserts a caller. The other kinds only suppose a consumer
- * that imports what a manifest entry, a binary or an entry file exports, or names a
- * library's published API, so such a root is live under reachability alone.
+ * tool reads the configuration it loads, a runtime runs a test file, a setup file, a
+ * worker and a command, the manifest names what enters the package, and an entry file, a
+ * configured root and a pattern assert a caller. A library's published API only supposes
+ * a consumer the run may not see, so it is live under reachability alone.
  */
 const NAMES_A_CALLER = {
-    "entry-file": false,
-    "manifest-entry": false,
-    "manifest-binary": false,
+    "entry-file": true,
+    "manifest-entry": true,
+    "manifest-binary": true,
     "published-api": false,
     configured: true,
     pattern: true,