@definitelytyped/eslint-plugin 0.0.179 → 0.0.181

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

@@ -1,15 +1,14 @@
 import { TSESTree } from "@typescript-eslint/utils";
-import { createRule } from "../util";
-
-type MessageId = "referencePathPackage" | "referencePathTest";
+import { commentsMatching, createRule } from "../util";
 
+type MessageId = "referencePathPackage" | "referencePathTest" | "referencePathOldVersion";
 const rule = createRule({
   name: "no-bad-reference",
   defaultOptions: [],
   meta: {
     type: "problem",
     docs: {
-      description: `Forbids <reference path="../etc"/> in any file, and forbid <reference path> in test files.`,
+      description: `Forbids <reference path="./vNN"/> in all files, <reference path="../etc"/> in declaration files, and all <reference path> in test files.`,
       recommended: "error",
     },
     messages: {
@@ -17,27 +16,24 @@ const rule = createRule({
         "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.",
     },
     schema: [],
   },
   create(context) {
-    const { comments } = context.getSourceCode().ast;
     const isDeclarationFile = context.getFilename().endsWith(".d.ts");
-
-    for (const comment of comments) {
-      const referenceMatch = comment.value.match(/<reference\s+path\s*=\s*"(.+)"\s*\/>/)?.[1];
-      if (!referenceMatch) {
-        continue;
+    commentsMatching(context.getSourceCode(), /<reference\s+path\s*=\s*"(.+)"\s*\/>/, (ref, comment) => {
+      if (ref.match(/^\.\/v\d+(?:\.\d+)?(?:\/.*)?$/)) {
+        report(comment, "referencePathOldVersion");
       }
-
       if (isDeclarationFile) {
-        if (referenceMatch.startsWith("..")) {
+        if (ref.startsWith("..")) {
           report(comment, "referencePathPackage");
         }
       } else {
         report(comment, "referencePathTest");
       }
-    }
+    });
 
     return {};
 

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

@@ -0,0 +1,84 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import { createRule, commentsMatching, getTypesPackageForDeclarationFile } from "../util";
+import fs from "fs";
+import path from "path";
+
+type MessageId = "noImportOfDevDependencies" | "noReferenceOfDevDependencies";
+const rule = createRule({
+  name: "no-import-of-dev-dependencies",
+  defaultOptions: [],
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Forbid imports and references to devDependencies inside .d.ts files.",
+      recommended: "error",
+    },
+    messages: {
+      noImportOfDevDependencies: `.d.ts files may not import packages in devDependencies.`,
+      noReferenceOfDevDependencies: `.d.ts files may not triple-slash reference packages in devDependencies.`,
+    },
+    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) => dep.replace(/@types\//, ""))
+        : [];
+      commentsMatching(context.getSourceCode(), /<reference\s+types\s*=\s*"(.+)"\s*\/>/, (ref, comment) => {
+        if (devdeps.includes(ref) && ref !== packageName) {
+          report(comment, "noReferenceOfDevDependencies");
+        }
+      });
+
+      return {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        ImportDeclaration(node) {
+          if (devdeps.includes(node.source.value) && node.source.value !== packageName) {
+            context.report({
+              messageId: "noImportOfDevDependencies",
+              node,
+            });
+          }
+        },
+      };
+    } else {
+      return {};
+    }
+    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,
+      });
+    }
+  },
+});
+function getPackageJson(sourceFile: 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

@@ -0,0 +1,40 @@
+import { createRule } from "../util";
+
+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.`,
+      recommended: "error",
+    },
+    messages: {
+      noOldDTHeader:
+        "Specify package metadata in package.json. Do not use a header like `// Type definitions for foo 1.2`",
+    },
+    schema: [],
+  },
+  create(context) {
+    const text = context.getSourceCode().text;
+    if (
+      context.getFilename().endsWith(".d.ts") &&
+      text.indexOf("// Type definitions for ") === 0 &&
+      text.indexOf("// Definitions by: ") > 0
+    ) {
+      context.report({
+        messageId: "noOldDTHeader",
+        loc: {
+          start: { column: 0, line: 1 },
+          end: {
+            column: "// Type definitions for ".length,
+            line: 1,
+          },
+        },
+      });
+    }
+    return {};
+  },
+});
+
+export = rule;

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

@@ -1,16 +1,17 @@
 import { createRule, getTypesPackageForDeclarationFile } from "../util";
