@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/dist/src/manifest.js

@@ -1,165 +0,0 @@
-/**
- * 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 or one of its scripts. {@link readManifest} reads one
- * directory's manifest, {@link packageEntries} those of the packages below the target root.
- */
-import { isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.js";
-/** The manifest's own name. */
-const MANIFEST = "package.json";
-/** The three members that name an entry point beside `exports` and `bin`. */
-const LEGACY_MEMBERS = ["main", "module", "types"];
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/**
- * Whether one member's value names a file of this package rather than another
- * package or a URL. A target written with no leading dot is a path too, which is
- * how the members that preceded `exports` are written.
- */
-function isTarget(value, requireDot) {
-    if (value === "" || isAbsolutePath(value) || value.includes("://")) {
-        return false;
-    }
-    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)}]`;
-}
-/**
- * Every target one `exports` value carries, at the member each is written under.
- *
- * 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") {
-        if (isTarget(value, true)) {
-            found.push({ member, path: value, role: "import", published: true });
-        }
-        return;
-    }
-    if (Array.isArray(value)) {
-        value.forEach((alternative, index) => {
-            exportTargets(alternative, below(member, String(index)), found);
-        });
-        return;
-    }
-    if (!isRecord(value)) {
-        return;
-    }
-    for (const [key, held] of Object.entries(value)) {
-        exportTargets(held, below(member, key), found);
-    }
-}
-/** The manifest at the target root, decoded, or undefined where there is none to read. */
-function manifestOf(host, targetRoot) {
-    let text;
-    try {
-        text = host.readFile(joinPath(targetRoot, MANIFEST));
-    }
-    catch {
-        return undefined;
-    }
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        // A manifest this program cannot read names no entry point, which is the same
-        // answer as an absent one. What a manifest's contents say is not refused here:
-        // the package manager owns that refusal, and an analysis of a tree it rejects
-        // is not the run's subject.
-        return undefined;
-    }
-    return isRecord(value) ? value : undefined;
-}
-/**
- * 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
- * it and there is one such configuration per project, while there is one manifest.
- */
-export function readManifest(host, targetRoot) {
-    const manifest = manifestOf(host, targetRoot);
-    if (manifest === undefined) {
-        return { entries: [], declaresExports: false };
-    }
-    const found = [];
-    for (const member of LEGACY_MEMBERS) {
-        const value = manifest[member];
-        if (typeof value === "string" && isTarget(value, false)) {
-            found.push({ member, path: value, role: "import", published: true });
-        }
-    }
-    const bin = manifest["bin"];
-    if (typeof bin === "string" && isTarget(bin, false)) {
-        found.push({ member: "bin", path: bin, role: "run", published: false });
-    }
-    else if (isRecord(bin)) {
-        for (const [command, value] of Object.entries(bin)) {
-            if (typeof value === "string" && isTarget(value, false)) {
-                found.push({ member: below("bin", command), path: value, role: "run", published: false });
-            }
-        }
-    }
-    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),
-            dir: targetRoot,
-        })),
-        declaresExports: manifest["exports"] !== undefined,
-    };
-}
-/**
- * The entry points the manifests of the nested packages in `dirs` name. Each entry is
- * spelled under its manifest's path below the target root, and is published by its own
- * manifest's rule, as the target's own entries are.
- */
-export function packageEntries(host, targetRoot, dirs) {
-    return dirs.flatMap((dir) => {
-        const manifest = readManifest(host, dir);
-        const where = `${relativePath(targetRoot, dir) ?? dir}/${MANIFEST}`;
-        return manifest.entries.map((entry) => ({
-            ...entry,
-            member: `${where} ${entry.member}`,
-            published: entry.published && (!manifest.declaresExports || entry.member.startsWith("exports")),
-        }));
-    });
-}

package/dist/src/matrix.js

@@ -1,246 +0,0 @@
-/**
- * One run's projects as one matrix: every declaration any project holds, keyed by its
- * position and carrying the configurations that hold it, swept once per configuration
- * and intersected, with the dead components computed once over every configuration.
- */
-import { componentsOf } from "./components.js";
-import { graphOf, OUTSIDE } from "./graph.js";
-import { byPosition } from "./position.js";
-import { reachedWithTheTests, sweep, } from "./sweep.js";
-/**
- * What makes one reference one reference, whichever configuration made it. A consumer's
- * position is rendered against its own root, so the consumer is part of what it names.
- */
-export function referenceKey(reference) {
-    const { path, line, column } = reference.position;
-    return [
-        reference.consumer ?? "",
-        reference.from,
-        reference.to,
-        path,
-        String(line),
-        String(column),
-        reference.use,
-    ].join("\u0000");
-}
-/**
- * Indexes what the passes answered for each configuration of one run, in the run's order.
- * 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();
-    const dependents = new Map();
-    per.forEach((one, index) => {
-        for (const [id, after] of one.dependents ?? []) {
-            if (!dependents.has(id)) {
-                dependents.set(id, after);
-            }
-        }
-        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]);
-            }
-            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);
-            const seen = firstSeen.get(key);
-            if (seen === undefined) {
-                firstSeen.set(key, index);
-            }
-            else if (seen !== index) {
-                continue;
-            }
-            references.push(reference);
-        }
-    });
-    symbols.sort((a, b) => byPosition(a.position, b.position));
-    const testUsed = new Set(per.flatMap((one) => one.testUsedFiles ?? []));
-    return {
-        configurations: per.map((one) => one.configuration),
-        graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles, one.supportFiles, one.ambient)),
-        union: graphOf(symbols, references, per.flatMap((one) => one.roots), [...new Set(per.flatMap((one) => one.testFiles))], [...new Set(per.flatMap((one) => one.supportFiles ?? []))], new Set(per.flatMap((one) => [...(one.ambient ?? [])]))),
-        heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
-        testUsed: symbols.map((symbol) => testUsed.has(symbol.position.path)),
-        dependents,
-    };
-}
-/**
- * Answers which declarations of the run are dead in every configuration that holds them.
- *
- * Liveness is a question about one configuration, because a file another configuration
- * does not compile makes no reference there and a root it does not hold seeds nothing
- * there, so each configuration is swept on its own graph under the run's input. A
- * declaration is a candidate when every configuration holding it judged it one: a
- * reference under one configuration is a reference, so what one project uses is never
- * reported, and a configuration that does not hold a declaration says nothing about it.
- * The candidate's relation is reference counting where every configuration found it so,
- * and reachability otherwise; its counts are the union's, one per reference.
- *
- * The components are computed once, over the union and the intersected dead set, so one
- * dead component is one entry of the run with one identifier.
- */
-export function sweepMatrix(matrix, input) {
-    const per = matrix.graphs.map((graph) => sweep(graph, input));
-    const byConfiguration = new Map(matrix.configurations.map((configuration, index) => [
-        configuration,
-        new Map((per[index]?.candidates ?? []).map((candidate) => [candidate.id, candidate])),
-    ]));
-    const union = matrix.union;
-    const heldBy = union.symbols.map(() => undefined);
-    const testReached = reachedWithTheTests(union, [
-        ...input.marked,
-        ...(input.exempt ?? []).map((record) => record.id),
-        ...(input.unanswered ?? []),
-    ]);
-    const judged = union.symbols.map((symbol, at) => {
-        const held = matrix.heldIn[at] ?? [];
-        const found = held.map((configuration) => byConfiguration.get(configuration)?.get(symbol.id));
-        return held.length === 0 || found.some((candidate) => candidate === undefined)
-            ? undefined
-            : found.filter((candidate) => candidate !== undefined);
-    });
-    // A configuration that does not hold a test's subject's caller finds the subject dead,
-    // so a test is of dead code only where every production subject it names is dead in
-    // every configuration that holds it.
-    const subjectsDead = (at) => (union.out[at] ?? []).every((edge) => union.test[edge.to] === true ||
-        union.support[edge.to] === true ||
-        union.ambient[edge.to] === true ||
-        union.subject[edge.to] !== true ||
-        judged[edge.to] !== undefined);
-    const admittedAt = (at) => judged[at]?.every((candidate) => candidate.testOfDeadCode) === true && subjectsDead(at);
-    const kept = keptByTests(union, testReached, admittedAt);
-    const testUsed = testUsedReach(union, union.symbols.map((_symbol, at) => matrix.testUsed[at] === true && testReached[at] === true), judged.map((one) => one !== undefined));
-    const candidates = [];
-    union.symbols.forEach((symbol, at) => {
-        const all = judged[at];
-        if (all === undefined) {
-            return;
-        }
-        const held = matrix.heldIn[at] ?? [];
-        const admitted = admittedAt(at);
-        const testRefs = union.made[at]?.test ?? 0;
-        const heldByTests = heldBy[union.parent[at] ?? OUTSIDE] ??
-            (union.support[at] === true && testRefs > 0 && !admitted ? symbol.id : undefined);
-        const unreferenced = union.test[at] === true && !admitted && testReached[at] !== true;
-        heldBy[at] = heldByTests;
-        const productionRefs = union.made[at]?.production ?? 0;
-        const counted = all.every((candidate) => candidate.relation === "reference-counting");
-        candidates.push({
-            id: symbol.id,
-            productionRefs,
-            testRefs,
-            // The run that judges a test-file declaration counts its test references.
-            relation: (unreferenced ? productionRefs + testRefs === 0 : counted)
-                ? "reference-counting"
-                : "reachability",
-            testOfDeadCode: admitted,
-            configurations: held,
-            heldByTests,
-            unreferencedTest: unreferenced,
-            testUsed: testUsed[at] === true,
-            keptByTests: kept[at] === true,
-        });
-    });
-    const liveUnder = liveAnywhere(union.symbols, per);
-    return {
-        liveUnder,
-        candidates,
-        components: deadComponents(matrix, { liveUnder, candidates }, new Set()),
-    };
-}
-/** Per declaration of the union, whether one of `seeds` is it or reaches it through `dead` declarations. */
-function testUsedReach(union, seeds, dead) {
-    // A file is no candidate, and its top level is what reaches what it alone calls.
-    const reached = seeds.map((seed, at) => seed && dead[at] === true);
-    const queue = seeds.flatMap((one, at) => (one ? [at] : []));
-    for (let at = queue.pop(); at !== undefined; at = queue.pop()) {
-        for (const edge of union.out[at] ?? []) {
-            if (dead[edge.to] === true && reached[edge.to] !== true) {
-                reached[edge.to] = true;
-                queue.push(edge.to);
-            }
-        }
-    }
-    return reached;
-}
-/** Per declaration of the union, whether test code `reached` holds and `admitted` rejects references it. */
-function keptByTests(union, reached, admitted) {
-    const kept = union.symbols.map(() => false);
-    union.out.forEach((edges, from) => {
-        const testCode = union.test[from] === true || union.support[from] === true;
-        if (!testCode || reached[from] !== true || admitted(from)) {
-            return;
-        }
-        for (const edge of edges) {
-            if (edge.test) {
-                kept[edge.to] = true;
-            }
-        }
-    });
-    return kept;
-}
-/**
- * The dead components of one sweep over the union, with the file declarations at `files`
- * dead as well: a file that is deleted whole takes the declarations it holds and every
- * dead declaration only its top level references with it.
- */
-export function deadComponents(matrix, result, files) {
-    const union = matrix.union;
-    const byId = new Map(result.candidates.map((candidate) => [candidate.id, candidate]));
-    const candidateAt = (at) => byId.get(union.symbols[at]?.id ?? "");
-    return componentsOf(union, union.symbols.map((_symbol, at) => {
-        const candidate = candidateAt(at);
-        return files.has(at) || (candidate !== undefined && candidate.heldByTests === undefined);
-    }), union.symbols.map((_symbol, at) => candidateAt(at)?.testOfDeadCode === true), union.symbols.map((_symbol, at) => candidateAt(at)?.unreferencedTest === true), positionsOf(union, matrix.dependents, result.liveUnder));
-}
-/**
- * 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);
-}
-/**
- * Each declaration's dependents by its place in the union, and per place whether the
- * declaration is live under reachability in some configuration.
- */
-function positionsOf(union, dependents, liveUnder) {
-    return {
-        dependents: union.symbols.map((symbol) => (dependents.get(symbol.id) ?? []).map((id) => union.at(id)).filter((at) => at !== OUTSIDE)),
-        live: union.symbols.map((symbol) => liveUnder.get(symbol.id)?.includes("reachability") === true),
-    };
-}
-/** The relations in the order a declaration's entry lists them. */
-const RELATIONS = ["reference-counting", "reachability"];
-/**
- * Per declaration, in site order, every relation that holds it live in at least one
- * configuration.
- */
-function liveAnywhere(symbols, per) {
-    const live = new Map();
-    for (const symbol of symbols) {
-        const relations = RELATIONS.filter((relation) => per.some((liveness) => (liveness.liveUnder.get(symbol.id) ?? []).includes(relation)));
-        if (relations.length > 0) {
-            live.set(symbol.id, relations);
-        }
-    }
-    return live;
-}

package/dist/src/pnpm-workspace.js

@@ -1,120 +0,0 @@
-/**
- * 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 };
-}