@cplieger/deadset-ts 4.0.1 → 5.1.0

package/src/manifest.ts

@@ -1,11 +1,9 @@
 /**
  * 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.
+ * shell running its command or one of its scripts.
  *
- * 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.
+ * One call reads one manifest, the one in the directory it is given.
  */
 
 import type { Host } from "./host.ts";
@@ -22,7 +20,9 @@ export 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";
+  | "run"
+  /** A token of one of the package's scripts, which the package manager runs. */
+  | "script";
 
 /** One entry point the manifest names. */
 export interface ManifestEntry {
@@ -59,6 +59,24 @@ 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)}]`;
@@ -67,12 +85,9 @@ function below(member: string, key: string): string {
 /**
  * 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.
+ * 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: unknown, member: string, found: ManifestEntry[]): void {
   if (typeof value === "string") {
@@ -116,11 +131,12 @@ function manifestOf(host: Host, targetRoot: string): Record<string, unknown> | u
   return isRecord(value) ? value : undefined;
 }
 
-/** What the target's own manifest declares about where the package is entered. */
+/** 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`. Each
+   * `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.
    */
   readonly entries: readonly ManifestEntry[];
@@ -134,7 +150,7 @@ export interface Manifest {
 }
 
 /**
- * What the target's own manifest declares about where the package is entered.
+ * 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
@@ -167,6 +183,23 @@ export function readManifest(host: Host, targetRoot: string): Manifest {
 
   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) })),
     declaresExports: manifest["exports"] !== undefined,

package/src/matrix.ts

@@ -21,6 +21,14 @@ export interface Configured {
   readonly roots: readonly Root[];
   /** The paths the reference pass classified as test files. */
   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 workspace-package files the configuration holds but does not
+   * compile itself. Their declarations count in its graph and its verdict on them is no
+   * finding.
+   */
+  readonly referenceOnly?: readonly string[] | undefined;
 }
 
 /** The run's configurations, indexed for the sweep. */
@@ -30,9 +38,10 @@ export interface Matrix {
   /** Per configuration, in the same order, the graph of what that configuration holds. */
   readonly graphs: readonly Graph[];
   /**
-   * The graph over every configuration at once: every declaration any configuration
-   * holds, once per position and in site order, and every reference any configuration
-   * makes, a reference several configurations make at one position counted once.
+   * The graph over every configuration at once: every declaration a configuration
+   * holds in a file it does not hold only for its references, once per position and in
+   * site order, and every reference any configuration makes, a reference several
+   * configurations make at one position counted once.
    */
   readonly union: Graph;
   /**
@@ -88,31 +97,30 @@ export function referenceKey(reference: Reference): string {
 
 /**
  * Indexes what the passes answered for each configuration of one run, in the run's order.
- *
- * A declaration is keyed across configurations by its identifier, which is its rendered
- * position and so is the same in every configuration that compiles its file; the fields
- * of the first configuration that holds it are the ones kept. A declaration one
- * configuration alone holds is in the union with that one configuration, so it is
- * judged where it exists rather than skipped.
- *
- * One reference written at one position of a file several configurations compile is seen
- * once per configuration and is one reference, so the union holds it once; two references
- * one configuration makes at one position are two.
+ * 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: readonly Configured[]): Matrix {
   const symbols: InventorySymbol[] = [];
   const holders = new Map<string, string[]>();
   const references: Reference[] = [];
   const firstSeen = new Map<string, number>();
+  const judged = new Set<string>();
   per.forEach((one, index) => {
+    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]);
-        symbols.push(symbol);
       } 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);
@@ -129,12 +137,15 @@ export function matrixOf(per: readonly Configured[]): Matrix {
 
   return {
     configurations: per.map((one) => one.configuration),
-    graphs: per.map((one) => graphOf(one.symbols, one.references, one.roots, one.testFiles)),
+    graphs: per.map((one) =>
+      graphOf(one.symbols, one.references, one.roots, one.testFiles, one.supportFiles),
+    ),
     union: graphOf(
       symbols,
       references,
       per.flatMap((one) => one.roots),
       [...new Set(per.flatMap((one) => one.testFiles))],
+      [...new Set(per.flatMap((one) => one.supportFiles ?? []))],
     ),
     heldIn: symbols.map((symbol) => holders.get(symbol.id) ?? []),
   };
@@ -197,6 +208,23 @@ export function sweepMatrix(matrix: Matrix, input: SweepInput): SweepResult {
   };
 }
 
+/**
+ * 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: Matrix,
+  result: SweepResult,
+  paths: ReadonlySet<string>,
+): readonly InventorySymbol[] {
+  return matrix.union.symbols.filter(
+    (symbol) =>
+      symbol.kind === "file" &&
+      paths.has(symbol.position.path) &&
+      (result.liveUnder.get(symbol.id)?.length ?? 0) === RELATIONS.length,
+  );
+}
+
 /** The relations in the order a declaration's entry lists them. */
 const RELATIONS: readonly Relation[] = ["reference-counting", "reachability"];
 

package/src/partial.ts

@@ -1,4 +1,5 @@
 import type { NotBuilt } from "./discover.ts";
+import { relativePath } from "./paths.ts";
 import type { UnansweredQuestion } from "./query.ts";
 
 /** What a run read only in part. */
@@ -7,6 +8,8 @@ interface Partial {
   readonly notBuilt: readonly NotBuilt[];
   /** Every question the checker could not answer, each once. */
   readonly unanswered: readonly UnansweredQuestion[];
+  /** The target root, absolute, which every configuration file is named below. */
+  readonly targetRoot: string;
 }
 
 /** A count with its noun, so a line reads for one as well as for several. */
@@ -29,7 +32,9 @@ export function partialNotes(partial: Partial): readonly string[] {
   if (partial.unanswered.length > 0) {
     const byProject = new Map<string, number>();
     for (const question of partial.unanswered) {
-      byProject.set(question.configFile, (byProject.get(question.configFile) ?? 0) + 1);
+      const configFile =
+        relativePath(partial.targetRoot, question.configFile) ?? question.configFile;
+      byProject.set(configFile, (byProject.get(configFile) ?? 0) + 1);
     }
     const where = [...byProject].map(([configFile, n]) => `${configFile}: ${String(n)}`).join(", ");
     notes.push(

package/src/pnpm-workspace.ts

@@ -0,0 +1,135 @@
+/**
+ * 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.
+ */
+
+/** What the document says about `packages`. */
+export type PnpmPackages =
+  | { readonly kind: "listed"; readonly patterns: readonly string[] }
+  /** The document declares no `packages` key. */
+  | { readonly kind: "absent" }
+  /** The key holds something this reader does not read, with what it holds. */
+  | { readonly kind: "refused"; readonly reason: string };
+
+/** 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: string): string {
+  let quote: string | undefined;
+  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: string): string | undefined {
+  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: string): readonly string[] | undefined {
+  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: string[] = [];
+  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: string): PnpmPackages {
+  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: string[] = [];
+  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 };
+}

package/src/position.ts

@@ -34,18 +34,39 @@ export class PositionError extends Error {
   }
 }
 
+/** Whether the compiler read one file through a content mapper, which makes it a component file. */
+export function isComponentFile(file: SourceFile): boolean {
+  return file.contentMapper !== undefined;
+}
+
+/**
+ * The length of the file as it is written. A component file's module holds the file's
+ * text at its own offsets and appends what it needs past its end.
+ */
+export function writtenLength(file: SourceFile): number {
+  return isComponentFile(file) ? file.originalText.length : file.text.length;
+}
+
 /**
  * The position of one offset of one file, rendered against the target root.
  *
  * `offset` is a UTF-16 code unit offset into the file's text, which is what every
- * node of the tree carries.
+ * node of the tree carries. An offset a component file's module appends renders where
+ * the module's span map places it in the file.
  */
 export function renderPosition(file: SourceFile, root: string, offset: number): Position {
   const path = relativePath(root, file.fileName);
   if (path === undefined) {
     throw new PositionError(file.fileName, root);
   }
-  const { line, character } = file.getLineAndCharacterOfPosition(offset);
+  const written =
+    isComponentFile(file) && offset >= file.originalText.length
+      ? Math.min(
+          file.spanMap?.virtualToOriginalPosition(offset).position ?? offset,
+          file.originalText.length,
+        )
+      : offset;
+  const { line, character } = file.getLineAndCharacterOfPosition(written);
   return { path, line: line + 1, column: character + 1 };
 }
 

package/src/print.ts

@@ -75,6 +75,8 @@ export function printConfig(config: Config, provenance: Provenance): string {
     ts: {
       test_files: config.ts.testFiles,
       entry_files: config.ts.entryFiles,
+      component_extensions: config.ts.componentExtensions,
+      disabled_conventions: config.ts.disabledConventions,
       injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
       lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
         components: entry.components.map(declarationOf),

package/src/query.ts

@@ -127,6 +127,32 @@ interface Assignability {
   readonly target: Type;
 }
 
+/**
+ * Each type's properties, asked of the checker once per type for every pass that shares
+ * the tables: the client keeps a type's properties once fetched, so a second pass asking
+ * for the same type makes no request, and only the first ask is counted as one.
+ */
+export interface PropertyTables {
+  /** One type's properties, and whether this call was the one that asked for them. */
+  of(type: Type): { readonly properties: Answer<readonly TSSymbol[]>; readonly asked: boolean };
+}
+
+/** The property tables over one project's questions. */
+export function propertyTables(queries: Pick<Queries, "propertiesOf">): PropertyTables {
+  const held = new Map<number, Answer<readonly TSSymbol[]>>();
+  return {
+    of: (type) => {
+      const known = held.get(type.id);
+      if (known !== undefined) {
+        return { properties: known, asked: false };
+      }
+      const properties = queries.propertiesOf(type);
+      held.set(type.id, properties);
+      return { properties, asked: true };
+    },
+  };
+}
+
 /** The questions one project's analysis asks, each guarded. */
 export interface Queries {
   /** The symbol each node resolves to. */