@definitelytyped/eslint-plugin 0.0.202 → 0.0.204

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

@@ -1,57 +0,0 @@
-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.",
-    },
-    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.sourceCode.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.name),
-      });
-    }
-
-    return {};
-  },
-});
-
-export = rule;

package/src/rules/no-single-element-tuple-type.ts

@@ -1,30 +0,0 @@
-import { createRule } from "../util";
-import { TSESTree } from "@typescript-eslint/utils";
-
-const rule = createRule({
-  name: "no-single-element-tuple-type",
-  defaultOptions: [],
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Forbids `[T]`, which should be `T[]`.",
-    },
-    messages: {
-      singleElementTupleType: `Type [T] is a single-element tuple type. You probably meant T[].`,
-    },
-    schema: [],
-  },
-  create(context) {
-    return {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      "TSTupleType[elementTypes.length=1]"(node: TSESTree.TSTupleType) {
-        context.report({
-          messageId: "singleElementTupleType",
-          node,
-        });
-      },
-    };
-  },
-});
-
-export = rule;

package/src/rules/no-unnecessary-generics.ts

@@ -1,119 +0,0 @@
-import { ESLintUtils, TSESTree } from "@typescript-eslint/utils";
-import * as ts from "typescript";
-
-import { createRule } from "../util";
-
-type ESTreeFunctionLikeWithTypeParameters = TSESTree.FunctionLike & {
-  typeParameters: {};
-};
-
-type TSSignatureDeclarationWithTypeParameters = ts.SignatureDeclaration & {
-  typeParameters: {};
-};
-
-const rule = createRule({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Forbids signatures using a generic parameter only once.",
-    },
-    messages: {
-      never: "Type parameter {{name}} is never used.",
-      sole: "Type parameter {{name}} is used only once.",
-    },
-    schema: [],
-    type: "problem",
-  },
-  name: "no-unnecessary-generics",
-  create(context) {
-    return {
-      [[
-        "ArrowFunctionExpression[typeParameters]",
-        "FunctionDeclaration[typeParameters]",
-        "FunctionExpression[typeParameters]",
-        "TSCallSignatureDeclaration[typeParameters]",
-        "TSConstructorType[typeParameters]",
-        "TSDeclareFunction[typeParameters]",
-        "TSFunctionType[typeParameters]",
-        "TSMethodSignature[typeParameters]",
-      ].join(", ")](esNode: ESTreeFunctionLikeWithTypeParameters) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const tsNode = parserServices.esTreeNodeToTSNodeMap.get(esNode) as TSSignatureDeclarationWithTypeParameters;
-        if (!tsNode.typeParameters) {
-          return;
-        }
-
-        const checker = parserServices.program.getTypeChecker();
-
-        for (const typeParameter of tsNode.typeParameters) {
-          const result = getSoleUse(tsNode, assertDefined(checker.getSymbolAtLocation(typeParameter.name)), checker);
-
-          if (result === "ok") {
-            continue;
-          }
-
-          context.report({
-            data: { name: typeParameter.name.text },
-            messageId: result,
-            node: parserServices.tsNodeToESTreeNodeMap.get(typeParameter),
-          });
-        }
-      },
-    };
-  },
-});
-
-type Result = "ok" | "never" | "sole";
-
-function getSoleUse(sig: ts.SignatureDeclaration, typeParameterSymbol: ts.Symbol, checker: ts.TypeChecker): Result {
-  const exit = {};
-  let soleUse: ts.Identifier | undefined;
-
-  try {
-    if (sig.typeParameters) {
-      for (const tp of sig.typeParameters) {
-        if (tp.constraint) {
-          recur(tp.constraint);
-        }
-      }
-    }
-    for (const param of sig.parameters) {
-      if (param.type) {
-        recur(param.type);
-      }
-    }
-    if (sig.type) {
-      recur(sig.type);
-    }
-  } catch (err) {
-    if (err === exit) {
-      return "ok";
-    }
-    throw err;
-  }
-
-  return soleUse ? "sole" : "never";
-
-  function recur(node: ts.Node): void {
-    if (ts.isIdentifier(node)) {
-      if (checker.getSymbolAtLocation(node) === typeParameterSymbol) {
-        if (soleUse === undefined) {
-          soleUse = node;
-        } else {
-          throw exit;
-        }
-      }
-    } else {
-      node.forEachChild(recur);
-    }
-  }
-}
-
-export = rule;
-
-function assertDefined<T>(value: T | undefined): T {
-  if (value === undefined) {
-    throw new Error("unreachable");
-  }
-  return value;
-}

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

