@rotki/eslint-plugin 0.7.0 → 1.1.0

package/dist/index.mjs

@@ -1,10 +1,10 @@
+import { TSESTree } from '@typescript-eslint/utils';
 import createDebug from 'debug';
-import { extname } from 'node:path';
 import * as compat from 'eslint-compat-utils';
+import { extname } from 'node:path';
 import { pascalCase, kebabCase } from 'scule';
-import { TSESTree } from '@typescript-eslint/utils';
 
-const version = "0.7.0";
+const version = "1.1.0";
 const pkg = {
 	version: version};
 
@@ -15,6 +15,63 @@ function getSourceCode(context) {
   return compat.getSourceCode(context);
 }
 
+function createRecommended(plugin, name, flat) {
+  const rules = Object.fromEntries(Object.entries(plugin.rules).filter(([_key, rule]) => rule.meta.recommended === "recommended" && !rule.meta.deprecated).map(([key]) => [`${name}/${key}`, 2]));
+  if (flat) {
+    return {
+      plugins: {
+        [name]: plugin
+      },
+      rules
+    };
+  } else {
+    return {
+      plugins: [name],
+      rules
+    };
+  }
+}
+
+function getStringLiteralValue(node, stringOnly = false) {
+  if (node.type === "Literal") {
+    if (node.value == null) {
+      if (!stringOnly && node.bigint != null)
+        return node.bigint;
+      return null;
+    }
+    if (typeof node.value === "string")
+      return node.value;
+    if (!stringOnly)
+      return String(node.value);
+    return null;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis.length === 1) {
+    return node.quasis[0].value.cooked;
+  }
+  return null;
+}
+function getStaticPropertyName(node) {
+  if (node.type === "Property" || node.type === "MethodDefinition") {
+    if (!node.computed) {
+      const key2 = node.key;
+      if (key2.type === "Identifier")
+        return key2.name;
+    }
+    const key = node.key;
+    return getStringLiteralValue(key);
+  } else if (node.type === "MemberExpression") {
+    if (!node.computed) {
+      const property2 = node.property;
+      if (property2.type === "Identifier")
+        return property2.name;
+      return null;
+    }
+    const property = node.property;
+    return getStringLiteralValue(property);
+  }
+  return null;
+}
+
 const blobUrl = "https://rotki.github.io/eslint-plugin/rules/";
 function RuleCreator(urlCreator) {
   return function createNamedRule({
@@ -77,65 +134,170 @@ function defineTemplateBodyVisitor(context, templateBodyVisitor, scriptVisitor,
   );
 }
 
-function getStringLiteralValue(node, stringOnly = false) {
-  if (node.type === "Literal") {
-    if (node.value == null) {
-      if (!stringOnly && node.bigint != null)
-        return node.bigint;
-      return null;
-    }
-    if (typeof node.value === "string")
-      return node.value;
-    if (!stringOnly)
-      return String(node.value);
-    return null;
-  }
-  if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis.length === 1) {
-    return node.quasis[0].value.cooked;
+const debug$3 = createDebug("@rotki/eslint-plugin:consistent-ref-type-annotation");
+const RULE_NAME$6 = "consistent-ref-type-annotation";
+const FIXABLE_METHODS = ["ref", "computed"];
+function checkAssignmentDeclaration(context, node, declaration, options) {
+  const source = getSourceCode(context);
+  const { allowInference } = options;
+  let declarationTypeArguments;
+  const init = declaration.init;
+  if (!(init && init.type === TSESTree.AST_NODE_TYPES.CallExpression))
+    return;
+  const callee = init.callee;
+  if (!(callee && callee.type === TSESTree.AST_NODE_TYPES.Identifier))
+    return;
+  if (!Array.prototype.includes.call(FIXABLE_METHODS, callee.name))
+    return;
+  const name = callee.name;
+  debug$3(`found ${name}, checking type arguments`);
+  const initializationTypeArguments = init.typeArguments;
+  const typeAnnotation = declaration.id.typeAnnotation;
+  if (typeAnnotation) {
+    const typeNode = typeAnnotation.typeAnnotation;
+    if (typeNode && typeNode.type === TSESTree.AST_NODE_TYPES.TSTypeReference)
+      declarationTypeArguments = typeNode.typeArguments;
   }
-  return null;
-}
-function getStaticPropertyName(node) {
-  if (node.type === "Property" || node.type === "MethodDefinition") {
-    if (!node.computed) {
-      const key2 = node.key;
-      if (key2.type === "Identifier")
-        return key2.name;
-    }
-    const key = node.key;
-    return getStringLiteralValue(key);
-  } else if (node.type === "MemberExpression") {
-    if (!node.computed) {
-      const property2 = node.property;
-      if (property2.type === "Identifier")
-        return property2.name;
-      return null;
+  if (initializationTypeArguments && !declarationTypeArguments)
+    return;
+  debug$3(`generating report for ${name}`);
+  if (!initializationTypeArguments && !declarationTypeArguments) {
+    if (allowInference) {
+      debug$3("type inference is allowed");
+    } else {
+      context.report({
+        data: {
+          name
+        },
+        messageId: "missingType",
+        node
+      });
     }
-    const property = node.property;
-    return getStringLiteralValue(property);
+    return;
   }
-  return null;
+  context.report({
+    data: {
+      name
+    },
+    fix(fixer) {
+      const fixes = [];
+      if (!initializationTypeArguments && callee)
+        fixes.push(fixer.insertTextAfter(callee, source.getText(declarationTypeArguments)));
+      if (typeAnnotation)
+        fixes.push(fixer.remove(typeAnnotation));
+      return fixes;
+    },
+    messageId: "inconsistent",
+    node
+  });
 }
-
-function createRecommended(plugin, name, flat) {
-  const rules = Object.fromEntries(Object.entries(plugin.rules).filter(([_key, rule]) => rule.meta.recommended === "recommended" && !rule.meta.deprecated).map(([key]) => [`${name}/${key}`, 2]));
-  if (flat) {
+const consistentRefTypeAnnotation = createEslintRule({
+  create(context, optionsWithDefault) {
+    const options = optionsWithDefault[0] || {};
+    const allowInference = options.allowInference;
     return {
-      plugins: {
-        [name]: plugin
-      },
-      rules
+      VariableDeclaration: (node) => {
+        const declarations = node.declarations;
+        for (const declaration of declarations) {
+          if (declaration.type !== TSESTree.AST_NODE_TYPES.VariableDeclarator)
+            continue;
+          checkAssignmentDeclaration(context, node, declaration, { allowInference });
+        }
+      }
     };
-  } else {
+  },
+  defaultOptions: [{ allowInference: false }],
+  meta: {
+    docs: {
+      description: "Ensures consistent type annotation position for ref, computed assignments",
+      recommendation: "recommended"
+    },
+    fixable: "code",
+    messages: {
+      inconsistent: `Generic type annotation for the {{ name }} call was not on the right side`,
+      missingType: `variable assignment for {{ name }} is missing the type annotation`
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          allowInference: {
+            type: "boolean"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
+  name: RULE_NAME$6
+});
+
+const RULE_NAME$5 = "max-dependencies";
+const maxDependencies = createEslintRule({
+  create(context, [options]) {
+    let dependencyCount = 0;
+    let firstImportNode = null;
     return {
-      plugins: [name],
-      rules
+      ImportDeclaration(node) {
+        if (!firstImportNode) {
+          firstImportNode = node;
+        }
+        if (options.ignoreTypeImports && node.importKind === "type") {
+          return;
+        }
+        dependencyCount++;
+      },
+      "Program:exit": function() {
+        if (dependencyCount > options.max) {
+          context.report({
+            data: {
+              count: dependencyCount,
+              max: options.max
+            },
+            messageId: "maxDependencies",
+            node: firstImportNode
+          });
+        }
+      }
     };
-  }
-}
+  },
+  defaultOptions: [
+    {
+      ignoreTypeImports: false,
+      max: 20
+    }
+  ],
+  meta: {
+    docs: {
+      description: "enforce a maximum number of dependencies per file",
+      recommendation: "recommended"
+    },
+    messages: {
+      maxDependencies: "Maximum number of dependencies ({{ max }}) exceeded ({{ count }})."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          ignoreTypeImports: {
+            type: "boolean"
+          },
+          max: {
+            minimum: 0,
+            type: "integer"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  },
+  name: RULE_NAME$5
+});
 
-const RULE_NAME$5 = "no-deprecated-classes";
-const debug$3 = createDebug("@rotki/eslint-plugin:no-deprecated-classes");
+const RULE_NAME$4 = "no-deprecated-classes";
+const debug$2 = createDebug("@rotki/eslint-plugin:no-deprecated-classes");
 const replacements$2 = [
   ["d-block", "block"],
   ["d-flex", "flex"],
@@ -187,7 +349,7 @@ function findReplacement(className) {
         return replace(matches);
     }
   }
-  return undefined;
+  return void 0;
 }
 function getRange(node) {
   if (node.type === "VAttribute" && node.value && node.value.range)
@@ -195,7 +357,7 @@ function getRange(node) {
   return node.range;
 }
 function reportReplacement(className, replacement, node, context, position = 1) {
-  debug$3(`found replacement ${replacement} for ${className}`);
+  debug$2(`found replacement ${replacement} for ${className}`);
   const source = getSourceCode(context);
   const initialRange = getRange(node);
   const range = [
@@ -308,11 +470,11 @@ const noDeprecatedClasses = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$5
+  name: RULE_NAME$4
 });
 
-const debug$2 = createDebug("@rotki/eslint-plugin:no-deprecated-components");
-const RULE_NAME$4 = "no-deprecated-components";
+const debug$1 = createDebug("@rotki/eslint-plugin:no-deprecated-components");
+const RULE_NAME$3 = "no-deprecated-components";
 const vuetify = {
   VApp: true,
   VAppBar: true,
@@ -365,7 +527,7 @@ const noDeprecatedComponents = createEslintRule({
           return;
         const replacement = replacements$1[tag];
         if (replacement || legacy && skipInLegacy.includes(tag)) {
-          debug$2(`${tag} has been deprecated`);
+          debug$1(`${tag} has been deprecated`);
           context.report({
             data: {
               name: tag
@@ -374,7 +536,7 @@ const noDeprecatedComponents = createEslintRule({
             node: element
           });
         } else {
-          debug$2(`${tag} has will be removed`);
+          debug$1(`${tag} has will be removed`);
           context.report({
             data: {
               name: tag
@@ -417,11 +579,11 @@ const noDeprecatedComponents = createEslintRule({
     ],
     type: "problem"
   },
-  name: RULE_NAME$4
+  name: RULE_NAME$3
 });
 
-const debug$1 = createDebug("@rotki/eslint-plugin:no-deprecated-props");
-const RULE_NAME$3 = "no-deprecated-props";
+const debug = createDebug("@rotki/eslint-plugin:no-deprecated-props");
+const RULE_NAME$2 = "no-deprecated-props";
 const replacements = {
   RuiRadio: {
     internalValue: "value"
@@ -433,7 +595,7 @@ function hasReplacement(tag) {
 function getPropName(node) {
   if (node.directive) {
     if (node.key.argument?.type !== "VIdentifier")
-      return undefined;
+      return void 0;
     return kebabCase(node.key.argument.rawName);
   }
   return kebabCase(node.key.rawName);
@@ -447,16 +609,16 @@ const noDeprecatedProps = createEslintRule({
         const tag = pascalCase(node.parent.parent.rawName);
         if (!hasReplacement(tag))
           return;
-        debug$1(`${tag} has replacement properties`);
+        debug(`${tag} has replacement properties`);
         const propName = getPropName(node);
         const propNameNode = node.directive ? node.key.argument : node.key;
         if (!propName || !propNameNode) {
-          debug$1("could not get prop name and/or node");
+          debug("could not get prop name and/or node");
           return;
         }
         Object.entries(replacements[tag]).forEach(([prop, replacement]) => {
           if (kebabCase(prop) === propName) {
-            debug$1(`preparing a replacement for ${tag}:${propName} -> ${replacement}`);
+            debug(`preparing a replacement for ${tag}:${propName} -> ${replacement}`);
             context.report({
               data: {
                 prop,
@@ -486,24 +648,27 @@ const noDeprecatedProps = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$3
+  name: RULE_NAME$2
 });
 
-const RULE_NAME$2 = "no-legacy-library-import";
-const legacyLibrary = "@rotki/ui-library-compat";
-const newLibrary = "@rotki/ui-library";
-const noLegacyLibraryImport = createEslintRule({
+const RULE_NAME$1 = "no-dot-ts-imports";
+const noDotTsImport = createEslintRule({
   create(context) {
     return {
       ImportDeclaration(node) {
-        if (!node.source.value.startsWith(legacyLibrary))
+        const importDeclaration = node.source.value;
+        if (!importDeclaration.endsWith(".ts"))
           return;
-        const replacement = node.source.value.replace(legacyLibrary, newLibrary);
+        const lastIndexOfExtension = importDeclaration.lastIndexOf(".ts");
+        const replacement = importDeclaration.substring(0, lastIndexOfExtension);
         context.report({
+          data: {
+            import: importDeclaration
+          },
           fix(fixer) {
             return fixer.replaceText(node.source, `'${replacement}'`);
           },
-          messageId: "replacedWith",
+          messageId: "invalidTSExtension",
           node: node.source
         });
       }
@@ -512,136 +677,34 @@ const noLegacyLibraryImport = createEslintRule({
   defaultOptions: [],
   meta: {
     docs: {
-      description: `Reports and replaces imports of ${legacyLibrary} with ${newLibrary}`,
+      description: "Checks and replaces .ts extension in import statements.",
       recommendation: "recommended"
     },
     fixable: "code",
     messages: {
-      replacedWith: `${legacyLibrary} has been replaced by ${newLibrary}`
+      invalidTSExtension: `'{{ import }}' has a .ts extension, please remove it'`
     },
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$2
-});
-
-const debug = createDebug("@rotki/eslint-plugin:consistent-ref-type-annotation");
-const RULE_NAME$1 = "consistent-ref-type-annotation";
-const FIXABLE_METHODS = ["ref", "computed"];
-function checkAssignmentDeclaration(context, node, declaration, options) {
-  const source = getSourceCode(context);
-  const { allowInference } = options;
-  let declarationTypeArguments;
-  const init = declaration.init;
-  if (!(init && init.type === TSESTree.AST_NODE_TYPES.CallExpression))
-    return;
-  const callee = init.callee;
-  if (!(callee && callee.type === TSESTree.AST_NODE_TYPES.Identifier))
-    return;
-  if (!Array.prototype.includes.call(FIXABLE_METHODS, callee.name))
-    return;
-  const name = callee.name;
-  debug(`found ${name}, checking type arguments`);
-  const initializationTypeArguments = init.typeArguments;
-  const typeAnnotation = declaration.id.typeAnnotation;
-  if (typeAnnotation) {
-    const typeNode = typeAnnotation.typeAnnotation;
-    if (typeNode && typeNode.type === TSESTree.AST_NODE_TYPES.TSTypeReference)
-      declarationTypeArguments = typeNode.typeArguments;
-  }
-  if (initializationTypeArguments && !declarationTypeArguments)
-    return;
-  debug(`generating report for ${name}`);
-  if (!initializationTypeArguments && !declarationTypeArguments) {
-    if (allowInference) {
-      debug("type inference is allowed");
-    } else {
-      context.report({
-        data: {
-          name
-        },
-        messageId: "missingType",
-        node
-      });
-    }
-    return;
-  }
-  context.report({
-    data: {
-      name
-    },
-    fix(fixer) {
-      const fixes = [];
-      if (!initializationTypeArguments && callee)
-        fixes.push(fixer.insertTextAfter(callee, source.getText(declarationTypeArguments)));
-      if (typeAnnotation)
-        fixes.push(fixer.remove(typeAnnotation));
-      return fixes;
-    },
-    messageId: "inconsistent",
-    node
-  });
-}
-const consistentRefTypeAnnotation = createEslintRule({
-  create(context, optionsWithDefault) {
-    const options = optionsWithDefault[0] || {};
-    const allowInference = options.allowInference;
-    return {
-      VariableDeclaration: (node) => {
-        const declarations = node.declarations;
-        for (const declaration of declarations) {
-          if (declaration.type !== TSESTree.AST_NODE_TYPES.VariableDeclarator)
-            continue;
-          checkAssignmentDeclaration(context, node, declaration, { allowInference });
-        }
-      }
-    };
-  },
-  defaultOptions: [{ allowInference: false }],
-  meta: {
-    docs: {
-      description: "Ensures consistent type annotation position for ref, computed assignments",
-      recommendation: "recommended"
-    },
-    fixable: "code",
-    messages: {
-      inconsistent: `Generic type annotation for the {{ name }} call was not on the right side`,
-      missingType: `variable assignment for {{ name }} is missing the type annotation`
-    },
-    schema: [
-      {
-        additionalProperties: false,
-        properties: {
-          allowInference: {
-            type: "boolean"
-          }
-        },
-        type: "object"
-      }
-    ],
-    type: "problem"
-  },
   name: RULE_NAME$1
 });
 
-const RULE_NAME = "no-dot-ts-imports";
-const noDotTsImport = createEslintRule({
+const RULE_NAME = "no-legacy-library-import";
+const legacyLibrary = "@rotki/ui-library-compat";
+const newLibrary = "@rotki/ui-library";
+const noLegacyLibraryImport = createEslintRule({
   create(context) {
     return {
       ImportDeclaration(node) {
-        const importDeclaration = node.source.value;
-        if (!importDeclaration.endsWith(".ts"))
+        if (!node.source.value.startsWith(legacyLibrary))
           return;
-        const lastIndexOfExtension = importDeclaration.lastIndexOf(".ts");
-        const replacement = importDeclaration.substring(0, lastIndexOfExtension);
+        const replacement = node.source.value.replace(legacyLibrary, newLibrary);
         context.report({
-          data: {
-            import: importDeclaration
-          },
           fix(fixer) {
             return fixer.replaceText(node.source, `'${replacement}'`);
           },
-          messageId: "invalidTSExtension",
+          messageId: "replacedWith",
           node: node.source
         });
       }
@@ -650,12 +713,12 @@ const noDotTsImport = createEslintRule({
   defaultOptions: [],
   meta: {
     docs: {
-      description: "Checks and replaces .ts extension in import statements.",
+      description: `Reports and replaces imports of ${legacyLibrary} with ${newLibrary}`,
       recommendation: "recommended"
     },
     fixable: "code",
     messages: {
-      invalidTSExtension: `'{{ import }}' has a .ts extension, please remove it'`
+      replacedWith: `${legacyLibrary} has been replaced by ${newLibrary}`
     },
     schema: [],
     type: "problem"
@@ -670,6 +733,7 @@ const plugin = {
   },
   rules: {
     "consistent-ref-type-annotation": consistentRefTypeAnnotation,
+    "max-dependencies": maxDependencies,
     "no-deprecated-classes": noDeprecatedClasses,
     "no-deprecated-components": noDeprecatedComponents,
     "no-deprecated-props": noDeprecatedProps,