@cplieger/deadset-ts 7.0.0-dev.1 → 7.0.0-dev.3

package/src/dependencies.ts

@@ -59,7 +59,7 @@ const SECTIONS: readonly (readonly [string, DependencySection])[] = [
 const PROJECT_OWNER = "";
 
 /** One dependency a manifest the run reads declares. */
-export interface DeclaredDependency {
+interface DeclaredDependency {
   readonly name: string;
   readonly section: DependencySection;
   /** Where the manifest writes the dependency's key, below the target root. */
@@ -71,28 +71,37 @@ export interface DeclaredDependency {
 /** What a configuration's own reading needs: packages no deletion of a declaration removes. */
 export function configurationNeeds(packages: readonly string[]): ProjectNeeds {
   return {
-    packages: new Set(packages),
     uses: new Map([[PROJECT_OWNER, new Set(packages)]]),
+    at: new Map([[ANYWHERE, new Set(packages)]]),
     unanswered: [],
   };
 }
 
+/** The key of {@link ProjectNeeds.at} for a use no file of the target governs. */
+const ANYWHERE = "";
+
 /** What the installed copy of one declared dependency states about itself. */
-export interface InstalledDependency {
+interface InstalledDependency {
   /** The commands its manifest's `bin` declares, by name. */
   readonly commands: readonly string[];
+  /** The packages its manifest's `peerDependencies` names, optional ones included. */
+  readonly peers: readonly string[];
 }
 
 /** What one project's own files and configuration need from outside the target. */
 export interface ProjectNeeds {
-  /** Every package a use names or resolves to. */
-  readonly packages: ReadonlySet<string>;
   /**
    * Per declaration of the inventory, the packages the uses written inside it name; a
    * use is held by the innermost declaration around it. The empty key holds what the
    * compiler configuration names, which no deletion removes.
    */
   readonly uses: ReadonlyMap<string, ReadonlySet<string>>;
+  /**
+   * Per absolute path of the file a use is written in, the packages it names, which a
+   * dependency only a manifest at or above that file declares serves. The empty key holds
+   * the uses no one file holds, which every manifest's dependency of that name serves.
+   */
+  readonly at: ReadonlyMap<string, ReadonlySet<string>>;
   /**
    * The files writing a module specifier the checker left unanswered, each of which may
    * use any dependency a manifest at or above it declares.
@@ -104,11 +113,14 @@ export interface ProjectNeeds {
 export interface Dependencies {
   /** Every declared dependency, manifest by manifest, in the order each writes them. */
   readonly declared: readonly DeclaredDependency[];
-  /** Every package some project needs. */
+  /**
+   * The declared dependencies, by {@link declarationKey}, a use written at or below their
+   * manifest's directory needs, and each declared peer of a needed one.
+   */
   readonly needed: ReadonlySet<string>;
   /**
    * The declared dependencies whose command a script entry of the manifest declaring them,
-   * or a workflow step for the target's manifest, runs, each by {@link declarationKey}.
+   * or a workflow step of the target, runs, each by {@link declarationKey}.
    */
   readonly ran: ReadonlySet<string>;
   /**
@@ -322,9 +334,10 @@ export function projectNeeds<Brand>(
     programPackages,
   );
   const uses = new Map<string, Set<string>>();
-  const use = (owners: readonly string[], named: Iterable<string>): void => {
+  const at = new Map<string, Set<string>>();
+  const use = (owners: readonly string[], named: Iterable<string>, path: string): void => {
     for (const one of named) {
-      packages.add(one);
+      at.set(path, (at.get(path) ?? new Set()).add(one));
       for (const owner of owners) {
         let set = uses.get(owner);
         if (set === undefined) {
@@ -335,11 +348,14 @@ export function projectNeeds<Brand>(
       }
     }
   };
-  use([PROJECT_OWNER], packages);
+  use([PROJECT_OWNER], packages, project.configFile);
 
   const unanswered: string[] = [];
   for (const file of project.ownSourceFiles()) {
-    if (fileNeeds(project, held, file, programPackages, use)) {
+    const inFile = (owners: readonly string[], named: Iterable<string>): void => {
+      use(owners, named, file.fileName);
+    };
+    if (fileNeeds(project, held, file, programPackages, inFile)) {
       unanswered.push(file.fileName);
     }
   }
@@ -363,22 +379,26 @@ export function projectNeeds<Brand>(
   for (const { file } of configuration.modules) {
     const names = declaredAt(file.fileName);
     for (const { node, text } of moduleStrings(file)) {
-      use(ownersOf(file, held, node), dependenciesNamed(text, names));
+      use(ownersOf(file, held, node), dependenciesNamed(text, names), file.fileName);
     }
   }
-  for (const document of configuration.documents) {
-    const names = declaredAt(document.path);
-    for (const text of document.strings) {
-      use([PROJECT_OWNER], dependenciesNamed(text, names));
+  for (const { strings, manifestDirs } of configuration.documents) {
+    for (const manifestDir of manifestDirs) {
+      const names = declaredAt(joinPath(manifestDir, "package.json"));
+      for (const text of strings) {
+        use([PROJECT_OWNER], dependenciesNamed(text, names), joinPath(manifestDir, MANIFEST));
+      }
     }
   }
-  for (const { file, manifestDir } of configuration.outside) {
-    const names = declaredAt(joinPath(manifestDir, "package.json"));
-    for (const { text } of moduleStrings(file)) {
-      use([PROJECT_OWNER], dependenciesNamed(text, names));
+  for (const { file, manifestDirs } of configuration.outside) {
+    for (const manifestDir of manifestDirs) {
+      const names = declaredAt(joinPath(manifestDir, "package.json"));
+      for (const { text } of moduleStrings(file)) {
+        use([PROJECT_OWNER], dependenciesNamed(text, names), joinPath(manifestDir, MANIFEST));
+      }
     }
   }
-  return { packages, uses, unanswered };
+  return { uses, at, unanswered };
 }
 
 /** The declarations of the inventory a use written at one node belongs to. */
@@ -634,8 +654,10 @@ function installedOf(host: Host, root: string, name: string): InstalledDependenc
     const read = readJSON(host, joinPath(dir, MODULES_DIR, name, MANIFEST));
     if (read !== undefined && isRecord(read.value)) {
       const bin = read.value["bin"];
+      const peers = read.value["peerDependencies"];
       // A string `bin` names one command, the package's name without its scope.
       return {
+        peers: isRecord(peers) ? Object.keys(peers) : [],
         commands:
           typeof bin === "string"
             ? bin === ""
@@ -707,13 +729,53 @@ function isInside(path: string, dir: string): boolean {
   return dir === "" || path.startsWith(`${dir}/`);
 }
 
+/** The directory below the target root a declared dependency's manifest is in, `""` being the root. */
+function manifestDir(dependency: DeclaredDependency): string {
+  const dir = dirnamePath(dependency.position.path);
+  return dir === "." ? "" : dir;
+}
+
+/**
+ * Adds to `needed` each declared dependency that the installed manifest of a needed or
+ * run declared dependency names as a peer, until no further one joins: the declaration of
+ * that name in the needing dependency's manifest or in a manifest above it, where the
+ * installed peer is resolved from. `peers` holds each declaration's installed peers by
+ * {@link declarationKey}.
+ */
+function addNeededPeers(
+  declared: readonly DeclaredDependency[],
+  peers: ReadonlyMap<string, readonly string[]>,
+  needed: Set<string>,
+  ran: ReadonlySet<string>,
+): void {
+  const pending = declared.filter(
+    (dependency) => needed.has(declarationKey(dependency)) || ran.has(declarationKey(dependency)),
+  );
+  for (let next = pending.pop(); next !== undefined; next = pending.pop()) {
+    const below = manifestDir(next);
+    for (const peer of peers.get(declarationKey(next)) ?? []) {
+      for (const dependency of declared) {
+        const key = declarationKey(dependency);
+        if (
+          dependency.name === peer &&
+          !needed.has(key) &&
+          (below === manifestDir(dependency) || isInside(below, manifestDir(dependency)))
+        ) {
+          needed.add(key);
+          pending.push(dependency);
+        }
+      }
+    }
+  }
+}
+
 /**
- * The run's dependency evidence: the target's manifest and each workspace member's in
- * `members` below the target root, read with the position of every dependency each
- * declares, what the projects and the commands its scripts and workflow steps run need,
- * and the last uses each deletion candidate holds. A member in `unbuilt` holds source only
- * in configurations the run could not build. A manifest the program cannot read declares
- * nothing.
+ * The run's dependency evidence over the target's manifest and those of `members` and
+ * `nested` packages below the root: each declared dependency's position, what the projects,
+ * scripts and workflow steps need, and each deletion candidate's last uses. A member in
+ * `unbuilt` holds source only in configurations the run could not build. An unreadable
+ * manifest declares nothing, nor does a nested package's uninstalled dependency, because
+ * no run requires a nested package to be installed.
  */
 export function dependenciesOf(
   host: Host,
@@ -722,12 +784,13 @@ export function dependenciesOf(
   candidates: readonly string[],
   members: readonly string[] = [],
   unbuiltMembers: readonly string[] = [],
+  nested: readonly string[] = [],
 ): Dependencies {
   const root = resolvePath(host.workingDirectory(), targetRoot);
   const scopeOf = packageScope(host, targetRoot);
   const manifests = new Map<string, string>([[root, MANIFEST]]);
   const unbuilt = new Set<string>();
-  for (const dir of [...members, ...unbuiltMembers]) {
+  for (const dir of [...members, ...unbuiltMembers, ...nested]) {
     const below = relativePath(root, dir);
     if (below !== undefined && !manifests.has(dir)) {
       manifests.set(dir, `${below}/${MANIFEST}`);
@@ -742,6 +805,8 @@ export function dependenciesOf(
   const workflow = new Set(workflowTokens(host, targetRoot));
   const declared: DeclaredDependency[] = [];
   const ran = new Set<string>();
+  const peers = new Map<string, readonly string[]>();
+  const uninstalledHere = new Set(nested);
   for (const [dir, path] of manifests) {
     const read = readJSON(host, joinPath(dir, MANIFEST));
     if (read === undefined || !isRecord(read.value)) {
@@ -749,13 +814,16 @@ export function dependenciesOf(
     }
     const tokens = scriptTokensOf(read.value);
     for (const dependency of declaredIn(read.text, read.value, path, scopeOf(path))) {
-      declared.push(dependency);
       const found = installedOf(host, dir, dependency.name);
+      if (found === undefined && uninstalledHere.has(dir)) {
+        continue;
+      }
+      declared.push(dependency);
       if (found === undefined) {
         continue;
       }
-      const runs = (command: string): boolean =>
-        tokens.has(command) || (dir === root && workflow.has(command));
+      peers.set(declarationKey(dependency), found.peers);
+      const runs = (command: string): boolean => tokens.has(command) || workflow.has(command);
       if (found.commands.some(runs)) {
         ran.add(declarationKey(dependency));
       }
@@ -765,25 +833,38 @@ export function dependenciesOf(
   // A declaration several projects compile is one user, and a use any project makes is
   // a use, so the uses are merged by declaration before anything is counted.
   const needed = new Set<string>();
+  const byName = new Map<string, DeclaredDependency[]>();
+  for (const dependency of declared) {
+    byName.set(dependency.name, [...(byName.get(dependency.name) ?? []), dependency]);
+  }
   const uses = new Map<string, Set<string>>();
   for (const project of perProject) {
     // A specifier the checker left unanswered may resolve to any dependency a manifest at
     // or above its file declares, and what the configuration needs is never deleted.
     const unanswered = project.unanswered.flatMap((file) => relativePath(root, file) ?? []);
-    const unknown = declared
-      .filter((dependency) => {
-        const dir = dirnamePath(dependency.position.path);
-        return unanswered.some((file) => isInside(file, dir === "." ? "" : dir));
-      })
-      .map((dependency) => dependency.name);
+    const unknownDeclared = declared.filter((dependency) =>
+      unanswered.some((file) => isInside(file, manifestDir(dependency))),
+    );
+    unknownDeclared.forEach((dependency) => needed.add(declarationKey(dependency)));
+    const unknown = unknownDeclared.map((dependency) => dependency.name);
     const held = unknown.length === 0 ? [] : [[PROJECT_OWNER, new Set(unknown)] as const];
     for (const [id, used] of [...project.uses, ...held]) {
       const merged = uses.get(id) ?? new Set<string>();
       used.forEach((one) => merged.add(one));
       uses.set(id, merged);
     }
-    [...project.packages, ...unknown].forEach((one) => needed.add(one));
+    for (const [path, named] of project.at) {
+      const below = path === ANYWHERE ? undefined : relativePath(root, path);
+      for (const one of named) {
+        for (const dependency of byName.get(one) ?? []) {
+          if (below === undefined || isInside(below, manifestDir(dependency))) {
+            needed.add(declarationKey(dependency));
+          }
+        }
+      }
+    }
   }
+  addNeededPeers(declared, peers, needed, ran);
   const users = new Map<string, number>();
   for (const used of uses.values()) {
     used.forEach((one) => users.set(one, (users.get(one) ?? 0) + 1));

package/src/discover.ts

@@ -34,7 +34,7 @@ export class DiscoveryError extends Error {
 const ERROR_CATEGORY: number = DiagnosticCategory.Error;
 
 /** Whether one diagnostic is an error, which is what fails a run closed. */
-export function isError(diagnostic: Diagnostic): boolean {
+function isError(diagnostic: Diagnostic): boolean {
   return diagnostic.category === ERROR_CATEGORY;
 }
 
@@ -113,7 +113,7 @@ export function projectErrors(sets: ProjectDiagnostics): ProjectErrors {
 }
 
 /** One project a run analyzes. */
-export interface DiscoveredProject {
+interface DiscoveredProject {
   /**
    * The name a run gives the project: the identifier the build matrix declares for
    * it, or, for a project discovery derived, its configuration file's path below the
@@ -162,7 +162,7 @@ export function isGuess(discovery: Discovery, configFile: string): boolean {
 }
 
 /** Every project discovery found, and where each came from. */
-export interface Discovery {
+interface Discovery {
   /** The projects, in discovery order, each once. */
   readonly projects: readonly DiscoveredProject[];
   /**

package/src/edges.ts

@@ -39,7 +39,7 @@ const REFERENCE_WANT =
   "a stable symbol reference naming one symbol exactly, <language>://<scope>#<fragment>";
 
 /** An edges document the Contract refuses: a malformed input, answered with the usage code. */
-export class EdgesError extends ConfigError {
+class EdgesError extends ConfigError {
   constructor(at: string, text: string, want: string) {
     super("malformed", EDGES_FILE, `${at}: ${text}: want ${want}`);
     this.name = "EdgesError";
@@ -174,7 +174,7 @@ export function readEdgeSides(host: Host, targetRoot: string): readonly EdgeSide
 }
 
 /** One side's verdict, as an evaluation names it. */
-export type EdgeState = "live" | "dead" | "absent";
+type EdgeState = "live" | "dead" | "absent";
 
 /** One edge evaluation: one side of this language, its state, and the finding it holds. */
 export interface EdgeEvaluation<F extends Finding = Finding> extends EdgeSide {
@@ -184,7 +184,7 @@ export interface EdgeEvaluation<F extends Finding = Finding> extends EdgeSide {
 }
 
 /** The findings a report publishes, and one evaluation per declared side of this language. */
-export interface Evaluated<F extends Finding> {
+interface Evaluated<F extends Finding> {
   readonly findings: readonly F[];
   /** Ordered by edge, then by side, each compared bytewise. */
   readonly evaluations: readonly EdgeEvaluation<F>[];