-
 const rule = createRule({
   name: "no-self-import",
   defaultOptions: [],
   meta: {
     type: "problem",
     docs: {
-      description: "Forbids declaration files to import the current package using a global import.",
+      description:
+        "Forbids declaration files to import the current package using a global import or old versions with a relative import.",
       recommended: "error",
     },
     messages: {
       useRelativeImport: "Declaration file should not use a global import of itself. Use a relative import.",
+      useOnlyCurrentVersion: "Don't import an old version of the current package.",
     },
     schema: [],
   },
@@ -25,6 +26,11 @@ const rule = createRule({
             messageId: "useRelativeImport",
             node,
           });
+        } else if (node.source.value.match(/^\.\/v\d+(?:\.\d+)?(?:\/.*)?$/)) {
+          context.report({
+            messageId: "useOnlyCurrentVersion",
+            node,
+          });
         }
       },
     };

package/src/rules/no-single-declare-module.ts

@@ -0,0 +1,58 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import * as ts from "typescript";
+
+import { createRule } from "../util";
+
+const rule = createRule({
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Don't use an ambient module declaration if there's just one -- write it as a normal module.",
+      recommended: "error",
+    },
+    messages: {
+      oneModuleDeclaration:
+        "File has only 1 ambient module declaration. Move the contents outside the ambient module block, rename the file to match the ambient module name, and remove the block.",
+    },
+    schema: [],
+    type: "problem",
+  },
+  name: "no-single-declare-module",
+  create(context) {
+    const services = ESLintUtils.getParserServices(context);
+    const sourceFile = services.esTreeNodeToTSNodeMap.get(context.getSourceCode().ast);
+
+    // If it's an external module, any module declarations inside are augmentations.
+    if (ts.isExternalModule(sourceFile)) {
+      return {};
+    }
+
+    let moduleDeclaration: ts.ModuleDeclaration | undefined;
+    for (const statement of sourceFile.statements) {
+      if (ts.isModuleDeclaration(statement) && ts.isStringLiteral(statement.name)) {
+        if (statement.name.text.indexOf("*") !== -1) {
+          // Ignore wildcard module declarations
+          return {};
+        }
+
+        if (moduleDeclaration === undefined) {
+          moduleDeclaration = statement;
+        } else {
+          // Has more than 1 declaration
+          return {};
+        }
+      }
+    }
+
+    if (moduleDeclaration) {
+      context.report({
+        messageId: "oneModuleDeclaration",
+        node: services.tsNodeToESTreeNodeMap.get(moduleDeclaration),
+      });
+    }
+
+    return {};
+  },
+});
+
+export = rule;

package/src/rules/no-useless-files.ts