@@ -1,51 +0,0 @@
-import { commentsMatching, createRule } from "../util";
-
-const rule = createRule({
-  name: "no-useless-files",
-  defaultOptions: [],
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Forbids files with no content.",
-    },
-    messages: {
-      noContent: "File has no content.",
-    },
-    schema: [],
-  },
-  create(context) {
-    const {
-      ast: { tokens, comments },
-    } = context.sourceCode;
-
-    if (tokens.length === 0) {
-      if (comments.length === 0) {
-        reportNoContent();
-      } else {
-        const referenceRegExp = /^\/\s*<reference\s*(types|path)\s*=\s*["|'](.*)["|']/;
-        let noReferenceFound = true;
-        commentsMatching(context.sourceCode, referenceRegExp, () => {
-          noReferenceFound = false;
-        });
-
-        if (noReferenceFound) {
-          reportNoContent();
-        }
-      }
-    }
-
-    return {};
-
-    function reportNoContent() {
-      context.report({
-        messageId: "noContent",
-        loc: {
-          start: { line: 1, column: 0 },
-          end: { line: 1, column: 0 },
-        },
-      });
-    }
-  },
-});
-
-export = rule;

package/src/rules/npm-naming/types.ts

@@ -1,14 +0,0 @@
-import { ExportErrorKind, Mode } from "@definitelytyped/dts-critic";
-
-export type CodeRawOptionError = [ExportErrorKind, boolean];
-
-export interface CodeRawOptions {
-  mode: Mode.Code;
-  errors: CodeRawOptionError[];
-}
-
-export interface NameOnlyRawOptions {
-  mode: Mode.NameOnly;
-}
-
-export type NpmNamingOptions = CodeRawOptions | NameOnlyRawOptions;

package/src/rules/npm-naming.ts

