fix: replace builtin-modules package with node's isBuiltin check (#2176)

## PR Checklist

- [x] Addresses an existing open issue: fixes #2175
- [x] That issue was marked as [`status: accepting
prs`](https://github.com/JoshuaKGoldberg/TypeStat/issues?q=is%3Aopen+is%3Aissue+label%3A%22status%3A+accepting+prs%22)
- [x] Steps in
[CONTRIBUTING.md](https://github.com/JoshuaKGoldberg/TypeStat/blob/main/.github/CONTRIBUTING.md)
were taken

## Overview

There is no need to use external package for this check, when we can use
node's own `isBuiltin()` check. However, it needed minimum node version
to be upgrade to `>=18.6`.

🐙

---------

Co-authored-by: Josh Goldberg ✨ <git@joshuakgoldberg.com>

Author: rubiesonthesky

package.json

@@ -42,7 +42,6 @@
 	"dependencies": {
 		"@phenomnomnominal/tsquery": "6.1.3",
 		"automutate": "0.9.0",
-		"builtin-modules": "4.0.0",
 		"chalk": "5.4.1",
 		"commander": "13.1.0",
 		"enquirer": "2.4.1",
@@ -89,7 +88,7 @@
 	},
 	"packageManager": "pnpm@10.1.0",
 	"engines": {
-		"node": ">=18"
+		"node": ">=18.6"
 	},
 	"publishConfig": {
 		"provenance": true

pnpm-lock.yaml

@@ -1,15 +1,10 @@
-import builtinModules from "builtin-modules";
-
-import { setSubtract } from "../../shared/sets.js";
 import { createFileNamesAndServices } from "../createFileNamesAndServices.js";
 import { createSingleUseProvider } from "../createSingleUseProvider.js";
 import { collectExistingTypingPackages } from "./missingTypes/collectExistingTypingPackages.js";
 import { collectPackageManagerRunner } from "./missingTypes/collectPackageManagerRunner.js";
 import { collectReferencedPackageNames } from "./missingTypes/collectReferencedPackageNames.js";
 import { filterTypedPackageNames } from "./missingTypes/filterTypedPackageNames.js";
 
-const uniqueBuiltinModules = new Set(builtinModules);
-
 /**
  * Creates a mutations provider that installs missing types modules.
  * @returns Provider to install missing types modules, if needed.
@@ -36,14 +31,10 @@ export const createInstallMissingTypesProvider = () => {
 
 					// Collect every package name referenced by every file in the project
 					const { services } = createFileNamesAndServices(options);
-					const referencedPackageNames =
-						collectReferencedPackageNames(services);
-
 					// Ignore package names already referenced in package.json or that don't exist in DefinitelyTyped
-					const missingPackageNames = setSubtract(
-						referencedPackageNames,
+					const missingPackageNames = collectReferencedPackageNames(
+						services,
 						new Set(existingPackageNames),
-						uniqueBuiltinModules,
 					);
 					const missingTypedPackageNames = await filterTypedPackageNames(
 						Array.from(missingPackageNames),

src/runtime/providers/createInstallMissingTypesProvider.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+
+import {
+	TypeStatCompilerOptions,
+	TypeStatOptions,
+} from "../../../options/types.js";
+import { createLanguageServices } from "../../../services/language.js";
+import { collectReferencedPackageNames } from "./collectReferencedPackageNames.js";
+
+describe("collectReferencedPackageNames", () => {
+	it("should return package names", () => {
+		const options: Partial<TypeStatOptions> = {
+			compilerOptions: {} as Readonly<TypeStatCompilerOptions>,
+			package: {
+				directory: process.cwd(),
+				file: "package.json",
+				missingTypes: true,
+			},
+			projectPath: "tsconfig.json",
+		};
+		const services = createLanguageServices(options as TypeStatOptions);
+
+		const packageNames = collectReferencedPackageNames(
+			services,
+			new Set<string>(),
+		);
+
+		expect(Array.from(packageNames)).toStrictEqual(["node", "automutate"]);
+	});
+
+	it("should ignore defined package names", () => {
+		const options: Partial<TypeStatOptions> = {
+			compilerOptions: {} as Readonly<TypeStatCompilerOptions>,
+			package: {
+				directory: process.cwd(),
+				file: "package.json",
+				missingTypes: true,
+			},
+			projectPath: "tsconfig.json",
+		};
+		const services = createLanguageServices(options as TypeStatOptions);
+
+		const packageNames = collectReferencedPackageNames(
+			services,
+			new Set<string>(["automutate"]),
+		);
+
+		expect(Array.from(packageNames)).toStrictEqual(["node"]);
+	});
+});

src/runtime/providers/missingTypes/collectReferencedPackageNames.test.ts

@@ -1,26 +1,41 @@
+import { isBuiltin } from "node:module";
 import ts from "typescript";
 
 import { LanguageServices } from "../../../services/language.js";
 
-export const collectReferencedPackageNames = (services: LanguageServices) => {
+export const collectReferencedPackageNames = (
+	services: LanguageServices,
+	ignoredPackages: ReadonlySet<string>,
+) => {
 	const packageNames = new Set<string>();
 
 	for (const sourceFile of services.program.getSourceFiles()) {
-		for (const packageName of collectFileReferencedPackageNames(sourceFile)) {
+		const collected = collectFileReferencedPackageNames(
+			sourceFile,
+			ignoredPackages,
+		);
+		for (const packageName of collected) {
 			packageNames.add(packageName);
 		}
 	}
 
 	return packageNames;
 };
 
-const collectFileReferencedPackageNames = (sourceFile: ts.SourceFile) => {
+const collectFileReferencedPackageNames = (
+	sourceFile: ts.SourceFile,
+	ignoredPackages: ReadonlySet<string>,
+) => {
 	const packageNames = new Set<string>();
 
 	const visitNode = (node: ts.Node) => {
 		const packageName = parsePackageNameFromNode(node);
 
-		if (packageName !== undefined) {
+		if (
+			packageName !== undefined &&
+			!isBuiltin(packageName) &&
+			!ignoredPackages.has(packageName)
+		) {
 			packageNames.add(packageName);
 		}