@rotki/eslint-plugin 1.2.0 → 1.3.0

package/dist/index.mjs

@@ -1,10 +1,13 @@
-import { TSESTree } from '@typescript-eslint/utils';
-import createDebug from 'debug';
+import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils';
 import * as compat from 'eslint-compat-utils';
-import { extname } from 'node:path';
+import debugFactory from 'debug';
+import { extname, resolve } from 'node:path';
 import { pascalCase, kebabCase } from 'scule';
+import { statSync, readFileSync } from 'node:fs';
+import { globSync } from 'tinyglobby';
+import { parse } from 'vue-eslint-parser';
 
-const version = "1.2.0";
+const version = "1.3.0";
 const pkg = {
 	version: version};
 
@@ -15,8 +18,34 @@ 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]));
+const COMPOSABLE_PATTERN = /^use[A-Z]/;
+function isComposableName(name) {
+  return COMPOSABLE_PATTERN.test(name);
+}
+function getEnclosingComposable(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === AST_NODE_TYPES.FunctionDeclaration && current.id && isComposableName(current.id.name))
+      return current;
+    if (current.type === AST_NODE_TYPES.ArrowFunctionExpression || current.type === AST_NODE_TYPES.FunctionExpression) {
+      const parent = current.parent;
+      if (parent?.type === AST_NODE_TYPES.VariableDeclarator && parent.id.type === AST_NODE_TYPES.Identifier && isComposableName(parent.id.name)) {
+        return current;
+      }
+    }
+    current = current.parent;
+  }
+  return void 0;
+}
+function isInsideComposable(node) {
+  return getEnclosingComposable(node) !== void 0;
+}
+function composableNameToPascal(name) {
+  return name.slice(3);
+}
+
+function createConfig(plugin, name, flat, category) {
+  const rules = Object.fromEntries(Object.entries(plugin.rules).filter(([_key, rule]) => rule.meta.docs?.recommendation === category && !rule.meta.deprecated).map(([key]) => [`${name}/${key}`, 2]));
   if (flat) {
     return {
       plugins: {
@@ -31,6 +60,9 @@ function createRecommended(plugin, name, flat) {
     };
   }
 }
+function createRecommended(plugin, name, flat) {
+  return createConfig(plugin, name, flat, "recommended");
+}
 
 function getStringLiteralValue(node, stringOnly = false) {
   if (node.type === "Literal") {
@@ -134,12 +166,491 @@ function defineTemplateBodyVisitor(context, templateBodyVisitor, scriptVisitor,
   );
 }
 
-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;
+const RULE_NAME$f = "composable-input-flexibility";
+function checkParamForRef(param) {
+  let annotation;
+  if (param.type === AST_NODE_TYPES.Identifier && param.typeAnnotation) {
+    annotation = param.typeAnnotation.typeAnnotation;
+  } else if (param.type === AST_NODE_TYPES.AssignmentPattern && param.left.type === AST_NODE_TYPES.Identifier && param.left.typeAnnotation) {
+    annotation = param.left.typeAnnotation.typeAnnotation;
+  }
+  if (annotation?.type === AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES.Identifier && annotation.typeName.name === "Ref") {
+    return annotation;
+  }
+  return void 0;
+}
+const composableInputFlexibility = createEslintRule({
+  create(context) {
+    return {
+      FunctionDeclaration: (node) => {
+        if (!node.id || !isComposableName(node.id.name))
+          return;
+        checkParams(node.params);
+      },
+      VariableDeclarator: (node) => {
+        if (node.id.type !== AST_NODE_TYPES.Identifier || !isComposableName(node.id.name))
+          return;
+        if (node.init?.type === AST_NODE_TYPES.ArrowFunctionExpression || node.init?.type === AST_NODE_TYPES.FunctionExpression) {
+          checkParams(node.init.params);
+        }
+      }
+    };
+    function checkParams(params) {
+      for (const param of params) {
+        const refType = checkParamForRef(param);
+        if (refType) {
+          context.report({
+            fix(fixer) {
+              return fixer.replaceText(refType.typeName, "MaybeRefOrGetter");
+            },
+            messageId: "preferMaybeRefOrGetter",
+            node: refType
+          });
+        }
+      }
+    }
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Prefer MaybeRefOrGetter over Ref for composable parameters",
+      recommendation: "stylistic"
+    },
+    fixable: "code",
+    messages: {
+      preferMaybeRefOrGetter: "Use MaybeRefOrGetter<T> instead of Ref<T> for composable parameters to increase input flexibility."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: RULE_NAME$f
+});
+
+const RULE_NAME$e = "composable-naming-convention";
+function getComposableFunction(node) {
+  if (node.type === AST_NODE_TYPES.FunctionDeclaration) {
+    if (!node.id || !isComposableName(node.id.name))
+      return void 0;
+    return { fn: node, name: node.id.name, params: node.params, returnType: node.returnType };
+  }
+  if (node.type === AST_NODE_TYPES.VariableDeclarator && node.id.type === AST_NODE_TYPES.Identifier && isComposableName(node.id.name) && node.init && (node.init.type === AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === AST_NODE_TYPES.FunctionExpression)) {
+    const fn = node.init;
+    return { fn, name: node.id.name, params: fn.params, returnType: fn.returnType };
+  }
+  return void 0;
+}
+function getTypeReferenceName(annotation) {
+  if (annotation.type === AST_NODE_TYPES.TSTypeReference && annotation.typeName.type === AST_NODE_TYPES.Identifier) {
+    return annotation.typeName.name;
+  }
+  return void 0;
+}
+const composableNamingConvention = createEslintRule({
+  create(context) {
+    return {
+      FunctionDeclaration: (node) => {
+        checkComposable(node);
+      },
+      VariableDeclarator: (node) => {
+        checkComposable(node);
+      }
+    };
+    function checkComposable(node) {
+      const info = getComposableFunction(node);
+      if (!info)
+        return;
+      const pascalName = composableNameToPascal(info.name);
+      const expectedOptions = `Use${pascalName}Options`;
+      const expectedReturn = `Use${pascalName}Return`;
+      for (const param of info.params) {
+        const annotation = getParamTypeAnnotation(param);
+        if (!annotation)
+          continue;
+        const typeName = getTypeReferenceName(annotation);
+        if (typeName && typeName.startsWith("Use") && typeName.endsWith("Options") && typeName !== expectedOptions) {
+          context.report({
+            data: { expected: expectedOptions, got: typeName },
+            messageId: "optionsNaming",
+            node: param
+          });
+        }
+      }
+      if (info.returnType) {
+        const returnTypeName = getTypeReferenceName(info.returnType.typeAnnotation);
+        if (returnTypeName && returnTypeName.startsWith("Use") && returnTypeName.endsWith("Return") && returnTypeName !== expectedReturn) {
+          context.report({
+            data: { expected: expectedReturn, got: returnTypeName },
+            messageId: "returnNaming",
+            node: info.returnType
+          });
+        }
+      }
+    }
+    function getParamTypeAnnotation(param) {
+      if (param.type === AST_NODE_TYPES.Identifier && param.typeAnnotation)
+        return param.typeAnnotation.typeAnnotation;
+      if (param.type === AST_NODE_TYPES.AssignmentPattern && param.left.type === AST_NODE_TYPES.Identifier && param.left.typeAnnotation) {
+        return param.left.typeAnnotation.typeAnnotation;
+      }
+      return void 0;
+    }
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Enforce consistent naming for composable options and return types",
+      recommendation: "stylistic"
+    },
+    messages: {
+      optionsNaming: "Options type should be named '{{ expected }}' instead of '{{ got }}'.",
+      returnNaming: "Return type should be named '{{ expected }}' instead of '{{ got }}'."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: RULE_NAME$e
+});
+
+const RULE_NAME$d = "composable-no-default-export";
+const composableNoDefaultExport = createEslintRule({
+  create(context) {
+    let hasComposable = false;
+    let defaultExportNode = null;
+    return {
+      "ExportDefaultDeclaration": (node) => {
+        defaultExportNode = node;
+      },
+      "FunctionDeclaration": (node) => {
+        if (node.id && isComposableName(node.id.name))
+          hasComposable = true;
+      },
+      "Program:exit": () => {
+        if (hasComposable && defaultExportNode) {
+          context.report({
+            messageId: "noDefaultExport",
+            node: defaultExportNode
+          });
+        }
+      },
+      "VariableDeclarator": (node) => {
+        if (node.id.type === AST_NODE_TYPES.Identifier && isComposableName(node.id.name) && node.init && (node.init.type === AST_NODE_TYPES.ArrowFunctionExpression || node.init.type === AST_NODE_TYPES.FunctionExpression)) {
+          hasComposable = true;
+        }
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Forbid default exports in files containing composables",
+      recommendation: "strict"
+    },
+    messages: {
+      noDefaultExport: "Files containing composables should use named exports instead of default exports."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: RULE_NAME$d
+});
+
+const RULE_NAME$c = "composable-prefer-shallowref";
+const composablePreferShallowref = createEslintRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (node.callee.type !== AST_NODE_TYPES.Identifier || node.callee.name !== "ref")
+          return;
+        if (!isInsideComposable(node))
+          return;
+        const arg = node.arguments[0];
+        if (!arg || arg.type !== AST_NODE_TYPES.Literal)
+          return;
+        context.report({
+          fix(fixer) {
+            return fixer.replaceText(node.callee, "shallowRef");
+          },
+          messageId: "preferShallowRef",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Prefer shallowRef() over ref() for primitive values in composables",
+      recommendation: "strict"
+    },
+    fixable: "code",
+    messages: {
+      preferShallowRef: "Use shallowRef() instead of ref() for primitive values in composables."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: RULE_NAME$c
+});
+
+const RULE_NAME$b = "composable-require-cleanup";
+const SIDE_EFFECT_CALLS = /* @__PURE__ */ new Set(["addEventListener", "setInterval", "setTimeout"]);
+const SIDE_EFFECT_CONSTRUCTORS = /* @__PURE__ */ new Set(["MutationObserver", "ResizeObserver", "IntersectionObserver"]);
+const CLEANUP_HOOKS = /* @__PURE__ */ new Set(["onUnmounted", "onBeforeUnmount", "onScopeDispose", "tryOnScopeDispose"]);
+const composableRequireCleanup = createEslintRule({
+  create(context) {
+    const scopeStack = [];
+    function enterComposable() {
+      scopeStack.push({ hasCleanup: false, sideEffects: [] });
+    }
+    function exitComposable() {
+      const scope = scopeStack.pop();
+      if (scope && scope.sideEffects.length > 0 && !scope.hasCleanup) {
+        for (const node of scope.sideEffects) {
+          context.report({
+            messageId: "requireCleanup",
+            node
+          });
+        }
+      }
+    }
+    function currentScope() {
+      return scopeStack.at(-1);
+    }
+    return {
+      "ArrowFunctionExpression": (node) => {
+        const parent = node.parent;
+        if (parent?.type === AST_NODE_TYPES.VariableDeclarator && parent.id.type === AST_NODE_TYPES.Identifier && isComposableName(parent.id.name)) {
+          enterComposable();
+        }
+      },
+      "ArrowFunctionExpression:exit": (node) => {
+        const parent = node.parent;
+        if (parent?.type === AST_NODE_TYPES.VariableDeclarator && parent.id.type === AST_NODE_TYPES.Identifier && isComposableName(parent.id.name)) {
+          exitComposable();
+        }
+      },
+      "CallExpression": (node) => {
+        const scope = currentScope();
+        if (!scope)
+          return;
+        if (node.callee.type === AST_NODE_TYPES.Identifier && CLEANUP_HOOKS.has(node.callee.name)) {
+          scope.hasCleanup = true;
+          return;
+        }
+        if (node.callee.type === AST_NODE_TYPES.MemberExpression && node.callee.property.type === AST_NODE_TYPES.Identifier && SIDE_EFFECT_CALLS.has(node.callee.property.name)) {
+          scope.sideEffects.push(node);
+          return;
+        }
+        if (node.callee.type === AST_NODE_TYPES.Identifier && SIDE_EFFECT_CALLS.has(node.callee.name)) {
+          scope.sideEffects.push(node);
+        }
+      },
+      "FunctionDeclaration": (node) => {
+        if (node.id && isComposableName(node.id.name))
+          enterComposable();
+      },
+      "FunctionDeclaration:exit": (node) => {
+        if (node.id && isComposableName(node.id.name))
+          exitComposable();
+      },
+      "FunctionExpression": (node) => {
+        const parent = node.parent;
+        if (parent?.type === AST_NODE_TYPES.VariableDeclarator && parent.id.type === AST_NODE_TYPES.Identifier && isComposableName(parent.id.name)) {
+          enterComposable();
+        }
+      },
+      "FunctionExpression:exit": (node) => {
+        const parent = node.parent;
+        if (parent?.type === AST_NODE_TYPES.VariableDeclarator && parent.id.type === AST_NODE_TYPES.Identifier && isComposableName(parent.id.name)) {
+          exitComposable();
+        }
+      },
+      "NewExpression": (node) => {
+        const scope = currentScope();
+        if (!scope)
+          return;
+        if (node.callee.type === AST_NODE_TYPES.Identifier && SIDE_EFFECT_CONSTRUCTORS.has(node.callee.name))
+          scope.sideEffects.push(node);
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Require cleanup hooks when composables use side effects",
+      recommendation: "strict"
+    },
+    messages: {
+      requireCleanup: "Side effect requires a cleanup hook (onUnmounted, onBeforeUnmount, or onScopeDispose)."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: RULE_NAME$b
+});
+
+const RULE_NAME$a = "composable-return-readonly";
+const REACTIVE_CREATORS = /* @__PURE__ */ new Set(["ref", "shallowRef", "computed"]);
+const composableReturnReadonly = createEslintRule({
+  create(context) {
+    const source = getSourceCode(context);
+    const reactiveVars = /* @__PURE__ */ new Set();
+    return {
+      ReturnStatement: (node) => {
+        if (!getEnclosingComposable(node))
+          return;
+        if (!node.argument || node.argument.type !== AST_NODE_TYPES.ObjectExpression)
+          return;
+        for (const prop of node.argument.properties) {
+          if (prop.type !== AST_NODE_TYPES.Property)
+            continue;
+          if (prop.shorthand && prop.key.type === AST_NODE_TYPES.Identifier && reactiveVars.has(prop.key.name)) {
+            const keyName = prop.key.name;
+            context.report({
+              data: { name: keyName },
+              fix(fixer) {
+                return fixer.replaceText(prop, `${keyName}: readonly(${keyName})`);
+              },
+              messageId: "wrapReadonly",
+              node: prop
+            });
+          } else if (!prop.shorthand && prop.value.type === AST_NODE_TYPES.Identifier && reactiveVars.has(prop.value.name)) {
+            context.report({
+              data: { name: prop.value.name },
+              fix(fixer) {
+                return fixer.replaceText(prop.value, `readonly(${prop.value.type === AST_NODE_TYPES.Identifier ? prop.value.name : source.getText(prop.value)})`);
+              },
+              messageId: "wrapReadonly",
+              node: prop
+            });
+          }
+        }
+      },
+      VariableDeclarator: (node) => {
+        if (!getEnclosingComposable(node))
+          return;
+        if (node.id.type !== AST_NODE_TYPES.Identifier)
+          return;
+        if (node.init?.type === AST_NODE_TYPES.CallExpression && node.init.callee.type === AST_NODE_TYPES.Identifier && REACTIVE_CREATORS.has(node.init.callee.name)) {
+          reactiveVars.add(node.id.name);
+        }
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Require returned refs from composables to be wrapped with readonly()",
+      recommendation: "strict"
+    },
+    fixable: "code",
+    messages: {
+      wrapReadonly: "Returned ref '{{ name }}' should be wrapped with readonly()."
+    },
+    schema: [],
+    type: "suggestion"
+  },
+  name: RULE_NAME$a
+});
+
+const RULE_NAME$9 = "composable-ssr-safety";
+const BROWSER_GLOBALS = /* @__PURE__ */ new Set(["window", "document", "navigator"]);
+const LIFECYCLE_HOOKS = /* @__PURE__ */ new Set(["onMounted", "onBeforeMount"]);
+function isInsideLifecycleHook(node) {
+  let current = node.parent;
+  while (current) {
+    if ((current.type === AST_NODE_TYPES.ArrowFunctionExpression || current.type === AST_NODE_TYPES.FunctionExpression) && current.parent?.type === AST_NODE_TYPES.CallExpression && current.parent.callee.type === AST_NODE_TYPES.Identifier && LIFECYCLE_HOOKS.has(current.parent.callee.name)) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function isInsideTypeofCheck(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === AST_NODE_TYPES.UnaryExpression && current.operator === "typeof")
+      return true;
+    if (current.type === AST_NODE_TYPES.IfStatement) {
+      const test = current.test;
+      if (hasTypeofCheck(test))
+        return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+function hasTypeofCheck(node) {
+  if (node.type === AST_NODE_TYPES.BinaryExpression) {
+    if (node.left.type === AST_NODE_TYPES.UnaryExpression && node.left.operator === "typeof" && node.left.argument.type === AST_NODE_TYPES.Identifier && BROWSER_GLOBALS.has(node.left.argument.name)) {
+      return true;
+    }
+    if (node.right.type === AST_NODE_TYPES.UnaryExpression && node.right.operator === "typeof" && node.right.argument.type === AST_NODE_TYPES.Identifier && BROWSER_GLOBALS.has(node.right.argument.name)) {
+      return true;
+    }
+  }
+  if (node.type === AST_NODE_TYPES.LogicalExpression)
+    return hasTypeofCheck(node.left) || hasTypeofCheck(node.right);
+  return false;
+}
+function isGuardedByIfTypeofOrLifecycle(node) {
+  if (isInsideLifecycleHook(node))
+    return true;
+  let current = node.parent;
+  while (current) {
+    if (current.type === AST_NODE_TYPES.IfStatement && hasTypeofCheck(current.test)) {
+      return true;
+    }
+    if (current.type === AST_NODE_TYPES.ConditionalExpression && hasTypeofCheck(current.test))
+      return true;
+    if (current.type === AST_NODE_TYPES.LogicalExpression && current.operator === "&&" && hasTypeofCheck(current.left)) {
+      return true;
+    }
+    current = current.parent;
+  }
+  return false;
+}
+const composableSsrSafety = createEslintRule({
+  create(context) {
+    return {
+      MemberExpression(node) {
+        if (node.object.type !== AST_NODE_TYPES.Identifier)
+          return;
+        if (!BROWSER_GLOBALS.has(node.object.name))
+          return;
+        if (!getEnclosingComposable(node))
+          return;
+        if (isInsideTypeofCheck(node))
+          return;
+        if (isGuardedByIfTypeofOrLifecycle(node))
+          return;
+        context.report({
+          data: { name: node.object.name },
+          messageId: "ssrUnsafe",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Require browser global access in composables to be SSR-safe",
+      recommendation: "strict"
+    },
+    messages: {
+      ssrUnsafe: "Access to '{{ name }}' in a composable must be guarded with a typeof check or placed inside onMounted/onBeforeMount."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: RULE_NAME$9
+});
+
+const debug$6 = debugFactory("@rotki/eslint-plugin:consistent-ref-type-annotation");
+const RULE_NAME$8 = "consistent-ref-type-annotation";
+const FIXABLE_METHODS = /* @__PURE__ */ new Set(["ref", "computed"]);
+function checkAssignmentDeclaration(context, source, node, declaration, allowInference) {
   let declarationTypeArguments;
   const init = declaration.init;
   if (!(init && init.type === TSESTree.AST_NODE_TYPES.CallExpression))
@@ -147,10 +658,10 @@ function checkAssignmentDeclaration(context, node, declaration, options) {
   const callee = init.callee;
   if (!(callee && callee.type === TSESTree.AST_NODE_TYPES.Identifier))
     return;
-  if (!Array.prototype.includes.call(FIXABLE_METHODS, callee.name))
+  if (!FIXABLE_METHODS.has(callee.name))
     return;
   const name = callee.name;
-  debug$3(`found ${name}, checking type arguments`);
+  debug$6(`found ${name}, checking type arguments`);
   const initializationTypeArguments = init.typeArguments;
   const typeAnnotation = declaration.id.typeAnnotation;
   if (typeAnnotation) {
@@ -160,10 +671,10 @@ function checkAssignmentDeclaration(context, node, declaration, options) {
   }
   if (initializationTypeArguments && !declarationTypeArguments)
     return;
-  debug$3(`generating report for ${name}`);
+  debug$6(`generating report for ${name}`);
   if (!initializationTypeArguments && !declarationTypeArguments) {
     if (allowInference) {
-      debug$3("type inference is allowed");
+      debug$6("type inference is allowed");
     } else {
       context.report({
         data: {
@@ -195,13 +706,14 @@ const consistentRefTypeAnnotation = createEslintRule({
   create(context, optionsWithDefault) {
     const options = optionsWithDefault[0] || {};
     const allowInference = options.allowInference;
+    const source = getSourceCode(context);
     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 });
+          checkAssignmentDeclaration(context, source, node, declaration, allowInference);
         }
       }
     };
@@ -230,10 +742,10 @@ const consistentRefTypeAnnotation = createEslintRule({
     ],
     type: "problem"
   },
-  name: RULE_NAME$6
+  name: RULE_NAME$8
 });
 
-const RULE_NAME$5 = "max-dependencies";
+const RULE_NAME$7 = "max-dependencies";
 const maxDependencies = createEslintRule({
   create(context, [options]) {
     let dependencyCount = 0;
@@ -293,12 +805,12 @@ const maxDependencies = createEslintRule({
     ],
     type: "suggestion"
   },
-  name: RULE_NAME$5
+  name: RULE_NAME$7
 });
 
-const RULE_NAME$4 = "no-deprecated-classes";
-const debug$2 = createDebug("@rotki/eslint-plugin:no-deprecated-classes");
-const replacements$2 = [
+const RULE_NAME$6 = "no-deprecated-classes";
+const debug$5 = debugFactory("@rotki/eslint-plugin:no-deprecated-classes");
+const stringReplacements = /* @__PURE__ */ new Map([
   ["d-block", "block"],
   ["d-flex", "flex"],
   ["flex-column", "flex-col"],
@@ -306,6 +818,11 @@ const replacements$2 = [
   ["flex-grow-0", "grow-0"],
   ["flex-shrink-1", "shrink"],
   ["flex-shrink-0", "shrink-0"],
+  ["text--secondary", "text-rui-text-secondary"],
+  ["white--text", "text-white"],
+  ["primary--text", "text-rui-primary"]
+]);
+const regexReplacements = [
   [
     /^align-(start|end|center|baseline|stretch)$/,
     ([align]) => `items-${align}`
@@ -320,9 +837,6 @@ const replacements$2 = [
     ([weight]) => `font-${weight}`
   ],
   [/^text-(capitalize|uppercase|lowercase)$/, ([casing]) => casing],
-  ["text--secondary", "text-rui-text-secondary"],
-  ["white--text", "text-white"],
-  ["primary--text", "text-rui-primary"],
   [
     /^([mp])([abelr-txy]?)-n(\d)$/,
     ([type, position, size]) => `-${type}${position === "a" ? "" : position}-${size}`
@@ -332,22 +846,14 @@ const replacements$2 = [
     ([type, size]) => `${type}-${size}`
   ]
 ];
-function isString(replacement) {
-  return typeof replacement[0] === "string";
-}
-function isRegex(replacement) {
-  return replacement[0] instanceof RegExp;
-}
 function findReplacement(className) {
-  for (const replacement of replacements$2) {
-    if (isString(replacement) && replacement[0] === className)
-      return replacement[1];
-    if (isRegex(replacement)) {
-      const matches = (replacement[0].exec(className) || []).slice(1);
-      const replace = replacement[1];
-      if (matches.length > 0 && typeof replace === "function")
-        return replace(matches);
-    }
+  const direct = stringReplacements.get(className);
+  if (direct !== void 0)
+    return direct;
+  for (const [regex, replace] of regexReplacements) {
+    const matches = regex.exec(className);
+    if (matches)
+      return replace(matches.slice(1));
   }
   return void 0;
 }
@@ -356,9 +862,8 @@ function getRange(node) {
     return node.value.range;
   return node.range;
 }
-function reportReplacement(className, replacement, node, context, position = 1) {
-  debug$2(`found replacement ${replacement} for ${className}`);
-  const source = getSourceCode(context);
+function reportReplacement(className, replacement, node, context, source, position = 1) {
+  debug$5(`found replacement ${replacement} for ${className}`);
   const initialRange = getRange(node);
   const range = [
     initialRange[0] + position,
@@ -433,6 +938,7 @@ function* extractClassNames(node, textOnly = false) {
 }
 const noDeprecatedClasses = createEslintRule({
   create(context) {
+    const source = getSourceCode(context);
     return defineTemplateBodyVisitor(context, {
       'VAttribute[directive=false][key.name="class"]': function(node) {
         if (!node.value || !node.value.value)
@@ -442,7 +948,7 @@ const noDeprecatedClasses = createEslintRule({
           const position = node.value.value.indexOf(className) + 1;
           if (!replacement)
             continue;
-          reportReplacement(className, replacement, node, context, position);
+          reportReplacement(className, replacement, node, context, source, position);
         }
       },
       "VAttribute[directive=true][key.name.name='bind'][key.argument.name='class'] > VExpressionContainer.value": function(node) {
@@ -452,7 +958,7 @@ const noDeprecatedClasses = createEslintRule({
           const replacement = findReplacement(className);
           if (!replacement)
             continue;
-          reportReplacement(className, replacement, reportNode, context, position);
+          reportReplacement(className, replacement, reportNode, context, source, position);
         }
       }
     });
@@ -470,11 +976,11 @@ const noDeprecatedClasses = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$4
+  name: RULE_NAME$6
 });
 
-const debug$1 = createDebug("@rotki/eslint-plugin:no-deprecated-components");
-const RULE_NAME$3 = "no-deprecated-components";
+const debug$4 = debugFactory("@rotki/eslint-plugin:no-deprecated-components");
+const RULE_NAME$5 = "no-deprecated-components";
 const vuetify = {
   VApp: true,
   VAppBar: true,
@@ -507,9 +1013,9 @@ const replacements$1 = {
   Fragment: false,
   ...vuetify
 };
-const skipInLegacy = [
+const skipInLegacy = /* @__PURE__ */ new Set([
   "Fragment"
-];
+]);
 function hasReplacement$1(tag) {
   return Object.prototype.hasOwnProperty.call(replacements$1, tag);
 }
@@ -517,17 +1023,17 @@ const noDeprecatedComponents = createEslintRule({
   create(context, optionsWithDefault) {
     const options = optionsWithDefault[0] || {};
     const legacy = options.legacy;
+    const sourceCode = getSourceCode(context);
+    if (sourceCode?.parserServices && !("getTemplateBodyTokenStore" in sourceCode.parserServices))
+      throw new Error("cannot find getTemplateBodyTokenStore in parserServices");
     return defineTemplateBodyVisitor(context, {
       VElement(element) {
         const tag = pascalCase(element.rawName);
-        const sourceCode = getSourceCode(context);
-        if (sourceCode?.parserServices && !("getTemplateBodyTokenStore" in sourceCode.parserServices))
-          throw new Error("cannot find getTemplateBodyTokenStore in parserServices");
         if (!hasReplacement$1(tag))
           return;
         const replacement = replacements$1[tag];
-        if (replacement || legacy && skipInLegacy.includes(tag)) {
-          debug$1(`${tag} has been deprecated`);
+        if (replacement || legacy && skipInLegacy.has(tag)) {
+          debug$4(`${tag} has been deprecated`);
           context.report({
             data: {
               name: tag
@@ -536,7 +1042,7 @@ const noDeprecatedComponents = createEslintRule({
             node: element
           });
         } else {
-          debug$1(`${tag} has will be removed`);
+          debug$4(`${tag} has will be removed`);
           context.report({
             data: {
               name: tag
@@ -579,18 +1085,24 @@ const noDeprecatedComponents = createEslintRule({
     ],
     type: "problem"
   },
-  name: RULE_NAME$3
+  name: RULE_NAME$5
 });
 
-const debug = createDebug("@rotki/eslint-plugin:no-deprecated-props");
-const RULE_NAME$2 = "no-deprecated-props";
+const debug$3 = debugFactory("@rotki/eslint-plugin:no-deprecated-props");
+const RULE_NAME$4 = "no-deprecated-props";
 const replacements = {
   RuiRadio: {
     internalValue: "value"
   }
 };
+const replacementMaps = new Map(
+  Object.entries(replacements).map(([tag, props]) => [
+    tag,
+    new Map(Object.entries(props).map(([prop, repl]) => [kebabCase(prop), { original: prop, replacement: repl }]))
+  ])
+);
 function hasReplacement(tag) {
-  return Object.prototype.hasOwnProperty.call(replacements, tag);
+  return replacementMaps.has(tag);
 }
 function getPropName(node) {
   if (node.directive) {
@@ -609,29 +1121,28 @@ const noDeprecatedProps = createEslintRule({
         const tag = pascalCase(node.parent.parent.rawName);
         if (!hasReplacement(tag))
           return;
-        debug(`${tag} has replacement properties`);
+        debug$3(`${tag} has replacement properties`);
         const propName = getPropName(node);
         const propNameNode = node.directive ? node.key.argument : node.key;
         if (!propName || !propNameNode) {
-          debug("could not get prop name and/or node");
+          debug$3("could not get prop name and/or node");
           return;
         }
-        Object.entries(replacements[tag]).forEach(([prop, replacement]) => {
-          if (kebabCase(prop) === propName) {
-            debug(`preparing a replacement for ${tag}:${propName} -> ${replacement}`);
-            context.report({
-              data: {
-                prop,
-                replacement
-              },
-              fix(fixer) {
-                return fixer.replaceText(propNameNode, replacement);
-              },
-              messageId: "replacedWith",
-              node: propNameNode
-            });
-          }
-        });
+        const match = replacementMaps.get(tag)?.get(propName);
+        if (match) {
+          debug$3(`preparing a replacement for ${tag}:${propName} -> ${match.replacement}`);
+          context.report({
+            data: {
+              prop: match.original,
+              replacement: match.replacement
+            },
+            fix(fixer) {
+              return fixer.replaceText(propNameNode, match.replacement);
+            },
+            messageId: "replacedWith",
+            node: propNameNode
+          });
+        }
       }
     });
   },
@@ -648,10 +1159,10 @@ const noDeprecatedProps = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$2
+  name: RULE_NAME$4
 });
 
-const RULE_NAME$1 = "no-dot-ts-imports";
+const RULE_NAME$3 = "no-dot-ts-imports";
 const noDotTsImport = createEslintRule({
   create(context) {
     return {
@@ -659,8 +1170,7 @@ const noDotTsImport = createEslintRule({
         const importDeclaration = node.source.value;
         if (!importDeclaration.endsWith(".ts"))
           return;
-        const lastIndexOfExtension = importDeclaration.lastIndexOf(".ts");
-        const replacement = importDeclaration.substring(0, lastIndexOfExtension);
+        const replacement = importDeclaration.slice(0, -3);
         context.report({
           data: {
             import: importDeclaration
@@ -687,10 +1197,10 @@ const noDotTsImport = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$1
+  name: RULE_NAME$3
 });
 
-const RULE_NAME = "no-legacy-library-import";
+const RULE_NAME$2 = "no-legacy-library-import";
 const legacyLibrary = "@rotki/ui-library-compat";
 const newLibrary = "@rotki/ui-library";
 const noLegacyLibraryImport = createEslintRule({
@@ -723,6 +1233,616 @@ const noLegacyLibraryImport = createEslintRule({
     schema: [],
     type: "problem"
   },
+  name: RULE_NAME$2
+});
+
+const I18N_FUNCTION_NAMES = /* @__PURE__ */ new Set(["t", "te", "tc", "$t", "$te", "$tc"]);
+const I18N_MEMBER_NAMES = /* @__PURE__ */ new Set(["$t", "$te", "$tc"]);
+function isAstNode(value) {
+  return value !== null && typeof value === "object" && "type" in value && typeof value.type === "string";
+}
+function isI18nCallExpression(node) {
+  const callee = node.callee;
+  if (!isAstNode(callee))
+    return false;
+  if (callee.type === "Identifier" && typeof callee.name === "string")
+    return I18N_FUNCTION_NAMES.has(callee.name);
+  return callee.type === "MemberExpression" && !callee.computed && isAstNode(callee.property) && callee.property.type === "Identifier" && typeof callee.property.name === "string" && I18N_MEMBER_NAMES.has(callee.property.name);
+}
+function getTemplateLiteralText(arg) {
+  const quasis = arg.quasis;
+  const expressions = arg.expressions;
+  if (!Array.isArray(quasis) || !Array.isArray(expressions) || quasis.length === 0)
+    return void 0;
+  const firstQuasi = quasis[0];
+  if (!firstQuasi || typeof firstQuasi !== "object" || !("value" in firstQuasi))
+    return void 0;
+  const quasiObj = firstQuasi.value;
+  if (!quasiObj || typeof quasiObj !== "object")
+    return void 0;
+  return "cooked" in quasiObj && typeof quasiObj.cooked === "string" ? quasiObj.cooked : "raw" in quasiObj && typeof quasiObj.raw === "string" ? quasiObj.raw : void 0;
+}
+function extractKeysFromCallExpression(node, keys) {
+  if (!isI18nCallExpression(node))
+    return;
+  const args = node.arguments;
+  if (!Array.isArray(args) || args.length === 0)
+    return;
+  const arg = args[0];
+  if (!isAstNode(arg))
+    return;
+  if (arg.type === "Literal" && typeof arg.value === "string") {
+    keys.add(arg.value);
+  } else if (arg.type === "TemplateLiteral") {
+    const text = getTemplateLiteralText(arg);
+    if (text === void 0)
+      return;
+    if (arg.expressions && Array.isArray(arg.expressions) && arg.expressions.length === 0 && Array.isArray(arg.quasis) && arg.quasis.length === 1)
+      keys.add(text);
+    else if (text)
+      keys.add(`${text}*`);
+  }
+}
+const TS_AST_CHILD_KEYS = /* @__PURE__ */ new Set([
+  "alternate",
+  "argument",
+  "arguments",
+  "block",
+  "body",
+  "callee",
+  "cases",
+  "consequent",
+  "declaration",
+  "declarations",
+  "discriminant",
+  "elements",
+  "expression",
+  "expressions",
+  "handler",
+  "init",
+  "left",
+  "object",
+  "params",
+  "properties",
+  "property",
+  "right",
+  "source",
+  "specifiers",
+  "tag",
+  "test",
+  "update",
+  "value"
+]);
+function walkTsAst(node, keys) {
+  if (!isAstNode(node))
+    return;
+  if (node.type === "CallExpression") {
+    extractKeysFromCallExpression(node, keys);
+  }
+  for (const key of TS_AST_CHILD_KEYS) {
+    if (!(key in node))
+      continue;
+    const child = node[key];
+    if (!child || typeof child !== "object")
+      continue;
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        walkTsAst(item, keys);
+      }
+    } else {
+      walkTsAst(child, keys);
+    }
+  }
+}
+
+const debug$2 = debugFactory("@rotki/eslint-plugin:i18n-vue-template");
+function isVElement(node) {
+  return "type" in node && node.type === "VElement";
+}
+function isVExpressionContainer(node) {
+  return "type" in node && node.type === "VExpressionContainer";
+}
+function isKeypathAttribute(attr) {
+  return attr.type === "VAttribute" && !attr.directive && (attr.key.name === "keypath" || attr.key.name === "path") && attr.value !== null && attr.value.type === "VLiteral";
+}
+function isVTDirective(attr) {
+  return attr.type === "VAttribute" && attr.directive && attr.key.name.type === "VIdentifier" && attr.key.name.rawName === "t";
+}
+function getDirectiveExpression(attr) {
+  if (attr.type !== "VAttribute" || !attr.directive)
+    return null;
+  if (!attr.value || attr.value.type !== "VExpressionContainer")
+    return null;
+  return attr.value.expression;
+}
+function extractKeysFromVueTemplate(templateBody, keys) {
+  walkVueTemplateNode(templateBody, keys);
+}
+function walkVueTemplateNode(node, keys) {
+  if (!node || typeof node !== "object")
+    return;
+  if (isVElement(node)) {
+    if (node.rawName === "i18n-t" || node.name === "i18n-t") {
+      for (const attr of node.startTag.attributes) {
+        if (isKeypathAttribute(attr))
+          keys.add(attr.value.value);
+      }
+    }
+    for (const attr of node.startTag.attributes) {
+      const expr = getDirectiveExpression(attr);
+      if (!expr)
+        continue;
+      if (isVTDirective(attr) && expr.type === "Literal" && typeof expr.value === "string")
+        keys.add(expr.value);
+      walkTsAst(expr, keys);
+    }
+    for (const child of node.children)
+      walkVueTemplateNode(child, keys);
+  } else if (isVExpressionContainer(node)) {
+    if (node.expression)
+      walkTsAst(node.expression, keys);
+  } else if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      if (child && typeof child === "object")
+        walkVueTemplateNode(child, keys);
+    }
+  }
+}
+function extractKeysFromSfcI18nBlock(content, keys) {
+  const i18nBlockRegex = /<i18n(?:\s[^>]*)?>([^]*?)<\/i18n>/g;
+  let match = i18nBlockRegex.exec(content);
+  while (match !== null) {
+    const blockContent = match[1].trim();
+    if (blockContent) {
+      try {
+        const parsed = JSON.parse(blockContent);
+        collectJsonKeys(parsed, "", keys);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        debug$2("Failed to parse <i18n> block as JSON: %s", message);
+        console.warn(`[@rotki/eslint-plugin] Failed to parse <i18n> block as JSON. If you are using JSON5, it is not supported. Error: ${message}`);
+      }
+    }
+    match = i18nBlockRegex.exec(content);
+  }
+}
+function collectJsonKeys(obj, prefix, keys) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj))
+    return;
+  for (const [key, value] of Object.entries(obj)) {
+    const fullKey = prefix ? `${prefix}.${key}` : key;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      collectJsonKeys(value, fullKey, keys);
+    } else {
+      keys.add(fullKey);
+    }
+  }
+}
+
+const debug$1 = debugFactory("@rotki/eslint-plugin:i18n-key-collector");
+const fileCache = /* @__PURE__ */ new Map();
+let cachedUsedKeys;
+const I18N_CALL_PATTERN = /\bt\s*\(|\bte\s*\(|\btc\s*\(|\$t\s*\(|\$te\s*\(|\$tc\s*\(/;
+const VUE_I18N_PATTERN = /\bt\s*\(|\bte\s*\(|\btc\s*\(|\$t\s*\(|\$te\s*\(|\$tc\s*\(|<i18n[\s>-]|v-t\b/;
+function parseSourceFile(content, filePath) {
+  const isVue = filePath.endsWith(".vue");
+  const source = isVue ? content : `<script lang="ts">
+${content}
+<\/script>`;
+  try {
+    return parse(source, {
+      parser: "@typescript-eslint/parser",
+      sourceType: "module"
+    });
+  } catch (error) {
+    debug$1(`Failed to parse file ${filePath}: ${String(error)}`);
+    return void 0;
+  }
+}
+function collectKeysFromFile(filePath) {
+  const keys = /* @__PURE__ */ new Set();
+  let mtimeMs;
+  try {
+    mtimeMs = statSync(filePath).mtimeMs;
+  } catch {
+    return keys;
+  }
+  const cached = fileCache.get(filePath);
+  if (cached && cached.mtimeMs === mtimeMs) {
+    return cached.keys;
+  }
+  let content;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    return keys;
+  }
+  const isVue = filePath.endsWith(".vue");
+  const pattern = isVue ? VUE_I18N_PATTERN : I18N_CALL_PATTERN;
+  if (!pattern.test(content)) {
+    fileCache.set(filePath, { keys, mtimeMs });
+    return keys;
+  }
+  const ast = parseSourceFile(content, filePath);
+  if (!ast)
+    return keys;
+  if (isVue) {
+    if (ast.templateBody) {
+      extractKeysFromVueTemplate(ast.templateBody, keys);
+    }
+    extractKeysFromSfcI18nBlock(content, keys);
+  }
+  if (ast.body) {
+    for (const node of ast.body) {
+      walkTsAst(node, keys);
+    }
+  }
+  fileCache.set(filePath, { keys, mtimeMs });
+  return keys;
+}
+function collectAllUsedKeys(srcDir, extensions) {
+  const resolvedSrc = resolve(srcDir);
+  if (cachedUsedKeys && cachedUsedKeys.srcDir === resolvedSrc && cachedUsedKeys.extensions.join(",") === extensions.join(",")) {
+    return cachedUsedKeys.keys;
+  }
+  const patterns = extensions.map((ext) => `**/*${ext}`);
+  const files = globSync(patterns, { absolute: true, cwd: resolvedSrc });
+  debug$1(`Found ${files.length} source files in ${resolvedSrc}`);
+  const allKeys = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const keys = collectKeysFromFile(file);
+    for (const key of keys) {
+      allKeys.add(key);
+    }
+  }
+  cachedUsedKeys = { extensions, keys: allKeys, srcDir: resolvedSrc };
+  return allKeys;
+}
+
+function extractLinkedKeys(value) {
+  const linkedKeyRegex = /@(?:\.\w+)?:(?:{([^}]+)}|(\w+(?:\.\w+)*))/g;
+  const keys = [];
+  let match = linkedKeyRegex.exec(value);
+  while (match !== null) {
+    const key = match[1] || match[2];
+    if (key)
+      keys.push(key);
+    match = linkedKeyRegex.exec(value);
+  }
+  return keys;
+}
+function prepareUsedKeys(usedKeys, ignorePatterns) {
+  const directKeys = /* @__PURE__ */ new Set();
+  const wildcardPrefixes = [];
+  for (const key of usedKeys) {
+    if (key.endsWith("*")) {
+      wildcardPrefixes.push(key.slice(0, -1));
+    } else {
+      directKeys.add(key);
+    }
+  }
+  const ignoreRegexps = ignorePatterns.map(
+    (pattern) => new RegExp(`^${pattern.replace(/[$()+?[\\\]^{|}]/g, "\\$&").replace(/\./g, "\\.").replace(/\*/g, ".*")}$`)
+  );
+  return { directKeys, ignoreRegexps, wildcardPrefixes };
+}
+function isKeyUsed(keyPath, prepared) {
+  if (prepared.directKeys.has(keyPath))
+    return true;
+  let dotIndex = keyPath.indexOf(".");
+  while (dotIndex !== -1) {
+    if (prepared.directKeys.has(keyPath.slice(0, dotIndex)))
+      return true;
+    dotIndex = keyPath.indexOf(".", dotIndex + 1);
+  }
+  for (const prefix of prepared.wildcardPrefixes) {
+    if (keyPath.startsWith(prefix))
+      return true;
+  }
+  for (const regex of prepared.ignoreRegexps) {
+    if (regex.test(keyPath))
+      return true;
+  }
+  return false;
+}
+
+const RULE_NAME$1 = "no-unused-i18n-keys";
+const debug = debugFactory("@rotki/eslint-plugin:no-unused-i18n-keys");
+function isLocaleFile(filename) {
+  return /(?:locales?|i18n|translations?|messages?|lang)\b/i.test(filename);
+}
+function isJsonProgram(ast) {
+  if (!ast || typeof ast !== "object" || !("type" in ast) || ast.type !== "Program")
+    return false;
+  if (!("body" in ast) || !Array.isArray(ast.body) || ast.body.length === 0)
+    return false;
+  const first = ast.body[0];
+  return first !== null && typeof first === "object" && "type" in first && first.type === "JSONExpressionStatement";
+}
+function isYamlProgram(ast) {
+  if (!ast || typeof ast !== "object" || !("type" in ast) || ast.type !== "Program")
+    return false;
+  if (!("body" in ast) || !Array.isArray(ast.body) || ast.body.length === 0)
+    return false;
+  const first = ast.body[0];
+  return first !== null && typeof first === "object" && "type" in first && first.type === "YAMLDocument";
+}
+function buildJsonKeyPaths(node, prefix, paths) {
+  for (const prop of node.properties) {
+    const keyName = prop.key.type === "JSONLiteral" ? String(prop.key.value) : prop.key.name;
+    const fullKey = prefix ? `${prefix}.${keyName}` : keyName;
+    if (prop.value.type === "JSONObjectExpression") {
+      buildJsonKeyPaths(prop.value, fullKey, paths);
+    } else {
+      paths.push({ key: fullKey, node: prop });
+    }
+  }
+}
+function collectJsonLinkedKeys(node, linkedKeys) {
+  for (const prop of node.properties) {
+    if (prop.value.type === "JSONLiteral" && typeof prop.value.value === "string") {
+      for (const key of extractLinkedKeys(prop.value.value)) {
+        linkedKeys.add(key);
+      }
+    } else if (prop.value.type === "JSONObjectExpression") {
+      collectJsonLinkedKeys(prop.value, linkedKeys);
+    }
+  }
+}
+function getYamlScalarValue(node) {
+  if (!node)
+    return void 0;
+  if (node.type === "YAMLWithMeta")
+    return getYamlScalarValue(node.value);
+  if (node.type === "YAMLScalar" && typeof node.value === "string")
+    return node.value;
+  return void 0;
+}
+function getYamlKeyName(node) {
+  if (!node)
+    return void 0;
+  if (node.type === "YAMLWithMeta")
+    return getYamlKeyName(node.value);
+  if (node.type === "YAMLScalar")
+    return String(node.value);
+  return void 0;
+}
+function isYamlMapping(node) {
+  if (!node)
+    return false;
+  if (node.type === "YAMLMapping")
+    return true;
+  if (node.type === "YAMLWithMeta" && node.value?.type === "YAMLMapping")
+    return true;
+  return false;
+}
+function getYamlMapping(node) {
+  if (!node)
+    return null;
+  if (node.type === "YAMLMapping")
+    return node;
+  if (node.type === "YAMLWithMeta" && node.value?.type === "YAMLMapping")
+    return node.value;
+  return null;
+}
+function buildYamlKeyPaths(node, prefix, paths) {
+  for (const pair of node.pairs) {
+    const keyName = getYamlKeyName(pair.key);
+    if (keyName === void 0)
+      continue;
+    const fullKey = prefix ? `${prefix}.${keyName}` : keyName;
+    if (isYamlMapping(pair.value)) {
+      const mapping = getYamlMapping(pair.value);
+      if (mapping) {
+        buildYamlKeyPaths(mapping, fullKey, paths);
+      }
+    } else {
+      paths.push({ key: fullKey, node: pair });
+    }
+  }
+}
+function collectYamlLinkedKeys(node, linkedKeys) {
+  for (const pair of node.pairs) {
+    const value = getYamlScalarValue(pair.value);
+    if (value) {
+      for (const key of extractLinkedKeys(value)) {
+        linkedKeys.add(key);
+      }
+    } else {
+      const mapping = getYamlMapping(pair.value);
+      if (mapping) {
+        collectYamlLinkedKeys(mapping, linkedKeys);
+      }
+    }
+  }
+}
+function removeJsonProperty(prop) {
+  const parent = prop.parent;
+  const index = parent.properties.indexOf(prop);
+  const isLast = index === parent.properties.length - 1;
+  const isOnly = parent.properties.length === 1;
+  let start = prop.range[0];
+  let end = prop.range[1];
+  if (isOnly) {
+    return { end, start };
+  }
+  if (isLast) {
+    const prev = parent.properties[index - 1];
+    start = prev.range[1];
+  } else {
+    end = parent.properties[index + 1].range[0];
+  }
+  return { end, start };
+}
+function removeYamlPair(pair) {
+  const parent = pair.parent;
+  const index = parent.pairs.indexOf(pair);
+  const isLast = index === parent.pairs.length - 1;
+  const isOnly = parent.pairs.length === 1;
+  let start = pair.range[0];
+  let end = pair.range[1];
+  if (isOnly) {
+    return { end, start };
+  }
+  if (isLast) {
+    const prev = parent.pairs[index - 1];
+    start = prev.range[1];
+  } else {
+    end = parent.pairs[index + 1].range[0];
+  }
+  return { end, start };
+}
+const noUnusedI18nKeys = createEslintRule({
+  create(context, optionsWithDefault) {
+    const options = optionsWithDefault[0];
+    const filename = getFilename(context);
+    if (!isLocaleFile(filename)) {
+      return {};
+    }
+    const sourceCode = getSourceCode(context);
+    const ast = sourceCode.ast;
+    if (isJsonProgram(ast)) {
+      debug(`Processing JSON locale file: ${filename}`);
+      const rootExpr = ast.body[0].expression;
+      if (rootExpr.type !== "JSONObjectExpression")
+        return {};
+      const usedKeys = collectAllUsedKeys(options.src, options.extensions);
+      const linkedKeys = /* @__PURE__ */ new Set();
+      collectJsonLinkedKeys(rootExpr, linkedKeys);
+      const allUsedKeys = /* @__PURE__ */ new Set([...usedKeys, ...linkedKeys]);
+      const prepared = prepareUsedKeys(allUsedKeys, options.ignoreKeys);
+      const paths = [];
+      buildJsonKeyPaths(rootExpr, "", paths);
+      return {
+        "Program:exit": function() {
+          for (const { key, node } of paths) {
+            if (!isKeyUsed(key, prepared)) {
+              const loc = node.loc;
+              context.report({
+                data: { key },
+                fix(fixer) {
+                  const { end, start } = removeJsonProperty(node);
+                  return fixer.removeRange([start, end]);
+                },
+                loc,
+                messageId: "unused"
+              });
+            }
+          }
+        }
+      };
+    }
+    if (isYamlProgram(ast)) {
+      debug(`Processing YAML locale file: ${filename}`);
+      const doc = ast.body[0];
+      const content = doc.content;
+      const mapping = getYamlMapping(content);
+      if (!mapping)
+        return {};
+      const usedKeys = collectAllUsedKeys(options.src, options.extensions);
+      const linkedKeys = /* @__PURE__ */ new Set();
+      collectYamlLinkedKeys(mapping, linkedKeys);
+      const allUsedKeys = /* @__PURE__ */ new Set([...usedKeys, ...linkedKeys]);
+      const prepared = prepareUsedKeys(allUsedKeys, options.ignoreKeys);
+      const paths = [];
+      buildYamlKeyPaths(mapping, "", paths);
+      return {
+        "Program:exit": function() {
+          for (const { key, node } of paths) {
+            if (!isKeyUsed(key, prepared)) {
+              const loc = node.loc;
+              context.report({
+                data: { key },
+                fix(fixer) {
+                  const { end, start } = removeYamlPair(node);
+                  return fixer.removeRange([start, end]);
+                },
+                loc,
+                messageId: "unused"
+              });
+            }
+          }
+        }
+      };
+    }
+    return {};
+  },
+  defaultOptions: [{
+    extensions: [".vue", ".ts"],
+    ignoreKeys: [],
+    src: "src"
+  }],
+  meta: {
+    docs: {
+      description: "disallow unused i18n keys in locale files",
+      recommendation: "recommended"
+    },
+    fixable: "code",
+    messages: {
+      unused: `The i18n key '{{ key }}' is unused`
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          extensions: {
+            items: { type: "string" },
+            type: "array"
+          },
+          ignoreKeys: {
+            items: { type: "string" },
+            type: "array"
+          },
+          src: {
+            type: "string"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "suggestion"
+  },
+  name: RULE_NAME$1
+});
+
+const RULE_NAME = "require-jsdoc-on-composable-options";
+const OPTIONS_PATTERN = /^Use\w+Options$/;
+const requireJsdocOnComposableOptions = createEslintRule({
+  create(context) {
+    const source = getSourceCode(context);
+    return {
+      TSInterfaceDeclaration(node) {
+        if (!OPTIONS_PATTERN.test(node.id.name))
+          return;
+        for (const member of node.body.body) {
+          if (member.type !== AST_NODE_TYPES.TSPropertySignature)
+            continue;
+          const comments = source.getCommentsBefore(member);
+          const hasJsdoc = comments.some((comment) => comment.type === "Block" && comment.value.startsWith("*"));
+          if (!hasJsdoc) {
+            const propertyName = member.key.type === AST_NODE_TYPES.Identifier ? member.key.name : source.getText(member.key);
+            context.report({
+              data: { interfaceName: node.id.name, property: propertyName },
+              messageId: "missingJsdoc",
+              node: member
+            });
+          }
+        }
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "Require JSDoc comments on composable options interface properties",
+      recommendation: "stylistic"
+    },
+    messages: {
+      missingJsdoc: "Property '{{ property }}' in '{{ interfaceName }}' should have a JSDoc comment."
+    },
+    schema: [],
+    type: "suggestion"
+  },
   name: RULE_NAME
 });
 
@@ -732,19 +1852,32 @@ const plugin = {
     version: pkg.version
   },
   rules: {
+    "composable-input-flexibility": composableInputFlexibility,
+    "composable-naming-convention": composableNamingConvention,
+    "composable-no-default-export": composableNoDefaultExport,
+    "composable-prefer-shallowref": composablePreferShallowref,
+    "composable-require-cleanup": composableRequireCleanup,
+    "composable-return-readonly": composableReturnReadonly,
+    "composable-ssr-safety": composableSsrSafety,
     "consistent-ref-type-annotation": consistentRefTypeAnnotation,
     "max-dependencies": maxDependencies,
     "no-deprecated-classes": noDeprecatedClasses,
     "no-deprecated-components": noDeprecatedComponents,
     "no-deprecated-props": noDeprecatedProps,
     "no-dot-ts-imports": noDotTsImport,
-    "no-legacy-library-import": noLegacyLibraryImport
+    "no-legacy-library-import": noLegacyLibraryImport,
+    "no-unused-i18n-keys": noUnusedI18nKeys,
+    "require-jsdoc-on-composable-options": requireJsdocOnComposableOptions
   }
 };
 
 const configs = {
   "recommended": createRecommended(plugin, "@rotki", false),
-  "recommended-flat": createRecommended(plugin, "@rotki", true)
+  "recommended-flat": createRecommended(plugin, "@rotki", true),
+  "strict": createConfig(plugin, "@rotki", false, "strict"),
+  "strict-flat": createConfig(plugin, "@rotki", true, "strict"),
+  "stylistic": createConfig(plugin, "@rotki", false, "stylistic"),
+  "stylistic-flat": createConfig(plugin, "@rotki", true, "stylistic")
 };
 
 const index = Object.assign(plugin, { configs });