@@ -1,211 +0,0 @@
-import {
-  CheckOptions as CriticOptions,
-  dtsCritic as critic,
-  ErrorKind,
-  ExportErrorKind,
-  Mode,
-  parseExportErrorKind,
-  CriticError,
-} from "@definitelytyped/dts-critic";
-
-import { addSuggestion } from "../suggestions";
-import { createRule, isMainFile } from "../util";
-import { CodeRawOptionError, NpmNamingOptions } from "./npm-naming/types";
-
-function parseEnabledErrors(errors: CodeRawOptionError[]): [ExportErrorKind, boolean][] {
-  const enabledChecks: [ExportErrorKind, boolean][] = [];
-  for (const tuple of errors) {
-    const error = parseExportErrorKind(tuple[0]);
-    if (error) {
-      enabledChecks.push([error, tuple[1]]);
-    }
-  }
-  return enabledChecks;
-}
-
-function parseRawOptions(rawOptions: NpmNamingOptions): CriticOptions {
-  switch (rawOptions.mode) {
-    case Mode.Code:
-      return { ...rawOptions, errors: new Map(parseEnabledErrors(rawOptions.errors)) };
-    case Mode.NameOnly:
-      return rawOptions;
-  }
-}
-
-const enabledSuggestions: ExportErrorKind[] = [ErrorKind.JsPropertyNotInDts, ErrorKind.JsSignatureNotInDts];
-
-function toOptionsWithSuggestions(options: CriticOptions): CriticOptions {
-  if (options.mode === Mode.NameOnly) {
-    return options;
-  }
-
-  const optionsWithSuggestions = { mode: options.mode, errors: new Map(options.errors) };
-
-  for (const err of enabledSuggestions) {
-    optionsWithSuggestions.errors.set(err, true);
-  }
-
-  return optionsWithSuggestions;
-}
-
-function eslintDisableOption(error: ErrorKind): string {
-  switch (error) {
-    case ErrorKind.NoMatchingNpmPackage:
-    case ErrorKind.NoMatchingNpmVersion:
-    case ErrorKind.NonNpmHasMatchingPackage:
-      return `"off"`;
-    case ErrorKind.NoDefaultExport:
-    case ErrorKind.NeedsExportEquals:
-    case ErrorKind.JsSignatureNotInDts:
-    case ErrorKind.JsPropertyNotInDts:
-    case ErrorKind.DtsSignatureNotInJs:
-    case ErrorKind.DtsPropertyNotInJs:
-      return JSON.stringify(["error", { mode: Mode.Code, errors: [[error, false]] }]);
-  }
-}
-
-const rule = createRule<[NpmNamingOptions], "error">({
-  name: "npm-naming",
-  defaultOptions: [
-    {
-      mode: Mode.NameOnly,
-    },
-  ],
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Ensure that package name and DefinitelyTyped header match npm package info.",
-    },
-    messages: {
-      error: `{{ error }}
-If you won't fix this error now or you think this error is wrong,
-you can disable this check by adding the following options to your project's .eslintrc.json file under "rules":
-
-    "@definitelytyped/npm-naming": {{ option }}`,
-    },
-    schema: [
-      {
-        oneOf: [
-          {
-            additionalProperties: false,
-            properties: {
-              mode: {
-                type: "string",
-                enum: [Mode.NameOnly],
-              },
-            },
-            type: "object",
-          },
-          {
-            additionalProperties: false,
-            type: "object",
-            properties: {
-              mode: {
-                type: "string",
-                enum: [Mode.Code],
-              },
-              errors: {
-                type: "array",
-                items: {
-                  type: "array",
-                  items: [
-                    {
-                      description: "Name of the check.",
-                      type: "string",
-                      enum: [ErrorKind.NeedsExportEquals, ErrorKind.NoDefaultExport],
-                    },
-                    {
-                      description: "Whether the check is enabled or disabled.",
-                      type: "boolean",
-                    },
-                  ],
-                  minItems: 2,
-                  maxItems: 2,
-                },
-              },
-            },
-          },
-        ],
-      },
-    ],
-  },
-  create(context, [rawOptions]) {
-    if (!isMainFile(context.filename, /*allowNested*/ false)) {
-      return {};
-    }
-
-    const options = parseRawOptions(rawOptions);
-    const optionsWithSuggestions = toOptionsWithSuggestions(options);
-    const diagnostics = critic(context.filename, /* sourcePath */ undefined, optionsWithSuggestions);
-    const errors = filterErrors(diagnostics);
-
-    for (const error of errors) {
-      switch (error.kind) {
-        case ErrorKind.NoMatchingNpmPackage:
-        case ErrorKind.NoMatchingNpmVersion:
-        case ErrorKind.NonNpmHasMatchingPackage:
-        case ErrorKind.DtsPropertyNotInJs:
-        case ErrorKind.DtsSignatureNotInJs:
-        case ErrorKind.JsPropertyNotInDts:
-        case ErrorKind.JsSignatureNotInDts:
-        case ErrorKind.NeedsExportEquals:
-        case ErrorKind.NoDefaultExport:
-          context.report({
-            data: {
-              error: error.message,
-              option: eslintDisableOption(error.kind),
-            },
-            loc: error.position
-              ? {
-                  start: context.sourceCode.getLocFromIndex(error.position.start),
-                  end: context.sourceCode.getLocFromIndex(error.position.start + error.position.length),
-                }
-              : {
-                  end: {
-                    line: 2,
-                    column: 0,
-                  },
-                  start: {
-                    line: 1,
-                    column: 0,
-                  },
-                },
-            messageId: "error",
-          });
-          break;
-      }
-    }
-
-    return {};
-
-    function filterErrors(diagnostics: CriticError[]): CriticError[] {
-      const errors: CriticError[] = [];
-
-      diagnostics.forEach((diagnostic) => {
-        if (isSuggestion(diagnostic)) {
-          addSuggestion(
-            context.filename,
-            "npm-naming",
-            diagnostic.message,
-            diagnostic.position?.start,
-            diagnostic.position?.length,
-          );
-        } else {
-          errors.push(diagnostic);
-        }
-      });
-
-      return errors;
-    }
-
-    function isSuggestion(diagnostic: CriticError): boolean {
-      return (
-        options.mode === Mode.Code &&
-        enabledSuggestions.includes(diagnostic.kind as ExportErrorKind) &&
-        !(options.errors as Map<ErrorKind, boolean>).get(diagnostic.kind)
-      );
-    }
-  },
-});
-
-export = rule;

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

