Report @types/pkg as unused if pkg already has types included

fixtures/types/index.ts

@@ -0,0 +1,2 @@
+import m from 'micromatch';
+m;

fixtures/types/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@fixtures/types",
+  "scripts": {
+    "pack": "webpack"
+  },
+  "devDependencies": {
+    "micromatch": "*",
+    "webpack": "*",
+    "@types/micromatch": "*",
+    "@types/webpack": "*"
+  }
+}

fixtures/types/tsconfig.json

@@ -0,0 +1 @@
+{}

src/DependencyDeputy.ts

@@ -28,6 +28,7 @@ export class DependencyDeputy {
   referencedBinaries: Map<string, Set<string>>;
   hostDependencies: Map<string, HostDependencies>;
   installedBinaries: Map<string, InstalledBinaries>;
+  hasTypesIncluded: Map<string, Set<string>>;
   ignoreBinaries: string[] = [];
   ignoreDependencies: string[] = [];
 
@@ -37,6 +38,7 @@ export class DependencyDeputy {
     this.referencedBinaries = new Map();
     this.hostDependencies = new Map();
     this.installedBinaries = new Map();
+    this.hasTypesIncluded = new Map();
   }
 
   public addWorkspace({
@@ -112,6 +114,14 @@ export class DependencyDeputy {
     return this.installedBinaries.get(workspaceName);
   }
 
+  setHasTypesIncluded(workspaceName: string, hasTypesIncluded: Set<string>) {
+    this.hasTypesIncluded.set(workspaceName, hasTypesIncluded);
+  }
+
+  getHasTypesIncluded(workspaceName: string) {
+    return this.installedBinaries.get(workspaceName);
+  }
+
   addReferencedDependency(workspaceName: string, packageName: string) {
     if (!this.referencedDependencies.has(workspaceName)) {
       this.referencedDependencies.set(workspaceName, new Set());
@@ -217,6 +227,7 @@ export class DependencyDeputy {
     for (const [workspaceName, { manifestPath, ignoreDependencies, ignoreBinaries }] of this._manifests.entries()) {
       const referencedDependencies = this.referencedDependencies.get(workspaceName);
       const installedBinaries = this.getInstalledBinaries(workspaceName);
+      const hasTypesIncluded = this.getHasTypesIncluded(workspaceName);
       const ignoreBins = [...IGNORED_GLOBAL_BINARIES, ...this.ignoreBinaries, ...ignoreBinaries];
       const ignoreDeps = [...IGNORED_DEPENDENCIES, ...this.ignoreDependencies, ...ignoreDependencies];
 
@@ -244,6 +255,9 @@ export class DependencyDeputy {
 
         const [scope, typedDependency] = dependency.split('/');
         if (scope === '@types') {
+          // The `pkg` dependency already has types included, i.e. this `@types/pkg` is obsolete
+          if (hasTypesIncluded?.has(typedDependency)) return false;
+
           const typedPackageName = getPackageFromDefinitelyTyped(typedDependency);
           // Ignore `@types/*` packages that don't have a related dependency (e.g. `@types/node`)
           if (IGNORE_DEFINITELY_TYPED.includes(typedPackageName)) return true;

src/WorkspaceWorker.ts

@@ -56,6 +56,7 @@ export class WorkspaceWorker {
   referencedDependencies: ReferencedDependencies = new Set();
   hostDependencies: HostDependencies = new Map();
   installedBinaries: InstalledBinaries = new Map();
+  hasTypesIncluded: Set<string> = new Set();
   entryFilePatterns: Set<string> = new Set();
   productionEntryFilePatterns: Set<string> = new Set();
 
@@ -120,7 +121,7 @@ export class WorkspaceWorker {
   }
 
   private async initReferencedDependencies() {
-    const { dependencies, hostDependencies, installedBinaries } = await npm.findDependencies({
+    const { dependencies, hostDependencies, installedBinaries, hasTypesIncluded } = await npm.findDependencies({
       manifest: this.manifest,
       isProduction: this.isProduction,
       isStrict: this.isStrict,
@@ -132,6 +133,7 @@ export class WorkspaceWorker {
     dependencies.forEach(dependency => this.referencedDependencies.add([filePath, dependency]));
     this.hostDependencies = hostDependencies;
     this.installedBinaries = installedBinaries;
+    this.hasTypesIncluded = hasTypesIncluded;
   }
 
   private getConfigForPlugin(pluginName: PluginName): PluginConfiguration {
@@ -291,6 +293,7 @@ export class WorkspaceWorker {
       hostDependencies: this.hostDependencies,
       installedBinaries: this.installedBinaries,
       referencedDependencies: this.referencedDependencies,
+      hasTypesIncluded: this.hasTypesIncluded,
       enabledPlugins: this.enabledPlugins,
       entryFilePatterns: Array.from(this.entryFilePatterns),
       productionEntryFilePatterns: Array.from(this.productionEntryFilePatterns),

src/index.ts

@@ -175,13 +175,15 @@ export const main = async (unresolvedConfiguration: CommandLineOptions) => {
       referencedDependencies,
       hostDependencies,
       installedBinaries,
+      hasTypesIncluded,
       enabledPlugins,
       entryFilePatterns,
       productionEntryFilePatterns,
     } = dependencies;
 
     deputy.addHostDependencies(name, hostDependencies);
     deputy.setInstalledBinaries(name, installedBinaries);
+    deputy.setHasTypesIncluded(name, hasTypesIncluded);
     enabledPluginsStore.set(name, enabledPlugins);
 
     referencedDependencies.forEach(([containingFilePath, specifier]) => {

src/manifest/index.ts

@@ -1,4 +1,5 @@
 import { _getDependenciesFromScripts } from '../binaries/index.js';
+import { isDefinitelyTyped } from '../util/modules.js';
 import { timerify } from '../util/Performance.js';
 import { getPackageManifest } from './helpers.js';
 import type { InstalledBinaries, HostDependencies } from '../types/workspace.js';
@@ -28,6 +29,8 @@ const findManifestDependencies = async ({ manifest, isProduction, isStrict, dir,
   // Find all binaries for each dependency
   const installedBinaries: InstalledBinaries = new Map();
 
+  const hasTypesIncluded = new Set<string>();
+
   const packageNames = [
     ...Object.keys(manifest.dependencies ?? {}),
     ...(isStrict ? Object.keys(manifest.peerDependencies ?? {}) : []),
@@ -62,13 +65,16 @@ const findManifestDependencies = async ({ manifest, isProduction, isStrict, dir,
           hostDependencies.set(packagePeerDependency, new Set([packageName]));
         }
       });
+
+      if (!isDefinitelyTyped(packageName) && (manifest.types || manifest.typings)) hasTypesIncluded.add(packageName);
     }
   }
 
   return {
     dependencies,
     hostDependencies,
     installedBinaries,
+    hasTypesIncluded,
   };
 };
 

tests/definitely-typed.test.ts

@@ -17,7 +17,7 @@ test('Find unused DT @types', async () => {
 
   assert.deepEqual(counters, {
     ...baseCounters,
-    devDependencies: 1,
+    devDependencies: 2,
     processed: 1,
     total: 1,
   });

tests/types.test.ts

@@ -0,0 +1,24 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { main } from '../src/index.js';
+import { resolve } from '../src/util/path.js';
+import baseArguments from './helpers/baseArguments.js';
+import baseCounters from './helpers/baseCounters.js';
+
+const cwd = resolve('fixtures/types');
+
+test('Find @types/pkg that are obsolete, since pkg has types included', async () => {
+  const { issues, counters } = await main({
+    ...baseArguments,
+    cwd,
+  });
+
+  assert(issues.devDependencies['package.json']['@types/webpack']);
+
+  assert.deepEqual(counters, {
+    ...baseCounters,
+    devDependencies: 1,
+    processed: 1,
+    total: 1,
+  });
+});