@rotki/eslint-plugin 1.3.2 → 1.5.0

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.5.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) {
@@ -129,13 +127,13 @@ function createRule({
   meta
 }) {
   return {
-    create: ((context) => {
+    create: (context) => {
       const optionsWithDefault = context.options.map((options, index) => ({
         ...defaultOptions[index] || {},
         ...options || {}
       }));
       return create(context, optionsWithDefault);
-    }),
+    },
     defaultOptions,
     meta
   };
@@ -166,7 +164,7 @@ function defineTemplateBodyVisitor(context, templateBodyVisitor, scriptVisitor,
   );
 }
 
-const RULE_NAME$f = "composable-input-flexibility";
+const RULE_NAME$h = "composable-input-flexibility";
 function checkParamForRef(param) {
   let annotation;
   if (param.type === AST_NODE_TYPES.Identifier && param.typeAnnotation) {
@@ -179,44 +177,73 @@ function checkParamForRef(param) {
   }
   return void 0;
 }
+function getParamName(param) {
+  if (param.type === AST_NODE_TYPES.Identifier)
+    return param.name;
+  if (param.type === AST_NODE_TYPES.AssignmentPattern && param.left.type === AST_NODE_TYPES.Identifier)
+    return param.left.name;
+  return void 0;
+}
+function isWriteReference(reference) {
+  const { identifier } = reference;
+  const parent = identifier.parent;
+  if (parent.type === AST_NODE_TYPES.CallExpression) {
+    return parent.callee.type === AST_NODE_TYPES.Identifier && parent.callee.name === "set" && parent.arguments[0] === identifier;
+  }
+  if (parent.type === AST_NODE_TYPES.MemberExpression && parent.object === identifier && !parent.computed && parent.property.type === AST_NODE_TYPES.Identifier && parent.property.name === "value") {
+    const grandparent = parent.parent;
+    if (grandparent.type === AST_NODE_TYPES.AssignmentExpression)
+      return grandparent.left === parent;
+    return grandparent.type === AST_NODE_TYPES.UpdateExpression;
+  }
+  return false;
+}
+function isWrittenParam(scope, name) {
+  const variable = scope.variables.find((candidate) => candidate.name === name);
+  return variable?.references.some(isWriteReference) ?? false;
+}
 const composableInputFlexibility = createEslintRule({
   create(context) {
     const autofix = context.options[0]?.autofix ?? false;
     return {
       FunctionDeclaration: (node) => {
-        if (!node.id || !isComposableName(node.id.name))
+        if (!node.id || !isComposableName(node.id.name) || !node.body)
           return;
-        checkParams(node.params);
+        checkParams(node.params, node);
       },
       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);
+          checkParams(node.init.params, node.init);
         }
       }
     };
-    function checkParams(params) {
+    function checkParams(params, fn) {
+      const scope = context.sourceCode.getScope(fn);
       for (const param of params) {
         const refType = checkParamForRef(param);
-        if (refType) {
-          context.report({
-            ...autofix ? {
+        if (!refType)
+          continue;
+        const name = getParamName(param);
+        if (name && isWrittenParam(scope, name))
+          continue;
+        context.report({
+          ...autofix ? {
+            fix(fixer) {
+              return fixer.replaceText(refType.typeName, "MaybeRefOrGetter");
+            }
+          } : {
+            suggest: [{
               fix(fixer) {
                 return fixer.replaceText(refType.typeName, "MaybeRefOrGetter");
-              }
-            } : {
-              suggest: [{
-                fix(fixer) {
-                  return fixer.replaceText(refType.typeName, "MaybeRefOrGetter");
-                },
-                messageId: "suggestMaybeRefOrGetter"
-              }]
-            },
-            messageId: "preferMaybeRefOrGetter",
-            node: refType
-          });
-        }
+              },
+              messageId: "suggestMaybeRefOrGetter"
+            }]
+          },
+          messageId: "preferMaybeRefOrGetter",
+          node: refType
+        });
       }
     }
   },
@@ -247,10 +274,10 @@ const composableInputFlexibility = createEslintRule({
     ],
     type: "suggestion"
   },
-  name: RULE_NAME$f
+  name: RULE_NAME$h
 });
 
