@vitest/eslint-plugin 1.1.19 → 1.1.21

package/dist/index.mjs

@@ -4,7 +4,7 @@ import { isAbsolute, posix } from 'node:path';
 import ts from 'typescript';
 import { createRequire } from 'node:module';
 
-const version = "1.1.18";
+const version = "1.1.20";
 
 function createEslintRule(rule) {
   const createRule = ESLintUtils.RuleCreator(
@@ -15,8 +15,7 @@ function createEslintRule(rule) {
 const joinNames = (a, b) => a && b ? `${a}.${b}` : null;
 const isFunction = (node) => node.type === AST_NODE_TYPES.FunctionExpression || node.type === AST_NODE_TYPES.ArrowFunctionExpression;
 function getNodeName(node) {
-  if (isSupportedAccessor(node))
-    return getAccessorValue(node);
+  if (isSupportedAccessor(node)) return getAccessorValue(node);
   switch (node.type) {
     case AST_NODE_TYPES.TaggedTemplateExpression:
       return getNodeName(node.tag);
@@ -83,6 +82,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";
@@ -155,10 +156,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";
@@ -325,6 +326,8 @@ const describeImportDefAsImport = (def) => {
     return null;
   if (def.node.type !== AST_NODE_TYPES.ImportSpecifier)
     return null;
+  if (def.node.imported.type != AST_NODE_TYPES.Identifier)
+    return null;
   if (def.parent.importKind === "type")
     return null;
   return {
@@ -448,8 +451,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)
@@ -459,13 +461,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],
@@ -523,8 +522,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);
@@ -536,8 +534,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();
@@ -663,8 +660,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,
@@ -738,18 +734,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: {
@@ -782,8 +766,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 === AST_NODE_TYPES.CallExpression ? unchecked.indexOf(node) : -1;
@@ -808,10 +792,9 @@ const expectExpect = createEslintRule({
           return;
         const name = getNodeName(node) ?? "";
         if (isTypeOfVitestFnCall(node, context, ["test"]) || additionalTestBlockFunctions.includes(name)) {
-          if (node.callee.type === AST_NODE_TYPES.MemberExpression && isSupportedAccessor(node.callee.property, "todo"))
-            return;
+          if (node.callee.type === 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));
         }
       },
@@ -826,6 +809,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) => [
@@ -891,6 +885,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) {
@@ -910,8 +906,7 @@ const consistentTestIt = createEslintRule({
         if (node.callee.type === 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;
@@ -1477,8 +1472,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") {
@@ -1558,16 +1552,13 @@ const noDoneCallback = createEslintRule({
         if (isVitestEach && node.callee.type !== AST_NODE_TYPES.TaggedTemplateExpression)
           return;
         const isInsideConcurrentTestOrDescribe = context.sourceCode.getAncestors(node).some((ancestor) => {
-          if (ancestor.type !== AST_NODE_TYPES.CallExpression)
-            return false;
+          if (ancestor.type !== 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 === 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)
@@ -1654,14 +1645,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({
@@ -2055,18 +2045,15 @@ const noTestReturnStatement = createEslintRule({
           return;
         const body = getBody(node.arguments);
         const returnStmt = body.find((stmt) => stmt.type === 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 === AST_NODE_TYPES.ReturnStatement);
-        if (!returnStmt)
-          return;
+        if (!returnStmt) return;
         context.report({ messageId: "noTestReturnStatement", node: returnStmt });
       }
     };
@@ -2093,8 +2080,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"
         ))
@@ -2137,8 +2123,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.isClassDeclaration(declaration) || ts.isClassExpression(declaration)) ?? false;
 }
 const compileMatcherPatterns = (matchers) => {
@@ -2237,17 +2222,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 == AST_NODE_TYPES.Identifier && m.name == "extend")) return;
         const [argument] = node.arguments;
         if (settings.typecheck) {
           const services = 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 === AST_NODE_TYPES.Identifier)
-          return;
+        if (!argument || allowArguments && argument.type === AST_NODE_TYPES.Identifier) return;
         if (!isStringNode(argument)) {
           if (argument.type === AST_NODE_TYPES.BinaryExpression && doesBinaryExpressionContainStringNode(argument))
             return;
@@ -2481,6 +2464,8 @@ const validExpect = createEslintRule({
           return;
         } else if (vitestFnCall?.type !== "expect") {
           return;
+        } else if (vitestFnCall.modifiers.some((mod) => mod.type === AST_NODE_TYPES.Identifier && mod.name == "to")) {
+          return;
         }
         const { parent: expect } = vitestFnCall.head.node;
         if (expect?.type !== AST_NODE_TYPES.CallExpression)
@@ -2689,8 +2674,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,
@@ -2727,8 +2711,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,
@@ -2889,8 +2872,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({
@@ -2930,8 +2912,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 !== AST_NODE_TYPES.CallExpression)
         return;
@@ -2980,13 +2961,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",
@@ -3074,8 +3053,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;
@@ -3139,8 +3117,7 @@ const preferMockPromiseShorthand = createEslintRule({
   defaultOptions: [],
   create(context) {
     const report = (property, isOnce, outerArgNode, innerArgNode = outerArgNode) => {
-      if (innerArgNode?.type !== AST_NODE_TYPES.CallExpression)
-        return;
+      if (innerArgNode?.type !== AST_NODE_TYPES.CallExpression) return;
       const argName = getNodeName(innerArgNode);
       if (argName !== "Promise.resolve" && argName !== "Promise.reject")
         return;
@@ -3246,13 +3223,10 @@ const preferViMocked = createEslintRule({
   create(context) {
     function check(node) {
       const { typeAnnotation } = node;
-      if (typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference)
-        return;
+      if (typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference) return;
       const { typeName } = typeAnnotation;
-      if (typeName.type !== AST_NODE_TYPES.Identifier)
-        return;
-      if (!mockTypes.includes(typeName.name))
-        return;
+      if (typeName.type !== AST_NODE_TYPES.Identifier) return;
+      if (!mockTypes.includes(typeName.name)) return;
       const fnName = context.sourceCode.text.slice(
         ...followTypeAssertionChain(node.expression).range
       );
@@ -3266,8 +3240,7 @@ const preferViMocked = createEslintRule({
     }
     return {
       TSAsExpression(node) {
-        if (node.parent.type === AST_NODE_TYPES.TSAsExpression)
-          return;
+        if (node.parent.type === AST_NODE_TYPES.TSAsExpression) return;
         check(node);
       },
       TSTypeAssertion(node) {
@@ -3281,12 +3254,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);
 };
@@ -3361,8 +3332,7 @@ const preferSnapshotHint = createEslintRule({
           return;
         }
         const matcherName = getAccessorValue(vitestFnCall.matcher);
-        if (!snapshotMatcherNames.includes(matcherName))
-          return;
+        if (!snapshotMatcherNames.includes(matcherName)) return;
         snapshotMatchers2.push(vitestFnCall);
       }
     };
@@ -3383,8 +3353,7 @@ const hasNonEachMembersAndParams = (vitestFnCall, functionExpression) => {
 };
 const reportUnexpectedReturnInDescribe = (blockStatement, context) => {
   blockStatement.body.forEach((node) => {
-    if (node.type !== AST_NODE_TYPES.ReturnStatement)
-      return;
+    if (node.type !== AST_NODE_TYPES.ReturnStatement) return;
     context.report({
       messageId: "unexpectedReturnInDescribe",
       node
@@ -3412,8 +3381,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 === AST_NODE_TYPES.Identifier && vitestFnCall.members[0].name === "todo")
           return;
         if (node.arguments.length < 1) {
@@ -3510,8 +3478,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) {
@@ -3565,8 +3532,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")) {
@@ -3653,11 +3619,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 !== AST_NODE_TYPES.BlockStatement)
-          return;
+        if (!isFunction(testFn) || testFn.body.type !== AST_NODE_TYPES.BlockStatement) return;
         checkBlockBody(testFn.body.body);
       }
     };
@@ -3697,19 +3661,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 !== AST_NODE_TYPES.CallExpression)
-            return false;
+          if (ancestor.type !== 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 === AST_NODE_TYPES.MemberExpression && isSupportedAccessor(ancestor.callee.property, "concurrent");
           return isTestRunningConcurrently;
         });
-        if (isInsideSequentialDescribeOrTest)
-          return;
+        if (isInsideSequentialDescribeOrTest) return;
         context.report({
           node,
           messageId: "requireLocalTestContext"
@@ -3721,8 +3681,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");
@@ -3828,11 +3787,9 @@ const preferSpyOn = createEslintRule({
     return {
       AssignmentExpression(node) {
         const { left, right } = node;
-        if (left.type !== AST_NODE_TYPES.MemberExpression)
-          return;
+        if (left.type !== AST_NODE_TYPES.MemberExpression) return;
         const vitestFnCall = getVitestFnCall(right);
-        if (!vitestFnCall)
-          return;
+        if (!vitestFnCall) return;
         context.report({
           node,
           messageId: "useViSpayOn",
@@ -3913,8 +3870,7 @@ const preferComparisonMatcher = createEslintRule({
         if (vitestFnCall?.type !== "expect" || vitestFnCall.args.length === 0)
           return;
         const { parent: expect } = vitestFnCall.head.node;
-        if (expect?.type !== AST_NODE_TYPES.CallExpression)
-          return;
+        if (expect?.type !== AST_NODE_TYPES.CallExpression) return;
         const {
           arguments: [comparison],
           range: [, expectCallEnd]
@@ -3926,8 +3882,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;
@@ -3980,8 +3935,7 @@ const preferToContain = createEslintRule({
         if (vitestFnCall?.type !== "expect" || vitestFnCall.args.length === 0)
           return;
         const { parent: expect } = vitestFnCall.head.node;
-        if (expect?.type !== AST_NODE_TYPES.CallExpression)
-          return;
+        if (expect?.type !== AST_NODE_TYPES.CallExpression) return;
         const {
           arguments: [includesCall],
           range: [, expectCallEnd]
@@ -4229,8 +4183,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",
@@ -4345,8 +4298,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);
   }
@@ -4976,48 +4928,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: {
@@ -5041,5 +4951,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"
+      }
+    }
+  }
+};
 
 export { plugin as default };