@@ -1,37 +0,0 @@
-import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
-
-import { createRule } from "../util";
-import { isDeclarationPath } from "@definitelytyped/utils";
-
-const rule = createRule({
-  defaultOptions: [],
-  meta: {
-    docs: {
-      description: "Forbids `const x: () => void`.",
-    },
-    messages: {
-      variableFunction: "Use a function declaration instead of a variable of function type.",
-    },
-    schema: [],
-    type: "problem",
-  },
-  name: "prefer-declare-function",
-  create(context) {
-    return {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      "VariableDeclaration > VariableDeclarator"(node: TSESTree.VariableDeclarator) {
-        if (
-          node.id.typeAnnotation?.typeAnnotation.type === AST_NODE_TYPES.TSFunctionType &&
-          isDeclarationPath(context.filename)
-        ) {
-          context.report({
-            messageId: "variableFunction",
-            node: node.id,
-          });
-        }
-      },
-    };
-  },
-});
-
-export = rule;

package/src/rules/redundant-undefined.ts

@@ -1,61 +0,0 @@
-import { createRule } from "../util";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-import { TSESTree } from "@typescript-eslint/types";
-
-const rule = createRule({
-  name: "redundant-undefined",
-  defaultOptions: [],
-  meta: {
-    type: "problem",
-    docs: {
-      description:
-        "Forbids optional parameters from including an explicit `undefined` in their type; requires it in optional properties.",
-    },
-    messages: {
-      redundantUndefined: `Parameter is optional, so no need to include \`undefined\` in the type.`,
-    },
-    schema: [],
-  },
-  create(context) {
-    return {
-      // eslint-disable-next-line @typescript-eslint/naming-convention
-      TSUnionType(node) {
-        const hasUndefinedType = node.types.some((t) => t.type === AST_NODE_TYPES.TSUndefinedKeyword);
-        if (
-          node.parent!.type === AST_NODE_TYPES.TSTypeAnnotation &&
-          isParameter(node.parent!.parent!) &&
-          node.parent.parent.optional &&
-          isFunctionLike(node.parent!.parent!.parent!) &&
-          hasUndefinedType
-        ) {
-          context.report({
-            messageId: "redundantUndefined",
-            node,
-          });
-        }
-      },
-    };
-  },
-});
-
-function isFunctionLike(node: TSESTree.Node): node is TSESTree.FunctionLike {
-  return (
-    node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
-    node.type === AST_NODE_TYPES.FunctionDeclaration ||
-    node.type === AST_NODE_TYPES.FunctionExpression ||
-    node.type === AST_NODE_TYPES.TSDeclareFunction ||
-    node.type === AST_NODE_TYPES.TSEmptyBodyFunctionExpression
-  );
-}
-/** Note: Does not include parameter properties because those can't be optional */
-function isParameter(node: TSESTree.Node): node is Exclude<TSESTree.Parameter, TSESTree.TSParameterProperty> {
-  return (
-    node.type === AST_NODE_TYPES.ArrayPattern ||
-    node.type === AST_NODE_TYPES.AssignmentPattern ||
-    node.type === AST_NODE_TYPES.Identifier ||
-    node.type === AST_NODE_TYPES.ObjectPattern ||
-    node.type === AST_NODE_TYPES.RestElement
-  );
-}
-
-export = rule;