-const RULE_NAME$e = "composable-naming-convention";
+const RULE_NAME$g = "composable-naming-convention";
 function getComposableFunction(node) {
   if (node.type === AST_NODE_TYPES.FunctionDeclaration) {
     if (!node.id || !isComposableName(node.id.name))
@@ -279,6 +306,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 +318,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 +350,10 @@ const composableNamingConvention = createEslintRule({
     schema: [],
     type: "suggestion"
   },
-  name: RULE_NAME$e
+  name: RULE_NAME$g
 });
 
-const RULE_NAME$d = "composable-no-default-export";
+const RULE_NAME$f = "composable-no-default-export";
 const composableNoDefaultExport = createEslintRule({
   create(context) {
     let hasComposable = false;
@@ -375,10 +393,10 @@ const composableNoDefaultExport = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$d
+  name: RULE_NAME$f
 });
 
-const RULE_NAME$c = "composable-prefer-shallowref";
+const RULE_NAME$e = "composable-prefer-shallowref";
 const composablePreferShallowref = createEslintRule({
   create(context) {
     const autofix = context.options[0]?.autofix ?? false;
@@ -437,10 +455,10 @@ const composablePreferShallowref = createEslintRule({
     ],
     type: "suggestion"
   },
-  name: RULE_NAME$c
+  name: RULE_NAME$e
 });
 
-const RULE_NAME$b = "composable-require-cleanup";
+const RULE_NAME$d = "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 +552,11 @@ const composableRequireCleanup = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$b
+  name: RULE_NAME$d
 });
 
-const RULE_NAME$a = "composable-return-readonly";
+const RULE_NAME$c = "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 +565,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 +617,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 +637,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 +659,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 +672,10 @@ const composableReturnReadonly = createEslintRule({
     ],
     type: "suggestion"
   },
-  name: RULE_NAME$a
+  name: RULE_NAME$c
 });
 
-const RULE_NAME$9 = "composable-ssr-safety";
+const RULE_NAME$b = "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 +702,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 +763,51 @@ const composableSsrSafety = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$9
+  name: RULE_NAME$b
 });
 
-const debug$6 = debugFactory("@rotki/eslint-plugin:consistent-ref-type-annotation");
-const RULE_NAME$8 = "consistent-ref-type-annotation";
+const debug$7 = debugFactory("@rotki/eslint-plugin:consistent-ref-type-annotation");
+const RULE_NAME$a = "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;
+  debug$7(`found ${name}, checking type arguments`);
+  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
-      });
-    }
+  debug$7(`generating report for ${name}`);
+  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 +856,10 @@ const consistentRefTypeAnnotation = createEslintRule({
     ],
     type: "problem"
   },
-  name: RULE_NAME$8
+  name: RULE_NAME$a
 });
 
