eslint-plugin-jest 25.7.0 → 26.0.0

package/lib/rules/valid-expect-in-promise.js

@@ -5,18 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const isPromiseChainCall = node => {
-  if (node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.property)) {
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.property)) {
     // promise methods should have at least 1 argument
     if (node.arguments.length === 0) {
       return false;
     }
 
-    switch ((0, _utils.getAccessorValue)(node.callee.property)) {
+    switch ((0, _utils2.getAccessorValue)(node.callee.property)) {
       case 'then':
         return node.arguments.length < 3;
 
@@ -36,13 +36,13 @@ const findTopMostCallExpression = node => {
   } = node;
 
   while (parent) {
-    if (parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+    if (parent.type === _utils.AST_NODE_TYPES.CallExpression) {
       topMostCallExpression = parent;
       parent = parent.parent;
       continue;
     }
 
-    if (parent.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+    if (parent.type !== _utils.AST_NODE_TYPES.MemberExpression) {
       break;
     }
 
@@ -53,13 +53,13 @@ const findTopMostCallExpression = node => {
 };
 
 const isTestCaseCallWithCallbackArg = node => {
-  if (!(0, _utils.isTestCaseCall)(node)) {
+  if (!(0, _utils2.isTestCaseCall)(node)) {
     return false;
   }
 
-  const isJestEach = (0, _utils.getNodeName)(node).endsWith('.each');
+  const isJestEach = (0, _utils2.getNodeName)(node).endsWith('.each');
 
-  if (isJestEach && node.callee.type !== _experimentalUtils.AST_NODE_TYPES.TaggedTemplateExpression) {
+  if (isJestEach && node.callee.type !== _utils.AST_NODE_TYPES.TaggedTemplateExpression) {
     // isJestEach but not a TaggedTemplateExpression, so this must be
     // the `jest.each([])()` syntax which this rule doesn't support due
     // to its complexity (see jest-community/eslint-plugin-jest#710)
@@ -70,7 +70,7 @@ const isTestCaseCallWithCallbackArg = node => {
   if (isJestEach || node.arguments.length >= 2) {
     const [, callback] = node.arguments;
     const callbackArgIndex = Number(isJestEach);
-    return callback && (0, _utils.isFunction)(callback) && callback.params.length === 1 + callbackArgIndex;
+    return callback && (0, _utils2.isFunction)(callback) && callback.params.length === 1 + callbackArgIndex;
   }
 
   return false;
@@ -85,23 +85,23 @@ const isPromiseMethodThatUsesValue = (node, identifier) => {
     return false;
   }
 
-  if (node.argument.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.argument.arguments.length > 0) {
-    const nodeName = (0, _utils.getNodeName)(node.argument);
+  if (node.argument.type === _utils.AST_NODE_TYPES.CallExpression && node.argument.arguments.length > 0) {
+    const nodeName = (0, _utils2.getNodeName)(node.argument);
 
     if (['Promise.all', 'Promise.allSettled'].includes(nodeName)) {
       const [firstArg] = node.argument.arguments;
 
-      if (firstArg.type === _experimentalUtils.AST_NODE_TYPES.ArrayExpression && firstArg.elements.some(nod => (0, _utils.isIdentifier)(nod, name))) {
+      if (firstArg.type === _utils.AST_NODE_TYPES.ArrayExpression && firstArg.elements.some(nod => (0, _utils2.isIdentifier)(nod, name))) {
         return true;
       }
     }
 
     if (['Promise.resolve', 'Promise.reject'].includes(nodeName) && node.argument.arguments.length === 1) {
-      return (0, _utils.isIdentifier)(node.argument.arguments[0], name);
+      return (0, _utils2.isIdentifier)(node.argument.arguments[0], name);
     }
   }
 
-  return (0, _utils.isIdentifier)(node.argument, name);
+  return (0, _utils2.isIdentifier)(node.argument, name);
 };
 /**
  * Attempts to determine if the runtime value represented by the given `identifier`
@@ -111,11 +111,11 @@ const isPromiseMethodThatUsesValue = (node, identifier) => {
 
 const isValueAwaitedInElements = (name, elements) => {
   for (const element of elements) {
-    if (element.type === _experimentalUtils.AST_NODE_TYPES.AwaitExpression && (0, _utils.isIdentifier)(element.argument, name)) {
+    if (element.type === _utils.AST_NODE_TYPES.AwaitExpression && (0, _utils2.isIdentifier)(element.argument, name)) {
       return true;
     }
 
-    if (element.type === _experimentalUtils.AST_NODE_TYPES.ArrayExpression && isValueAwaitedInElements(name, element.elements)) {
+    if (element.type === _utils.AST_NODE_TYPES.ArrayExpression && isValueAwaitedInElements(name, element.elements)) {
       return true;
     }
   }
@@ -132,7 +132,7 @@ const isValueAwaitedInArguments = (name, call) => {
   let node = call;
 
   while (node) {
-    if (node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+    if (node.type === _utils.AST_NODE_TYPES.CallExpression) {
       if (isValueAwaitedInElements(name, node.arguments)) {
         return true;
       }
@@ -140,7 +140,7 @@ const isValueAwaitedInArguments = (name, call) => {
       node = node.callee;
     }
 
-    if (node.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+    if (node.type !== _utils.AST_NODE_TYPES.MemberExpression) {
       break;
     }
 
@@ -155,12 +155,12 @@ const getLeftMostCallExpression = call => {
   let node = call;
 
   while (node) {
-    if (node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+    if (node.type === _utils.AST_NODE_TYPES.CallExpression) {
       leftMostCallExpression = node;
       node = node.callee;
     }
 
-    if (node.type !== _experimentalUtils.AST_NODE_TYPES.MemberExpression) {
+    if (node.type !== _utils.AST_NODE_TYPES.MemberExpression) {
       break;
     }
 
@@ -187,42 +187,42 @@ const isValueAwaitedOrReturned = (identifier, body) => {
       continue;
     }
 
-    if (node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement) {
+    if (node.type === _utils.AST_NODE_TYPES.ReturnStatement) {
       return isPromiseMethodThatUsesValue(node, identifier);
     }
 
-    if (node.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement) {
+    if (node.type === _utils.AST_NODE_TYPES.ExpressionStatement) {
       // it's possible that we're awaiting the value as an argument
-      if (node.expression.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+      if (node.expression.type === _utils.AST_NODE_TYPES.CallExpression) {
         if (isValueAwaitedInArguments(name, node.expression)) {
           return true;
         }
 
         const leftMostCall = getLeftMostCallExpression(node.expression);
 
-        if ((0, _utils.isExpectCall)(leftMostCall) && leftMostCall.arguments.length > 0 && (0, _utils.isIdentifier)(leftMostCall.arguments[0], name)) {
+        if ((0, _utils2.isExpectCall)(leftMostCall) && leftMostCall.arguments.length > 0 && (0, _utils2.isIdentifier)(leftMostCall.arguments[0], name)) {
           const {
             modifier
-          } = (0, _utils.parseExpectCall)(leftMostCall);
+          } = (0, _utils2.parseExpectCall)(leftMostCall);
 
-          if ((modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils.ModifierName.resolves || (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils.ModifierName.rejects) {
+          if ((modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.resolves || (modifier === null || modifier === void 0 ? void 0 : modifier.name) === _utils2.ModifierName.rejects) {
             return true;
           }
         }
       }
 
-      if (node.expression.type === _experimentalUtils.AST_NODE_TYPES.AwaitExpression && isPromiseMethodThatUsesValue(node.expression, identifier)) {
+      if (node.expression.type === _utils.AST_NODE_TYPES.AwaitExpression && isPromiseMethodThatUsesValue(node.expression, identifier)) {
         return true;
       } // (re)assignment changes the runtime value, so if we've not found an
       // await or return already we act as if we've reached the end of the body
 
 
-      if (node.expression.type === _experimentalUtils.AST_NODE_TYPES.AssignmentExpression) {
+      if (node.expression.type === _utils.AST_NODE_TYPES.AssignmentExpression) {
         var _getNodeName;
 
         // unless we're assigning to the same identifier, in which case
         // we might be chaining off the existing promise value
-        if ((0, _utils.isIdentifier)(node.expression.left, name) && (_getNodeName = (0, _utils.getNodeName)(node.expression.right)) !== null && _getNodeName !== void 0 && _getNodeName.startsWith(`${name}.`) && isPromiseChainCall(node.expression.right)) {
+        if ((0, _utils2.isIdentifier)(node.expression.left, name) && (_getNodeName = (0, _utils2.getNodeName)(node.expression.right)) !== null && _getNodeName !== void 0 && _getNodeName.startsWith(`${name}.`) && isPromiseChainCall(node.expression.right)) {
           continue;
         }
 
@@ -230,7 +230,7 @@ const isValueAwaitedOrReturned = (identifier, body) => {
       }
     }
 
-    if (node.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement && isValueAwaitedOrReturned(identifier, node.body)) {
+    if (node.type === _utils.AST_NODE_TYPES.BlockStatement && isValueAwaitedOrReturned(identifier, node.body)) {
       return true;
     }
   }
@@ -242,7 +242,7 @@ const findFirstBlockBodyUp = node => {
   let parent = node;
 
   while (parent) {
-    if (parent.type === _experimentalUtils.AST_NODE_TYPES.BlockStatement) {
+    if (parent.type === _utils.AST_NODE_TYPES.BlockStatement) {
       return parent.body;
     }
 
@@ -258,11 +258,11 @@ const isDirectlyWithinTestCaseCall = node => {
   let parent = node;
 
   while (parent) {
-    if ((0, _utils.isFunction)(parent)) {
+    if ((0, _utils2.isFunction)(parent)) {
       var _parent;
 
       parent = parent.parent;
-      return !!(((_parent = parent) === null || _parent === void 0 ? void 0 : _parent.type) === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isTestCaseCall)(parent));
+      return !!(((_parent = parent) === null || _parent === void 0 ? void 0 : _parent.type) === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isTestCaseCall)(parent));
     }
 
     parent = parent.parent;
@@ -275,14 +275,14 @@ const isVariableAwaitedOrReturned = variable => {
   const body = findFirstBlockBodyUp(variable); // it's pretty much impossible for us to track destructuring assignments,
   // so we return true to bailout gracefully
 
-  if (!(0, _utils.isIdentifier)(variable.id)) {
+  if (!(0, _utils2.isIdentifier)(variable.id)) {
     return true;
   }
 
   return isValueAwaitedOrReturned(variable.id, body);
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -326,7 +326,7 @@ var _default = (0, _utils.createRule)({
         // an expect call, mark the deepest chain as having an expect call
 
 
-        if (chains.length > 0 && (0, _utils.isExpectCall)(node)) {
+        if (chains.length > 0 && (0, _utils2.isExpectCall)(node)) {
           chains[0] = true;
         }
       },
@@ -336,7 +336,7 @@ var _default = (0, _utils.createRule)({
         // make promises containing expects safe in a test for us to be able to
         // accurately check, so we just bail out completely if it's present
         if (inTestCaseWithDoneCallback) {
-          if ((0, _utils.isTestCaseCall)(node)) {
+          if ((0, _utils2.isTestCaseCall)(node)) {
             inTestCaseWithDoneCallback = false;
           }
 
@@ -368,7 +368,7 @@ var _default = (0, _utils.createRule)({
         }
 
         switch (parent.type) {
-          case _experimentalUtils.AST_NODE_TYPES.VariableDeclarator:
+          case _utils.AST_NODE_TYPES.VariableDeclarator:
             {
               if (isVariableAwaitedOrReturned(parent)) {
                 return;
@@ -377,20 +377,20 @@ var _default = (0, _utils.createRule)({
               break;
             }
 
-          case _experimentalUtils.AST_NODE_TYPES.AssignmentExpression:
+          case _utils.AST_NODE_TYPES.AssignmentExpression:
             {
-              if (parent.left.type === _experimentalUtils.AST_NODE_TYPES.Identifier && isValueAwaitedOrReturned(parent.left, findFirstBlockBodyUp(parent))) {
+              if (parent.left.type === _utils.AST_NODE_TYPES.Identifier && isValueAwaitedOrReturned(parent.left, findFirstBlockBodyUp(parent))) {
                 return;
               }
 
               break;
             }
 
-          case _experimentalUtils.AST_NODE_TYPES.ExpressionStatement:
+          case _utils.AST_NODE_TYPES.ExpressionStatement:
             break;
 
-          case _experimentalUtils.AST_NODE_TYPES.ReturnStatement:
-          case _experimentalUtils.AST_NODE_TYPES.AwaitExpression:
+          case _utils.AST_NODE_TYPES.ReturnStatement:
+          case _utils.AST_NODE_TYPES.AwaitExpression:
           default:
             return;
         }

package/lib/rules/valid-expect.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 /*
  * This implementation is ported from from eslint-plugin-jasmine.
@@ -22,11 +22,11 @@ var _utils = require("./utils");
  * @Returns CallExpressionNode
  */
 const getPromiseCallExpressionNode = node => {
-  if (node.type === _experimentalUtils.AST_NODE_TYPES.ArrayExpression && node.parent && node.parent.type === _experimentalUtils.AST_NODE_TYPES.CallExpression) {
+  if (node.type === _utils.AST_NODE_TYPES.ArrayExpression && node.parent && node.parent.type === _utils.AST_NODE_TYPES.CallExpression) {
     node = node.parent;
   }
 
-  if (node.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && node.callee.type === _experimentalUtils.AST_NODE_TYPES.MemberExpression && (0, _utils.isSupportedAccessor)(node.callee.object) && (0, _utils.getAccessorValue)(node.callee.object) === 'Promise' && node.parent) {
+  if (node.type === _utils.AST_NODE_TYPES.CallExpression && node.callee.type === _utils.AST_NODE_TYPES.MemberExpression && (0, _utils2.isSupportedAccessor)(node.callee.object) && (0, _utils2.getAccessorValue)(node.callee.object) === 'Promise' && node.parent) {
     return node;
   }
 
@@ -36,7 +36,7 @@ const getPromiseCallExpressionNode = node => {
 const findPromiseCallExpressionNode = node => {
   var _node$parent;
 
-  return (_node$parent = node.parent) !== null && _node$parent !== void 0 && _node$parent.parent && [_experimentalUtils.AST_NODE_TYPES.CallExpression, _experimentalUtils.AST_NODE_TYPES.ArrayExpression].includes(node.parent.type) ? getPromiseCallExpressionNode(node.parent) : null;
+  return (_node$parent = node.parent) !== null && _node$parent !== void 0 && _node$parent.parent && [_utils.AST_NODE_TYPES.CallExpression, _utils.AST_NODE_TYPES.ArrayExpression].includes(node.parent.type) ? getPromiseCallExpressionNode(node.parent) : null;
 };
 
 const getParentIfThenified = node => {
@@ -44,7 +44,7 @@ const getParentIfThenified = node => {
 
   const grandParentNode = (_node$parent2 = node.parent) === null || _node$parent2 === void 0 ? void 0 : _node$parent2.parent;
 
-  if (grandParentNode && grandParentNode.type === _experimentalUtils.AST_NODE_TYPES.CallExpression && (0, _utils.isExpectMember)(grandParentNode.callee) && ['then', 'catch'].includes((0, _utils.getAccessorValue)(grandParentNode.callee.property)) && grandParentNode.parent) {
+  if (grandParentNode && grandParentNode.type === _utils.AST_NODE_TYPES.CallExpression && (0, _utils2.isExpectMember)(grandParentNode.callee) && ['then', 'catch'].includes((0, _utils2.getAccessorValue)(grandParentNode.callee.property)) && grandParentNode.parent) {
     // Just in case `then`s are chained look one above.
     return getParentIfThenified(grandParentNode);
   }
@@ -53,18 +53,18 @@ const getParentIfThenified = node => {
 };
 
 const isAcceptableReturnNode = (node, allowReturn) => {
-  if (allowReturn && node.type === _experimentalUtils.AST_NODE_TYPES.ReturnStatement) {
+  if (allowReturn && node.type === _utils.AST_NODE_TYPES.ReturnStatement) {
     return true;
   }
 
-  if (node.type === _experimentalUtils.AST_NODE_TYPES.ConditionalExpression && node.parent) {
+  if (node.type === _utils.AST_NODE_TYPES.ConditionalExpression && node.parent) {
     return isAcceptableReturnNode(node.parent, allowReturn);
   }
 
-  return [_experimentalUtils.AST_NODE_TYPES.ArrowFunctionExpression, _experimentalUtils.AST_NODE_TYPES.AwaitExpression].includes(node.type);
+  return [_utils.AST_NODE_TYPES.ArrowFunctionExpression, _utils.AST_NODE_TYPES.AwaitExpression].includes(node.type);
 };
 
-const isNoAssertionsParentNode = node => node.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement || node.type === _experimentalUtils.AST_NODE_TYPES.AwaitExpression && node.parent !== undefined && node.parent.type === _experimentalUtils.AST_NODE_TYPES.ExpressionStatement;
+const isNoAssertionsParentNode = node => node.type === _utils.AST_NODE_TYPES.ExpressionStatement || node.type === _utils.AST_NODE_TYPES.AwaitExpression && node.parent !== undefined && node.parent.type === _utils.AST_NODE_TYPES.ExpressionStatement;
 
 const promiseArrayExceptionKey = ({
   start,
@@ -73,7 +73,7 @@ const promiseArrayExceptionKey = ({
 
 const defaultAsyncMatchers = ['toReject', 'toResolve'];
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -146,7 +146,7 @@ var _default = (0, _utils.createRule)({
 
     return {
       CallExpression(node) {
-        if (!(0, _utils.isExpectCall)(node)) {
+        if (!(0, _utils2.isExpectCall)(node)) {
           return;
         }
 
@@ -154,10 +154,10 @@ var _default = (0, _utils.createRule)({
           expect,
           modifier,
           matcher
-        } = (0, _utils.parseExpectCall)(node);
+        } = (0, _utils2.parseExpectCall)(node);
 
         if (expect.arguments.length < minArgs) {
-          const expectLength = (0, _utils.getAccessorValue)(expect.callee).length;
+          const expectLength = (0, _utils2.getAccessorValue)(expect.callee).length;
           const loc = {
             start: {
               column: node.loc.start.column + expectLength,
@@ -216,7 +216,7 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if ((0, _utils.isExpectMember)(matcher.node.parent)) {
+        if ((0, _utils2.isExpectMember)(matcher.node.parent)) {
           context.report({
             messageId: 'modifierUnknown',
             data: {
@@ -235,7 +235,7 @@ var _default = (0, _utils.createRule)({
         }
 
         const parentNode = matcher.node.parent;
-        const shouldBeAwaited = modifier && modifier.name !== _utils.ModifierName.not || asyncMatchers.includes(matcher.name);
+        const shouldBeAwaited = modifier && modifier.name !== _utils2.ModifierName.not || asyncMatchers.includes(matcher.name);
 
         if (!parentNode.parent || !shouldBeAwaited) {
           return;
@@ -246,7 +246,7 @@ var _default = (0, _utils.createRule)({
          */
 
 
-        const isParentArrayExpression = parentNode.parent.type === _experimentalUtils.AST_NODE_TYPES.ArrayExpression;
+        const isParentArrayExpression = parentNode.parent.type === _utils.AST_NODE_TYPES.ArrayExpression;
         const orReturned = alwaysAwait ? '' : ' or returned';
         /**
          * An async assertion can be chained with `then` or `catch` statements.
@@ -277,7 +277,7 @@ var _default = (0, _utils.createRule)({
 
       // nothing called on "expect()"
       'CallExpression:exit'(node) {
-        if ((0, _utils.isExpectCall)(node) && isNoAssertionsParentNode(node.parent)) {
+        if ((0, _utils2.isExpectCall)(node) && isNoAssertionsParentNode(node.parent)) {
           context.report({
             messageId: 'matcherNotFound',
             node

package/lib/rules/valid-title.js

@@ -5,25 +5,25 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _experimentalUtils = require("@typescript-eslint/experimental-utils");
+var _utils = require("@typescript-eslint/utils");
 
-var _utils = require("./utils");
+var _utils2 = require("./utils");
 
 const trimFXprefix = word => ['f', 'x'].includes(word.charAt(0)) ? word.substr(1) : word;
 
 const doesBinaryExpressionContainStringNode = binaryExp => {
-  if ((0, _utils.isStringNode)(binaryExp.right)) {
+  if ((0, _utils2.isStringNode)(binaryExp.right)) {
     return true;
   }
 
-  if (binaryExp.left.type === _experimentalUtils.AST_NODE_TYPES.BinaryExpression) {
+  if (binaryExp.left.type === _utils.AST_NODE_TYPES.BinaryExpression) {
     return doesBinaryExpressionContainStringNode(binaryExp.left);
   }
 
-  return (0, _utils.isStringNode)(binaryExp.left);
+  return (0, _utils2.isStringNode)(binaryExp.left);
 };
 
-const quoteStringValue = node => node.type === _experimentalUtils.AST_NODE_TYPES.TemplateLiteral ? `\`${node.quasis[0].value.raw}\`` : node.raw;
+const quoteStringValue = node => node.type === _utils.AST_NODE_TYPES.TemplateLiteral ? `\`${node.quasis[0].value.raw}\`` : node.raw;
 
 const compileMatcherPattern = matcherMaybeWithMessage => {
   const [matcher, message] = Array.isArray(matcherMaybeWithMessage) ? matcherMaybeWithMessage : [matcherMaybeWithMessage];
@@ -57,7 +57,7 @@ const MatcherAndMessageSchema = {
   additionalItems: false
 };
 
-var _default = (0, _utils.createRule)({
+var _default = (0, _utils2.createRule)({
   name: __filename,
   meta: {
     docs: {
@@ -130,7 +130,7 @@ var _default = (0, _utils.createRule)({
       CallExpression(node) {
         var _mustNotMatchPatterns, _mustMatchPatterns$je;
 
-        if (!(0, _utils.isDescribeCall)(node) && !(0, _utils.isTestCaseCall)(node)) {
+        if (!(0, _utils2.isDescribeCall)(node) && !(0, _utils2.isTestCaseCall)(node)) {
           return;
         }
 
@@ -140,12 +140,12 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        if (!(0, _utils.isStringNode)(argument)) {
-          if (argument.type === _experimentalUtils.AST_NODE_TYPES.BinaryExpression && doesBinaryExpressionContainStringNode(argument)) {
+        if (!(0, _utils2.isStringNode)(argument)) {
+          if (argument.type === _utils.AST_NODE_TYPES.BinaryExpression && doesBinaryExpressionContainStringNode(argument)) {
             return;
           }
 
-          if (argument.type !== _experimentalUtils.AST_NODE_TYPES.TemplateLiteral && !(ignoreTypeOfDescribeName && (0, _utils.isDescribeCall)(node))) {
+          if (argument.type !== _utils.AST_NODE_TYPES.TemplateLiteral && !(ignoreTypeOfDescribeName && (0, _utils2.isDescribeCall)(node))) {
             context.report({
               messageId: 'titleMustBeString',
               loc: argument.loc
@@ -155,13 +155,13 @@ var _default = (0, _utils.createRule)({
           return;
         }
 
-        const title = (0, _utils.getStringValue)(argument);
+        const title = (0, _utils2.getStringValue)(argument);
 
         if (!title) {
           context.report({
             messageId: 'emptyTitle',
             data: {
-              jestFunctionName: (0, _utils.isDescribeCall)(node) ? _utils.DescribeAlias.describe : _utils.TestCaseName.test
+              jestFunctionName: (0, _utils2.isDescribeCall)(node) ? _utils2.DescribeAlias.describe : _utils2.TestCaseName.test
             },
             node
           });
@@ -191,7 +191,7 @@ var _default = (0, _utils.createRule)({
           });
         }
 
-        const nodeName = trimFXprefix((0, _utils.getNodeName)(node));
+        const nodeName = trimFXprefix((0, _utils2.getNodeName)(node));
         const [firstWord] = title.split(' ');
 
         if (firstWord.toLowerCase() === nodeName) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-jest",
-  "version": "25.7.0",
+  "version": "26.0.0",
   "description": "Eslint rules for Jest",
   "keywords": [
     "eslint",
@@ -82,7 +82,7 @@
     ]
   },
   "dependencies": {
-    "@typescript-eslint/experimental-utils": "^5.0.0"
+    "@typescript-eslint/utils": "^5.10.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.4.4",
@@ -127,7 +127,7 @@
     "typescript": "^4.4.0"
   },
   "peerDependencies": {
-    "@typescript-eslint/eslint-plugin": "^4.0.0 || ^5.0.0",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
     "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0"
   },
   "peerDependenciesMeta": {