@rotki/eslint-plugin 1.3.2 → 1.4.0

package/README.md

@@ -38,11 +38,9 @@ export default [
 
 Or configure individual rules:
 
-<!-- eslint-disable perfectionist/sort-imports -->
-
 ```js
-import * as jsoncParser from 'jsonc-eslint-parser';
 import rotkiPlugin from '@rotki/eslint-plugin';
+import * as jsoncParser from 'jsonc-eslint-parser';
 
 export default [
   {
@@ -62,20 +60,10 @@ export default [
 ];
 ```
 
-<!-- eslint-enable perfectionist/sort-imports -->
-
 ## Rules
 
-| Rule                                                                                                         | Description                                                               | Fixable     |
-| ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------- | ----------- |
-| [consistent-ref-type-annotation](https://rotki.github.io/eslint-plugin/rules/consistent-ref-type-annotation) | Ensures consistent type annotation position for ref, computed assignments | :black_nib: |
-| [max-dependencies](https://rotki.github.io/eslint-plugin/rules/max-dependencies)                             | Enforce a maximum number of dependencies per file                         |             |
-| [no-deprecated-classes](https://rotki.github.io/eslint-plugin/rules/no-deprecated-classes)                   | Disallow deprecated vuetify css classes                                   | :black_nib: |
-| [no-deprecated-components](https://rotki.github.io/eslint-plugin/rules/no-deprecated-components)             | Disallow deprecated components                                            | :black_nib: |
-| [no-deprecated-props](https://rotki.github.io/eslint-plugin/rules/no-deprecated-props)                       | Replace deprecated props with their replacements                          | :black_nib: |
-| [no-dot-ts-imports](https://rotki.github.io/eslint-plugin/rules/no-dot-ts-imports)                           | Disallow .ts extension in import statements                               | :black_nib: |
-| [no-legacy-library-import](https://rotki.github.io/eslint-plugin/rules/no-legacy-library-import)             | Disallow imports from @rotki/ui-library-compat                            | :black_nib: |
-| [no-unused-i18n-keys](https://rotki.github.io/eslint-plugin/rules/no-unused-i18n-keys)                       | Disallow unused i18n keys in locale files                                 | :black_nib: |
+See the [full list of available rules](https://rotki.github.io/eslint-plugin/rules/),
+including which are enabled by the `recommended` preset and which are auto-fixable.
 
 ## Documentation
 

package/dist/index.d.mts

@@ -27,6 +27,7 @@ type Options$3 = [{
 
 type Options$2 = [{
     autofix?: boolean;
+    writablePrefixes?: string[];
 }];
 
 type Options$1 = [{
@@ -57,6 +58,7 @@ declare const plugin: {
         'no-deprecated-props': PluginRuleModule<[]>;
         'no-dot-ts-imports': PluginRuleModule<[]>;
         'no-legacy-library-import': PluginRuleModule<[]>;
+        'no-redundant-flex-row': PluginRuleModule<[]>;
         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
     };
@@ -82,6 +84,7 @@ declare const _default: {
         'no-deprecated-props': PluginRuleModule<[]>;
         'no-dot-ts-imports': PluginRuleModule<[]>;
         'no-legacy-library-import': PluginRuleModule<[]>;
+        'no-redundant-flex-row': PluginRuleModule<[]>;
         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
     };
@@ -109,6 +112,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };
@@ -145,6 +149,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };
@@ -181,6 +186,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };
@@ -217,6 +223,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };
@@ -253,6 +260,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };
@@ -289,6 +297,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };

package/dist/index.d.ts

@@ -27,6 +27,7 @@ type Options$3 = [{
 
 type Options$2 = [{
     autofix?: boolean;
+    writablePrefixes?: string[];
 }];
 
 type Options$1 = [{
@@ -57,6 +58,7 @@ declare const plugin: {
         'no-deprecated-props': PluginRuleModule<[]>;
         'no-dot-ts-imports': PluginRuleModule<[]>;
         'no-legacy-library-import': PluginRuleModule<[]>;
+        'no-redundant-flex-row': PluginRuleModule<[]>;
         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
     };
@@ -82,6 +84,7 @@ declare const _default: {
         'no-deprecated-props': PluginRuleModule<[]>;
         'no-dot-ts-imports': PluginRuleModule<[]>;
         'no-legacy-library-import': PluginRuleModule<[]>;
+        'no-redundant-flex-row': PluginRuleModule<[]>;
         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
     };
@@ -109,6 +112,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };
@@ -145,6 +149,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };
@@ -181,6 +186,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };
@@ -217,6 +223,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };
@@ -253,6 +260,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };
@@ -289,6 +297,7 @@ declare const _default: {
                         'no-deprecated-props': PluginRuleModule<[]>;
                         'no-dot-ts-imports': PluginRuleModule<[]>;
                         'no-legacy-library-import': PluginRuleModule<[]>;
+                        'no-redundant-flex-row': PluginRuleModule<[]>;
                         'no-unused-i18n-keys': PluginRuleModule<Options$6>;
                         'require-jsdoc-on-composable-options': PluginRuleModule<[]>;
                     };

package/dist/index.mjs

@@ -1,5 +1,4 @@
 import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils';
-import * as compat from 'eslint-compat-utils';
 import debugFactory from 'debug';
 import { extname, resolve } from 'node:path';
 import { pascalCase, kebabCase } from 'scule';
@@ -7,32 +6,35 @@ import { statSync, readFileSync } from 'node:fs';
 import { globSync } from 'tinyglobby';
 import { parse } from 'vue-eslint-parser';
 
-const version = "1.3.2";
+const version = "1.4.0";
 const pkg = {
 	version: version};
 
 function getFilename(context) {
-  return compat.getFilename(context);
+  return context.filename;
 }
 function getSourceCode(context) {
-  return compat.getSourceCode(context);
+  return context.sourceCode;
 }
 
 const COMPOSABLE_PATTERN = /^use[A-Z]/;
 function isComposableName(name) {
   return COMPOSABLE_PATTERN.test(name);
 }
+function isComposableNode(node) {
+  if (node.type === AST_NODE_TYPES.FunctionDeclaration)
+    return !!node.id && isComposableName(node.id.name);
+  if (node.type === AST_NODE_TYPES.ArrowFunctionExpression || node.type === AST_NODE_TYPES.FunctionExpression) {
+    const parent = node.parent;
+    return parent?.type === AST_NODE_TYPES.VariableDeclarator && parent.id.type === AST_NODE_TYPES.Identifier && isComposableName(parent.id.name);
+  }
+  return false;
+}
 function getEnclosingComposable(node) {
   let current = node.parent;
   while (current) {
-    if (current.type === AST_NODE_TYPES.FunctionDeclaration && current.id && isComposableName(current.id.name))
+    if (isComposableNode(current))
       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;
@@ -64,22 +66,18 @@ function createRecommended(plugin, name, flat) {
   return createConfig(plugin, name, flat, "recommended");
 }
 
+function getLiteralValue(node, stringOnly) {
+  if (node.value == null)
+    return !stringOnly && node.bigint != null ? node.bigint : null;
+  if (typeof node.value === "string")
+    return node.value;
+  return stringOnly ? null : String(node.value);
+}
 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) {
+  if (node.type === "Literal")
+    return getLiteralValue(node, stringOnly);
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0 && node.quasis.length === 1)
     return node.quasis[0].value.cooked;
-  }
   return null;
 }
 function getStaticPropertyName(node) {
@@ -166,7 +164,7 @@ function defineTemplateBodyVisitor(context, templateBodyVisitor, scriptVisitor,
   );
 }
 
-const RULE_NAME$f = "composable-input-flexibility";
+const RULE_NAME$g = "composable-input-flexibility";
 function checkParamForRef(param) {
   let annotation;
   if (param.type === AST_NODE_TYPES.Identifier && param.typeAnnotation) {
@@ -247,10 +245,10 @@ const composableInputFlexibility = createEslintRule({
     ],
     type: "suggestion"
   },
-  name: RULE_NAME$f
+  name: RULE_NAME$g
 });
 
-const RULE_NAME$e = "composable-naming-convention";
+const RULE_NAME$f = "composable-naming-convention";
 function getComposableFunction(node) {
   if (node.type === AST_NODE_TYPES.FunctionDeclaration) {
     if (!node.id || !isComposableName(node.id.name))
@@ -279,6 +277,9 @@ const composableNamingConvention = createEslintRule({
         checkComposable(node);
       }
     };
+    function isMismatchedConvention(typeName, prefix, suffix, expected) {
+      return !!typeName && typeName.startsWith(prefix) && typeName.endsWith(suffix) && typeName !== expected;
+    }
     function checkComposable(node) {
       const info = getComposableFunction(node);
       if (!info)
@@ -288,26 +289,14 @@ const composableNamingConvention = createEslintRule({
       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
-          });
-        }
+        const typeName = annotation ? getTypeReferenceName(annotation) : void 0;
+        if (isMismatchedConvention(typeName, "Use", "Options", 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
-          });
-        }
+        if (isMismatchedConvention(returnTypeName, "Use", "Return", expectedReturn))
+          context.report({ data: { expected: expectedReturn, got: returnTypeName }, messageId: "returnNaming", node: info.returnType });
       }
     }
     function getParamTypeAnnotation(param) {
@@ -332,10 +321,10 @@ const composableNamingConvention = createEslintRule({
     schema: [],
     type: "suggestion"
   },
-  name: RULE_NAME$e
+  name: RULE_NAME$f
 });
 
-const RULE_NAME$d = "composable-no-default-export";
+const RULE_NAME$e = "composable-no-default-export";
 const composableNoDefaultExport = createEslintRule({
   create(context) {
     let hasComposable = false;
@@ -375,10 +364,10 @@ const composableNoDefaultExport = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$d
+  name: RULE_NAME$e
 });
 
-const RULE_NAME$c = "composable-prefer-shallowref";
+const RULE_NAME$d = "composable-prefer-shallowref";
 const composablePreferShallowref = createEslintRule({
   create(context) {
     const autofix = context.options[0]?.autofix ?? false;
@@ -437,10 +426,10 @@ const composablePreferShallowref = createEslintRule({
     ],
     type: "suggestion"
   },
-  name: RULE_NAME$c
+  name: RULE_NAME$d
 });
 
-const RULE_NAME$b = "composable-require-cleanup";
+const RULE_NAME$c = "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"]);
@@ -534,10 +523,11 @@ const composableRequireCleanup = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$b
+  name: RULE_NAME$c
 });
 
-const RULE_NAME$a = "composable-return-readonly";
+const RULE_NAME$b = "composable-return-readonly";
+const DEFAULT_WRITABLE_PREFIXES = ["model"];
 const REACTIVE_CREATORS = /* @__PURE__ */ new Set(["ref", "shallowRef"]);
 const READONLY_CREATORS = /* @__PURE__ */ new Set(["computed"]);
 function isReadonlyCall(node) {
@@ -546,9 +536,49 @@ function isReadonlyCall(node) {
 const composableReturnReadonly = createEslintRule({
   create(context) {
     const autofix = context.options[0]?.autofix ?? false;
+    const writablePrefixes = context.options[0]?.writablePrefixes ?? DEFAULT_WRITABLE_PREFIXES;
     const source = getSourceCode(context);
     const reactiveVars = /* @__PURE__ */ new Set();
     const readonlyVars = /* @__PURE__ */ new Set();
+    function isWritableByConvention(name) {
+      return writablePrefixes.some((prefix) => {
+        if (!name.startsWith(prefix))
+          return false;
+        const next = name[prefix.length];
+        return next === void 0 || next >= "A" && next <= "Z";
+      });
+    }
+    function reportWithFixOrSuggest(prop, name, messageId, suggestMessageId, fixFn) {
+      context.report({
+        data: { name },
+        ...autofix ? { fix: fixFn } : { suggest: [{ data: { name }, fix: fixFn, messageId: suggestMessageId }] },
+        messageId,
+        node: prop
+      });
+    }
+    function checkUnnecessaryReadonly(prop) {
+      const valueNode = prop.shorthand ? null : prop.value;
+      if (!valueNode || !isReadonlyCall(valueNode))
+        return false;
+      const innerName = valueNode.arguments[0].name;
+      if (!readonlyVars.has(innerName))
+        return false;
+      reportWithFixOrSuggest(prop, innerName, "unnecessaryReadonly", "suggestRemoveReadonly", (fixer) => fixer.replaceText(valueNode, innerName));
+      return true;
+    }
+    function checkMissingReadonly(prop) {
+      if (prop.shorthand && prop.key.type === AST_NODE_TYPES.Identifier && reactiveVars.has(prop.key.name)) {
+        const keyName = prop.key.name;
+        if (isWritableByConvention(keyName))
+          return;
+        reportWithFixOrSuggest(prop, keyName, "wrapReadonly", "suggestWrapReadonly", (fixer) => fixer.replaceText(prop, `${keyName}: readonly(${keyName})`));
+      } else if (!prop.shorthand && prop.value.type === AST_NODE_TYPES.Identifier && reactiveVars.has(prop.value.name)) {
+        const valueName = prop.value.name;
+        if (isWritableByConvention(valueName))
+          return;
+        reportWithFixOrSuggest(prop, valueName, "wrapReadonly", "suggestWrapReadonly", (fixer) => fixer.replaceText(prop.value, `readonly(${prop.value.type === AST_NODE_TYPES.Identifier ? prop.value.name : source.getText(prop.value)})`));
+      }
+    }
     return {
       ReturnStatement: (node) => {
         if (!getEnclosingComposable(node))
@@ -558,39 +588,8 @@ const composableReturnReadonly = createEslintRule({
         for (const prop of node.argument.properties) {
           if (prop.type !== AST_NODE_TYPES.Property)
             continue;
-          const valueNode = prop.shorthand ? null : prop.value;
-          if (valueNode && isReadonlyCall(valueNode)) {
-            const innerName = valueNode.arguments[0].name;
-            if (readonlyVars.has(innerName)) {
-              const fixFn = (fixer) => fixer.replaceText(valueNode, innerName);
-              context.report({
-                data: { name: innerName },
-                ...autofix ? { fix: fixFn } : { suggest: [{ data: { name: innerName }, fix: fixFn, messageId: "suggestRemoveReadonly" }] },
-                messageId: "unnecessaryReadonly",
-                node: prop
-              });
-              continue;
-            }
-          }
-          if (prop.shorthand && prop.key.type === AST_NODE_TYPES.Identifier && reactiveVars.has(prop.key.name)) {
-            const keyName = prop.key.name;
-            const fixFn = (fixer) => fixer.replaceText(prop, `${keyName}: readonly(${keyName})`);
-            context.report({
-              data: { name: keyName },
-              ...autofix ? { fix: fixFn } : { suggest: [{ data: { name: keyName }, fix: fixFn, messageId: "suggestWrapReadonly" }] },
-              messageId: "wrapReadonly",
-              node: prop
-            });
-          } else if (!prop.shorthand && prop.value.type === AST_NODE_TYPES.Identifier && reactiveVars.has(prop.value.name)) {
-            const valueName = prop.value.name;
-            const fixFn = (fixer) => fixer.replaceText(prop.value, `readonly(${prop.value.type === AST_NODE_TYPES.Identifier ? prop.value.name : source.getText(prop.value)})`);
-            context.report({
-              data: { name: valueName },
-              ...autofix ? { fix: fixFn } : { suggest: [{ data: { name: valueName }, fix: fixFn, messageId: "suggestWrapReadonly" }] },
-              messageId: "wrapReadonly",
-              node: prop
-            });
-          }
+          if (!checkUnnecessaryReadonly(prop))
+            checkMissingReadonly(prop);
         }
       },
       VariableDeclarator: (node) => {
@@ -609,7 +608,7 @@ const composableReturnReadonly = createEslintRule({
       }
     };
   },
-  defaultOptions: [{ autofix: false }],
+  defaultOptions: [{ autofix: false, writablePrefixes: DEFAULT_WRITABLE_PREFIXES }],
   meta: {
     docs: {
       description: "Require returned refs from composables to be wrapped with readonly()",
@@ -631,6 +630,12 @@ const composableReturnReadonly = createEslintRule({
             default: false,
             description: "Enable auto-fix. When disabled, the fix is available as a suggestion.",
             type: "boolean"
+          },
+          writablePrefixes: {
+            default: DEFAULT_WRITABLE_PREFIXES,
+            description: "Returned variables whose name starts with one of these prefixes are exempt from the readonly() requirement (e.g. refs intended for v-model binding).",
+            items: { type: "string" },
+            type: "array"
           }
         },
         type: "object"
@@ -638,10 +643,10 @@ const composableReturnReadonly = createEslintRule({
     ],
     type: "suggestion"
   },
-  name: RULE_NAME$a
+  name: RULE_NAME$b
 });
 
-const RULE_NAME$9 = "composable-ssr-safety";
+const RULE_NAME$a = "composable-ssr-safety";
 const BROWSER_GLOBALS = /* @__PURE__ */ new Set(["window", "document", "navigator"]);
 const LIFECYCLE_HOOKS = /* @__PURE__ */ new Set(["onMounted", "onBeforeMount"]);
 function isInsideLifecycleHook(node) {
@@ -668,15 +673,12 @@ function isInsideTypeofCheck(node) {
   }
   return false;
 }
+function isTypeofBrowserGlobal(node) {
+  return node.type === AST_NODE_TYPES.UnaryExpression && node.operator === "typeof" && node.argument.type === AST_NODE_TYPES.Identifier && BROWSER_GLOBALS.has(node.argument.name);
+}
 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.BinaryExpression)
+    return isTypeofBrowserGlobal(node.left) || isTypeofBrowserGlobal(node.right);
   if (node.type === AST_NODE_TYPES.LogicalExpression)
     return hasTypeofCheck(node.left) || hasTypeofCheck(node.right);
   return false;
@@ -732,56 +734,51 @@ const composableSsrSafety = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$9
+  name: RULE_NAME$a
 });
 
 const debug$6 = debugFactory("@rotki/eslint-plugin:consistent-ref-type-annotation");
-const RULE_NAME$8 = "consistent-ref-type-annotation";
+const RULE_NAME$9 = "consistent-ref-type-annotation";
 const FIXABLE_METHODS = /* @__PURE__ */ new Set(["ref", "computed"]);
-function checkAssignmentDeclaration(context, source, node, declaration, allowInference) {
-  let declarationTypeArguments;
+function getFixableCallExpression(declaration) {
   const init = declaration.init;
-  if (!(init && init.type === TSESTree.AST_NODE_TYPES.CallExpression))
-    return;
+  if (!init || init.type !== TSESTree.AST_NODE_TYPES.CallExpression)
+    return void 0;
   const callee = init.callee;
-  if (!(callee && callee.type === TSESTree.AST_NODE_TYPES.Identifier))
-    return;
-  if (!FIXABLE_METHODS.has(callee.name))
+  if (!callee || callee.type !== TSESTree.AST_NODE_TYPES.Identifier || !FIXABLE_METHODS.has(callee.name))
+    return void 0;
+  return { callee, init };
+}
+function getDeclarationTypeArguments(declaration) {
+  const typeNode = declaration.id.typeAnnotation?.typeAnnotation;
+  if (typeNode?.type === TSESTree.AST_NODE_TYPES.TSTypeReference)
+    return typeNode.typeArguments;
+  return void 0;
+}
+function checkAssignmentDeclaration(context, source, node, declaration, allowInference) {
+  const call = getFixableCallExpression(declaration);
+  if (!call)
     return;
+  const { callee, init } = call;
   const name = callee.name;
   debug$6(`found ${name}, checking type arguments`);
-  const initializationTypeArguments = init.typeArguments;
+  const initTypeArgs = init.typeArguments;
+  const declTypeArgs = getDeclarationTypeArguments(declaration);
   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)
+  if (initTypeArgs && !declTypeArgs)
     return;
   debug$6(`generating report for ${name}`);
-  if (!initializationTypeArguments && !declarationTypeArguments) {
-    if (allowInference) {
-      debug$6("type inference is allowed");
-    } else {
-      context.report({
-        data: {
-          name
-        },
-        messageId: "missingType",
-        node
-      });
-    }
+  if (!initTypeArgs && !declTypeArgs) {
+    if (!allowInference)
+      context.report({ data: { name }, messageId: "missingType", node });
     return;
   }
   context.report({
-    data: {
-      name
-    },
+    data: { name },
     fix(fixer) {
       const fixes = [];
-      if (!initializationTypeArguments && callee)
-        fixes.push(fixer.insertTextAfter(callee, source.getText(declarationTypeArguments)));
+      if (!initTypeArgs && callee)
+        fixes.push(fixer.insertTextAfter(callee, source.getText(declTypeArgs)));
       if (typeAnnotation)
         fixes.push(fixer.remove(typeAnnotation));
       return fixes;
@@ -830,10 +827,10 @@ const consistentRefTypeAnnotation = createEslintRule({
     ],
     type: "problem"
   },
-  name: RULE_NAME$8
+  name: RULE_NAME$9
 });
 
-const RULE_NAME$7 = "max-dependencies";
+const RULE_NAME$8 = "max-dependencies";
 const maxDependencies = createEslintRule({
   create(context, [options]) {
     let dependencyCount = 0;
@@ -893,10 +890,10 @@ const maxDependencies = createEslintRule({
     ],
     type: "suggestion"
   },
-  name: RULE_NAME$7
+  name: RULE_NAME$8
 });
 
-const RULE_NAME$6 = "no-deprecated-classes";
+const RULE_NAME$7 = "no-deprecated-classes";
 const debug$5 = debugFactory("@rotki/eslint-plugin:no-deprecated-classes");
 const stringReplacements = /* @__PURE__ */ new Map([
   ["d-block", "block"],
@@ -973,51 +970,62 @@ function reportReplacement(className, replacement, node, context, source, positi
     messageId: "replacedWith"
   });
 }
+function splitClassNames(classNames, reportNode) {
+  return classNames.split(/\s+/).map((className) => ({ className, position: classNames.indexOf(className) + 1, reportNode }));
+}
+function* extractFromObject(node) {
+  for (const prop of node.properties) {
+    if (prop.type !== "Property")
+      continue;
+    const classNames = getStaticPropertyName(prop);
+    if (classNames)
+      yield* splitClassNames(classNames, prop.key);
+  }
+}
+function* extractFromArray(node) {
+  for (const element of node.elements) {
+    if (element == null || element.type === "SpreadElement")
+      continue;
+    yield* extractClassNames(element);
+  }
+}
+function* extractFromTemplateLiteral(node) {
+  for (const templateElement of node.quasis) {
+    const classNames = templateElement.value.cooked;
+    if (classNames !== null)
+      yield* splitClassNames(classNames, templateElement);
+  }
+  for (const expr of node.expressions)
+    yield* extractClassNames(expr, true);
+}
+function* extractFromBinary(node) {
+  if (node.operator !== "+")
+    return;
+  if (node.left.type !== "PrivateIdentifier")
+    yield* extractClassNames(node.left, true);
+  yield* extractClassNames(node.right, true);
+}
 function* extractClassNames(node, textOnly = false) {
   if (node.type === "Literal") {
-    const classNames = `${node.value}`;
-    yield* classNames.split(/\s+/).map((className) => ({ className, position: classNames.indexOf(className) + 1, reportNode: node }));
+    yield* splitClassNames(`${node.value}`, node);
     return;
   }
   if (node.type === "TemplateLiteral") {
-    for (const templateElement of node.quasis) {
-      const classNames = templateElement.value.cooked;
-      if (classNames === null)
-        continue;
-      yield* classNames.split(/\s+/).map((className) => ({ className, position: classNames.indexOf(className) + 1, reportNode: templateElement }));
-    }
-    for (const expr of node.expressions)
-      yield* extractClassNames(expr, true);
+    yield* extractFromTemplateLiteral(node);
     return;
   }
   if (node.type === "BinaryExpression") {
-    if (node.operator !== "+")
-      return;
-    yield* extractClassNames(node.left, true);
-    yield* extractClassNames(node.right, true);
+    yield* extractFromBinary(node);
     return;
   }
   if (textOnly)
     return;
   if (node.type === "ObjectExpression") {
-    for (const prop of node.properties) {
-      if (prop.type !== "Property")
-        continue;
-      const classNames = getStaticPropertyName(prop);
-      if (!classNames)
-        continue;
-      yield* classNames.split(/\s+/).map((className) => ({ className, position: classNames.indexOf(className) + 1, reportNode: prop.key }));
-    }
+    yield* extractFromObject(node);
     return;
   }
   if (node.type === "ArrayExpression") {
-    for (const element of node.elements) {
-      if (element == null)
-        continue;
-      if (element.type === "SpreadElement")
-        continue;
-      yield* extractClassNames(element);
-    }
+    yield* extractFromArray(node);
   }
   if (node.type === "ConditionalExpression") {
     yield* extractClassNames(node.consequent);
@@ -1064,11 +1072,11 @@ const noDeprecatedClasses = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$6
+  name: RULE_NAME$7
 });
 
 const debug$4 = debugFactory("@rotki/eslint-plugin:no-deprecated-components");
-const RULE_NAME$5 = "no-deprecated-components";
+const RULE_NAME$6 = "no-deprecated-components";
 const vuetify = {
   VApp: true,
   VAppBar: true,
@@ -1105,7 +1113,7 @@ const skipInLegacy = /* @__PURE__ */ new Set([
   "Fragment"
 ]);
 function hasReplacement$1(tag) {
-  return Object.prototype.hasOwnProperty.call(replacements$1, tag);
+  return Object.hasOwn(replacements$1, tag);
 }
 const noDeprecatedComponents = createEslintRule({
   create(context, optionsWithDefault) {
@@ -1173,11 +1181,10 @@ const noDeprecatedComponents = createEslintRule({
     ],
     type: "problem"
   },
-  name: RULE_NAME$5
+  name: RULE_NAME$6
 });
 
-const debug$3 = debugFactory("@rotki/eslint-plugin:no-deprecated-props");
-const RULE_NAME$4 = "no-deprecated-props";
+const RULE_NAME$5 = "no-deprecated-props";
 const replacements = {
   RuiRadio: {
     internalValue: "value"
@@ -1200,37 +1207,34 @@ function getPropName(node) {
   }
   return kebabCase(node.key.rawName);
 }
+function isNonBindDirective(node) {
+  return node.directive && node.value?.type === "VExpressionContainer" && (node.key.name.name !== "bind" || !node.key.argument);
+}
+function getPropNameNode(node) {
+  return node.directive ? node.key.argument : node.key;
+}
 const noDeprecatedProps = createEslintRule({
   create(context) {
     return defineTemplateBodyVisitor(context, {
       VAttribute(node) {
-        if (node.directive && (node.value?.type === "VExpressionContainer" && (node.key.name.name !== "bind" || !node.key.argument)))
+        if (isNonBindDirective(node))
           return;
         const tag = pascalCase(node.parent.parent.rawName);
         if (!hasReplacement(tag))
           return;
-        debug$3(`${tag} has replacement properties`);
         const propName = getPropName(node);
-        const propNameNode = node.directive ? node.key.argument : node.key;
-        if (!propName || !propNameNode) {
-          debug$3("could not get prop name and/or node");
+        const propNameNode = getPropNameNode(node);
+        if (!propName || !propNameNode)
           return;
-        }
         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
-          });
-        }
+        if (!match)
+          return;
+        context.report({
+          data: { prop: match.original, replacement: match.replacement },
+          fix: (fixer) => fixer.replaceText(propNameNode, match.replacement),
+          messageId: "replacedWith",
+          node: propNameNode
+        });
       }
     });
   },
@@ -1247,10 +1251,10 @@ const noDeprecatedProps = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$4
+  name: RULE_NAME$5
 });
 
-const RULE_NAME$3 = "no-dot-ts-imports";
+const RULE_NAME$4 = "no-dot-ts-imports";
 const noDotTsImport = createEslintRule({
   create(context) {
     return {
@@ -1285,10 +1289,10 @@ const noDotTsImport = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$3
+  name: RULE_NAME$4
 });
 
-const RULE_NAME$2 = "no-legacy-library-import";
+const RULE_NAME$3 = "no-legacy-library-import";
 const legacyLibrary = "@rotki/ui-library-compat";
 const newLibrary = "@rotki/ui-library";
 const noLegacyLibraryImport = createEslintRule({
@@ -1321,6 +1325,119 @@ const noLegacyLibraryImport = createEslintRule({
     schema: [],
     type: "problem"
   },
+  name: RULE_NAME$3
+});
+
+const RULE_NAME$2 = "no-redundant-flex-row";
+const debug$3 = debugFactory("@rotki/eslint-plugin:no-redundant-flex-row");
+function stripImportant(token) {
+  return token.replace(/^!/, "").replace(/!$/, "");
+}
+function isUnconditional(token) {
+  return !token.includes(":");
+}
+function isFlexDisplay(token) {
+  if (!isUnconditional(token))
+    return false;
+  const base = stripImportant(token);
+  return base === "flex" || base === "inline-flex";
+}
+function isFlexRow(token) {
+  if (!isUnconditional(token))
+    return false;
+  return stripImportant(token) === "flex-row";
+}
+function tokenize(value) {
+  const tokens = [];
+  const matcher = /\S+/g;
+  let match;
+  while ((match = matcher.exec(value)) !== null)
+    tokens.push({ start: match.index, text: match[0] });
+  return tokens;
+}
+function removalRange(value, token, contentStart) {
+  let startRel = token.start;
+  let endRel = token.start + token.text.length;
+  if (startRel > 0 && /\s/.test(value[startRel - 1])) {
+    while (startRel > 0 && /\s/.test(value[startRel - 1]))
+      startRel--;
+  } else {
+    while (endRel < value.length && /\s/.test(value[endRel]))
+      endRel++;
+  }
+  return [contentStart + startRel, contentStart + endRel];
+}
+function reportRedundant(source, context, sourceCode) {
+  const tokens = tokenize(source.value);
+  if (!tokens.some((token) => isFlexDisplay(token.text)))
+    return;
+  for (const token of tokens) {
+    if (!isFlexRow(token.text))
+      continue;
+    debug$3(`found redundant flex-row token '${token.text}'`);
+    const tokenRange = [
+      source.contentStart + token.start,
+      source.contentStart + token.start + token.text.length
+    ];
+    const removal = removalRange(source.value, token, source.contentStart);
+    context.report({
+      data: { className: token.text },
+      fix(fixer) {
+        return fixer.removeRange(removal);
+      },
+      loc: {
+        end: sourceCode.getLocFromIndex(tokenRange[1]),
+        start: sourceCode.getLocFromIndex(tokenRange[0])
+      },
+      messageId: "redundantFlexRow"
+    });
+  }
+}
+function plainStringLists(expression) {
+  if (expression.type === "Literal" && typeof expression.value === "string")
+    return [{ contentStart: expression.range[0] + 1, value: expression.value }];
+  if (expression.type === "TemplateLiteral" && expression.expressions.length === 0 && expression.quasis.length === 1) {
+    const quasi = expression.quasis[0];
+    const cooked = quasi.value.cooked;
+    if (cooked !== null)
+      return [{ contentStart: quasi.range[0] + 1, value: cooked }];
+  }
+  return [];
+}
+const noRedundantFlexRow = createEslintRule({
+  create(context) {
+    const sourceCode = getSourceCode(context);
+    return defineTemplateBodyVisitor(context, {
+      'VAttribute[directive=false][key.name="class"]': function(node) {
+        if (!node.value || !node.value.value || !node.value.range)
+          return;
+        reportRedundant(
+          { contentStart: node.value.range[0] + 1, value: node.value.value },
+          context,
+          sourceCode
+        );
+      },
+      "VAttribute[directive=true][key.name.name='bind'][key.argument.name='class'] > VExpressionContainer.value": function(node) {
+        if (!node.expression)
+          return;
+        for (const source of plainStringLists(node.expression))
+          reportRedundant(source, context, sourceCode);
+      }
+    });
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "disallow redundant `flex-row` since `flex` already defaults to the row direction",
+      recommendation: "recommended"
+    },
+    fixable: "code",
+    messages: {
+      redundantFlexRow: `'{{ className }}' is redundant because 'flex' already lays out in the row direction; remove it, or keep it only behind a conditional variant (e.g. 'sm:flex-row')`
+    },
+    schema: [],
+    type: "suggestion"
+  },
   name: RULE_NAME$2
 });
 
@@ -1337,18 +1454,39 @@ function isI18nCallExpression(node) {
     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)
+function getQuasiText(quasi) {
+  if (!quasi || typeof quasi !== "object" || !("value" in quasi))
     return void 0;
-  const firstQuasi = quasis[0];
-  if (!firstQuasi || typeof firstQuasi !== "object" || !("value" in firstQuasi))
-    return void 0;
-  const quasiObj = firstQuasi.value;
+  const quasiObj = quasi.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;
+  if ("cooked" in quasiObj && typeof quasiObj.cooked === "string")
+    return quasiObj.cooked;
+  if ("raw" in quasiObj && typeof quasiObj.raw === "string")
+    return quasiObj.raw;
+  return void 0;
+}
+function getTemplateLiteralText(arg) {
+  const { expressions, quasis } = arg;
+  if (!Array.isArray(quasis) || !Array.isArray(expressions) || quasis.length === 0)
+    return void 0;
+  return getQuasiText(quasis[0]);
+}
+function isStaticTemplateLiteral(arg) {
+  return Array.isArray(arg.expressions) && arg.expressions.length === 0 && Array.isArray(arg.quasis) && arg.quasis.length === 1;
+}
+function extractKeyFromArg(arg) {
+  if (arg.type === "Literal" && typeof arg.value === "string")
+    return arg.value;
+  if (arg.type === "TemplateLiteral") {
+    const text = getTemplateLiteralText(arg);
+    if (text === void 0)
+      return void 0;
+    if (isStaticTemplateLiteral(arg))
+      return text;
+    return text ? `${text}*` : void 0;
+  }
+  return void 0;
 }
 function extractKeysFromCallExpression(node, keys) {
   if (!isI18nCallExpression(node))
@@ -1359,17 +1497,9 @@ function extractKeysFromCallExpression(node, keys) {
   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 key = extractKeyFromArg(arg);
+  if (key)
+    keys.add(key);
 }
 const TS_AST_CHILD_KEYS = /* @__PURE__ */ new Set([
   "alternate",
@@ -1446,34 +1576,44 @@ function getDirectiveExpression(attr) {
 function extractKeysFromVueTemplate(templateBody, keys) {
   walkVueTemplateNode(templateBody, keys);
 }
+function collectI18nTKeys(element, keys) {
+  if (element.rawName !== "i18n-t" && element.name !== "i18n-t")
+    return;
+  for (const attr of element.startTag.attributes) {
+    if (isKeypathAttribute(attr))
+      keys.add(attr.value.value);
+  }
+}
+function collectAttributeKeys(element, keys) {
+  for (const attr of element.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);
+  }
+}
+function walkChildren(node, keys) {
+  if (!("children" in node) || !Array.isArray(node.children))
+    return;
+  for (const child of node.children) {
+    if (child && typeof child === "object")
+      walkVueTemplateNode(child, 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);
+    collectI18nTKeys(node, keys);
+    collectAttributeKeys(node, keys);
+    walkChildren(node, 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);
-    }
+  } else {
+    walkChildren(node, keys);
   }
 }
 function extractKeysFromSfcI18nBlock(content, keys) {
@@ -1527,45 +1667,42 @@ ${content}
     return void 0;
   }
 }
-function collectKeysFromFile(filePath) {
-  const keys = /* @__PURE__ */ new Set();
-  let mtimeMs;
+function readFileWithMtime(filePath) {
   try {
-    mtimeMs = statSync(filePath).mtimeMs;
+    const mtimeMs = statSync(filePath).mtimeMs;
+    const content = readFileSync(filePath, "utf-8");
+    return { content, 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;
+    return void 0;
   }
-  const ast = parseSourceFile(content, filePath);
-  if (!ast)
-    return keys;
+}
+function extractKeysFromAst(ast, content, isVue, keys) {
   if (isVue) {
-    if (ast.templateBody) {
+    if (ast.templateBody)
       extractKeysFromVueTemplate(ast.templateBody, keys);
-    }
     extractKeysFromSfcI18nBlock(content, keys);
   }
   if (ast.body) {
-    for (const node of ast.body) {
+    for (const node of ast.body)
       walkTsAst(node, keys);
-    }
   }
-  fileCache.set(filePath, { keys, mtimeMs });
+}
+function collectKeysFromFile(filePath) {
+  const file = readFileWithMtime(filePath);
+  if (!file)
+    return /* @__PURE__ */ new Set();
+  const cached = fileCache.get(filePath);
+  if (cached && cached.mtimeMs === file.mtimeMs)
+    return cached.keys;
+  const keys = /* @__PURE__ */ new Set();
+  const isVue = filePath.endsWith(".vue");
+  const pattern = isVue ? VUE_I18N_PATTERN : I18N_CALL_PATTERN;
+  if (pattern.test(file.content)) {
+    const ast = parseSourceFile(file.content, filePath);
+    if (ast)
+      extractKeysFromAst(ast, file.content, isVue, keys);
+  }
+  fileCache.set(filePath, { keys, mtimeMs: file.mtimeMs });
   return keys;
 }
 function collectAllUsedKeys(srcDir, extensions) {
@@ -1639,21 +1776,22 @@ 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;
+function isProgramWithBody(ast) {
+  return !!ast && typeof ast === "object" && "type" in ast && ast.type === "Program" && "body" in ast && Array.isArray(ast.body) && ast.body.length > 0;
+}
+function getProgramFirstBodyType(ast) {
+  if (!isProgramWithBody(ast))
+    return void 0;
   const first = ast.body[0];
-  return first !== null && typeof first === "object" && "type" in first && first.type === "JSONExpressionStatement";
+  if (!first || typeof first !== "object" || !("type" in first) || typeof first.type !== "string")
+    return void 0;
+  return first.type;
+}
+function isJsonProgram(ast) {
+  return getProgramFirstBodyType(ast) === "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";
+  return getProgramFirstBodyType(ast) === "YAMLDocument";
 }
 function buildJsonKeyPaths(node, prefix, paths) {
   for (const prop of node.properties) {
@@ -1954,6 +2092,7 @@ const plugin = {
     "no-deprecated-props": noDeprecatedProps,
     "no-dot-ts-imports": noDotTsImport,
     "no-legacy-library-import": noLegacyLibraryImport,
+    "no-redundant-flex-row": noRedundantFlexRow,
     "no-unused-i18n-keys": noUnusedI18nKeys,
     "require-jsdoc-on-composable-options": requireJsdocOnComposableOptions
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rotki/eslint-plugin",
-  "version": "1.3.2",
+  "version": "1.4.0",
   "type": "module",
   "license": "AGPL-3.0",
   "bugs": {
@@ -25,43 +25,44 @@
   },
   "sideEffects": false,
   "peerDependencies": {
-    "eslint": "^9.20.0"
+    "eslint": "^9.20.0 || ^10.0.0"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "8.55.0",
+    "@typescript-eslint/utils": "8.60.1",
     "debug": "4.4.3",
-    "eslint-compat-utils": "0.6.5",
-    "jsonc-eslint-parser": "2.4.2",
+    "jsonc-eslint-parser": "3.1.0",
     "scule": "1.3.0",
-    "tinyglobby": "0.2.15",
-    "vue-eslint-parser": "10.4.0",
+    "tinyglobby": "0.2.17",
+    "vue-eslint-parser": "10.4.1",
     "yaml-eslint-parser": "2.0.0"
   },
   "devDependencies": {
-    "@commitlint/cli": "20.4.1",
-    "@commitlint/config-conventional": "20.4.1",
-    "@rotki/eslint-config": "4.5.0",
-    "@rotki/eslint-plugin": "1.2.0",
-    "@types/debug": "4.1.12",
-    "@types/node": "24.10.13",
-    "@typescript-eslint/eslint-plugin": "8.55.0",
-    "@typescript-eslint/parser": "8.55.0",
-    "@typescript-eslint/rule-tester": "8.55.0",
-    "@vitest/coverage-v8": "4.0.18",
-    "bumpp": "10.4.1",
-    "eslint": "9.39.2",
+    "@commitlint/cli": "21.0.2",
+    "@commitlint/config-conventional": "21.0.2",
+    "@rotki/eslint-config": "6.1.0",
+    "@rotki/eslint-plugin": "1.3.2",
+    "@types/debug": "4.1.13",
+    "@types/node": "24.13.1",
+    "@typescript-eslint/eslint-plugin": "8.60.1",
+    "@typescript-eslint/parser": "8.60.1",
+    "@typescript-eslint/rule-tester": "8.60.1",
+    "@vitest/coverage-v8": "4.1.8",
+    "bumpp": "11.1.0",
+    "eslint": "10.4.1",
     "husky": "9.1.7",
-    "lint-staged": "16.2.7",
+    "lint-staged": "17.0.7",
+    "oxc-minify": "0.135.0",
+    "prettier": "3.8.1",
     "rimraf": "6.1.3",
-    "tsx": "4.21.0",
-    "typescript": "5.9.3",
+    "tsx": "4.22.4",
+    "typescript": "6.0.3",
     "unbuild": "3.6.1",
-    "vitepress": "1.6.4",
-    "vitest": "4.0.18"
+    "vitepress": "2.0.0-alpha.17",
+    "vitest": "4.1.8"
   },
   "engines": {
     "node": ">=24 <25",
-    "pnpm": ">=10 <11"
+    "pnpm": ">=10 <12"
   },
   "lint-staged": {
     "*.{js,cjs,ts,vue,yml,json,md}": "eslint"