@cplieger/deadset-ts 2.2.1 → 3.0.0

package/dist/src/glob.js

@@ -0,0 +1,65 @@
+/**
+ * Glob patterns over the paths of the target's own files, as the configuration
+ * writes them. Both `ts.test_files` and `ts.entry_files` name files this way, and
+ * one grammar answers for both.
+ *
+ * A configured root is not written in this grammar. It names a symbol reference
+ * rather than a path, `*` there spans the solidus and a brace list means nothing,
+ * so that rule is written where it is read.
+ */
+/**
+ * One literal run of a pattern, with every character the expression syntax claims
+ * escaped.
+ *
+ * The set is the syntax characters and the solidus, and it is closed: an escape of any
+ * other character is refused outright by the expression syntax under the unicode flag,
+ * so escaping a hyphen, which needs none outside a character class, would refuse every
+ * pattern that names a hyphenated path.
+ */
+function quoted(text) {
+    return text.replaceAll(/[.*+?^${}()|[\]\\/]/gu, (character) => `\\${character}`);
+}
+/**
+ * The expression one glob pattern denotes. `**` spans path separators while `*` and `?`
+ * do not, a brace list is an alternation of its members, and every other character
+ * stands for itself.
+ */
+export function globExpression(pattern) {
+    let source = "^";
+    let at = 0;
+    while (at < pattern.length) {
+        const rest = pattern.slice(at);
+        if (rest.startsWith("**/")) {
+            source += "(?:[^/]*/)*";
+            at += 3;
+            continue;
+        }
+        if (rest.startsWith("**")) {
+            source += ".*";
+            at += 2;
+            continue;
+        }
+        const character = pattern[at] ?? "";
+        at += 1;
+        if (character === "*") {
+            source += "[^/]*";
+            continue;
+        }
+        if (character === "?") {
+            source += "[^/]";
+            continue;
+        }
+        if (character === "{") {
+            const close = pattern.indexOf("}", at);
+            if (close < 0) {
+                source += "\\{";
+                continue;
+            }
+            source += `(?:${pattern.slice(at, close).split(",").map(quoted).join("|")})`;
+            at = close + 1;
+            continue;
+        }
+        source += quoted(character);
+    }
+    return new RegExp(`${source}$`, "u");
+}

package/dist/src/graph.js