-const RULE_NAME$7 = "max-dependencies";
+const RULE_NAME$9 = "max-dependencies";
 const maxDependencies = createEslintRule({
   create(context, [options]) {
     let dependencyCount = 0;
@@ -893,11 +919,11 @@ const maxDependencies = createEslintRule({
     ],
     type: "suggestion"
   },
-  name: RULE_NAME$7
+  name: RULE_NAME$9
 });
 
-const RULE_NAME$6 = "no-deprecated-classes";
-const debug$5 = debugFactory("@rotki/eslint-plugin:no-deprecated-classes");
+const RULE_NAME$8 = "no-deprecated-classes";
+const debug$6 = debugFactory("@rotki/eslint-plugin:no-deprecated-classes");
 const stringReplacements = /* @__PURE__ */ new Map([
   ["d-block", "block"],
   ["d-flex", "flex"],
@@ -951,7 +977,7 @@ function getRange(node) {
   return node.range;
 }
 function reportReplacement(className, replacement, node, context, source, position = 1) {
-  debug$5(`found replacement ${replacement} for ${className}`);
+  debug$6(`found replacement ${replacement} for ${className}`);
   const initialRange = getRange(node);
   const range = [
     initialRange[0] + position,
@@ -973,51 +999,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 +1101,11 @@ const noDeprecatedClasses = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$6
+  name: RULE_NAME$8
 });
 
-const debug$4 = debugFactory("@rotki/eslint-plugin:no-deprecated-components");
-const RULE_NAME$5 = "no-deprecated-components";
+const debug$5 = debugFactory("@rotki/eslint-plugin:no-deprecated-components");
+const RULE_NAME$7 = "no-deprecated-components";
 const vuetify = {
   VApp: true,
   VAppBar: true,
@@ -1105,7 +1142,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) {
@@ -1121,7 +1158,7 @@ const noDeprecatedComponents = createEslintRule({
           return;
         const replacement = replacements$1[tag];
         if (replacement || legacy && skipInLegacy.has(tag)) {
-          debug$4(`${tag} has been deprecated`);
+          debug$5(`${tag} has been deprecated`);
           context.report({
             data: {
               name: tag
@@ -1130,7 +1167,7 @@ const noDeprecatedComponents = createEslintRule({
             node: element
           });
         } else {
-          debug$4(`${tag} has will be removed`);
+          debug$5(`${tag} has will be removed`);
           context.report({
             data: {
               name: tag
@@ -1173,11 +1210,10 @@ const noDeprecatedComponents = createEslintRule({
     ],
     type: "problem"
   },
-  name: RULE_NAME$5
+  name: RULE_NAME$7
 });
 
-const debug$3 = debugFactory("@rotki/eslint-plugin:no-deprecated-props");
-const RULE_NAME$4 = "no-deprecated-props";
+const RULE_NAME$6 = "no-deprecated-props";
 const replacements = {
   RuiRadio: {
     internalValue: "value"
@@ -1200,37 +1236,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 +1280,10 @@ const noDeprecatedProps = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$4
+  name: RULE_NAME$6
 });
 
-const RULE_NAME$3 = "no-dot-ts-imports";
+const RULE_NAME$5 = "no-dot-ts-imports";
 const noDotTsImport = createEslintRule({
   create(context) {
     return {
@@ -1285,10 +1318,10 @@ const noDotTsImport = createEslintRule({
     schema: [],
     type: "problem"
   },
-  name: RULE_NAME$3
+  name: RULE_NAME$5
 });
 
-const RULE_NAME$2 = "no-legacy-library-import";
+const RULE_NAME$4 = "no-legacy-library-import";
 const legacyLibrary = "@rotki/ui-library-compat";
 const newLibrary = "@rotki/ui-library";
 const noLegacyLibraryImport = createEslintRule({
@@ -1321,6 +1354,261 @@ const noLegacyLibraryImport = createEslintRule({
     schema: [],
     type: "problem"
   },
+  name: RULE_NAME$4
+});
+
+const RULE_NAME$3 = "no-redundant-flex-row";
+const debug$4 = 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$4(`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$3
+});
+
+const RULE_NAME$2 = "no-shared-pinia";
+const debug$3 = debugFactory("@rotki/eslint-plugin:no-shared-pinia");
+const DESCRIBE_NAMES = /* @__PURE__ */ new Set(["describe", "fdescribe", "xdescribe", "suite"]);
+const BEFORE_EACH_NAMES = /* @__PURE__ */ new Set(["beforeEach"]);
+const DEFAULT_FACTORIES = ["createPinia", "createCustomPinia", "createTestingPinia"];
+const DEFAULT_TEST_FILE_PATTERN = "\\.(spec|test)\\.[cm]?[jt]sx?$";
+function isFunctionNode(node) {
+  return node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+}
+function getRootCalleeName(callee) {
+  if (callee.type === "Identifier")
+    return callee.name;
+  if (callee.type === "MemberExpression")
+    return getRootCalleeName(callee.object);
+  if (callee.type === "CallExpression")
+    return getRootCalleeName(callee.callee);
+  return null;
+}
+function callbackOwnerName(fn) {
+  const parent = fn.parent;
+  if (!parent || parent.type !== "CallExpression")
+    return null;
+  return getRootCalleeName(parent.callee);
+}
+function isBeforeEachCallback(fn) {
+  const owner = callbackOwnerName(fn);
+  return owner != null && BEFORE_EACH_NAMES.has(owner);
+}
+function isDescribeCallback(fn) {
+  const owner = callbackOwnerName(fn);
+  return owner != null && DESCRIBE_NAMES.has(owner);
+}
+function nearestFunction(node) {
+  let current = node.parent;
+  while (current) {
+    if (isFunctionNode(current))
+      return current;
+    current = current.parent;
+  }
+  return null;
+}
+function buildTestFileMatcher(pattern) {
+  const regex = new RegExp(pattern, "u");
+  return (filename) => regex.test(filename);
+}
+const noSharedPinia = createEslintRule({
+  create(context, optionsWithDefault) {
+    const options = optionsWithDefault[0] ?? {};
+    const factories = new Set(options.factories ?? DEFAULT_FACTORIES);
+    const isTestFile = buildTestFileMatcher(options.testFilePattern ?? DEFAULT_TEST_FILE_PATTERN);
+    const filename = getFilename(context);
+    if (!isTestFile(filename)) {
+      debug$3(`skipping non-test file '${filename}'`);
+      return {};
+    }
+    let program = null;
+    const candidates = [];
+    const freshContainers = /* @__PURE__ */ new Set();
+    return {
+      CallExpression(node) {
+        const name = getRootCalleeName(node.callee);
+        if (name == null || !factories.has(name) || program == null)
+          return;
+        const enclosing = nearestFunction(node);
+        if (enclosing != null && isBeforeEachCallback(enclosing)) {
+          freshContainers.add(nearestFunction(enclosing) ?? program);
+          return;
+        }
+        if (enclosing != null && !isDescribeCallback(enclosing))
+          return;
+        candidates.push({
+          atModuleScope: enclosing == null,
+          container: enclosing ?? program,
+          factory: name,
+          node
+        });
+      },
+      Program(node) {
+        program = node;
+      },
+      "Program:exit": function() {
+        const isProtected = (container) => {
+          let current = container;
+          while (current != null) {
+            if (freshContainers.has(current))
+              return true;
+            if (current.type === "Program")
+              break;
+            current = nearestFunction(current) ?? program;
+          }
+          return false;
+        };
+        for (const candidate of candidates) {
+          if (isProtected(candidate.container))
+            continue;
+          debug$3(`found shared pinia via '${candidate.factory}' ${candidate.atModuleScope ? "at module scope" : "in describe body"}`);
+          context.report({
+            data: {
+              factory: candidate.factory,
+              location: candidate.atModuleScope ? "at module scope" : "in the `describe` body"
+            },
+            messageId: "sharedPinia",
+            node: candidate.node
+          });
+        }
+      }
+    };
+  },
+  defaultOptions: [
+    {
+      factories: DEFAULT_FACTORIES,
+      testFilePattern: DEFAULT_TEST_FILE_PATTERN
+    }
+  ],
+  meta: {
+    docs: {
+      description: "disallow a Pinia instance shared across tests via `describe`-body or module scope",
+      recommendation: "recommended"
+    },
+    messages: {
+      sharedPinia: "`{{ factory }}()` is called {{ location }}, so the Pinia instance is shared across every test and store state leaks between them. Create a fresh instance per test with `beforeEach(() => setActivePinia(createPinia()))`, or add an inline disable if the shared instance is intentional."
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          factories: {
+            items: { type: "string" },
+            type: "array"
+          },
+          testFilePattern: {
+            type: "string"
+          }
+        },
+        type: "object"
+      }
+    ],
+    type: "problem"
+  },
   name: RULE_NAME$2
 });
 
@@ -1337,18 +1625,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 +1668,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 +1747,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 +1838,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 +1947,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 +2263,8 @@ const plugin = {
     "no-deprecated-props": noDeprecatedProps,
     "no-dot-ts-imports": noDotTsImport,
     "no-legacy-library-import": noLegacyLibraryImport,
+    "no-redundant-flex-row": noRedundantFlexRow,
+    "no-shared-pinia": noSharedPinia,
     "no-unused-i18n-keys": noUnusedI18nKeys,
     "require-jsdoc-on-composable-options": requireJsdocOnComposableOptions
   }