@cplieger/deadset-ts 4.0.1 → 5.1.0

package/dist/src/verbs/print-projects.js

@@ -1,66 +1,27 @@
-import { discoverProjects, DiscoveryError, isGuess, projectErrors, renderDiagnostic, targetRelative, } from "../discover.js";
+import { runProjects } from "../analysis.js";
 import { partialNotes } from "../partial.js";
-import { relativePath, resolvePath } from "../paths.js";
-import { resolveMatrix } from "../resolve.js";
-import { diagnosticsOf, runSession } from "../session.js";
-import { EXIT_CLEAN, EXIT_FAILURE } from "./verb.js";
+import { resolvePath } from "../paths.js";
+import { resolveUnkinded } from "../resolve.js";
+import { EXIT_CLEAN } from "./verb.js";
 /**
- * Writes the name of every project one run analyzes, one per line, having read each
- * project's diagnostics first: the identifier the build matrix declares for it, or,
- * where discovery derived the project, its configuration file's path below the
- * target root. A derived project that does not load is not one the run analyzes, so it
- * is named on the error stream instead, as the analysis drops it.
+ * Writes the name of every project one run analyzes, one per line: the identifier the
+ * build matrix declares for it, or, where discovery derived the project, its
+ * configuration file's path below the target root. The projects are read as the
+ * analysis reads them, so a project the analysis drops is named on the error stream
+ * instead, and one that fails the analysis fails this command the same way.
  */
 export const printProjectsVerb = ({ out, err, host, inputs, scope, openClient }) => {
-    const matrix = resolveMatrix(inputs());
+    const config = resolveUnkinded(inputs());
     const scoped = scope();
-    const engine = openClient(false);
-    const discovered = discoverProjects(engine, host, scoped, matrix);
-    const ids = new Map(discovered.projects.map((project) => [project.configFile, project.id]));
-    const root = resolvePath(host.workingDirectory(), scoped.target.path);
-    const notBuilt = [...discovered.notBuilt];
-    const failures = [];
-    const session = runSession(engine, discovered.configFiles, (project) => {
-        const id = ids.get(project.configFile) ?? project.configFile;
-        const errors = projectErrors(diagnosticsOf(project));
-        const [unloaded] = errors.load;
-        if (unloaded !== undefined && isGuess(discovered, project.configFile)) {
-            const error = renderDiagnostic(unloaded, (path) => relativePath(root, path) ?? path);
-            notBuilt.push({ id, configFile: project.configFile, error: targetRelative(error, root) });
-            return undefined;
-        }
-        failures.push(...[...errors.load, ...errors.check].map((one) => renderDiagnostic(one)));
-        return id;
-    }, discovered.derived ? "record" : "refuse");
-    for (const configFile of session.unopened) {
-        if (!isGuess(discovered, configFile)) {
-            throw new DiscoveryError(`${configFile} opened no project`, []);
-        }
-        notBuilt.push({
-            id: ids.get(configFile) ?? configFile,
-            configFile,
-            error: "the compiler opened no project for the configuration",
-        });
-    }
-    if (failures.length > 0) {
-        for (const line of failures) {
-            err.write(`${line}\n`);
-        }
-        err.write(`deadset-ts: ${String(failures.length)} error(s), so no answer was produced\n`);
-        return EXIT_FAILURE;
-    }
-    const projects = session.projects.filter((id) => id !== undefined);
-    if (projects.length === 0 && notBuilt.length > 0) {
-        for (const note of partialNotes({ notBuilt, unanswered: [] })) {
-            err.write(`deadset-ts: ${note}\n`);
-        }
-        err.write("deadset-ts: no configuration discovery derived could be built\n");
-        return EXIT_FAILURE;
-    }
-    for (const id of projects) {
+    const answer = runProjects(openClient(config), host, scoped, config);
+    for (const id of answer.configurations) {
         out.write(`${id}\n`);
     }
-    for (const note of partialNotes({ notBuilt, unanswered: [] })) {
+    for (const note of partialNotes({
+        notBuilt: answer.notBuilt,
+        unanswered: answer.unanswered,
+        targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
+    })) {
         err.write(`deadset-ts: ${note}\n`);
     }
     return EXIT_CLEAN;

package/dist/src/verbs/print-retained.js

@@ -1,6 +1,7 @@
 import { runSweep } from "../analysis.js";
 import { retainedLines } from "../exempt.js";
 import { partialNotes } from "../partial.js";
+import { resolvePath } from "../paths.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN } from "./verb.js";
 /**
@@ -13,14 +14,18 @@ import { EXIT_CLEAN } from "./verb.js";
 export const printRetainedVerb = ({ out, err, host, inputs, scope, openClient }) => {
     const { config } = resolve(inputs());
     const scoped = scope();
-    const swept = runSweep(openClient(false), host, scoped, config, {
+    const swept = runSweep(openClient(config), host, scoped, config, {
         marked: [],
         mode: { production: true },
     });
     for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
         out.write(`${line}\n`);
     }
-    for (const note of partialNotes({ notBuilt: swept.notBuilt, unanswered: swept.unanswered })) {
+    for (const note of partialNotes({
+        notBuilt: swept.notBuilt,
+        unanswered: swept.unanswered,
+        targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
+    })) {
         err.write(`deadset-ts: ${note}\n`);
     }
     return EXIT_CLEAN;

package/dist/src/verbs/print-roots.js

@@ -1,5 +1,6 @@
 import { runRoots } from "../analysis.js";
 import { partialNotes } from "../partial.js";
+import { resolvePath } from "../paths.js";
 import { resolve } from "../resolve.js";
 import { EXIT_CLEAN, EXIT_FINDINGS } from "./verb.js";
 /**
@@ -25,7 +26,7 @@ function rootLine(root, several) {
 export const printRootsVerb = ({ out, err, host, inputs, scope, openClient }) => {
     const { config, provenance } = resolve(inputs());
     const scoped = scope();
-    const answer = runRoots(openClient(false), host, scoped, config, provenance);
+    const answer = runRoots(openClient(config), host, scoped, config, provenance);
     const several = answer.configurations.length > 1;
     for (const root of answer.roots) {
         out.write(`${rootLine(root, several)}\n`);
@@ -33,7 +34,11 @@ export const printRootsVerb = ({ out, err, host, inputs, scope, openClient }) =>
     for (const finding of answer.findings) {
         err.write(`${finding.code}: roots.patterns names nothing: ${finding.symbol.ref}\n`);
     }
-    for (const note of partialNotes({ notBuilt: answer.notBuilt, unanswered: answer.unanswered })) {
+    for (const note of partialNotes({
+        notBuilt: answer.notBuilt,
+        unanswered: answer.unanswered,
+        targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
+    })) {
         err.write(`deadset-ts: ${note}\n`);
     }
     return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;

package/dist/src/version-range.js

@@ -0,0 +1,255 @@
+/**
+ * Whether a version satisfies a dependency range, under the grammar npm, pnpm and yarn
+ * share: `||` alternatives of hyphen ranges or comparator runs, `x` and missing parts
+ * standing for any value, and a prerelease admitted only where a comparator names one
+ * of the same version. A range this grammar does not read is satisfied by nothing.
+ */
+const NUMBER = /^(?:0|[1-9]\d*)$/u;
+const IDENTIFIER = /^[0-9A-Za-z-]+$/u;
+const WILDCARD = new Set(["x", "X", "*"]);
+/** The prerelease identifiers after a hyphen, or `undefined` where one is malformed. */
+function prereleaseOf(text) {
+    if (text === undefined) {
+        return [];
+    }
+    const parts = text.split(".");
+    return parts.every((part) => IDENTIFIER.test(part)) ? parts : undefined;
+}
+/**
+ * One version as a range writes it, a leading `v` or `=` allowed, or `undefined`
+ * where it is not one.
+ */
+function partialOf(text) {
+    const match = /^[v=]?([^.+-]+)(?:\.([^.+-]+)(?:\.([^.+-]+)(?:-([^+]+))?)?)?(?:\+[0-9A-Za-z.-]+)?$/u.exec(text);
+    if (match === null) {
+        return undefined;
+    }
+    const parts = [];
+    let wild = false;
+    for (const part of [match[1], match[2], match[3]]) {
+        if (part === undefined || WILDCARD.has(part)) {
+            wild = true;
+            parts.push(undefined);
+            continue;
+        }
+        if (wild || !NUMBER.test(part)) {
+            return undefined;
+        }
+        parts.push(Number(part));
+    }
+    const prerelease = prereleaseOf(match[4]);
+    if (prerelease === undefined || (prerelease.length > 0 && wild)) {
+        return undefined;
+    }
+    return { major: parts[0], minor: parts[1], patch: parts[2], prerelease };
+}
+/** One exact version, or `undefined` where the text is not one. */
+function versionOf(text) {
+    const partial = partialOf(text.trim());
+    if (partial?.major === undefined || partial.minor === undefined || partial.patch === undefined) {
+        return undefined;
+    }
+    return {
+        major: partial.major,
+        minor: partial.minor,
+        patch: partial.patch,
+        prerelease: partial.prerelease,
+    };
+}
+function exact(major, minor, patch, prerelease = []) {
+    return { major, minor, patch, prerelease };
+}
+/** The lowest prerelease of one version, which bounds a range from above. */
+function floorOf(major, minor, patch) {
+    return exact(major, minor, patch, ["0"]);
+}
+function compareIdentifiers(a, b) {
+    const numericA = NUMBER.test(a);
+    const numericB = NUMBER.test(b);
+    if (numericA && numericB) {
+        return Math.sign(Number(a) - Number(b));
+    }
+    if (numericA !== numericB) {
+        return numericA ? -1 : 1;
+    }
+    return a === b ? 0 : a < b ? -1 : 1;
+}
+/** Two versions ordered by precedence. */
+function compare(a, b) {
+    const core = Math.sign(a.major - b.major) || Math.sign(a.minor - b.minor) || Math.sign(a.patch - b.patch);
+    if (core !== 0) {
+        return core;
+    }
+    if (a.prerelease.length === 0 || b.prerelease.length === 0) {
+        return Math.sign(b.prerelease.length - a.prerelease.length);
+    }
+    for (let at = 0; at < Math.max(a.prerelease.length, b.prerelease.length); at += 1) {
+        const left = a.prerelease[at];
+        const right = b.prerelease[at];
+        if (left === undefined || right === undefined) {
+            return left === undefined ? -1 : 1;
+        }
+        const order = compareIdentifiers(left, right);
+        if (order !== 0) {
+            return order;
+        }
+    }
+    return 0;
+}
+function passes(version, comparator) {
+    const order = compare(version, comparator.version);
+    switch (comparator.operator) {
+        case "<":
+            return order < 0;
+        case "<=":
+            return order <= 0;
+        case ">":
+            return order > 0;
+        case ">=":
+            return order >= 0;
+        case "=":
+            return order === 0;
+    }
+}
+/** The comparators a version with missing parts stands for: any value of each. */
+function anyOf(partial) {
+    const { major, minor } = partial;
+    if (major === undefined) {
+        return [{ operator: ">=", version: exact(0, 0, 0) }];
+    }
+    if (minor === undefined) {
+        return [
+            { operator: ">=", version: exact(major, 0, 0) },
+            { operator: "<", version: floorOf(major + 1, 0, 0) },
+        ];
+    }
+    if (partial.patch === undefined) {
+        return [
+            { operator: ">=", version: exact(major, minor, 0) },
+            { operator: "<", version: floorOf(major, minor + 1, 0) },
+        ];
+    }
+    return [{ operator: "=", version: exact(major, minor, partial.patch, partial.prerelease) }];
+}
+/** The lowest version a partial version stands for. */
+function lowest(partial) {
+    return exact(partial.major ?? 0, partial.minor ?? 0, partial.patch ?? 0, partial.prerelease);
+}
+function tilde(partial) {
+    const { major, minor } = partial;
+    if (major === undefined || minor === undefined) {
+        return anyOf(partial);
+    }
+    return [
+        { operator: ">=", version: lowest(partial) },
+        { operator: "<", version: floorOf(major, minor + 1, 0) },
+    ];
+}
+function caret(partial) {
+    const { major, minor, patch } = partial;
+    if (major === undefined) {
+        return anyOf(partial);
+    }
+    const from = { operator: ">=", version: lowest(partial) };
+    if (major > 0 || minor === undefined) {
+        return [from, { operator: "<", version: floorOf(major + 1, 0, 0) }];
+    }
+    if (minor > 0 || patch === undefined) {
+        return [from, { operator: "<", version: floorOf(0, minor + 1, 0) }];
+    }
+    return [from, { operator: "<", version: floorOf(0, 0, patch + 1) }];
+}
+/** The comparators one primitive comparison stands for, a partial version filled in. */
+function primitive(operator, partial) {
+    const { major, minor, patch } = partial;
+    if (major === undefined) {
+        return operator === "<" || operator === ">"
+            ? [{ operator: "<", version: floorOf(0, 0, 0) }]
+            : [{ operator: ">=", version: exact(0, 0, 0) }];
+    }
+    if (minor !== undefined && patch !== undefined) {
+        return [{ operator, version: lowest(partial) }];
+    }
+    const next = minor === undefined ? exact(major + 1, 0, 0) : exact(major, minor + 1, 0);
+    switch (operator) {
+        case ">":
+            return [{ operator: ">=", version: next }];
+        case ">=":
+            return [{ operator: ">=", version: lowest(partial) }];
+        case "<":
+            return [{ operator: "<", version: floorOf(major, minor ?? 0, 0) }];
+        case "<=":
+            return [{ operator: "<", version: floorOf(next.major, next.minor, 0) }];
+    }
+}
+/** The comparators one written comparator stands for, or `undefined` where it is none. */
+function comparatorsOf(token) {
+    const match = /^(<=|>=|<|>|=|~>|~|\^)?(.*)$/u.exec(token);
+    const operator = match?.[1] ?? "";
+    const partial = partialOf(match?.[2] ?? "");
+    if (partial === undefined) {
+        return undefined;
+    }
+    switch (operator) {
+        case "~":
+        case "~>":
+            return tilde(partial);
+        case "^":
+            return caret(partial);
+        case "<":
+        case "<=":
+        case ">":
+        case ">=":
+            return primitive(operator, partial);
+        default:
+            return anyOf(partial);
+    }
+}
+/** The comparators of one alternative, or `undefined` where it does not read. */
+function alternativeOf(text) {
+    const spaced = text.trim().replaceAll(/(<=|>=|<|>|=|~>|~|\^)\s+/gu, "$1");
+    if (spaced === "") {
+        return anyOf({ prerelease: [] });
+    }
+    const hyphen = /^(\S+)\s+-\s+(\S+)$/u.exec(spaced);
+    if (hyphen !== null) {
+        const from = partialOf(hyphen[1] ?? "");
+        const to = partialOf(hyphen[2] ?? "");
+        if (from === undefined || to === undefined) {
+            return undefined;
+        }
+        return [...primitive(">=", from), ...(to.major === undefined ? [] : primitive("<=", to))];
+    }
+    const found = [];
+    for (const token of spaced.split(/\s+/u)) {
+        const comparators = comparatorsOf(token);
+        if (comparators === undefined) {
+            return undefined;
+        }
+        found.push(...comparators);
+    }
+    return found;
+}
+/** Whether one alternative admits one version, its prerelease rule included. */
+function admits(alternative, version) {
+    if (!alternative.every((comparator) => passes(version, comparator))) {
+        return false;
+    }
+    if (version.prerelease.length === 0) {
+        return true;
+    }
+    return alternative.some(({ version: bound }) => bound.prerelease.length > 0 &&
+        bound.major === version.major &&
+        bound.minor === version.minor &&
+        bound.patch === version.patch);
+}
+/** Whether `version` satisfies `range`; `false` where either does not read. */
+export function satisfies(version, range) {
+    const parsed = versionOf(version);
+    if (parsed === undefined) {
+        return false;
+    }
+    const alternatives = range.split("||").map(alternativeOf);
+    return (alternatives.every((alternative) => alternative !== undefined) &&
+        alternatives.some((alternative) => admits(alternative, parsed)));
+}

package/dist/src/version.js

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "4.0.0";
+export const CONTRACT_VERSION = "5.2.0";

package/dist/src/workspace-manifests.js

@@ -0,0 +1,68 @@
+/**
+ * The entry points the manifests of a workspace name, read back to the members'
+ * sources. Each member's manifest is read the way the target's own is, and each target
+ * is read back to the source file its member's configurations compile it from. A
+ * member whose manifest forbids publishing it exports nothing anyone outside the
+ * workspace imports, so only its commands are entry points.
+ */
+import { emittedFrom } from "./emit-map.js";
+import { readManifest } from "./manifest.js";
+import { joinPath, relativePath } from "./paths.js";
+/** The one character a subpath pattern of a manifest's `exports` holds. */
+const SUBPATH_WILDCARD = "*";
+/** The paths one written target stands for in its member's sources, itself included. */
+function sourcesOf(resolver, member, path) {
+    if (!path.includes(SUBPATH_WILDCARD)) {
+        const source = resolver.sourceOf(member, path);
+        return source === undefined ? [path] : [source];
+    }
+    const patterns = member.configurations.flatMap(({ layout }) => layout === undefined ? [] : emittedFrom(path, layout));
+    return [...new Set([path, ...patterns])];
+}
+/** One manifest's entries with every target read back to its member's sources. */
+function sourceEntries(resolver, member, entries, spelled) {
+    return entries.flatMap((entry) => sourcesOf(resolver, member, entry.path).map((path) => ({
+        ...entry,
+        member: spelled(entry),
+        path,
+    })));
+}
+/**
+ * The target's own manifest with its targets read back to the sources of the member
+ * the target is, where it is one.
+ */
+export function targetManifestIn(resolver, targetRoot, manifest) {
+    const member = resolver.workspace.members.find((one) => one.dir === targetRoot);
+    return member === undefined
+        ? manifest
+        : {
+            ...manifest,
+            entries: sourceEntries(resolver, member, manifest.entries, (entry) => entry.member),
+        };
+}
+/**
+ * The entry points every other member's manifest names, each spelled as the member
+ * that named it under the manifest's path below the target root, a private member's
+ * `exports` left out: only the workspace imports a private package, and the workspace
+ * is analyzed. An entry is published where its member is not private and the member
+ * named in its own manifest is one a consumer imports.
+ */
+export function memberEntries(host, resolver, targetRoot) {
+    return resolver.workspace.members.flatMap((member) => {
+        if (member.dir === targetRoot) {
+            return [];
+        }
+        const manifest = readManifest(host, member.dir);
+        const where = relativePath(targetRoot, joinPath(member.dir, "package.json")) ??
+            joinPath(member.dir, "package.json");
+        const kept = manifest.entries.flatMap((entry) => {
+            const exported = entry.member.startsWith("exports");
+            if (member.private && exported) {
+                return [];
+            }
+            const published = !member.private && entry.published && (manifest.declaresExports ? exported : true);
+            return [{ ...entry, published }];
+        });
+        return sourceEntries(resolver, member, kept, (entry) => `${where} ${entry.member}`);
+    });
+}