@rotki/eslint-plugin 0.7.0 → 1.0.0

package/README.md

@@ -1,15 +1,45 @@
 # @rotki/eslint-plugin
 
-rotki's ESLint plugin.
+[![npm version](https://img.shields.io/npm/v/@rotki/eslint-plugin.svg)](https://www.npmjs.com/package/@rotki/eslint-plugin)
 
-Inspired by [intlify/eslint-plugin-vue-i18n](https://github.com/intlify/eslint-plugin-vue-i18n)
-and [vuetifyjs/eslint-plugin-vuetify](https://github.com/vuetifyjs/eslint-plugin-vuetify).
+An ESLint plugin for rotki projects that provides custom rules and configurations to maintain consistent code quality.
 
-The plugin was bootstrapped from on `intlify/eslint-plugin-vue-i18n`.
+## Overview
+
+This ESLint plugin is designed specifically for rotki projects, drawing inspiration from established plugins like:
+
+- [intlify/eslint-plugin-vue-i18n](https://github.com/intlify/eslint-plugin-vue-i18n)
+- [vuetifyjs/eslint-plugin-vuetify](https://github.com/vuetifyjs/eslint-plugin-vuetify)
+
+## Installation
+
+```bash
+# Using pnpm (recommended)
+pnpm add -D @rotki/eslint-plugin
+
+# Using npm
+npm install --save-dev @rotki/eslint-plugin
+
+# Using yarn
+yarn add -D @rotki/eslint-plugin
+```
 
 ## Documentation
 
-See [here](https://rotki.github.io/eslint-plugin)
+For detailed usage instructions, available rules, and configuration options,
+please visit our [documentation](https://rotki.github.io/eslint-plugin).
+
+## Contributing
+
+Contributions are welcome!
+Please read our [Contributing Guide](./CONTRIBUTING.md) before submitting a Pull Request.
+The guide includes detailed information about:
+
+- Project prerequisites
+- Development setup
+- Commit message conventions
+- Code style and linting
+- Pull request process
 
 ## License
 

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.0.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,107 @@ 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$5 = "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) {
-    return {
-      plugins: {
-        [name]: plugin
-      },
-      rules
-    };
-  } else {
+const consistentRefTypeAnnotation = createEslintRule({
+  create(context, optionsWithDefault) {
+    const options = optionsWithDefault[0] || {};
+    const allowInference = options.allowInference;
     return {
-      plugins: [name],
-      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 });
+        }
+      }
     };
-  }
-}
+  },
+  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$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 +286,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 +294,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 +407,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 +464,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 +473,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 +516,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 +532,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 +546,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 +585,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 +614,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 +650,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"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rotki/eslint-plugin",
-  "version": "0.7.0",
+  "version": "1.0.0",
   "type": "module",
   "license": "AGPL-3.0",
   "bugs": {
@@ -20,7 +20,6 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "require": "./dist/index.cjs",
       "import": "./dist/index.mjs"
     }
   },
@@ -29,39 +28,39 @@
     "eslint": "^9.0.0"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "8.23.0",
+    "@typescript-eslint/utils": "8.26.0",
     "debug": "4.4.0",
     "eslint-compat-utils": "0.6.4",
     "jsonc-eslint-parser": "2.4.0",
     "scule": "1.3.0",
-    "vue-eslint-parser": "9.4.3",
-    "yaml-eslint-parser": "1.2.3"
+    "vue-eslint-parser": "10.1.1",
+    "yaml-eslint-parser": "1.3.0"
   },
   "devDependencies": {
     "@commitlint/cli": "19.7.1",
     "@commitlint/config-conventional": "19.7.1",
-    "@rotki/eslint-config": "3.7.0",
+    "@rotki/eslint-config": "4.0.1",
     "@types/debug": "4.1.12",
     "@types/node": "20",
-    "@typescript-eslint/eslint-plugin": "8.23.0",
-    "@typescript-eslint/parser": "8.23.0",
-    "@typescript-eslint/rule-tester": "8.23.0",
-    "@vitest/coverage-v8": "3.0.5",
-    "bumpp": "10.0.1",
+    "@typescript-eslint/eslint-plugin": "8.26.0",
+    "@typescript-eslint/parser": "8.26.0",
+    "@typescript-eslint/rule-tester": "8.26.0",
+    "@vitest/coverage-v8": "3.0.8",
+    "bumpp": "10.0.3",
     "debug": "4.4.0",
-    "eslint": "9.19.0",
+    "eslint": "9.21.0",
     "husky": "9.1.7",
     "lint-staged": "15.4.3",
     "rimraf": "6.0.1",
-    "ts-node": "10.9.2",
-    "typescript": "5.7.3",
-    "unbuild": "3.3.1",
+    "tsx": "4.19.3",
+    "typescript": "5.8.2",
+    "unbuild": "3.5.0",
     "vitepress": "1.6.3",
-    "vitest": "3.0.5"
+    "vitest": "3.0.8"
   },
   "engines": {
     "node": ">=20",
-    "pnpm": ">=9 <10"
+    "pnpm": ">=10 <11"
   },
   "lint-staged": {
     "*.{js,cjs,ts,vue,yml,json,md}": "eslint"
@@ -69,15 +68,15 @@
   "scripts": {
     "clean": "rimraf .nyc_output coverage dist docs/.vitepress/dist",
     "coverage": "nyc report --reporter lcov && opener coverage/lcov-report/index.html",
-    "generate": "node --experimental-specifier-resolution=node --loader ts-node/esm scripts/update-rule-docs.ts",
-    "generate:index": "node --experimental-specifier-resolution=node --loader ts-node/esm scripts/update-docs-index.ts",
+    "generate": "tsx scripts/update-rule-docs.ts",
+    "generate:index": "tsx scripts/update-docs-index.ts",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "build": "unbuild",
     "dev": "unbuild --stub",
     "test": "vitest",
     "test:coverage": "vitest run --coverage",
-    "new": "node --experimental-specifier-resolution=node --loader ts-node/esm ./scripts/new-rule.ts",
+    "new": "tsx ./scripts/new-rule.ts",
     "docs": "vitepress dev docs",
     "docs:build": "pnpm run generate && pnpm run generate:index && vitepress build docs",
     "typecheck": "tsc --noEmit",