@definitelytyped/eslint-plugin 0.0.186 → 0.0.188

package/dist/util.d.ts

@@ -4,3 +4,18 @@ import { RuleListener, RuleModule, SourceCode } from "@typescript-eslint/utils/d
 export declare const createRule: <TOptions extends readonly unknown[], TMessageIds extends string>(opts: Readonly<RuleWithMetaAndName<TOptions, TMessageIds, RuleListener>>) => RuleModule<TMessageIds, TOptions>;
 export declare function getTypesPackageForDeclarationFile(file: string): string | undefined;
 export declare function commentsMatching(sourceFile: Readonly<SourceCode>, regex: RegExp, f: (match: string, c: TSESTree.Comment) => void): void;
+export interface TypesPackageInfo {
+    dir: string;
+    /** package.json with name="@types/foo__bar-baz" */
+    packageJson: PackageJSON;
+    /** real package name being typed, like "@foo/bar-baz" */
+    realName: string;
+}
+export interface PackageJSON {
+    name: string;
+    version: string;
+    owners: string[];
+    dependencies?: Record<string, string | undefined>;
+    devDependencies?: Record<string, string | undefined>;
+}
+export declare function findTypesPackage(file: string): TypesPackageInfo | undefined;

package/dist/util.js

@@ -1,21 +1,22 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.commentsMatching = exports.getTypesPackageForDeclarationFile = exports.createRule = void 0;
+exports.findTypesPackage = exports.commentsMatching = exports.getTypesPackageForDeclarationFile = exports.createRule = void 0;
 const utils_1 = require("@definitelytyped/utils");
 const utils_2 = require("@typescript-eslint/utils");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 // Possible TS bug can't figure out how to do declaration emit of created rules
 // without an explicit type annotation here due to pnpm symlink stuff
 exports.createRule = utils_2.ESLintUtils.RuleCreator((name) => `https://github.com/microsoft/DefinitelyTyped-tools/tree/master/packages/eslint-plugin/docs/rules/${name}.md`);
 function getTypesPackageForDeclarationFile(file) {
-    var _a, _b;
-    if (!file.endsWith(".d.ts")) {
+    var _a;
+    if (!(0, utils_1.isDeclarationPath)(file)) {
         return undefined;
     }
-    const match = (_a = file.match(/types\/([^\/]+)\//)) === null || _a === void 0 ? void 0 : _a[1];
-    if (!match) {
-        return undefined;
-    }
-    return (_b = (0, utils_1.unmangleScopedPackage)(match)) !== null && _b !== void 0 ? _b : match;
+    return (_a = findTypesPackage(file)) === null || _a === void 0 ? void 0 : _a.realName;
 }
 exports.getTypesPackageForDeclarationFile = getTypesPackageForDeclarationFile;
 function commentsMatching(sourceFile, regex, f) {
@@ -26,4 +27,45 @@ function commentsMatching(sourceFile, regex, f) {
     }
 }
 exports.commentsMatching = commentsMatching;
+function findUp(p, fn) {
+    p = path_1.default.resolve(p);
+    const root = path_1.default.parse(p).root;
+    while (true) {
+        const v = fn(p);
+        if (v !== undefined) {
+            return v;
+        }
+        if (p === root) {
+            break;
+        }
+        p = path_1.default.dirname(p);
+    }
+    return undefined;
+}
+// TODO(jakebailey): pull this helper out to util package?
+function isTypesPackage(packageJson) {
+    return (typeof packageJson.name === "string" &&
+        packageJson.name.startsWith("@types/") &&
+        typeof packageJson.version === "string" &&
+        Array.isArray(packageJson.owners));
+}
+function findTypesPackage(file) {
+    return findUp(file, (p) => {
+        const packageJsonPath = path_1.default.join(p, "package.json");
+        if (!fs_1.default.existsSync(packageJsonPath)) {
+            return undefined;
+        }
+        const packageJsonContents = fs_1.default.readFileSync(packageJsonPath, "utf8");
+        const packageJson = JSON.parse(packageJsonContents);
+        if (!isTypesPackage(packageJson)) {
+            return undefined;
+        }
+        return {
+            dir: p,
+            packageJson,
+            realName: (0, utils_1.typesPackageNameToRealName)(packageJson.name),
+        };
+    });
+}
+exports.findTypesPackage = findTypesPackage;
 //# sourceMappingURL=util.js.map

package/dist/util.js.map

@@ -1 +1 @@
-{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";;;AAAA,kDAA+D;AAC/D,oDAAiE;AAIjE,+EAA+E;AAC/E,qEAAqE;AACxD,QAAA,UAAU,GAEkB,mBAAW,CAAC,WAAW,CAC9D,CAAC,IAAI,EAAE,EAAE,CACP,oGAAoG,IAAI,KAAK,CAChH,CAAC;AAEF,SAAgB,iCAAiC,CAAC,IAAY;;IAC5D,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;QAC3B,OAAO,SAAS,CAAC;KAClB;IAED,MAAM,KAAK,GAAG,MAAA,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,0CAAG,CAAC,CAAC,CAAC;IACnD,IAAI,CAAC,KAAK,EAAE;QACV,OAAO,SAAS,CAAC;KAClB;IAED,OAAO,MAAA,IAAA,6BAAqB,EAAC,KAAK,CAAC,mCAAI,KAAK,CAAC;AAC/C,CAAC;AAXD,8EAWC;AAED,SAAgB,gBAAgB,CAC9B,UAAgC,EAChC,KAAa,EACb,CAA+C;IAE/C,KAAK,MAAM,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE;QAC7C,MAAM,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC;YAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;KACzB;AACH,CAAC;AATD,4CASC"}
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";;;;;;AAAA,kDAAuF;AACvF,oDAAiE;AAGjE,gDAAwB;AACxB,4CAAoB;AAEpB,+EAA+E;AAC/E,qEAAqE;AACxD,QAAA,UAAU,GAEkB,mBAAW,CAAC,WAAW,CAC9D,CAAC,IAAI,EAAE,EAAE,CACP,oGAAoG,IAAI,KAAK,CAChH,CAAC;AAEF,SAAgB,iCAAiC,CAAC,IAAY;;IAC5D,IAAI,CAAC,IAAA,yBAAiB,EAAC,IAAI,CAAC,EAAE;QAC5B,OAAO,SAAS,CAAC;KAClB;IACD,OAAO,MAAA,gBAAgB,CAAC,IAAI,CAAC,0CAAE,QAAQ,CAAC;AAC1C,CAAC;AALD,8EAKC;AAED,SAAgB,gBAAgB,CAC9B,UAAgC,EAChC,KAAa,EACb,CAA+C;IAE/C,KAAK,MAAM,OAAO,IAAI,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE;QAC7C,MAAM,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC;YAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;KACzB;AACH,CAAC;AATD,4CASC;AAED,SAAS,MAAM,CAAe,CAAS,EAAE,EAAgC;IACvE,CAAC,GAAG,cAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACpB,MAAM,IAAI,GAAG,cAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAEhC,OAAO,IAAI,EAAE;QACX,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;QAChB,IAAI,CAAC,KAAK,SAAS,EAAE;YACnB,OAAO,CAAC,CAAC;SACV;QACD,IAAI,CAAC,KAAK,IAAI,EAAE;YACd,MAAM;SACP;QACD,CAAC,GAAG,cAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;KACrB;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAkBD,0DAA0D;AAC1D,SAAS,cAAc,CAAC,WAAiC;IACvD,OAAO,CACL,OAAO,WAAW,CAAC,IAAI,KAAK,QAAQ;QACpC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC;QACtC,OAAO,WAAW,CAAC,OAAO,KAAK,QAAQ;QACvC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAClC,CAAC;AACJ,CAAC;AAED,SAAgB,gBAAgB,CAAC,IAAY;IAC3C,OAAO,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,EAAE;QACxB,MAAM,eAAe,GAAG,cAAI,CAAC,IAAI,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;QACrD,IAAI,CAAC,YAAE,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE;YACnC,OAAO,SAAS,CAAC;SAClB;QAED,MAAM,mBAAmB,GAAG,YAAE,CAAC,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,CAAC;QACrE,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC;QACpD,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,EAAE;YAChC,OAAO,SAAS,CAAC;SAClB;QACD,OAAO;YACL,GAAG,EAAE,CAAC;YACN,WAAW;YACX,QAAQ,EAAE,IAAA,kCAA0B,EAAC,WAAW,CAAC,IAAI,CAAC;SACvD,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC;AAlBD,4CAkBC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@definitelytyped/eslint-plugin",
-  "version": "0.0.186",
+  "version": "0.0.188",
   "description": "ESLint rules for DefinitelyTyped",
   "main": "./dist/index.js",
   "publishConfig": {
@@ -20,7 +20,7 @@
   "dependencies": {
     "@typescript-eslint/types": "^5.56.0",
     "@typescript-eslint/utils": "^5.55.0",
-    "@definitelytyped/utils": "0.0.182"
+    "@definitelytyped/utils": "0.0.184"
   },
   "peerDependencies": {
     "@typescript-eslint/eslint-plugin": "^5.0.0",

package/src/configs/all.ts

@@ -136,6 +136,7 @@ export const all: Linter.BaseConfig = {
       },
       rules: {
         ...Object.fromEntries(Object.keys(rules).map((name) => [`@definitelytyped/${name}`, "error"])),
+        "unicode-bom": ["error", "never"],
         "@typescript-eslint/ban-ts-comment": [
           "error",
           {

package/src/rules/no-bad-reference.ts

@@ -1,58 +1,201 @@
-import { TSESTree } from "@typescript-eslint/utils";
-import { commentsMatching, createRule } from "../util";
+import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
+import { createRule, findTypesPackage } from "../util";
+import * as ts from "typescript";
+import path from "path";
+import { isDeclarationPath } from "@definitelytyped/utils";
+
+interface Reference {
+  kind: "path" | "import" | "types";
+  text: string;
+  range: ts.TextRange;
+}
 
-type MessageId = "referencePathPackage" | "referencePathTest" | "referencePathOldVersion";
 const rule = createRule({
   name: "no-bad-reference",
   defaultOptions: [],
   meta: {
     type: "problem",
     docs: {
-      description: `Forbids <reference path="./vNN"/> in all files, <reference path="../etc"/> in declaration files, and all <reference path> in test files.`,
+      description:
+        "Forbids bad references, including those that resolve outside of the package or path references in non-declaration files.",
       recommended: "error",
     },
     messages: {
-      referencePathPackage:
-        "Don't use <reference path> to reference another package. Use an import or <reference types> instead.",
-      referencePathTest:
-        "Don't use <reference path> in test files. Use <reference types> or include the file in 'tsconfig.json'.",
-      referencePathOldVersion: "Don't use <reference path> to reference an old version of the current package.",
+      importOutside:
+        'The import "{{text}}" resolves outside of the package. Use a bare import to reference other packages.',
+      importLeaves: 'The import "{{text}}" resolves to the current package, but uses relative paths.',
+      referenceOutside:
+        'The reference "{{text}}" resolves outside of the package. Use a global reference to reference other packages.',
+      referenceLeaves: 'The reference "{{text}}" resolves to the current package, but uses relative paths.',
+      testReference:
+        'The path reference "{{text}}" is disallowed outside declaration files. Use "<reference types>" or include the file in tsconfig instead.',
+      backslashes: "Use forward slashes in paths.",
     },
     schema: [],
   },
   create(context) {
-    const isDeclarationFile = context.getFilename().endsWith(".d.ts");
-    commentsMatching(context.getSourceCode(), /<reference\s+path\s*=\s*"(.+)"\s*\/>/, (ref, comment) => {
-      if (ref.match(/^\.\/v\d+(?:\.\d+)?(?:\/.*)?$/)) {
-        report(comment, "referencePathOldVersion");
-      }
-      if (isDeclarationFile) {
-        if (ref.startsWith("..")) {
-          report(comment, "referencePathPackage");
-        }
+    const containingFileName = context.getFilename();
+    const typesPackage = findTypesPackage(containingFileName);
+    if (!typesPackage) {
+      return {};
+    }
+
+    const containingDirectory = path.dirname(containingFileName);
+
+    const realNamePlusSlash = typesPackage.realName + "/";
+    function isRelativeOrSelf(name: string) {
+      return name.startsWith(".") || name.startsWith(realNamePlusSlash);
+    }
+
+    const ast = context.getSourceCode().ast;
+    const parserServices = ESLintUtils.getParserServices(context, true);
+    const sourceFile = parserServices.esTreeNodeToTSNodeMap.get(ast);
+
+    const refs: Reference[] = [];
+    for (const ref of sourceFile.referencedFiles) {
+      if (isDeclarationPath(containingFileName)) {
+        refs.push({ kind: "path", text: ref.fileName, range: ref });
       } else {
-        report(comment, "referencePathTest");
+        context.report({
+          messageId: "testReference",
+          loc: tsRangeToESLintLocation(ref, sourceFile),
+          data: { text: ref.fileName },
+        });
+      }
+    }
+    for (const ref of sourceFile.typeReferenceDirectives) {
+      if (isRelativeOrSelf(ref.fileName)) {
+        refs.push({ kind: "types", text: ref.fileName, range: ref });
       }
-    });
+    }
+    for (const ref of imports(sourceFile)) {
+      if (isRelativeOrSelf(ref.text)) {
+        refs.push({ kind: "import", text: ref.text, range: ref });
+      }
+    }
 
-    return {};
+    for (const ref of refs) {
+      if (ref.text.includes("\\")) {
+        context.report({
+          messageId: "backslashes",
+          loc: tsRangeToESLintLocation(ref.range, sourceFile),
+        });
+      }
+
+      const p = ref.text.startsWith(realNamePlusSlash)
+        ? path.posix.join(
+            path.posix.relative(containingDirectory, typesPackage.dir),
+            ref.text.slice(realNamePlusSlash.length)
+          )
+        : ref.text;
+
+      const resolved = path.resolve(containingDirectory, p);
+      const otherPackage = findTypesPackage(resolved);
+
+      if (otherPackage && otherPackage.dir === typesPackage.dir) {
+        // Perf trick; if a path doesn't have ".." anywhere, then it can't have resolved
+        // up and out of a package dir so we can skip this work.
+        if (p.includes("..")) {
+          // If we resolved to something in the correct package, we still could have
+          // gotten here by leaving the package (up into a parent, or down into a versioned dir).
+          // Manually walk the path to see if that happened.
+          const parts = p.split("/");
+          let cwd = containingDirectory;
+          for (const part of parts) {
+            if (part === "" || part === ".") {
+              continue;
+            }
+            if (part === "..") {
+              cwd = path.posix.dirname(cwd);
+            } else {
+              cwd = path.posix.join(cwd, part);
+            }
+            const otherPackage = findTypesPackage(cwd);
+            if (otherPackage && otherPackage.dir === typesPackage.dir) {
+              continue;
+            }
+
+            context.report({
+              messageId: ref.kind === "import" ? "importLeaves" : "referenceLeaves",
+              loc: tsRangeToESLintLocation(ref.range, sourceFile),
+              data: { text: ref.text },
+            });
+          }
+        }
+
+        continue;
+      }
 
-    function report(comment: TSESTree.Comment, messageId: MessageId) {
       context.report({
-        loc: {
-          end: {
-            column: comment.value.lastIndexOf(`"`),
-            line: comment.loc.end.line,
-          },
-          start: {
-            column: comment.value.indexOf(`"`) + 1,
-            line: comment.loc.start.line,
-          },
-        },
-        messageId,
+        messageId: ref.kind === "import" ? "importOutside" : "referenceOutside",
+        loc: tsRangeToESLintLocation(ref.range, sourceFile),
+        data: { text: ref.text },
       });
     }
+
+    return {};
   },
 });
 
+function tsRangeToESLintLocation(range: ts.TextRange, sourceFile: ts.SourceFile): TSESTree.SourceLocation {
+  const pos = sourceFile.getLineAndCharacterOfPosition(range.pos);
+  const end = sourceFile.getLineAndCharacterOfPosition(range.end);
+  return {
+    start: { line: pos.line + 1, column: pos.character + 1 },
+    end: { line: end.line + 1, column: end.character + 1 },
+  };
+}
+
+/**
+ * All strings referenced in `import` statements.
+ * Does *not* include <reference> directives.
+ */
+function imports({ statements }: ts.SourceFile): Iterable<ts.StringLiteralLike> {
+  const result: ts.StringLiteralLike[] = [];
+  for (const node of statements) {
+    recur(node);
+  }
+  return result;
+
+  function recur(node: ts.Node) {
+    switch (node.kind) {
+      case ts.SyntaxKind.ImportDeclaration:
+      case ts.SyntaxKind.ExportDeclaration: {
+        const { moduleSpecifier } = node as ts.ImportDeclaration | ts.ExportDeclaration;
+        if (moduleSpecifier && moduleSpecifier.kind === ts.SyntaxKind.StringLiteral) {
+          result.push(moduleSpecifier as ts.StringLiteral);
+        }
+        break;
+      }
+
+      case ts.SyntaxKind.ImportEqualsDeclaration: {
+        const { moduleReference } = node as ts.ImportEqualsDeclaration;
+        if (moduleReference.kind === ts.SyntaxKind.ExternalModuleReference) {
+          result.push(parseRequire(moduleReference));
+        }
+        break;
+      }
+
+      case ts.SyntaxKind.ImportType: {
+        const { argument } = node as ts.ImportTypeNode;
+        if (ts.isLiteralTypeNode(argument) && ts.isStringLiteral(argument.literal)) {
+          result.push(argument.literal);
+        }
+        break;
+      }
+
+      default:
+        ts.forEachChild(node, recur);
+    }
+  }
+}
+
+function parseRequire(reference: ts.ExternalModuleReference): ts.StringLiteralLike {
+  const { expression } = reference;
+  if (!expression || !ts.isStringLiteral(expression)) {
+    throw new Error(`Bad 'import =' reference: ${reference.getText()}`);
+  }
+  return expression;
+}
+
 export = rule;

package/src/rules/no-declare-current-package.ts

@@ -19,6 +19,9 @@ const rule = createRule({
   },
   create(context) {
     const packageName = getTypesPackageForDeclarationFile(context.getFilename());
+    if (!packageName) {
+      return {};
+    }
 
     return {
       // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -28,7 +31,7 @@ const rule = createRule({
           (node.id.value === packageName || node.id.value.startsWith(packageName + "/"))
         ) {
           const text = node.id.value;
-          const preferred = text === packageName ? '"index.d.ts"' : `"${text}.d.ts" or "${text}/index.d.ts`;
+          const preferred = text === packageName ? '"index.d.ts"' : `"${text}.d.ts" or "${text}/index.d.ts"`;
           context.report({
             messageId: "noDeclareCurrentPackage",
             data: { text, preferred },

package/src/rules/no-import-default-of-export-equals.ts

@@ -1,3 +1,4 @@
+import { isDeclarationPath } from "@definitelytyped/utils";
 import { createRule } from "../util";
 import { ESLintUtils } from "@typescript-eslint/utils";
 import * as ts from "typescript";
@@ -19,7 +20,7 @@ const rule = createRule({
   create(context) {
     const parserServices = ESLintUtils.getParserServices(context);
     const checker = parserServices.program.getTypeChecker();
-    if (context.getFilename().endsWith(".d.ts")) {
+    if (isDeclarationPath(context.getFilename())) {
       return {
         // eslint-disable-next-line @typescript-eslint/naming-convention
         ImportDeclaration(node) {

package/src/rules/no-import-of-dev-dependencies.ts

@@ -1,8 +1,6 @@
 import { TSESTree } from "@typescript-eslint/utils";
-import { createRule, commentsMatching, getTypesPackageForDeclarationFile } from "../util";
-import fs from "fs";
-import path from "path";
-import { unmangleScopedPackage } from "@definitelytyped/utils";
+import { createRule, commentsMatching, findTypesPackage } from "../util";
+import { isDeclarationPath, isTypesPackageName, typesPackageNameToRealName } from "@definitelytyped/utils";
 
 type MessageId = "noImportOfDevDependencies" | "noReferenceOfDevDependencies";
 const rule = createRule({
@@ -21,45 +19,47 @@ const rule = createRule({
     schema: [],
   },
   create(context) {
-    const packageName = getTypesPackageForDeclarationFile(context.getFilename());
-    if (context.getFilename().endsWith(".d.ts")) {
-      const packageJson = getPackageJson(context.getPhysicalFilename?.() ?? context.getFilename());
-      const devdeps = packageJson
-        ? Object.keys(packageJson.devDependencies).map((dep) => {
-            const withoutTypes = dep.replace(/^@types\//, "");
-            return unmangleScopedPackage(withoutTypes) || withoutTypes;
-          })
-        : [];
-      const deps = packageJson
-        ? Object.keys(packageJson.dependencies ?? {}).map((dep) => {
-            const withoutTypes = dep.replace(/^@types\//, "");
-            return unmangleScopedPackage(withoutTypes) || withoutTypes;
-          })
-        : [];
-      commentsMatching(context.getSourceCode(), /<reference\s+types\s*=\s*"(.+)"\s*\/>/, (ref, comment) => {
-        if (devdeps.includes(ref) && ref !== packageName && !deps.includes(ref)) {
-          report(comment, "noReferenceOfDevDependencies");
-        }
-      });
+    if (!isDeclarationPath(context.getFilename())) {
+      return {};
+    }
 
-      return {
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        ImportDeclaration(node) {
-          if (
-            devdeps.includes(node.source.value) &&
-            node.source.value !== packageName &&
-            !deps.includes(node.source.value)
-          ) {
-            context.report({
-              messageId: "noImportOfDevDependencies",
-              node,
-            });
-          }
-        },
-      };
-    } else {
+    const info = findTypesPackage(context.getFilename());
+    if (!info) {
+      return {};
+    }
+
+    const packageJson = info.packageJson;
+    if (!packageJson.devDependencies) {
       return {};
     }
+
+    const devDeps = Object.keys(packageJson.devDependencies)
+      .map((dep) => {
+        if (isTypesPackageName(dep)) {
+          return typesPackageNameToRealName(dep);
+        }
+        return dep;
+      })
+      .filter((dep) => dep !== info.realName && packageJson.dependencies?.[dep] === undefined); // TODO(jakebailey): add test for this case from https://github.com/microsoft/DefinitelyTyped-tools/pull/773
+
+    commentsMatching(context.getSourceCode(), /<reference\s+types\s*=\s*"(.+)"\s*\/>/, (ref, comment) => {
+      if (devDeps.includes(ref)) {
+        report(comment, "noReferenceOfDevDependencies");
+      }
+    });
+
+    return {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      ImportDeclaration(node) {
+        if (devDeps.includes(node.source.value)) {
+          context.report({
+            messageId: "noImportOfDevDependencies",
+            node,
+          });
+        }
+      },
+    };
+
     function report(comment: TSESTree.Comment, messageId: MessageId) {
       context.report({
         loc: {
@@ -77,24 +77,5 @@ const rule = createRule({
     }
   },
 });
-function getPackageJson(
-  sourceFile: string
-): { dependencies?: Record<string, string>; devDependencies: Record<string, string> } | undefined {
-  let dir = path.dirname(sourceFile);
-  let text: string | undefined;
-  while (dir !== "/") {
-    try {
-      text = fs.readFileSync(path.join(dir, "package.json"), "utf8");
-      break;
-    } catch {
-      // presumably because file does not exist, so continue
-    }
-    dir = path.dirname(dir);
-  }
-  if (!text) return undefined;
-  const json = JSON.parse(text);
-  if ("devDependencies" in json) return json;
-  return undefined;
-}
 
 export = rule;

package/src/rules/no-old-dt-header.ts

@@ -1,3 +1,4 @@
+import { isDeclarationPath } from "@definitelytyped/utils";
 import { createRule } from "../util";
 
 const rule = createRule({
@@ -18,7 +19,7 @@ const rule = createRule({
   create(context) {
     const text = context.getSourceCode().text;
     if (
-      context.getFilename().endsWith(".d.ts") &&
+      isDeclarationPath(context.getFilename()) &&
       text.indexOf("// Type definitions for ") === 0 &&
       text.indexOf("// Definitions by: ") > 0
     ) {

package/src/rules/no-relative-import-in-test.ts

@@ -1,6 +1,7 @@
 import { ESLintUtils } from "@typescript-eslint/utils";
 import * as ts from "typescript";
 import { createRule } from "../util";
+import { isDeclarationPath } from "@definitelytyped/utils";
 
 const rule = createRule({
   name: "no-relative-import-in-test",
@@ -18,11 +19,7 @@ const rule = createRule({
     schema: [],
   },
   create(context) {
-    if (
-      context.getFilename().endsWith(".d.ts") ||
-      context.getFilename().endsWith(".d.mts") ||
-      context.getFilename().endsWith(".d.cts")
-    ) {
+    if (isDeclarationPath(context.getFilename())) {
       return {};
     }
 

package/src/rules/no-self-import.ts

@@ -17,6 +17,9 @@ const rule = createRule({
   },
   create(context) {
     const packageName = getTypesPackageForDeclarationFile(context.getFilename());
+    if (!packageName) {
+      return {};
+    }
 
     return {
       // eslint-disable-next-line @typescript-eslint/naming-convention

package/src/rules/prefer-declare-function.ts

@@ -1,6 +1,7 @@
 import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
 
 import { createRule } from "../util";
+import { isDeclarationPath } from "@definitelytyped/utils";
 
 const rule = createRule({
   defaultOptions: [],
@@ -22,7 +23,7 @@ const rule = createRule({
       "VariableDeclaration > VariableDeclarator"(node: TSESTree.VariableDeclarator) {
         if (
           node.id.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES.TSFunctionType &&
-          context.getFilename().endsWith(".d.ts")
+          isDeclarationPath(context.getFilename())
         ) {
           context.report({
             messageId: "variableFunction",