Fix typed peer dep + improve some peer/host namings (fixes #239)

Author: webpro

src/DependencyDeputy.ts

@@ -8,8 +8,7 @@ import {
 import { isDefinitelyTyped, getDefinitelyTypedFor, getPackageFromDefinitelyTyped } from './util/modules.js';
 import type { Workspace } from './ConfigurationChief.js';
 import type { ConfigurationHints, Issue } from './types/issues.js';
-import type { WorkspaceManifests } from './types/workspace.js';
-import type { PeerDependencies, InstalledBinaries } from './types/workspace.js';
+import type { WorkspaceManifests, HostDependencies, InstalledBinaries } from './types/workspace.js';
 import type { PackageJson } from '@npmcli/package-json';
 
 type Options = {
@@ -27,7 +26,7 @@ export class DependencyDeputy {
   _manifests: WorkspaceManifests = new Map();
   referencedDependencies: Map<string, Set<string>>;
   referencedBinaries: Map<string, Set<string>>;
-  peerDependencies: Map<string, PeerDependencies>;
+  hostDependencies: Map<string, HostDependencies>;
   installedBinaries: Map<string, InstalledBinaries>;
   ignoreBinaries: string[] = [];
   ignoreDependencies: string[] = [];
@@ -36,7 +35,7 @@ export class DependencyDeputy {
     this.isStrict = isStrict;
     this.referencedDependencies = new Map();
     this.referencedBinaries = new Map();
-    this.peerDependencies = new Map();
+    this.hostDependencies = new Map();
     this.installedBinaries = new Map();
   }
 
@@ -127,12 +126,12 @@ export class DependencyDeputy {
     this.referencedBinaries.get(workspaceName)?.add(binaryName);
   }
 
-  addPeerDependencies(workspaceName: string, peerDependencies: Map<string, Set<string>>) {
-    this.peerDependencies.set(workspaceName, peerDependencies);
+  addHostDependencies(workspaceName: string, hostDependencies: HostDependencies) {
+    this.hostDependencies.set(workspaceName, hostDependencies);
   }
 
-  getPeerDependenciesOf(workspaceName: string, dependency: string) {
-    return Array.from(this.peerDependencies.get(workspaceName)?.get(dependency) ?? []);
+  getHostDependenciesFor(workspaceName: string, dependency: string) {
+    return Array.from(this.hostDependencies.get(workspaceName)?.get(dependency) ?? []);
   }
 
   getPeerDependencies(workspaceName: string) {
@@ -249,23 +248,25 @@ export class DependencyDeputy {
           // Ignore `@types/*` packages that don't have a related dependency (e.g. `@types/node`)
           if (IGNORE_DEFINITELY_TYPED.includes(typedPackageName)) return true;
 
-          // Ignore typed dependencies that have a peer dependency that's referenced
-          // Example: `next` has `react-dom` as peer dependency, so when `@types/react-dom` is listed it can be ignored
-          const peerDependencies = this.getPeerDependenciesOf(workspaceName, typedPackageName);
-          if (peerDependencies.length) {
-            return !!peerDependencies.find(peerDependency => isReferencedDependency(peerDependency, true));
-          }
+          // Ignore typed dependencies that have a host dependency that's referenced
+          // Example: `next` (host) has `react-dom` and/or `@types/react-dom` (peer), peers can be ignored if host `next` is referenced
+          const hostDependencies = [
+            ...this.getHostDependenciesFor(workspaceName, dependency),
+            ...this.getHostDependenciesFor(workspaceName, typedPackageName),
+          ];
+          if (hostDependencies.length) return !!hostDependencies.find(host => isReferencedDependency(host, true));
 
           if (!referencedDependencies) return false;
 
           return referencedDependencies.has(typedPackageName);
         }
 
-        // A dependency may not be referenced, but it may be a peerDependency of another.
-        // If that "host" dependency is also not referenced we'll report this dependency as unused.
-        const peerDependenciesOf = this.getPeerDependenciesOf(workspaceName, dependency);
-        peerDependenciesOf.forEach(dep => (!peerDepRecs[dep] ? (peerDepRecs[dep] = 1) : peerDepRecs[dep]++));
-        return peerDependenciesOf.some(peerDependency => isReferencedDependency(peerDependency, true));
+        // A dependency may not be referenced, but it may be a peer dep of another.
+        // If that host is also not referenced we'll report this dependency as unused.
+        const hostDependencies = this.getHostDependenciesFor(workspaceName, dependency);
+
+        hostDependencies.forEach(dep => (!peerDepRecs[dep] ? (peerDepRecs[dep] = 1) : peerDepRecs[dep]++));
+        return hostDependencies.some(peerDependency => isReferencedDependency(peerDependency, true));
       };
 
       const isNotReferencedDependency = (dependency: string): boolean => !isReferencedDependency(dependency);

src/WorkspaceWorker.ts

@@ -7,7 +7,7 @@ import { getKeysByValue } from './util/object.js';
 import { join, toPosix } from './util/path.js';
 import type { Configuration, PluginConfiguration, PluginName, WorkspaceConfiguration } from './types/config.js';
 import type { PackageJsonWithPlugins } from './types/plugins.js';
-import type { InstalledBinaries, PeerDependencies } from './types/workspace.js';
+import type { InstalledBinaries, HostDependencies } from './types/workspace.js';
 import type { Entries } from 'type-fest';
 
 type PluginNames = Entries<typeof plugins>;
@@ -51,7 +51,7 @@ export class WorkspaceWorker {
   enabled: Record<PluginName, boolean>;
   enabledPlugins: PluginName[] = [];
   referencedDependencies: ReferencedDependencies = new Set();
-  peerDependencies: PeerDependencies = new Map();
+  hostDependencies: HostDependencies = new Map();
   installedBinaries: InstalledBinaries = new Map();
 
   constructor({
@@ -115,7 +115,7 @@ export class WorkspaceWorker {
   }
 
   private async initReferencedDependencies() {
-    const { dependencies, peerDependencies, installedBinaries } = await npm.findDependencies({
+    const { dependencies, hostDependencies, installedBinaries } = await npm.findDependencies({
       manifest: this.manifest,
       isProduction: this.isProduction,
       isStrict: this.isStrict,
@@ -125,7 +125,7 @@ export class WorkspaceWorker {
 
     const filePath = join(this.dir, 'package.json');
     dependencies.forEach(dependency => this.referencedDependencies.add([filePath, dependency]));
-    this.peerDependencies = peerDependencies;
+    this.hostDependencies = hostDependencies;
     this.installedBinaries = installedBinaries;
   }
 
@@ -313,7 +313,7 @@ export class WorkspaceWorker {
     await this.findDependenciesByPlugins();
 
     return {
-      peerDependencies: this.peerDependencies,
+      hostDependencies: this.hostDependencies,
       installedBinaries: this.installedBinaries,
       referencedDependencies: this.referencedDependencies,
       enabledPlugins: this.enabledPlugins,

src/index.ts

@@ -230,9 +230,9 @@ export const main = async (unresolvedConfiguration: CommandLineOptions) => {
     // Get peerDependencies, installed binaries, entry files gathered through all plugins, and hand over
     // A bit of an entangled hotchpotch, but it's all related, and efficient in terms of reading package.json once, etc.
     const dependencies = await worker.findAllDependencies();
-    const { referencedDependencies, peerDependencies, installedBinaries, enabledPlugins } = dependencies;
+    const { referencedDependencies, hostDependencies, installedBinaries, enabledPlugins } = dependencies;
 
-    deputy.addPeerDependencies(name, peerDependencies);
+    deputy.addHostDependencies(name, hostDependencies);
     deputy.setInstalledBinaries(name, installedBinaries);
     enabledPluginsStore.set(name, enabledPlugins);
 

src/manifest/index.ts

@@ -1,7 +1,7 @@
 import { _getDependenciesFromScripts } from '../binaries/index.js';
 import { timerify } from '../util/Performance.js';
 import { getPackageManifest } from './helpers.js';
-import type { InstalledBinaries, PeerDependencies } from '../types/workspace.js';
+import type { InstalledBinaries, HostDependencies } from '../types/workspace.js';
 import type { PackageJson } from '@npmcli/package-json';
 
 type Options = {
@@ -14,7 +14,7 @@ type Options = {
 
 const findManifestDependencies = async ({ manifest, isProduction, isStrict, dir, cwd }: Options) => {
   const scriptFilter = isProduction ? ['start', 'postinstall'] : [];
-  const peerDependencies: PeerDependencies = new Map();
+  const hostDependencies: HostDependencies = new Map();
 
   const scripts = Object.entries(manifest.scripts ?? {}).reduce((scripts, [scriptName, script]) => {
     if (script && (scriptFilter.length === 0 || scriptFilter.includes(scriptName))) {
@@ -56,18 +56,18 @@ const findManifestDependencies = async ({ manifest, isProduction, isStrict, dir,
       // Read and store peer dependencies
       const packagePeerDependencies = Object.keys(manifest.peerDependencies ?? {});
       packagePeerDependencies.forEach(packagePeerDependency => {
-        if (peerDependencies.has(packagePeerDependency)) {
-          peerDependencies.get(packagePeerDependency)?.add(packageName);
+        if (hostDependencies.has(packagePeerDependency)) {
+          hostDependencies.get(packagePeerDependency)?.add(packageName);
         } else {
-          peerDependencies.set(packagePeerDependency, new Set([packageName]));
+          hostDependencies.set(packagePeerDependency, new Set([packageName]));
         }
       });
     }
   }
 
   return {
     dependencies,
-    peerDependencies,
+    hostDependencies,
     installedBinaries,
   };
 };

src/types/workspace.ts

@@ -14,6 +14,6 @@ type WorkspaceManifest = {
 
 export type WorkspaceManifests = Map<string, WorkspaceManifest>;
 
-export type PeerDependencies = Map<string, Set<string>>;
+export type HostDependencies = Map<string, Set<string>>;
 
 export type InstalledBinaries = Map<string, Set<string>>;

tests/npm-scripts.test.ts

@@ -19,7 +19,7 @@ test('Referenced dependencies in npm scripts', async () => {
     cwd,
   };
 
-  const { dependencies, peerDependencies, installedBinaries } = await npm.findDependencies(config);
+  const { dependencies, hostDependencies, installedBinaries } = await npm.findDependencies(config);
 
   assert.deepEqual(dependencies, [
     'bin:nodemon',
@@ -37,10 +37,10 @@ test('Referenced dependencies in npm scripts', async () => {
     'bin:runnable',
   ]);
 
-  const expectedPeerDependencies = new Map();
-  expectedPeerDependencies.set('pm2-peer-dep', new Set(['pm2']));
+  const expectedHostDependencies = new Map();
+  expectedHostDependencies.set('pm2-peer-dep', new Set(['pm2']));
 
-  assert.deepEqual(peerDependencies, expectedPeerDependencies);
+  assert.deepEqual(hostDependencies, expectedHostDependencies);
 
   assert.deepEqual(
     installedBinaries,