@rotki/eslint-plugin 0.6.1 → 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,117 +1,12 @@
+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 name = "@rotki/eslint-plugin";
-const version = "0.6.1";
-const packageManager = "pnpm@9.15.0";
-const type = "module";
-const license = "AGPL-3.0";
-const bugs = {
-	url: "https://github.com/rotki/eslint-plugin/issues"
-};
-const repository = {
-	type: "git",
-	url: "https://github.com/rotki/eslint-plugin.git"
-};
-const author = "Rotki Solutions GmbH <info@rotki.com>";
-const files = [
-	"dist"
-];
-const main = "./dist/index.mjs";
-const module = "./dist/index.mjs";
-const types = "./dist/index.d.ts";
-const exports = {
-	".": {
-		types: "./dist/index.d.ts",
-		require: "./dist/index.cjs",
-		"import": "./dist/index.mjs"
-	}
-};
-const sideEffects = false;
-const 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",
-	lint: "eslint .",
-	"lint:fix": "eslint . --fix",
-	build: "unbuild",
-	dev: "unbuild --stub",
-	prepublishOnly: "pnpm run build",
-	test: "vitest",
-	"test:coverage": "vitest run --coverage",
-	"new": "node --experimental-specifier-resolution=node --loader ts-node/esm ./scripts/new-rule.ts",
-	docs: "vitepress dev docs",
-	"docs:build": "pnpm run generate && pnpm run generate:index && vitepress build docs",
-	prepare: "husky",
-	typecheck: "tsc --noEmit",
-	release: "bumpp -r --no-push"
-};
-const peerDependencies = {
-	eslint: "^9.0.0"
-};
-const dependencies = {
-	"@typescript-eslint/utils": "8.18.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"
-};
-const devDependencies = {
-	"@commitlint/cli": "19.6.0",
-	"@commitlint/config-conventional": "19.6.0",
-	"@rotki/eslint-config": "3.6.0",
-	"@types/debug": "4.1.12",
-	"@types/node": "20",
-	"@typescript-eslint/eslint-plugin": "8.18.0",
-	"@typescript-eslint/parser": "8.18.0",
-	"@typescript-eslint/rule-tester": "8.18.0",
-	"@vitest/coverage-v8": "2.1.8",
-	bumpp: "9.9.0",
-	debug: "4.4.0",
-	eslint: "9.16.0",
-	husky: "9.1.7",
-	"lint-staged": "15.2.11",
-	rimraf: "6.0.1",
-	"ts-node": "10.9.2",
-	typescript: "5.7.2",
-	unbuild: "2.0.0",
-	vitepress: "1.5.0",
-	vitest: "2.1.8"
-};
-const engines = {
-	node: ">=20",
-	pnpm: ">=9 <10"
-};
+const version = "1.0.0";
 const pkg = {
-	name: name,
-	version: version,
-	packageManager: packageManager,
-	type: type,
-	license: license,
-	bugs: bugs,
-	repository: repository,
-	author: author,
-	files: files,
-	main: main,
-	module: module,
-	types: types,
-	exports: exports,
-	sideEffects: sideEffects,
-	scripts: scripts,
-	peerDependencies: peerDependencies,
-	dependencies: dependencies,
-	devDependencies: devDependencies,
-	engines: engines,
-	"lint-staged": {
-	"*.{js,cjs,ts,vue,yml,json,md}": "eslint"
-}
-};
+	version: version};
 
 function getFilename(context) {
   return compat.getFilename(context);
@@ -120,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({
@@ -182,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"],
@@ -300,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 = [
@@ -413,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,
@@ -470,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
@@ -479,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
@@ -522,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"
@@ -552,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,
@@ -591,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
         });
       }
@@ -617,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
         });
       }
@@ -755,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"
@@ -782,13 +677,12 @@ const plugin = {
     "no-legacy-library-import": noLegacyLibraryImport
   }
 };
-const plugin$1 = plugin;
 
 const configs = {
-  "recommended": createRecommended(plugin$1, "@rotki", false),
-  "recommended-flat": createRecommended(plugin$1, "@rotki", true)
+  "recommended": createRecommended(plugin, "@rotki", false),
+  "recommended-flat": createRecommended(plugin, "@rotki", true)
 };
 
-const index = Object.assign(plugin$1, { configs });
+const index = Object.assign(plugin, { configs });
 
 export { index as default };