@cplieger/deadset-ts 4.0.1 → 5.0.0

package/dist/src/manifest.js

@@ -1,11 +1,9 @@
 /**
  * The entry points a package manifest names, which are roots because something
  * outside the analyzed program reaches them: a consumer importing the package, or a
- * shell running its command.
+ * shell running its command or one of its scripts.
  *
- * Only the target's own manifest is read. A manifest below the target root belongs
- * to another package, whose entry points are that package's roots and not this
- * target's.
+ * One call reads one manifest, the one in the directory it is given.
  */
 import { isAbsolutePath, joinPath, resolvePath } from "./paths.js";
 /** The manifest's own name. */
@@ -26,6 +24,21 @@ function isTarget(value, requireDot) {
     }
     return !requireDot || value.startsWith("./");
 }
+/** Where a script's command line splits into tokens: white space and the shell's operators. */
+const SCRIPT_SEPARATORS = /\s+|&&|\|\||;|\|/u;
+/** A token written inside one pair of quotes. */
+const QUOTED = /^(["'])(.*)\1$/su;
+/**
+ * Every token one script's command line holds, each with one pair of enclosing quotes
+ * removed. A token holding a wildcard is a pattern rather than a path, and names no
+ * entry point.
+ */
+export function scriptTokens(command) {
+    return command
+        .split(SCRIPT_SEPARATORS)
+        .map((token) => token.replace(QUOTED, "$2"))
+        .filter((token) => token !== "" && !token.includes("*"));
+}
 /** One member's spelling below another: `exports` then `exports["."]`. */
 function below(member, key) {
     return `${member}[${JSON.stringify(key)}]`;
@@ -33,12 +46,9 @@ function below(member, key) {
 /**
  * Every target one `exports` value carries, at the member each is written under.
  *
- * The value is a string, an object whose keys are subpaths or conditions, or an
- * array of alternatives, nested to any depth, and a `null` blocks a subpath rather
- * than naming a target. Every level is walked because a condition names a different
- * file of the same package and each is an entry point of its own; a key's meaning
- * is not read, because a subpath and a condition both lead to a target and the
- * walk needs no more than that.
+ * The value nests strings, subpath or condition objects and alternative arrays to
+ * any depth; a `null` blocks a subpath. Every level is walked, because each
+ * condition names its own entry file, and a key's meaning is never read.
  */
 function exportTargets(value, member, found) {
     if (typeof value === "string") {
@@ -83,7 +93,7 @@ function manifestOf(host, targetRoot) {
     return isRecord(value) ? value : undefined;
 }
 /**
- * What the target's own manifest declares about where the package is entered.
+ * What the manifest in `targetRoot` declares about where its package is entered.
  *
  * A target is taken as written. It is not resolved to a source file here, because
  * which file a target names is a fact about the compiler configuration that emits
@@ -113,6 +123,22 @@ export function readManifest(host, targetRoot) {
         }
     }
     exportTargets(manifest["exports"], "exports", found);
+    const scripts = manifest["scripts"];
+    if (isRecord(scripts)) {
+        for (const [name, command] of Object.entries(scripts)) {
+            if (typeof command !== "string") {
+                continue;
+            }
+            for (const token of new Set(scriptTokens(command))) {
+                found.push({
+                    member: below("scripts", name),
+                    path: token,
+                    role: "script",
+                    published: false,
+                });
+            }
+        }
+    }
     return {
         entries: found.map((entry) => ({ ...entry, path: resolvePath(targetRoot, entry.path) })),
         declaresExports: manifest["exports"] !== undefined,

package/dist/src/matrix.js

@@ -32,32 +32,31 @@ export function referenceKey(reference) {
 }
 /**
  * Indexes what the passes answered for each configuration of one run, in the run's order.
- *
- * A declaration is keyed across configurations by its identifier, which is its rendered
- * position and so is the same in every configuration that compiles its file; the fields
- * of the first configuration that holds it are the ones kept. A declaration one
- * configuration alone holds is in the union with that one configuration, so it is
- * judged where it exists rather than skipped.
- *
- * One reference written at one position of a file several configurations compile is seen
- * once per configuration and is one reference, so the union holds it once; two references
- * one configuration makes at one position are two.
+ * A declaration is keyed by its rendered position, with the fields of the first
+ * configuration that judges it; one in a file every holder holds only for its references
+ * is judged by none and is not in the union. One reference at one position of a file
+ * several configurations compile is one reference; two one configuration makes are two.
  */
 export function matrixOf(per) {
     const symbols = [];
     const holders = new Map();
     const references = [];
     const firstSeen = new Map();
+    const judged = new Set();
     per.forEach((one, index) => {
+        const referenceOnly = new Set(one.referenceOnly);
         for (const symbol of one.symbols) {
             const held = holders.get(symbol.id);
             if (held === undefined) {
                 holders.set(symbol.id, [one.configuration]);
-                symbols.push(symbol);
             }
             else if (!held.includes(one.configuration)) {
                 held.push(one.configuration);
             }
+            if (!referenceOnly.has(symbol.position.path) && !judged.has(symbol.id)) {
+                judged.add(symbol.id);
+                symbols.push(symbol);
+            }
         }
         for (const reference of one.references) {
             const key = referenceKey(reference);
@@ -74,8 +73,8 @@ export function matrixOf(per) {
     symbols.sort((a, b) => byPosition(a.position, b.position) || compare(a.ref, b.ref));
     return {
         configurations: per.map((one) => one.configuration),
-        graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles)),
-        union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))]),
+        graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles, one.supportFiles)),
+        union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))], [...new Set(per.flatMap((one) => one.supportFiles ?? []))]),
         heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
     };
 }
