@vitest/eslint-plugin 1.1.20 → 1.1.21

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Verité Mugabo  Makuza
+Copyright (c) 2022 - PRESENT Verité Mugabo  Makuza
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/index.cjs

@@ -23,7 +23,7 @@ function _interopNamespaceCompat(e) {
 const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
 const ts__default = /*#__PURE__*/_interopDefaultCompat(ts);
 
-const version = "1.1.19";
+const version = "1.1.20";
 
 function createEslintRule(rule) {
   const createRule = utils.ESLintUtils.RuleCreator(
@@ -34,8 +34,7 @@ function createEslintRule(rule) {
 const joinNames = (a, b) => a && b ? `${a}.${b}` : null;
 const isFunction = (node) => node.type === utils.AST_NODE_TYPES.FunctionExpression || node.type === utils.AST_NODE_TYPES.ArrowFunctionExpression;
 function getNodeName(node) {
-  if (isSupportedAccessor(node))
-    return getAccessorValue(node);
+  if (isSupportedAccessor(node)) return getAccessorValue(node);
   switch (node.type) {
     case utils.AST_NODE_TYPES.TaggedTemplateExpression:
       return getNodeName(node.tag);
@@ -102,6 +101,8 @@ var HookName = /* @__PURE__ */ ((HookName2) => {
   return HookName2;
 })(HookName || {});
 var ModifierName = /* @__PURE__ */ ((ModifierName2) => {
+  ModifierName2["to"] = "to";
+  ModifierName2["have"] = "have";
   ModifierName2["not"] = "not";
   ModifierName2["rejects"] = "rejects";
   ModifierName2["resolves"] = "resolves";
@@ -174,10 +175,10 @@ const findModifiersAndMatcher = (members) => {
       if (!ModifierName.hasOwnProperty(name))
         return "modifier-unknown";
     } else if (modifiers.length === 1) {
-      if (name !== ModifierName.not)
+      if (name !== ModifierName.not && name != ModifierName.have)
         return "modifier-unknown";
       const firstModifier = getAccessorValue(modifiers[0]);
-      if (firstModifier !== ModifierName.resolves && firstModifier !== ModifierName.rejects)
+      if (firstModifier !== ModifierName.resolves && firstModifier !== ModifierName.rejects && firstModifier !== ModifierName.to)
         return "modifier-unknown";
     } else {
       return "modifier-unknown";
@@ -344,6 +345,8 @@ const describeImportDefAsImport = (def) => {
     return null;
   if (def.node.type !== utils.AST_NODE_TYPES.ImportSpecifier)
     return null;
+  if (def.node.imported.type != utils.AST_NODE_TYPES.Identifier)
+    return null;
   if (def.parent.importKind === "type")
     return null;
   return {
@@ -467,8 +470,7 @@ const lowerCaseTitle = createEslintRule({
     return {
       CallExpression(node) {
         const vitestFnCall = parseVitestFnCall(node, context);
-        if (!vitestFnCall || !hasStringAsFirstArgument)
-          return;
+        if (!vitestFnCall || !hasStringAsFirstArgument) return;
         if (vitestFnCall?.type === "describe") {
           numberOfDescribeBlocks++;
           if (ignoreTopLevelDescribe && numberOfDescribeBlocks === 1)
@@ -478,13 +480,10 @@ const lowerCaseTitle = createEslintRule({
         }
         const [firstArgument] = node.arguments;
         const description = getStringValue(firstArgument);
-        if (typeof description !== "string")
-          return;
-        if (allowedPrefixes.some((prefix) => description.startsWith(prefix)))
-          return;
+        if (typeof description !== "string") return;
+        if (allowedPrefixes.some((prefix) => description.startsWith(prefix))) return;
         const firstCharacter = description.charAt(0);
-        if (ignores.includes(vitestFnCall.name) || lowercaseFirstCharacterOnly && (!firstCharacter || firstCharacter === firstCharacter.toLowerCase()) || !lowercaseFirstCharacterOnly && description === description.toLowerCase())
-          return;
+        if (ignores.includes(vitestFnCall.name) || lowercaseFirstCharacterOnly && (!firstCharacter || firstCharacter === firstCharacter.toLowerCase()) || !lowercaseFirstCharacterOnly && description === description.toLowerCase()) return;
         context.report({
           messageId: lowercaseFirstCharacterOnly ? "lowerCaseTitle" : "fullyLowerCaseTitle",
           node: node.arguments[0],
@@ -542,8 +541,7 @@ const maxNestedDescribe = createEslintRule({
   create(context, [{ max }]) {
     const stack = [];
     function pushStack(node) {
-      if (node.parent?.type !== "CallExpression")
-        return;
+      if (node.parent?.type !== "CallExpression") return;
       if (node.parent.callee.type !== "Identifier" || node.parent.callee.name !== "describe")
         return;
       stack.push(0);
@@ -555,8 +553,7 @@ const maxNestedDescribe = createEslintRule({
       }
     }
     function popStack(node) {
-      if (node.parent?.type !== "CallExpression")
-        return;
+      if (node.parent?.type !== "CallExpression") return;
       if (node.parent.callee.type !== "Identifier" || node.parent.callee.name !== "describe")
         return;
       stack.pop();
@@ -682,8 +679,7 @@ const noFocusedTests = createEslintRule({
           }
           if (callee.type === "TaggedTemplateExpression") {
             const tagCall = callee.tag.type === "MemberExpression" ? callee.tag.object : null;
-            if (!tagCall)
-              return;
+            if (!tagCall) return;
             if (tagCall.type === "MemberExpression" && isTestOrDescribe(tagCall.object) && isOnly(tagCall.property)) {
               context.report({
                 node: tagCall.property,
@@ -757,18 +753,6 @@ function parsePluginSettings(settings) {
 }
 
 const RULE_NAME$U = "expect-expect";
-function matchesAssertFunctionName(nodeName, patterns) {
-  return patterns.some(
-    (p) => new RegExp(
-      `^${p.split(".").map((x) => {
-        if (x === "**")
-          return "[_a-z\\d\\.]*";
-        return x.replace(/\*/gu, "[a-z\\d]*");
-      }).join("\\.")}(\\.|$)`,
-      "ui"
-    ).test(nodeName)
-  );
-}
 const expectExpect = createEslintRule({
   name: RULE_NAME$U,
   meta: {
@@ -801,8 +785,8 @@ const expectExpect = createEslintRule({
   create(context, [{ assertFunctionNames = ["expect"], additionalTestBlockFunctions = [] }]) {
     const unchecked = [];
     const settings = parsePluginSettings(context.settings);
-    if (settings.typecheck)
-      assertFunctionNames.push("expectTypeOf", "assertType");
+    if (settings.typecheck) assertFunctionNames.push("expectTypeOf", "assertType");
+    const assertFunctionRegexps = assertFunctionNames.map(buildPatternRegexp);
     function checkCallExpression(nodes) {
       for (const node of nodes) {
         const index = node.type === utils.AST_NODE_TYPES.CallExpression ? unchecked.indexOf(node) : -1;
@@ -827,10 +811,9 @@ const expectExpect = createEslintRule({
           return;
         const name = getNodeName(node) ?? "";
         if (isTypeOfVitestFnCall(node, context, ["test"]) || additionalTestBlockFunctions.includes(name)) {
-          if (node.callee.type === utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "todo"))
-            return;
+          if (node.callee.type === utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "todo")) return;
           unchecked.push(node);
-        } else if (matchesAssertFunctionName(name, assertFunctionNames)) {
+        } else if (assertFunctionRegexps.some((p) => p.test(name))) {
           checkCallExpression(context.sourceCode.getAncestors(node));
         }
       },
@@ -845,6 +828,17 @@ const expectExpect = createEslintRule({
     };
   }
 });
+function buildPatternRegexp(pattern) {
+  const parts = pattern.split(".").map((x) => {
+    if (x === "**")
+      return "[_a-z\\d\\.]*";
+    return x.replace(/\*/gu, "[a-z\\d]*");
+  });
+  return new RegExp(
+    `^${parts.join("\\.")}(\\.|$)`,
+    "ui"
+  );
+}
 
 const RULE_NAME$T = "consistent-test-it";
 const buildFixer = (callee, nodeName, preferredTestKeyword) => (fixer) => [
@@ -910,6 +904,8 @@ const consistentTestIt = createEslintRule({
         for (const specifier of node.specifiers) {
           if (specifier.type !== "ImportSpecifier")
             continue;
+          if (specifier.imported.type !== "Identifier")
+            continue;
           if (specifier.local.name !== specifier.imported.name)
             continue;
           if (specifier.local.name === oppositeTestKeyword) {
@@ -929,8 +925,7 @@ const consistentTestIt = createEslintRule({
         if (node.callee.type === utils.AST_NODE_TYPES.Identifier && node.callee.name === "bench")
           return;
         const vitestFnCall = parseVitestFnCall(node, context);
-        if (!vitestFnCall)
-          return;
+        if (!vitestFnCall) return;
         if (vitestFnCall.type === "describe") {
           describeNestingLevel++;
           return;
@@ -1496,8 +1491,7 @@ const noDisabledTests = createEslintRule({
     return {
       CallExpression(node) {
         const vitestFnCall = parseVitestFnCall(node, context);
-        if (!vitestFnCall)
-          return;
+        if (!vitestFnCall) return;
         if (vitestFnCall.type === "describe")
           suiteDepth++;
         if (vitestFnCall.type === "test") {
@@ -1577,16 +1571,13 @@ const noDoneCallback = createEslintRule({
         if (isVitestEach && node.callee.type !== utils.AST_NODE_TYPES.TaggedTemplateExpression)
           return;
         const isInsideConcurrentTestOrDescribe = context.sourceCode.getAncestors(node).some((ancestor) => {
-          if (ancestor.type !== utils.AST_NODE_TYPES.CallExpression)
-            return false;
+          if (ancestor.type !== utils.AST_NODE_TYPES.CallExpression) return false;
           const isNotInsideDescribeOrTest = !isTypeOfVitestFnCall(ancestor, context, ["describe", "test"]);
-          if (isNotInsideDescribeOrTest)
-            return false;
+          if (isNotInsideDescribeOrTest) return false;
           const isTestRunningConcurrently = ancestor.callee.type === utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(ancestor.callee.property, "concurrent");
           return isTestRunningConcurrently;
         });
-        if (isInsideConcurrentTestOrDescribe)
-          return;
+        if (isInsideConcurrentTestOrDescribe) return;
         const callback = findCallbackArg(node, isVitestEach, context);
         const callbackArgIndex = Number(isVitestEach);
         if (!callback || !isFunction(callback) || callback.params.length !== 1 + callbackArgIndex)
@@ -1673,14 +1664,13 @@ const noDuplicateHooks = createEslintRule({
     const hooksContexts = [{}];
     return {
       CallExpression(node) {
-        var _a;
         const vitestFnCall = parseVitestFnCall(node, context);
         if (vitestFnCall?.type === "describe")
           hooksContexts.push({});
         if (vitestFnCall?.type !== "hook")
           return;
         const currentLayer = hooksContexts[hooksContexts.length - 1];
-        currentLayer[_a = vitestFnCall.name] || (currentLayer[_a] = 0);
+        currentLayer[vitestFnCall.name] ||= 0;
         currentLayer[vitestFnCall.name] += 1;
         if (currentLayer[vitestFnCall.name] > 1) {
           context.report({
@@ -2074,18 +2064,15 @@ const noTestReturnStatement = createEslintRule({
           return;
         const body = getBody(node.arguments);
         const returnStmt = body.find((stmt) => stmt.type === utils.AST_NODE_TYPES.ReturnStatement);
-        if (!returnStmt)
-          return;
+        if (!returnStmt) return;
         context.report({ messageId: "noTestReturnStatement", node: returnStmt });
       },
       FunctionDeclaration(node) {
         const declaredVariables = context.sourceCode.getDeclaredVariables(node);
         const testCallExpressions = getTestCallExpressionsFromDeclaredVariables(declaredVariables, context);
-        if (testCallExpressions.length === 0)
-          return;
+        if (testCallExpressions.length === 0) return;
         const returnStmt = node.body.body.find((stmt) => stmt.type === utils.AST_NODE_TYPES.ReturnStatement);
-        if (!returnStmt)
-          return;
+        if (!returnStmt) return;
         context.report({ messageId: "noTestReturnStatement", node: returnStmt });
       }
     };
@@ -2112,8 +2099,7 @@ const preferCalledWith = createEslintRule({
     return {
       CallExpression(node) {
         const vitestFnCall = parseVitestFnCall(node, context);
-        if (vitestFnCall?.type !== "expect")
-          return;
+        if (vitestFnCall?.type !== "expect") return;
         if (vitestFnCall.modifiers.some(
           (node2) => getAccessorValue(node2) === "not"
         ))
@@ -2156,8 +2142,7 @@ function isFunctionType(type) {
 }
 function isClassType(type) {
   const symbol = type.getSymbol();
-  if (!symbol)
-    return false;
+  if (!symbol) return false;
   return symbol.getDeclarations()?.some((declaration) => ts__default.isClassDeclaration(declaration) || ts__default.isClassExpression(declaration)) ?? false;
 }
 const compileMatcherPatterns = (matchers) => {
@@ -2256,17 +2241,15 @@ const validTitle = createEslintRule({
     return {
       CallExpression(node) {
         const vitestFnCall = parseVitestFnCall(node, context);
-        if (vitestFnCall?.type !== "describe" && vitestFnCall?.type !== "test" && vitestFnCall?.type !== "it")
-          return;
+        if (vitestFnCall?.type !== "describe" && vitestFnCall?.type !== "test" && vitestFnCall?.type !== "it") return;
+        if (vitestFnCall.members.some((m) => m.type == utils.AST_NODE_TYPES.Identifier && m.name == "extend")) return;
         const [argument] = node.arguments;
         if (settings.typecheck) {
           const services = utils.ESLintUtils.getParserServices(context);
           const type = services.getTypeAtLocation(argument);
-          if (isFunctionType(type) || isClassType(type))
-            return;
+          if (isFunctionType(type) || isClassType(type)) return;
         }
-        if (!argument || allowArguments && argument.type === utils.AST_NODE_TYPES.Identifier)
-          return;
+        if (!argument || allowArguments && argument.type === utils.AST_NODE_TYPES.Identifier) return;
         if (!isStringNode(argument)) {
           if (argument.type === utils.AST_NODE_TYPES.BinaryExpression && doesBinaryExpressionContainStringNode(argument))
             return;
@@ -2500,6 +2483,8 @@ const validExpect = createEslintRule({
           return;
         } else if (vitestFnCall?.type !== "expect") {
           return;
+        } else if (vitestFnCall.modifiers.some((mod) => mod.type === utils.AST_NODE_TYPES.Identifier && mod.name == "to")) {
+          return;
         }
         const { parent: expect } = vitestFnCall.head.node;
         if (expect?.type !== utils.AST_NODE_TYPES.CallExpression)
@@ -2708,8 +2693,7 @@ const preferToBeTruthy = createEslintRule({
     return {
       CallExpression(node) {
         const vitestFnCall = parseVitestFnCall(node, context);
-        if (!(vitestFnCall?.type === "expect" || vitestFnCall?.type === "expectTypeOf"))
-          return;
+        if (!(vitestFnCall?.type === "expect" || vitestFnCall?.type === "expectTypeOf")) return;
         if (vitestFnCall.args.length === 1 && isTrueLiteral(getFirstMatcherArg(vitestFnCall)) && EqualityMatcher.hasOwnProperty(getAccessorValue(vitestFnCall.matcher))) {
           context.report({
             node: vitestFnCall.matcher,
@@ -2746,8 +2730,7 @@ const preferToBeFalsy = createEslintRule({
     return {
       CallExpression(node) {
         const vitestFnCall = parseVitestFnCall(node, context);
-        if (!(vitestFnCall?.type === "expect" || vitestFnCall?.type === "expectTypeOf"))
-          return;
+        if (!(vitestFnCall?.type === "expect" || vitestFnCall?.type === "expectTypeOf")) return;
         if (vitestFnCall.args.length === 1 && isFalseLiteral(getFirstMatcherArg(vitestFnCall)) && EqualityMatcher.hasOwnProperty(getAccessorValue(vitestFnCall.matcher))) {
           context.report({
             node: vitestFnCall.matcher,
@@ -2908,8 +2891,7 @@ const preferStrictEqual = createEslintRule({
     return {
       CallExpression(node) {
         const vitestFnCall = parseVitestFnCall(node, context);
-        if (vitestFnCall?.type !== "expect")
-          return;
+        if (vitestFnCall?.type !== "expect") return;
         const { matcher } = vitestFnCall;
         if (isSupportedAccessor(matcher, "toEqual")) {
           context.report({
@@ -2949,8 +2931,7 @@ const preferExpectResolves = createEslintRule({
   create: (context) => ({
     CallExpression(node) {
       const vitestFnCall = parseVitestFnCall(node, context);
-      if (vitestFnCall?.type !== "expect")
-        return;
+      if (vitestFnCall?.type !== "expect") return;
       const { parent } = vitestFnCall.head.node;
       if (parent?.type !== utils.AST_NODE_TYPES.CallExpression)
         return;
@@ -2999,13 +2980,11 @@ const preferEach = createEslintRule({
       return "describe";
     };
     const enterForLoop = () => {
-      if (vitestFnCalls.length === 0 || inTestCaseCall)
-        return;
+      if (vitestFnCalls.length === 0 || inTestCaseCall) return;
       vitestFnCalls.length = 0;
     };
     const exitForLoop = (node) => {
-      if (vitestFnCalls.length === 0 || inTestCaseCall)
-        return;
+      if (vitestFnCalls.length === 0 || inTestCaseCall) return;
       context.report({
         node,
         messageId: "preferEach",
@@ -3093,8 +3072,7 @@ const preferHooksInOrder = createEslintRule({
     let inHook = false;
     return {
       CallExpression(node) {
-        if (inHook)
-          return;
+        if (inHook) return;
         const vitestFnCall = parseVitestFnCall(node, context);
         if (vitestFnCall?.type !== "hook") {
           previousHookIndex = -1;
@@ -3158,8 +3136,7 @@ const preferMockPromiseShorthand = createEslintRule({
   defaultOptions: [],
   create(context) {
     const report = (property, isOnce, outerArgNode, innerArgNode = outerArgNode) => {
-      if (innerArgNode?.type !== utils.AST_NODE_TYPES.CallExpression)
-        return;
+      if (innerArgNode?.type !== utils.AST_NODE_TYPES.CallExpression) return;
       const argName = getNodeName(innerArgNode);
       if (argName !== "Promise.resolve" && argName !== "Promise.reject")
         return;
@@ -3203,7 +3180,7 @@ const preferMockPromiseShorthand = createEslintRule({
   }
 });
 
-const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 const eslintRequire = node_module.createRequire(require$1.resolve("eslint"));
 eslintRequire.resolve("espree");
 const STATEMENT_LIST_PARENTS = /* @__PURE__ */ new Set([
@@ -3265,13 +3242,10 @@ const preferViMocked = createEslintRule({
   create(context) {
     function check(node) {
       const { typeAnnotation } = node;
-      if (typeAnnotation.type !== utils.AST_NODE_TYPES.TSTypeReference)
-        return;
+      if (typeAnnotation.type !== utils.AST_NODE_TYPES.TSTypeReference) return;
       const { typeName } = typeAnnotation;
-      if (typeName.type !== utils.AST_NODE_TYPES.Identifier)
-        return;
-      if (!mockTypes.includes(typeName.name))
-        return;
+      if (typeName.type !== utils.AST_NODE_TYPES.Identifier) return;
+      if (!mockTypes.includes(typeName.name)) return;
       const fnName = context.sourceCode.text.slice(
         ...followTypeAssertionChain(node.expression).range
       );
@@ -3285,8 +3259,7 @@ const preferViMocked = createEslintRule({
     }
     return {
       TSAsExpression(node) {
-        if (node.parent.type === utils.AST_NODE_TYPES.TSAsExpression)
-          return;
+        if (node.parent.type === utils.AST_NODE_TYPES.TSAsExpression) return;
         check(node);
       },
       TSTypeAssertion(node) {
@@ -3300,12 +3273,10 @@ const RULE_NAME$j = "prefer-snapshot-hint";
 const snapshotMatchers = ["toMatchSnapshot", "toThrowErrorMatchingSnapshot"];
 const snapshotMatcherNames = snapshotMatchers;
 const isSnapshotMatcherWithoutHint = (expectFnCall) => {
-  if (expectFnCall.args.length === 0)
-    return true;
+  if (expectFnCall.args.length === 0) return true;
   if (!isSupportedAccessor(expectFnCall.matcher, "toMatchSnapshot"))
     return expectFnCall.args.length !== 1;
-  if (expectFnCall.args.length === 2)
-    return false;
+  if (expectFnCall.args.length === 2) return false;
   const [arg] = expectFnCall.args;
   return !isStringNode(arg);
 };
@@ -3380,8 +3351,7 @@ const preferSnapshotHint = createEslintRule({
           return;
         }
         const matcherName = getAccessorValue(vitestFnCall.matcher);
-        if (!snapshotMatcherNames.includes(matcherName))
-          return;
+        if (!snapshotMatcherNames.includes(matcherName)) return;
         snapshotMatchers2.push(vitestFnCall);
       }
     };
@@ -3402,8 +3372,7 @@ const hasNonEachMembersAndParams = (vitestFnCall, functionExpression) => {
 };
 const reportUnexpectedReturnInDescribe = (blockStatement, context) => {
   blockStatement.body.forEach((node) => {
-    if (node.type !== utils.AST_NODE_TYPES.ReturnStatement)
-      return;
+    if (node.type !== utils.AST_NODE_TYPES.ReturnStatement) return;
     context.report({
       messageId: "unexpectedReturnInDescribe",
       node
@@ -3431,8 +3400,7 @@ const validDescribeCallback = createEslintRule({
     return {
       CallExpression(node) {
         const vitestFnCall = parseVitestFnCall(node, context);
-        if (vitestFnCall?.type !== "describe")
-          return;
+        if (vitestFnCall?.type !== "describe") return;
         if (vitestFnCall?.members[0]?.type === utils.AST_NODE_TYPES.Identifier && vitestFnCall.members[0].name === "todo")
           return;
         if (node.arguments.length < 1) {
@@ -3529,8 +3497,7 @@ const requireTopLevelDescribe = createEslintRule({
     return {
       CallExpression(node) {
         const vitestFnCall = parseVitestFnCall(node, context);
-        if (!vitestFnCall)
-          return;
+        if (!vitestFnCall) return;
         if (vitestFnCall.type === "describe") {
           numberOfDescribeBlocks++;
           if (numberOfDescribeBlocks === 1) {
@@ -3584,8 +3551,7 @@ const requireToThrowMessage = createEslintRule({
     return {
       CallExpression(node) {
         const vitestFnCall = parseVitestFnCall(node, context);
-        if (vitestFnCall?.type !== "expect")
-          return;
+        if (vitestFnCall?.type !== "expect") return;
         const { matcher } = vitestFnCall;
         const matcherName = getAccessorValue(matcher);
         if (vitestFnCall.args.length === 0 && ["toThrow", "toThrowError"].includes(matcherName) && !vitestFnCall.modifiers.some((nod) => getAccessorValue(nod) === "not")) {
@@ -3672,11 +3638,9 @@ const requireHook = createEslintRule({
         checkBlockBody(program.body);
       },
       CallExpression(node) {
-        if (!isTypeOfVitestFnCall(node, context, ["describe"]) || node.arguments.length < 2)
-          return;
+        if (!isTypeOfVitestFnCall(node, context, ["describe"]) || node.arguments.length < 2) return;
         const [, testFn] = node.arguments;
-        if (!isFunction(testFn) || testFn.body.type !== utils.AST_NODE_TYPES.BlockStatement)
-          return;
+        if (!isFunction(testFn) || testFn.body.type !== utils.AST_NODE_TYPES.BlockStatement) return;
         checkBlockBody(testFn.body.body);
       }
     };
@@ -3716,19 +3680,15 @@ const requireLocalTestContextForConcurrentSnapshots = createEslintRule({
           "toThrowErrorMatchingInlineSnapshot"
           // @ts-ignore
         ].includes(node.callee?.property.name);
-        if (isNotASnapshotAssertion)
-          return;
+        if (isNotASnapshotAssertion) return;
         const isInsideSequentialDescribeOrTest = !context.sourceCode.getAncestors(node).some((ancestor) => {
-          if (ancestor.type !== utils.AST_NODE_TYPES.CallExpression)
-            return false;
+          if (ancestor.type !== utils.AST_NODE_TYPES.CallExpression) return false;
           const isNotInsideDescribeOrTest = !isTypeOfVitestFnCall(ancestor, context, ["describe", "test"]);
-          if (isNotInsideDescribeOrTest)
-            return false;
+          if (isNotInsideDescribeOrTest) return false;
           const isTestRunningConcurrently = ancestor.callee.type === utils.AST_NODE_TYPES.MemberExpression && isSupportedAccessor(ancestor.callee.property, "concurrent");
           return isTestRunningConcurrently;
         });
-        if (isInsideSequentialDescribeOrTest)
-          return;
+        if (isInsideSequentialDescribeOrTest) return;
         context.report({
           node,
           messageId: "requireLocalTestContext"
@@ -3740,8 +3700,7 @@ const requireLocalTestContextForConcurrentSnapshots = createEslintRule({
 
 const RULE_NAME$d = "prefer-todo";
 const isTargetedTestCase = (vitestFnCall) => {
-  if (vitestFnCall.members.some((s) => getAccessorValue(s) !== "skip"))
-    return false;
+  if (vitestFnCall.members.some((s) => getAccessorValue(s) !== "skip")) return false;
   if (vitestFnCall.name.startsWith("x"))
     return false;
   return !vitestFnCall.name.startsWith("f");
@@ -3847,11 +3806,9 @@ const preferSpyOn = createEslintRule({
     return {
       AssignmentExpression(node) {
         const { left, right } = node;
-        if (left.type !== utils.AST_NODE_TYPES.MemberExpression)
-          return;
+        if (left.type !== utils.AST_NODE_TYPES.MemberExpression) return;
         const vitestFnCall = getVitestFnCall(right);
-        if (!vitestFnCall)
-          return;
+        if (!vitestFnCall) return;
         context.report({
           node,
           messageId: "useViSpayOn",
@@ -3932,8 +3889,7 @@ const preferComparisonMatcher = createEslintRule({
         if (vitestFnCall?.type !== "expect" || vitestFnCall.args.length === 0)
           return;
         const { parent: expect } = vitestFnCall.head.node;
-        if (expect?.type !== utils.AST_NODE_TYPES.CallExpression)
-          return;
+        if (expect?.type !== utils.AST_NODE_TYPES.CallExpression) return;
         const {
           arguments: [comparison],
           range: [, expectCallEnd]
@@ -3945,8 +3901,7 @@ const preferComparisonMatcher = createEslintRule({
         const [modifier] = vitestFnCall.modifiers;
         const hasNot = vitestFnCall.modifiers.some((nod) => getAccessorValue(nod) === "not");
         const preferredMatcher = determineMatcher(comparison.operator, matcherArg.value === hasNot);
-        if (!preferredMatcher)
-          return;
+        if (!preferredMatcher) return;
         context.report({
           fix(fixer) {
             const { sourceCode } = context;
@@ -3999,8 +3954,7 @@ const preferToContain = createEslintRule({
         if (vitestFnCall?.type !== "expect" || vitestFnCall.args.length === 0)
           return;
         const { parent: expect } = vitestFnCall.head.node;
-        if (expect?.type !== utils.AST_NODE_TYPES.CallExpression)
-          return;
+        if (expect?.type !== utils.AST_NODE_TYPES.CallExpression) return;
         const {
           arguments: [includesCall],
           range: [, expectCallEnd]
@@ -4248,8 +4202,7 @@ var StatementType = /* @__PURE__ */ ((StatementType2) => {
 const paddingAlwaysTester = (prevNode, nextNode, paddingContext) => {
   const { sourceCode, ruleContext } = paddingContext;
   const paddingLines = getPaddingLineSequences(prevNode, nextNode, sourceCode);
-  if (paddingLines.length > 0)
-    return;
+  if (paddingLines.length > 0) return;
   ruleContext.report({
     node: nextNode,
     messageId: "missingPadding",
@@ -4364,8 +4317,7 @@ const testPadding = (prevNode, nextNode, paddingContext) => {
 };
 const verifyNode = (node, paddingContext) => {
   const { scopeInfo } = paddingContext;
-  if (!isValidParent(node?.parent.type))
-    return;
+  if (!isValidParent(node?.parent.type)) return;
   if (scopeInfo.prevNode) {
     testPadding(scopeInfo.prevNode, node, paddingContext);
   }
@@ -4995,48 +4947,6 @@ const plugin = {
     [RULE_NAME$2]: paddingAroundTestBlocks,
     [RULE_NAME]: validExpectInPromise
   },
-  configs: {
-    "legacy-recommended": createConfigLegacy(recommended),
-    "legacy-all": createConfigLegacy(allRules),
-    "recommended": {
-      plugins: {
-        get vitest() {
-          return plugin;
-        }
-      },
-      rules: createConfig(recommended)
-    },
-    "all": {
-      plugins: {
-        get vitest() {
-          return plugin;
-        }
-      },
-      rules: createConfig(allRules)
-    },
-    "env": {
-      languageOptions: {
-        globals: {
-          suite: "writable",
-          test: "writable",
-          describe: "writable",
-          it: "writable",
-          expectTypeOf: "writable",
-          assertType: "writable",
-          expect: "writable",
-          assert: "writable",
-          vitest: "writable",
-          vi: "writable",
-          beforeAll: "writable",
-          afterAll: "writable",
-          beforeEach: "writable",
-          afterEach: "writable",
-          onTestFailed: "writable",
-          onTestFinished: "writable"
-        }
-      }
-    }
-  },
   environments: {
     env: {
       globals: {
@@ -5060,5 +4970,43 @@ const plugin = {
     }
   }
 };
+plugin.configs = {
+  "legacy-recommended": createConfigLegacy(recommended),
+  "legacy-all": createConfigLegacy(allRules),
+  "recommended": {
+    plugins: {
+      ["vitest"]: plugin
+    },
+    rules: createConfig(recommended)
+  },
+  "all": {
+    plugins: {
+      ["vitest"]: plugin
+    },
+    rules: createConfig(allRules)
+  },
+  "env": {
+    languageOptions: {
+      globals: {
+        suite: "writable",
+        test: "writable",
+        describe: "writable",
+        it: "writable",
+        expectTypeOf: "writable",
+        assertType: "writable",
+        expect: "writable",
+        assert: "writable",
+        vitest: "writable",
+        vi: "writable",
+        beforeAll: "writable",
+        afterAll: "writable",
+        beforeEach: "writable",
+        afterEach: "writable",
+        onTestFailed: "writable",
+        onTestFinished: "writable"
+      }
+    }
+  }
+};
 
 module.exports = plugin;