@cplieger/deadset-ts 4.0.1 → 5.0.0

package/src/verbs/print-retained.ts

@@ -1,6 +1,7 @@
 import { runSweep } from "../analysis.ts";
 import { retainedLines } from "../exempt.ts";
 import { partialNotes } from "../partial.ts";
+import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
 import { EXIT_CLEAN, type Verb } from "./verb.ts";
 
@@ -14,14 +15,18 @@ import { EXIT_CLEAN, type Verb } from "./verb.ts";
 export const printRetainedVerb: Verb = ({ 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/src/verbs/print-roots.ts

@@ -1,5 +1,6 @@
 import { runRoots, type RunRoot } from "../analysis.ts";
 import { partialNotes } from "../partial.ts";
+import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
 import { EXIT_CLEAN, EXIT_FINDINGS, type Verb } from "./verb.ts";
 
@@ -27,7 +28,7 @@ function rootLine(root: RunRoot, several: boolean): string {
 export const printRootsVerb: Verb = ({ 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`);
@@ -35,7 +36,11 @@ export const printRootsVerb: Verb = ({ 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/src/verbs/verb.ts

@@ -1,4 +1,4 @@
-import type { Inputs } from "../config.ts";
+import type { Config, Inputs } from "../config.ts";
 import type { Emitters } from "../findings/emitter.ts";
 import type { Host } from "../host.ts";
 import type { Writer } from "../run.ts";
@@ -24,8 +24,11 @@ export interface Invocation {
   readonly inputs: () => Inputs;
   /** The scope the options name: the document `--scope` names, or the target. */
   readonly scope: () => Scope;
-  /** Opens the compiler client. A client the verb opened is closed if the verb throws. */
-  readonly openClient: (collectTiming: boolean) => Engine;
+  /**
+   * Opens the compiler client for a run under `config`. A client the verb opened is
+   * closed if the verb throws.
+   */
+  readonly openClient: (config: Config) => Engine;
   /** The emitter of every kind family, which a verb that reports findings runs. */
   readonly emitters: Emitters;
   /** The arguments after the verb's name, as written. */

package/src/version-range.ts

@@ -0,0 +1,309 @@
+/**
+ * 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.
+ */
+
+/** A version: three numbers and the prerelease identifiers, build metadata dropped. */
+interface Version {
+  readonly major: number;
+  readonly minor: number;
+  readonly patch: number;
+  readonly prerelease: readonly string[];
+}
+
+/** One comparison a version must pass. */
+interface Comparator {
+  readonly operator: "<" | "<=" | ">" | ">=" | "=";
+  readonly version: Version;
+}
+
+/** A version whose parts may be missing or a wildcard, as a range writes one. */
+interface Partial {
+  readonly major?: number | undefined;
+  readonly minor?: number | undefined;
+  readonly patch?: number | undefined;
+  readonly prerelease: readonly string[];
+}
+
+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: string | undefined): readonly string[] | undefined {
+  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: string): Partial | undefined {
+  const match =
+    /^[v=]?([^.+-]+)(?:\.([^.+-]+)(?:\.([^.+-]+)(?:-([^+]+))?)?)?(?:\+[0-9A-Za-z.-]+)?$/u.exec(
+      text,
+    );
+  if (match === null) {
+    return undefined;
+  }
+  const parts: (number | undefined)[] = [];
+  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: string): Version | undefined {
+  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: number,
+  minor: number,
+  patch: number,
+  prerelease: readonly string[] = [],
+): Version {
+  return { major, minor, patch, prerelease };
+}
+
+/** The lowest prerelease of one version, which bounds a range from above. */
+function floorOf(major: number, minor: number, patch: number): Version {
+  return exact(major, minor, patch, ["0"]);
+}
+
+function compareIdentifiers(a: string, b: string): number {
+  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: Version, b: Version): number {
+  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: Version, comparator: Comparator): boolean {
+  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: Partial): Comparator[] {
+  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: Partial): Version {
+  return exact(partial.major ?? 0, partial.minor ?? 0, partial.patch ?? 0, partial.prerelease);
+}
+
+function tilde(partial: Partial): Comparator[] {
+  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: Partial): Comparator[] {
+  const { major, minor, patch } = partial;
+  if (major === undefined) {
+    return anyOf(partial);
+  }
+  const from = { operator: ">=" as const, 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: Partial): Comparator[] {
+  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: string): Comparator[] | undefined {
+  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: string): Comparator[] | undefined {
+  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: Comparator[] = [];
+  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: readonly Comparator[], version: Version): boolean {
+  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: string, range: string): boolean {
+  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/src/version.ts

@@ -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.1.0";

package/src/workspace-manifests.ts

@@ -0,0 +1,100 @@
+/**
+ * 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.ts";
+import type { Host } from "./host.ts";
+import { readManifest, type Manifest, type ManifestEntry } from "./manifest.ts";
+import { joinPath, relativePath } from "./paths.ts";
+import type { WorkspaceMember } from "./workspace.ts";
+import type { WorkspaceResolver } from "./workspace-resolution.ts";
+
+/** 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: WorkspaceResolver,
+  member: WorkspaceMember,
+  path: string,
+): readonly string[] {
+  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: WorkspaceResolver,
+  member: WorkspaceMember,
+  entries: readonly ManifestEntry[],
+  spelled: (entry: ManifestEntry) => string,
+): readonly ManifestEntry[] {
+  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: WorkspaceResolver,
+  targetRoot: string,
+  manifest: Manifest,
+): 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: Host,
+  resolver: WorkspaceResolver,
+  targetRoot: string,
+): readonly ManifestEntry[] {
+  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): ManifestEntry[] => {
+      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}`);
+  });
+}