@@ -131,6 +130,15 @@ export function sweepMatrix(matrix, input) {
         components: componentsOf(union, dead, testOfDeadCode),
     };
 }
+/**
+ * The file declarations at `paths`, below the target root, that one sweep holds live
+ * under both relations, the rule a judged declaration is live by.
+ */
+export function liveFilesAt(matrix, result, paths) {
+    return matrix.union.symbols.filter((symbol) => symbol.kind === "file" &&
+        paths.has(symbol.position.path) &&
+        (result.liveUnder.get(symbol.id)?.length ?? 0) === RELATIONS.length);
+}
 /** The relations in the order a declaration's entry lists them. */
 const RELATIONS = ["reference-counting", "reachability"];
 /**

package/dist/src/partial.js

@@ -1,3 +1,4 @@
+import { relativePath } from "./paths.js";
 /** A count with its noun, so a line reads for one as well as for several. */
 function counted(n, one, many) {
     return `${String(n)} ${n === 1 ? one : many}`;
@@ -14,7 +15,8 @@ export function partialNotes(partial) {
     if (partial.unanswered.length > 0) {
         const byProject = new Map();
         for (const question of partial.unanswered) {
-            byProject.set(question.configFile, (byProject.get(question.configFile) ?? 0) + 1);
+            const configFile = relativePath(partial.targetRoot, question.configFile) ?? question.configFile;
+            byProject.set(configFile, (byProject.get(configFile) ?? 0) + 1);
         }
         const where = [...byProject].map(([configFile, n]) => `${configFile}: ${String(n)}`).join(", ");
         notes.push(`the checker answered ${counted(partial.unanswered.length, "question", "questions")} with a failure (${where}); every declaration an answer could have kept live is kept live and reported by nothing`);

package/dist/src/pnpm-workspace.js

@@ -0,0 +1,120 @@
+/**
+ * The `packages` list of a `pnpm-workspace.yaml`. The document is read as far as that
+ * one key needs and no further: a top-level `packages` key holding a block sequence or
+ * a one-line flow sequence of plain or quoted strings. Any other value of the key is
+ * refused rather than guessed at, because a list read wrong names the wrong packages.
+ */
+/** The characters a plain scalar may not start with. */
+const INDICATORS = new Set(["[", "]", "{", "}", ",", "&", "*", "!", "|", ">", "%", "@", "`", "#"]);
+/** One line with its comment removed, a `#` inside quotes kept. */
+function uncommented(line) {
+    let quote;
+    for (let at = 0; at < line.length; at += 1) {
+        const character = line[at];
+        if (quote !== undefined) {
+            if (character === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (character === "'" || character === '"') {
+            quote = character;
+        }
+        else if (character === "#" && (at === 0 || /\s/u.test(line[at - 1] ?? ""))) {
+            return line.slice(0, at).trimEnd();
+        }
+    }
+    return line.trimEnd();
+}
+/** One scalar as written, or `undefined` where it is not a string this reader reads. */
+function scalarOf(text) {
+    const value = text.trim();
+    if (value.length >= 2 && value.startsWith("'") && value.endsWith("'")) {
+        const inner = value.slice(1, -1);
+        return /'(?!')/u.test(inner.replaceAll("''", "")) ? undefined : inner.replaceAll("''", "'");
+    }
+    if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+        const inner = value.slice(1, -1);
+        return inner.includes("\\") || inner.includes('"') ? undefined : inner;
+    }
+    if (value === "" ||
+        INDICATORS.has(value[0] ?? "") ||
+        value.startsWith("'") ||
+        value.startsWith('"')) {
+        return undefined;
+    }
+    if (value.startsWith("- ") || value.startsWith("? ") || /:(?:\s|$)/u.test(value)) {
+        return undefined;
+    }
+    return value;
+}
+/** The entries of a one-line flow sequence, or `undefined` where one does not read. */
+function flowOf(text) {
+    const inner = text.slice(1, -1).trim();
+    if (inner === "") {
+        return [];
+    }
+    const entries = inner.split(",");
+    if (entries.length > 1 && entries.at(-1)?.trim() === "") {
+        entries.pop();
+    }
+    const found = [];
+    for (const entry of entries) {
+        const value = scalarOf(entry);
+        if (value === undefined) {
+            return undefined;
+        }
+        found.push(value);
+    }
+    return found;
+}
+const KEY = /^(?:packages|'packages'|"packages")\s*:(?:\s(.*))?$/u;
+/** The `packages` list one `pnpm-workspace.yaml` text declares. */
+export function pnpmPackages(text) {
+    const lines = text.split(/\r?\n/u).map(uncommented);
+    const keys = lines.flatMap((line, at) => (KEY.test(line) ? [at] : []));
+    const [at] = keys;
+    if (at === undefined) {
+        return { kind: "absent" };
+    }
+    if (keys.length > 1) {
+        return { kind: "refused", reason: "the packages key is declared more than once" };
+    }
+    const rest = (KEY.exec(lines[at] ?? "")?.[1] ?? "").trim();
+    if (rest !== "") {
+        const listed = rest.startsWith("[") && rest.endsWith("]") ? flowOf(rest) : undefined;
+        return listed === undefined
+            ? {
+                kind: "refused",
+                reason: `packages holds ${JSON.stringify(rest)}, not a sequence of strings`,
+            }
+            : { kind: "listed", patterns: listed };
+    }
+    const patterns = [];
+    for (const line of lines.slice(at + 1)) {
+        if (line.trim() === "") {
+            continue;
+        }
+        const item = /^(\s*)-(?:\s+(.*))?$/u.exec(line);
+        if (item === null) {
+            if (/^\s/u.test(line)) {
+                return {
+                    kind: "refused",
+                    reason: `packages holds ${JSON.stringify(line.trim())}, not a sequence item`,
+                };
+            }
+            break;
+        }
+        const value = scalarOf(item[2] ?? "");
+        if (value === undefined) {
+            return {
+                kind: "refused",
+                reason: `the packages item ${JSON.stringify(line.trim())} is not a plain or quoted string`,
+            };
+        }
+        patterns.push(value);
+    }
+    return patterns.length === 0
+        ? { kind: "refused", reason: "packages holds no sequence" }
+        : { kind: "listed", patterns };
+}

package/dist/src/position.js

@@ -13,18 +13,33 @@ export class PositionError extends Error {
         this.file = file;
     }
 }
+/** Whether the compiler read one file through a content mapper, which makes it a component file. */
+export function isComponentFile(file) {
+    return file.contentMapper !== undefined;
+}
+/**
+ * The length of the file as it is written. A component file's module holds the file's
+ * text at its own offsets and appends what it needs past its end.
+ */
+export function writtenLength(file) {
+    return isComponentFile(file) ? file.originalText.length : file.text.length;
+}
 /**
  * The position of one offset of one file, rendered against the target root.
  *
  * `offset` is a UTF-16 code unit offset into the file's text, which is what every
- * node of the tree carries.
+ * node of the tree carries. An offset a component file's module appends renders where
+ * the module's span map places it in the file.
  */
 export function renderPosition(file, root, offset) {
     const path = relativePath(root, file.fileName);
     if (path === undefined) {
         throw new PositionError(file.fileName, root);
     }
-    const { line, character } = file.getLineAndCharacterOfPosition(offset);
+    const written = isComponentFile(file) && offset >= file.originalText.length
+        ? Math.min(file.spanMap?.virtualToOriginalPosition(offset).position ?? offset, file.originalText.length)
+        : offset;
+    const { line, character } = file.getLineAndCharacterOfPosition(written);
     return { path, line: line + 1, column: character + 1 };
 }
 /**

package/dist/src/print.js

@@ -64,6 +64,8 @@ export function printConfig(config, provenance) {
         ts: {
             test_files: config.ts.testFiles,
             entry_files: config.ts.entryFiles,
+            component_extensions: config.ts.componentExtensions,
+            disabled_conventions: config.ts.disabledConventions,
             injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
             lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
                 components: entry.components.map(declarationOf),