@@ -0,0 +1,116 @@
+/**
+ * One project's declarations, the references between them and the roots that seed
+ * reachability, indexed for the sweep. The graph reads no file and asks the compiler
+ * nothing, so a sweep over it is a function of the values it was built from, and the
+ * inventory's order is the order every set a sweep answers reads in.
+ */
+/** The position of a declaration the inventory does not hold. */
+export const OUTSIDE = -1;
+/**
+ * Whether the sweep judges a declaration of each kind. A file is not judged by either
+ * relation: whether a file is built and whether anything imports it are the subjects of
+ * the file kinds, which read the program rather than ask whether anything references the
+ * file. The Contract's finding schema names the kinds that carry no liveness relation,
+ * and a test holds this table to that list.
+ */
+const SWEPT = {
+    file: false,
+    function: true,
+    class: true,
+    interface: true,
+    type: true,
+    enum: true,
+    namespace: true,
+    variable: true,
+    "export-alias": true,
+    method: true,
+    "class-member": true,
+    "interface-method": true,
+    "type-member": true,
+    "enum-member": true,
+    "type-parameter": true,
+};
+/**
+ * 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.
+ */
+const NAMES_A_CALLER = {
+    "entry-file": false,
+    "manifest-entry": false,
+    "manifest-binary": false,
+    "published-api": false,
+    configured: true,
+    pattern: true,
+    "test-runner": true,
+    "lint-configuration": true,
+    "mutation-testing": true,
+    "browser-tests": true,
+    worker: true,
+};
+/** Whether the sweep judges a declaration of one kind. */
+export function swept(kind) {
+    return SWEPT[kind];
+}
+/** Whether a root of one kind names a caller rather than supposing one. */
+export function namesACaller(kind) {
+    return NAMES_A_CALLER[kind];
+}
+/**
+ * Indexes one project's inventory, references and roots. `testFiles` are the paths the
+ * reference pass classified as test files, so a declaration one holds is a test
+ * declaration. A reference to a declaration the inventory does not hold is dropped; one
+ * from such a declaration still counts toward its target, because reference counting
+ * asks whether any declaration names the target. A root naming nothing is dropped.
+ */
+export function graphOf(symbols, references, roots, testFiles) {
+    const index = new Map(symbols.map((symbol, at) => [symbol.id, at]));
+    const at = (id) => index.get(id) ?? OUTSIDE;
+    const tests = new Set(testFiles);
+    const out = symbols.map(() => []);
+    const made = symbols.map(() => ({ production: 0, test: 0 }));
+    for (const reference of references) {
+        const to = at(reference.to);
+        if (to === OUTSIDE) {
+            continue;
+        }
+        const counts = made[to];
+        if (counts !== undefined) {
+            if (reference.test) {
+                counts.test += 1;
+            }
+            else {
+                counts.production += 1;
+            }
+        }
+        out[at(reference.from)]?.push({ to, test: reference.test });
+    }
+    const parent = symbols.map((symbol) => at(symbol.parent));
+    const exportsOf = symbols.map(() => []);
+    symbols.forEach((symbol, position) => {
+        const container = parent[position] ?? OUTSIDE;
+        if (symbol.exported && symbols[container]?.kind === "file") {
+            exportsOf[container]?.push(position);
+        }
+    });
+    const rooted = [];
+    for (const root of roots) {
+        const position = at(root.id);
+        if (position !== OUTSIDE) {
+            rooted.push({ at: position, kind: root.kind });
+        }
+    }
+    return {
+        symbols,
+        out,
+        made,
+        parent,
+        test: symbols.map((symbol) => tests.has(symbol.position.path)),
+        subject: symbols.map((symbol) => swept(symbol.kind)),
+        exportsOf,
+        rooted,
+        at,
+    };
+}

package/dist/src/index.js

@@ -1,6 +1,5 @@
 export { run, SETTING_OPTIONS } from "./run.js";
-export { inventory, nodeKey, } from "./inventory.js";
-export { DEFAULT_BATCH_CAP, references, } from "./references.js";
+export { DECLINED_CONVENTIONS } from "./entry-point-gaps.js";
 export { byPosition, positionKey, PositionError, renderPosition, } from "./position.js";
 export { computedComponent, isRef, nameComponent, REF_EXPRESSIONS, renderRef, } from "./ref.js";
 export { CONTRACT_VERSION } from "./version.js";

package/dist/src/manifest.js

@@ -0,0 +1,120 @@
+/**
+ * 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.
+ *
+ * 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.
+ */
+import { isAbsolutePath, joinPath, 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("./");
+}
+/** 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 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.
+ */
+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 target's own manifest declares about where the 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);
+    return {
+        entries: found.map((entry) => ({ ...entry, path: resolvePath(targetRoot, entry.path) })),
+        declaresExports: manifest["exports"] !== undefined,
+    };
+}

package/dist/src/print.js

@@ -19,12 +19,9 @@ export function printConfig(config, provenance) {
             min_confidence: config.analysis.minConfidence,
             generated_files: config.analysis.generatedFiles,
             consumer_tests: config.analysis.consumerTests,
-            configurations: config.analysis.configurations.map((entry) => ({
-                id: entry.id,
-                os: entry.os,
-                arch: entry.arch,
-                tags: entry.tags,
-            })),
+            configurations: config.analysis.configurations.map((entry) => entry.shape === "project"
+                ? { id: entry.id, project: entry.project }
+                : { id: entry.id, os: entry.os, arch: entry.arch, tags: entry.tags }),
             matrix: { complete: config.analysis.matrixComplete },
             template_dirs: config.analysis.templateDirs,
             template_delimiters: {