@@ -1,4 +1,4 @@
-import { createRule } from "../util";
+import { commentsMatching, createRule } from "../util";
 
 const rule = createRule({
   name: "no-useless-files",
@@ -25,15 +25,9 @@ const rule = createRule({
       } else {
         const referenceRegExp = /^\/\s*<reference\s*(types|path)\s*=\s*["|'](.*)["|']/;
         let noReferenceFound = true;
-
-        for (const comment of comments) {
-          const referenceMatch = comment.value.match(referenceRegExp)?.[1];
-          if (!referenceMatch) {
-            continue;
-          }
+        commentsMatching(context.getSourceCode(), referenceRegExp, () => {
           noReferenceFound = false;
-          break;
-        }
+        });
 
         if (noReferenceFound) {
           reportNoContent();

package/src/util.ts

@@ -1,7 +1,7 @@
 import { unmangleScopedPackage } from "@definitelytyped/utils";
-import { ESLintUtils } from "@typescript-eslint/utils";
+import { TSESTree, ESLintUtils } from "@typescript-eslint/utils";
 import { RuleWithMetaAndName } from "@typescript-eslint/utils/dist/eslint-utils";
-import { RuleListener, RuleModule } from "@typescript-eslint/utils/dist/ts-eslint";
+import { RuleListener, RuleModule, SourceCode } from "@typescript-eslint/utils/dist/ts-eslint";
 import { basename, dirname } from "path";
 
 // Possible TS bug can't figure out how to do declaration emit of created rules
@@ -46,3 +46,14 @@ export function isMainFile(fileName: string, allowNested: boolean) {
   // Allow "types/foo/index.d.ts", not "types/foo/utils/index.d.ts"
   return basename(dirname(parent)) === "types";
 }
+
+export function commentsMatching(
+  sourceFile: Readonly<SourceCode>,
+  regex: RegExp,
+  f: (match: string, c: TSESTree.Comment) => void
+): void {
+  for (const comment of sourceFile.ast.comments) {
+    const m = comment.value.match(regex);
+    if (m) f(m[1], comment);
+  }
+}

package/test/no-bad-reference.test.ts

@@ -44,6 +44,66 @@ ruleTester.run("@definitelytyped/no-bad-reference", noBadReference, {
       ],
       filename: "types.d.ts",
     },
+    {
+      code: `/// <reference path="./v11" />`,
+      errors: [
+        {
+          column: 20,
+          endColumn: 25,
+          line: 1,
+          messageId: "referencePathOldVersion",
+        },
+      ],
+      filename: "types.d.ts",
+    },
+    {
+      code: `/// <reference path="./v11/index" />`,
+      errors: [
+        {
+          column: 20,
+          endColumn: 31,
+          line: 1,
+          messageId: "referencePathOldVersion",
+        },
+      ],
+      filename: "types.d.ts",
+    },
+    {
+      code: `/// <reference path="./v11/subdir/file" />`,
+      errors: [
+        {
+          column: 20,
+          endColumn: 37,
+          line: 1,
+          messageId: "referencePathOldVersion",
+        },
+      ],
+      filename: "types.d.ts",
+    },
+    {
+      code: `/// <reference path="./v0.1" />`,
+      errors: [
+        {
+          column: 20,
+          endColumn: 26,
+          line: 1,
+          messageId: "referencePathOldVersion",
+        },
+      ],
+      filename: "types.d.ts",
+    },
+    {
+      code: `/// <reference path="./v0.1/index" />`,
+      errors: [
+        {
+          column: 20,
+          endColumn: 32,
+          line: 1,
+          messageId: "referencePathOldVersion",
+        },
+      ],
+      filename: "types.d.ts",
+    },
   ],
   valid: [
     ``,
@@ -57,6 +117,14 @@ ruleTester.run("@definitelytyped/no-bad-reference", noBadReference, {
       code: `/// <reference path="./other" />`,
       filename: "types.d.ts",
     },
+    {
+      code: `/// <reference path="./v1gardenpath" />`,
+      filename: "types.d.ts",
+    },
+    {
+      code: `/// <reference path="./v1verb/other" />`,
+      filename: "types.d.ts",
+    },
     {
       code: `/// <reference path="other" />
 /// <reference path="other2" />`,

package/test/no-import-of-dev-dependencies.test.ts

@@ -0,0 +1,72 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as noImportDefaultOfDevDependencies from "../src/rules/no-import-of-dev-dependencies";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: 2018,
+  },
+});
+
+ruleTester.run("@definitelytyped/no-import-of-dev-dependencies", noImportDefaultOfDevDependencies, {
+  invalid: [
+    {
+      filename: "index.d.ts",
+      code: `import eslint from "eslint"`,
+      errors: [
+        {
+          line: 1,
+          messageId: "noImportOfDevDependencies",
+        },
+      ],
+    },
+    // test @types/ removal
+    {
+      filename: "index.d.ts",
+      code: `import yargs from "yargs"`,
+      errors: [
+        {
+          line: 1,
+          messageId: "noImportOfDevDependencies",
+        },
+      ],
+    },
+    {
+      filename: "index.d.ts",
+      code: `/// <reference types="node" />`,
+      errors: [
+        {
+          line: 1,
+          messageId: "noReferenceOfDevDependencies",
+        },
+      ],
+    },
+  ],
+  valid: [
+    {
+      filename: "index.d.ts",
+      code: `import other from 'other'`,
+    },
+    {
+      filename: "types/yargs/index.d.ts",
+      code: `import self from "yargs"`,
+    },
+    {
+      filename: "index.d.ts",
+      code: `/// <reference types="other"/>`,
+    },
+    {
+      filename: "test.ts",
+      code: `import eslint from "eslint"`,
+    },
+    {
+      filename: "test.ts",
+      code: `import yargs from "yargs"`,
+    },
+    {
+      filename: "test.ts",
+      code: `/// <reference types="node" />`,
+    },
+  ],
+});

package/test/no-old-dt-header.test.ts

@@ -0,0 +1,71 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+import * as noOldDtHeader from "../src/rules/no-old-dt-header";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+});
+
+ruleTester.run("@definitelytyped/no-old-dt-header", noOldDtHeader, {
+  invalid: [
+    {
+      code: `// Type definitions for AFRAME 1.2
+// Project: https://aframe.io/
+// Definitions by: Paul Shannon <https://github.com/devpaul>
+//                 Roberto Ritger <https://github.com/bertoritger>
+//                 Trygve Wastvedt <https://github.com/twastvedt>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 4.4
+
+/**
+ * Extended tests and examples available at https://github.com/devpaul/aframe-experiments.git
+ */
+
+import * as anime from "animejs";
+import * as three from "three";`,
+      errors: [
+        {
+          column: 1,
+          endColumn: 25,
+          line: 1,
+          messageId: "noOldDTHeader",
+        },
+      ],
+      filename: "index.d.ts",
+    },
+    {
+      code: `// Type definitions for AFRAME 1.2
+// Definitions by: Paul Shannon <https://github.com/devpaul>`,
+      errors: [
+        {
+          column: 1,
+          endColumn: 25,
+          line: 1,
+          messageId: "noOldDTHeader",
+        },
+      ],
+      filename: "types.d.ts",
+    },
+  ],
+  valid: [
+    {
+      code: `// Type definitions for AFRAME 1.2
+// Definitions by: Paul Shannon <https://github.com/devpaul>`,
+      filename: "test.ts",
+    },
+    {
+      code: `// Type definitions for AFRAME 1.2`,
+      filename: "types.d.ts",
+    },
+    {
+      code: `// Definitions by: Paul Shannon <https://github.com/devpaul>`,
+      filename: "types.d.ts",
+    },
+    {
+      code: `// A line before the old header
+      // Type definitions for AFRAME 1.2
+// Definitions by: Paul Shannon <https://github.com/devpaul>`,
+      filename: "types.d.ts",
+    },
+  ],
+});

package/test/no-self-import.test.ts

@@ -28,6 +28,66 @@ ruleTester.run("@definitelytyped/no-self-import", dtHeader, {
       ],
       filename: "types/this-package/index.d.ts",
     },
+    {
+      code: `import old from "./v11"`,
+      errors: [
+        {
+          column: 1,
+          endColumn: 24,
+          line: 1,
+          messageId: "useOnlyCurrentVersion",
+        },
+      ],
+      filename: "types.d.ts",
+    },
+    {
+      code: `import old from "./v11/index"`,
+      errors: [
+        {
+          column: 1,
+          endColumn: 30,
+          line: 1,
+          messageId: "useOnlyCurrentVersion",
+        },
+      ],
+      filename: "types.d.ts",
+    },
+    {
+      code: `import old from "./v11/subdir/file"`,
+      errors: [
+        {
+          column: 1,
+          endColumn: 36,
+          line: 1,
+          messageId: "useOnlyCurrentVersion",
+        },
+      ],
+      filename: "types.d.ts",
+    },
+    {
+      code: `import old from "./v0.1"`,
+      errors: [
+        {
+          column: 1,
+          endColumn: 25,
+          line: 1,
+          messageId: "useOnlyCurrentVersion",
+        },
+      ],
+      filename: "types.d.ts",
+    },
+    {
+      code: `import old from "./v0.1/index"`,
+      errors: [
+        {
+          column: 1,
+          endColumn: 31,
+          line: 1,
+          messageId: "useOnlyCurrentVersion",
+        },
+      ],
+      filename: "types.d.ts",
+    },
   ],
   valid: [
     {
@@ -42,5 +102,13 @@ ruleTester.run("@definitelytyped/no-self-import", dtHeader, {
       code: `import myself from "this-package";`,
       filename: "types/grandparent/this-package/index.d.ts",
     },
+    {
+      code: `import old from "./v1gardenpath"`,
+      filename: "types.d.ts",
+    },
+    {
+      code: `import old from "./v1verb/other"`,
+      filename: "types.d.ts",
+    },
   ],
 });

package/test/no-single-declare-module.test.ts

@@ -0,0 +1,50 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import path from "path";
+
+import rule from "../src/rules/no-single-declare-module";
+
+const ruleTester = new ESLintUtils.RuleTester({
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    tsconfigRootDir: __dirname,
+    project: "./tsconfig.no-single-declare-module.json",
+  },
+});
+
+ruleTester.run("no-single-declare-module", rule, {
+  invalid: [
+    {
+      code: `
+        declare module "foo" {}
+
+        // Other global declarations don't affect this. They should go in "declare global".
+        interface I {}
+      `,
+      errors: [
+        {
+          line: 2,
+          messageId: "oneModuleDeclaration",
+        },
+      ],
+    },
+  ],
+  valid: [
+    {
+      code: `
+        import x from "x";
+        declare module "foo" {}
+      `,
+    },
+    {
+      code: `
+        declare module "foo" {}
+        declare module "bar" {}      
+      `,
+    },
+    {
+      code: `
+        declare module "*.svg" {}
+      `,
+    },
+  ],
+});

package/test/tsconfig.no-single-declare-module.json

@@ -0,0 +1,7 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "esnext"
+  },
+  "files": ["file.ts"]
+}