@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/src/manifest.ts

@@ -7,45 +7,47 @@
 
 import type { Host } from "./host.ts";
 import { isAbsolutePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import { isRecord } from "./json-document.ts";
+import { MANIFEST, manifestAt, readJSON } from "./fs/manifest.ts";
+import { scriptTokens } from "./text/shell.ts";
 
 /** 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"] as const;
 
-/** What reaches one entry point the manifest names. */
+/** What reaches one entry the manifest names. */
 type EntryRole =
   /** A consumer importing the package, which is a caller the analysis cannot see. */
   | "import"
   /** A shell running the package's command, which is a caller that exists. */
   | "run"
-  /** A token of one of the package's scripts, which the package manager runs. */
+  /** A token of one of the package's scripts, or the whole of a command string the package runs. */
   | "script";
 
-/** One entry point the manifest names. */
+/** One entry point the manifest names, or the whole of one command string the package runs. */
 export interface ManifestEntry {
   /**
-   * The member that named it, spelled as a reader of the manifest reads one:
-   * `main`, `bin["deadset-ts"]`, `exports["."]["import"]`. It is what a maintainer
-   * edits, so it is what a root reports as the string that named it.
+   * The member that named it as a maintainer edits it, `main`, `bin["deadset-ts"]` or
+   * `exports["."]["import"]`: what a root reports as the string that named it.
    */
   readonly member: string;
-  /** The target the member carries, resolved against the manifest's directory. */
+  /** The target the member carries, resolved against the manifest's directory, or that directory for a whole command string. */
   readonly path: string;
   readonly role: EntryRole;
   /**
-   * Whether the member declares what a consumer may import, which is `exports` and
-   * the three members that preceded it. A command is published too, and is not this:
-   * `exports` is the surface a library's published API is read from.
+   * Whether the member declares what a consumer may import, the surface a library's published
+   * API is read from: `exports`, `browser` and the three members that preceded `exports`.
    */
   readonly published: boolean;
   /** The directory of the manifest that names it, which `path` was resolved against. */
   readonly dir: string;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  /**
+   * On the entry of a whole command string, which names no entry point and whose path is the
+   * manifest's directory, that string: rooting enters no file for it and holds each file
+   * `spelledFiles` reads it to name.
+   */
+  readonly command?: string;
 }
 
 /**
@@ -60,35 +62,45 @@ function isTarget(value: string, requireDot: boolean): boolean {
   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: string): readonly string[] {
-  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: string, key: string): string {
   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.
+ * The command strings one manifest runs, each at the member it is written under: each of its
+ * `scripts`, and the `exec` command of nodemon's configuration, in the manifest's `nodemonConfig`
+ * or the `nodemon.json` beside it, which nodemon runs the watched script with:
+ * https://github.com/remy/nodemon#config-files
+ */
+export function manifestCommands(
+  host: Host,
+  dir: string,
+  manifest: Record<string, unknown>,
+): readonly { readonly member: string; readonly command: string }[] {
+  const scripts = manifest["scripts"];
+  const nodemon = {
+    nodemonConfig: manifest["nodemonConfig"],
+    "nodemon.json": readJSON(host, joinPath(dir, "nodemon.json")),
+  };
+  const written = [
+    ...Object.entries(isRecord(scripts) ? scripts : {}).map(
+      ([name, value]) => [below("scripts", name), value] as const,
+    ),
+    ...Object.entries(nodemon).map(
+      ([member, config]) =>
+        [below(member, "exec"), isRecord(config) ? config["exec"] : undefined] as const,
+    ),
+  ];
+  return written.flatMap(([member, command]) =>
+    typeof command === "string" ? [{ member, command }] : [],
+  );
+}
+
+/**
+ * Every target one `exports` value carries, at the member each is written under. Every level of
+ * strings, subpath or condition objects and alternative arrays is walked, because each condition
+ * names its own entry file; a `null` blocks a subpath, and a key's meaning is never read.
  */
 function exportTargets(value: unknown, member: string, found: Omit<ManifestEntry, "dir">[]): void {
   if (typeof value === "string") {
@@ -111,41 +123,18 @@ function exportTargets(value: unknown, member: string, found: Omit<ManifestEntry
   }
 }
 
-/** The manifest at the target root, decoded, or undefined where there is none to read. */
-function manifestOf(host: Host, targetRoot: string): Record<string, unknown> | undefined {
-  let text: string;
-  try {
-    text = host.readFile(joinPath(targetRoot, MANIFEST));
-  } catch {
-    return undefined;
-  }
-  let value: unknown;
-  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 one manifest declares about where its package is entered. */
 export interface Manifest {
   /**
-   * Every entry point the manifest names, in the order the members are read: `main`,
-   * `module`, `types`, then each `bin` command, then every target of `exports`, then
-   * every token of each script, which names a file only where one is at its path. Each
-   * path is absolute.
+   * Every entry the manifest names, by absolute path, in the order read: the entry points `main`,
+   * `module`, `types`, `browser` and each file it maps, each `bin` command, every `exports` target
+   * and per script each token, which names a file only where one is at its path; and per command
+   * string {@link manifestCommands} reads one entry of its whole text, which is no entry point.
    */
   readonly entries: readonly ManifestEntry[];
   /**
-   * Whether an `exports` member is written at all. A package that declares one has
-   * said exactly what a consumer may import, so its published API is what `exports`
-   * reaches; a package that declares none publishes whatever the members that
-   * preceded it name.
+   * Whether an `exports` member is written: then the published API is what `exports` reaches,
+   * and otherwise whatever the members that preceded it name.
    */
   readonly declaresExports: boolean;
 }
@@ -158,7 +147,7 @@ export interface Manifest {
  * it and there is one such configuration per project, while there is one manifest.
  */
 export function readManifest(host: Host, targetRoot: string): Manifest {
-  const manifest = manifestOf(host, targetRoot);
+  const manifest = manifestAt(host, targetRoot);
   if (manifest === undefined) {
     return { entries: [], declaresExports: false };
   }
@@ -171,6 +160,24 @@ export function readManifest(host: Host, targetRoot: string): Manifest {
     }
   }
 
+  // A `browser` string replaces `main` in a browser bundle, and an object replaces each
+  // module it maps with the file it names: https://github.com/defunctzombie/package-browser-field-spec
+  const browser = manifest["browser"];
+  if (typeof browser === "string" && isTarget(browser, false)) {
+    found.push({ member: "browser", path: browser, role: "import", published: true });
+  } else if (isRecord(browser)) {
+    for (const [replaced, value] of Object.entries(browser)) {
+      if (typeof value === "string" && isTarget(value, true)) {
+        found.push({
+          member: below("browser", replaced),
+          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 });
@@ -190,16 +197,15 @@ export function readManifest(host: Host, targetRoot: string): Manifest {
       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,
-        });
+      const member = below("scripts", name);
+      for (const path of new Set(scriptTokens(command))) {
+        found.push({ member, path, role: "script", published: false });
       }
     }
   }
+  for (const { member, command } of manifestCommands(host, targetRoot, manifest)) {
+    found.push({ member, path: ".", role: "script", published: false, command });
+  }
 
   return {
     entries: found.map((entry) => ({

package/src/matrix.ts

@@ -30,6 +30,10 @@ export interface Configured {
   readonly testFiles: readonly string[];
   /** The paths of the test-support files, which only test code imports. */
   readonly supportFiles?: readonly string[] | undefined;
+  /** The paths of the files only tests reach that are no test-support file. */
+  readonly testUsedFiles?: readonly string[] | undefined;
+  /** The ids of the ambient declarations, which describe code the target does not implement. */
+  readonly ambient?: ReadonlySet<string> | undefined;
   /**
    * The paths of the workspace-package files the configuration holds but does not
    * compile itself. Their declarations count in its graph and its verdict on them is no
@@ -58,6 +62,11 @@ export interface Matrix {
    * whose project holds it, in the run's order.
    */
   readonly heldIn: readonly (readonly string[])[];
+  /**
+   * Per declaration of {@link Matrix.union}, whether a file only tests reach that is no
+   * test-support file holds it in some configuration: production code only tests use.
+   */
+  readonly testUsed: readonly boolean[];
   /** Each declaration's dependents, by id, as the first configuration holding it states them. */
   readonly dependents: ReadonlyMap<string, readonly string[]>;
 }
@@ -79,6 +88,17 @@ export interface MatrixCandidate extends Candidate {
    * shape nothing references would be.
    */
   readonly unreferencedTest: boolean;
+  /**
+   * Whether it is dead only because code only tests use is: production code only tests
+   * use holds it and the run that counts test references reaches it, or such a
+   * declaration reaches it through dead declarations.
+   */
+  readonly testUsed: boolean;
+  /**
+   * Whether test code the run that counts test references reaches, and that is no test of
+   * dead code, references it: a test that stays keeps it.
+   */
+  readonly keptByTests: boolean;
 }
 
 /** One run's sweep. */
@@ -156,11 +176,12 @@ export function matrixOf(per: readonly Configured[]): Matrix {
     }
   });
   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),
+      graphOf(one.symbols, one.references, one.roots, one.testFiles, one.supportFiles, one.ambient),
     ),
     union: graphOf(
       symbols,
@@ -168,8 +189,10 @@ export function matrixOf(per: readonly Configured[]): Matrix {
       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,
   };
 }
@@ -199,22 +222,33 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
   );
 
   const union = matrix.union;
-  const dead = union.symbols.map(() => false);
-  const testOfDeadCode = union.symbols.map(() => false);
   const heldBy: (string | undefined)[] = union.symbols.map(() => undefined);
-  const unreferencedTest = union.symbols.map(() => false);
-  const testReached = reachedWithTheTests(union, [
+  const held = [
     ...input.marked,
     ...(input.exempt ?? []).map((record) => record.id),
     ...(input.unanswered ?? []),
-  ]);
-  const judged = union.symbols.map((symbol, at): readonly Candidate[] | undefined => {
+  ];
+  const testReached = reachedWithTheTests(union, held);
+  // A test uses what it names: a file a test reads through a star re-export or a
+  // namespace keeps the exports nothing names at their own class.
+  const testNamed = reachedWithTheTests(union, held, false);
+  const everywhere = union.symbols.map((symbol, at): readonly Candidate[] | undefined => {
     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 is Candidate => candidate !== undefined);
   });
+  const compiled = compiledReferences(
+    matrix,
+    new Set(
+      union.symbols.flatMap((symbol, at) => (everywhere[at] === undefined ? [] : [symbol.id])),
+    ),
+    input.mode,
+  );
+  const judged = everywhere.map((found, at) =>
+    compiled.has(union.symbols[at]?.id ?? "") ? undefined : found,
+  );
   // 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.
@@ -223,9 +257,18 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
       (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: number): boolean =>
+    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 && testNamed[at] === true),
+    judged.map((one) => one !== undefined),
+  );
   const candidates: MatrixCandidate[] = [];
   union.symbols.forEach((symbol, at) => {
     const all = judged[at];
@@ -233,16 +276,13 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
       return;
     }
     const held = matrix.heldIn[at] ?? [];
-    const admitted = all.every((candidate) => candidate.testOfDeadCode) && subjectsDead(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;
-    dead[at] = true;
-    testOfDeadCode[at] = admitted;
     heldBy[at] = heldByTests;
-    unreferencedTest[at] = unreferenced;
     const productionRefs = union.made[at]?.production ?? 0;
     const counted = all.every((candidate) => candidate.relation === "reference-counting");
     candidates.push({
@@ -257,6 +297,8 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
       configurations: held,
       heldByTests,
       unreferencedTest: unreferenced,
+      testUsed: testUsed[at] === true,
+      keptByTests: kept[at] === true,
     });
   });
 
@@ -264,16 +306,110 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
   return {
     liveUnder,
     candidates,
-    components: componentsOf(
-      union,
-      dead.map((one, at) => one && heldBy[at] === undefined),
-      testOfDeadCode,
-      unreferencedTest,
-      positionsOf(union, matrix.dependents, liveUnder),
-    ),
+    components: deadComponents(matrix, { liveUnder, candidates }, new Set()),
   };
 }
 
+/**
+ * Every declaration of `dead`, those dead in every configuration that holds them, that a
+ * configuration's graph references from a judged declaration outside `dead` or already
+ * kept, until none joins: deleting one would break that configuration's compile. A
+ * production run counts no reference a test file made.
+ */
+function compiledReferences(
+  matrix: Matrix,
+  dead: ReadonlySet<string>,
+  mode: SweepInput["mode"],
+): ReadonlySet<string> {
+  const kept = new Set<string>();
+  for (let changed = true; changed;) {
+    changed = false;
+    for (const graph of matrix.graphs) {
+      graph.out.forEach((edges, from) => {
+        const id = graph.symbols[from]?.id ?? "";
+        if (graph.subject[from] !== true || (dead.has(id) && !kept.has(id))) {
+          return;
+        }
+        for (const edge of edges) {
+          const to = graph.symbols[edge.to]?.id ?? "";
+          if ((!mode.production || !edge.test) && dead.has(to) && !kept.has(to)) {
+            kept.add(to);
+            changed = true;
+          }
+        }
+      });
+    }
+  }
+  return kept;
+}
+
+/** Per declaration of the union, whether one of `seeds` is it or reaches it through `dead` declarations. */
+function testUsedReach(
+  union: Graph,
+  seeds: readonly boolean[],
+  dead: readonly boolean[],
+): readonly boolean[] {
+  // 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: Graph,
+  reached: readonly boolean[],
+  admitted: (at: number) => boolean,
+): readonly boolean[] {
+  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: Matrix,
+  result: Pick<SweepResult, "liveUnder" | "candidates">,
+  files: ReadonlySet<number>,
+): readonly Component[] {
+  const union = matrix.union;
+  const byId = new Map(result.candidates.map((candidate) => [candidate.id, candidate]));
+  const candidateAt = (at: number): MatrixCandidate | undefined =>
+    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.