@definitelytyped/eslint-plugin 0.0.202 → 0.0.204

package/src/rules/no-any-union.ts

@@ -1,33 +0,0 @@
-import { createRule } from "../util";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
-const rule = createRule({
-  name: "no-any-union",
-  defaultOptions: [],
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Forbid a union to contain `any`",
-    },
-    messages: {
-      anyUnion: "Including `any` in a union will override all other members of the union.",
-    },
-    schema: [],
-  },
-  create(context) {
-    return {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      TSUnionType(node) {
-        const hasAnyType = node.types.some((t) => t.type === AST_NODE_TYPES.TSAnyKeyword);
-        if (hasAnyType) {
-          context.report({
-            messageId: "anyUnion",
-            node,
-          });
-        }
-      },
-    };
-  },
-});
-
-export = rule;

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

@@ -1,199 +0,0 @@
-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;
-}
-
-const rule = createRule({
-  name: "no-bad-reference",
-  defaultOptions: [],
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Forbids bad references, including those that resolve outside of the package or path references in non-declaration files.",
-    },
-    messages: {
-      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 containingFileName = context.filename;
-    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.sourceCode.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 {
-        context.report({
-          messageId: "testReference",
-          loc: tsRangeToESLintLocation(ref),
-          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: { pos: ref.getStart(), end: ref.getEnd() } });
-      }
-    }
-
-    for (const ref of refs) {
-      if (ref.text.includes("\\")) {
-        context.report({
-          messageId: "backslashes",
-          loc: tsRangeToESLintLocation(ref.range),
-        });
-      }
-
-      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),
-              data: { text: ref.text },
-            });
-          }
-        }
-
-        continue;
-      }
-
-      context.report({
-        messageId: ref.kind === "import" ? "importOutside" : "referenceOutside",
-        loc: tsRangeToESLintLocation(ref.range),
-        data: { text: ref.text },
-      });
-    }
-
-    return {};
-
-    function tsRangeToESLintLocation(range: ts.TextRange): TSESTree.SourceLocation {
-      return {
-        // line is 1 indexed, but column is 0 indexed. >.<
-        start: context.sourceCode.getLocFromIndex(range.pos),
-        end: context.sourceCode.getLocFromIndex(range.end),
-      };
-    }
-  },
-});
-
-/**
- * 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-const-enum.ts

@@ -1,31 +0,0 @@
-import { createRule } from "../util";
-
-const rule = createRule({
-  name: "no-const-enum",
-  defaultOptions: [],
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Forbid `const enum`",
-    },
-    messages: {
-      constEnum: "Use of `const enum` is forbidden.",
-    },
-    schema: [],
-  },
-  create(context) {
-    return {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      TSEnumDeclaration(node) {
-        if (node.const) {
-          context.report({
-            messageId: "constEnum",
-            node,
-          });
-        }
-      },
-    };
-  },
-});
-
-export = rule;

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

@@ -1,47 +0,0 @@
-import { createRule } from "../util";
-
-const rule = createRule({
-  name: "no-dead-reference",
-  defaultOptions: [],
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Ensures that all `/// <reference>` comments go at the top of the file.",
-    },
-    messages: {
-      referenceAtTop: "`/// <reference>` directive must be at top of file to take effect.",
-    },
-    schema: [],
-  },
-  create(context) {
-    const source = context.sourceCode;
-    if (source.ast.body.length) {
-      // 'm' flag makes it multiline, so `^` matches the beginning of any line.
-      // 'g' flag lets us set rgx.lastIndex
-      const rgx = /^\s*(\/\/\/ <reference.*)/gm;
-
-      // Start search at the first statement. (`/// <reference>` before that is OK.)
-      rgx.lastIndex = source.ast.body[0].range?.[0] ?? 0;
-
-      while (true) {
-        const match = rgx.exec(source.text);
-        if (match === null) {
-          break;
-        }
-
-        const length = match[1].length;
-        const start = match.index + match[0].length - length;
-        context.report({
-          messageId: "referenceAtTop",
-          loc: {
-            start: source.getLocFromIndex(start),
-            end: source.getLocFromIndex(start + match[1].length),
-          },
-        });
-      }
-    }
-    return {};
-  },
-});
-
-export = rule;

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

@@ -1,45 +0,0 @@
-import { createRule, getTypesPackageForDeclarationFile } from "../util";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-
-const rule = createRule({
-  name: "no-declare-current-package",
-  defaultOptions: [],
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Don't use an ambient module declaration of the current package; use a normal module.",
-    },
-    messages: {
-      noDeclareCurrentPackage:
-        `Instead of declaring a module with \`declare module "{{ text }}"\`, ` +
-        `write its contents in directly in {{ preferred }}.`,
-    },
-    schema: [],
-  },
-  create(context) {
-    const packageName = getTypesPackageForDeclarationFile(context.filename);
-    if (!packageName) {
-      return {};
-    }
-
-    return {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      TSModuleDeclaration(node) {
-        if (
-          node.id.type === AST_NODE_TYPES.Literal &&
-          (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"`;
-          context.report({
-            messageId: "noDeclareCurrentPackage",
-            data: { text, preferred },
-            node: node.id,
-          });
-        }
-      },
-    };
-  },
-});
-
-export = rule;

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

@@ -1,68 +0,0 @@
-import { isDeclarationPath } from "@definitelytyped/utils";
-import { createRule } from "../util";
-import { ESLintUtils } from "@typescript-eslint/utils";
-import * as ts from "typescript";
-
-const rule = createRule({
-  name: "no-import-default-of-export-equals",
-  defaultOptions: [],
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Forbid a default import to reference an `export =` module.",
-    },
-    messages: {
-      noImportDefaultOfExportEquals: `The module {{moduleName}} uses \`export = \`. Import with \`import {{importName}} = require({{moduleName}})\`.`,
-    },
-    schema: [],
-  },
-  create(context) {
-    const parserServices = ESLintUtils.getParserServices(context);
-    const checker = parserServices.program.getTypeChecker();
-    if (isDeclarationPath(context.filename)) {
-      return {
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        ImportDeclaration(node) {
-          const defaultName = node.specifiers.find((spec) => spec.type === "ImportDefaultSpecifier")?.local;
-          if (!defaultName) {
-            return;
-          }
-          const importName = defaultName.name;
-          const source = parserServices.esTreeNodeToTSNodeMap.get(node.source);
-          const sym = checker.getSymbolAtLocation(source);
-          if (
-            sym?.declarations?.some(
-              (d) => getStatements(d)?.some((s) => ts.isExportAssignment(s) && !!s.isExportEquals),
-            )
-          ) {
-            context.report({
-              messageId: "noImportDefaultOfExportEquals",
-              data: { moduleName: node.source.value, importName },
-              node: defaultName,
-            });
-          }
-        },
-      };
-    } else {
-      return {};
-    }
-  },
-});
-
-function getStatements(decl: ts.Declaration): readonly ts.Statement[] | undefined {
-  return ts.isSourceFile(decl)
-    ? decl.statements
-    : ts.isModuleDeclaration(decl)
-      ? getModuleDeclarationStatements(decl)
-      : undefined;
-}
-
-function getModuleDeclarationStatements(node: ts.ModuleDeclaration): readonly ts.Statement[] | undefined {
-  let { body } = node;
-  while (body && body.kind === ts.SyntaxKind.ModuleDeclaration) {
-    body = body.body;
-  }
-  return body && ts.isModuleBlock(body) ? body.statements : undefined;
-}
-
-export = rule;

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

@@ -1,93 +0,0 @@
-import { TSESTree } from "@typescript-eslint/utils";
-import { createRule, commentsMatching, findTypesPackage, getImportSource } from "../util";
-import { isDeclarationPath, isTypesPackageName, typesPackageNameToRealName } from "@definitelytyped/utils";
-
-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.",
-    },
-    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) {
-    if (!isDeclarationPath(context.filename)) {
-      return {};
-    }
-
-    const info = findTypesPackage(context.filename);
-    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.sourceCode, /<reference\s+types\s*=\s*"(.+)"\s*\/>/, (ref, comment) => {
-      if (devDeps.includes(ref)) {
-        report(comment, "noReferenceOfDevDependencies");
-      }
-    });
-
-    function lint(node: TSESTree.ImportDeclaration | TSESTree.TSImportEqualsDeclaration) {
-      const source = getImportSource(node);
-      if (!source) {
-        return;
-      }
-
-      if (devDeps.includes(source.value)) {
-        context.report({
-          messageId: "noImportOfDevDependencies",
-          node,
-        });
-      }
-    }
-
-    return {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      ImportDeclaration(node) {
-        lint(node);
-      },
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      TSImportEqualsDeclaration(node) {
-        lint(node);
-      },
-    };
-
-    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,
-      });
-    }
-  },
-});
-
-export = rule;

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

@@ -1,40 +0,0 @@
-import { isDeclarationPath } from "@definitelytyped/utils";
-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.`,
-    },
-    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.sourceCode.text;
-    if (
-      isDeclarationPath(context.filename) &&
-      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-relative-import-in-test.ts

@@ -1,72 +0,0 @@
-import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
-import * as ts from "typescript";
-import { createRule, getImportSource } from "../util";
-import { isDeclarationPath } from "@definitelytyped/utils";
-
-const rule = createRule({
-  name: "no-relative-import-in-test",
-  defaultOptions: [],
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Forbids test (non-declaration) files to use relative imports.",
-    },
-    messages: {
-      useGlobalImport:
-        "Test file should not use a relative import. Use a global import as if this were a user of the package.",
-    },
-    schema: [],
-  },
-  create(context) {
-    if (isDeclarationPath(context.filename)) {
-      return {};
-    }
-
-    const services = ESLintUtils.getParserServices(context);
-    const checker = services.program.getTypeChecker();
-
-    function lint(node: TSESTree.ImportDeclaration | TSESTree.TSImportEqualsDeclaration) {
-      const source = getImportSource(node);
-      if (!source) {
-        return;
-      }
-
-      if (!source.value.startsWith(".")) {
-        return;
-      }
-
-      const moduleSymbol = checker.getSymbolAtLocation(services.esTreeNodeToTSNodeMap.get(source));
-      if (!moduleSymbol) {
-        // TODO(jakebailey): generally speaking, this should be an error; you can't import a non-module.
-        return;
-      }
-
-      if (!moduleSymbol.declarations) {
-        return;
-      }
-
-      for (const declaration of moduleSymbol.declarations) {
-        if (ts.isSourceFile(declaration) && declaration.isDeclarationFile) {
-          context.report({
-            messageId: "useGlobalImport",
-            node: source,
-          });
-          return;
-        }
-      }
-    }
-
-    return {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      ImportDeclaration(node) {
-        lint(node);
-      },
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      TSImportEqualsDeclaration(node) {
-        lint(node);
-      },
-    };
-  },
-});
-
-export = rule;

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

@@ -1,56 +0,0 @@
-import { TSESTree } from "@typescript-eslint/utils";
-import { createRule, getImportSource, 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 or old versions with a relative import.",
-    },
-    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: [],
-  },
-  create(context) {
-    const packageName = getTypesPackageForDeclarationFile(context.filename);
-    if (!packageName) {
-      return {};
-    }
-
-    function lint(node: TSESTree.ImportDeclaration | TSESTree.TSImportEqualsDeclaration) {
-      const source = getImportSource(node);
-      if (!source) {
-        return;
-      }
-
-      if (source.value === packageName || source.value.startsWith(packageName + "/")) {
-        context.report({
-          messageId: "useRelativeImport",
-          node,
-        });
-      } else if (source.value.match(/^\.\/v\d+(?:\.\d+)?(?:\/.*)?$/)) {
-        context.report({
-          messageId: "useOnlyCurrentVersion",
-          node,
-        });
-      }
-    }
-
-    return {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      ImportDeclaration(node) {
-        lint(node);
-      },
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      TSImportEqualsDeclaration(node) {
-        lint(node);
-      },
-    };
-  },
-});
-
-export = rule;