eslint 7.4.0 → 7.5.0

package/lib/rules/prefer-regex-literals.js

@@ -102,11 +102,8 @@ module.exports = {
          */
         function isStringRawTaggedStaticTemplateLiteral(node) {
             return node.type === "TaggedTemplateExpression" &&
-                node.tag.type === "MemberExpression" &&
-                node.tag.object.type === "Identifier" &&
-                node.tag.object.name === "String" &&
-                isGlobalReference(node.tag.object) &&
-                astUtils.getStaticPropertyName(node.tag) === "raw" &&
+                astUtils.isSpecificMemberAccess(node.tag, "String", "raw") &&
+                isGlobalReference(astUtils.skipChainExpression(node.tag).object) &&
                 isStaticTemplateLiteral(node.quasi);
         }
 

package/lib/rules/prefer-spread.js

@@ -18,17 +18,13 @@ const astUtils = require("./utils/ast-utils");
  */
 function isVariadicApplyCalling(node) {
     return (
-        node.callee.type === "MemberExpression" &&
-        node.callee.property.type === "Identifier" &&
-        node.callee.property.name === "apply" &&
-        node.callee.computed === false &&
+        astUtils.isSpecificMemberAccess(node.callee, null, "apply") &&
         node.arguments.length === 2 &&
         node.arguments[1].type !== "ArrayExpression" &&
         node.arguments[1].type !== "SpreadElement"
     );
 }
 
-
 /**
  * Checks whether or not `thisArg` is not changed by `.apply()`.
  * @param {ASTNode|null} expectedThis The node that is the owner of the applied function.
@@ -75,7 +71,7 @@ module.exports = {
                     return;
                 }
 
-                const applied = node.callee.object;
+                const applied = astUtils.skipChainExpression(astUtils.skipChainExpression(node.callee).object);
                 const expectedThis = (applied.type === "MemberExpression") ? applied.object : null;
                 const thisArg = node.arguments[0];
 

package/lib/rules/radix.js

@@ -166,9 +166,12 @@ module.exports = {
                 if (variable && !isShadowed(variable)) {
                     variable.references.forEach(reference => {
                         const node = reference.identifier.parent;
+                        const maybeCallee = node.parent.type === "ChainExpression"
+                            ? node.parent
+                            : node;
 
-                        if (isParseIntMethod(node) && astUtils.isCallee(node)) {
-                            checkArguments(node.parent);
+                        if (isParseIntMethod(node) && astUtils.isCallee(maybeCallee)) {
+                            checkArguments(maybeCallee.parent);
                         }
                     });
                 }

package/lib/rules/sort-imports.js

@@ -44,6 +44,10 @@ module.exports = {
                     ignoreMemberSort: {
                         type: "boolean",
                         default: false
+                    },
+                    allowSeparatedGroups: {
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -66,6 +70,7 @@ module.exports = {
             ignoreDeclarationSort = configuration.ignoreDeclarationSort || false,
             ignoreMemberSort = configuration.ignoreMemberSort || false,
             memberSyntaxSortOrder = configuration.memberSyntaxSortOrder || ["none", "all", "multiple", "single"],
+            allowSeparatedGroups = configuration.allowSeparatedGroups || false,
             sourceCode = context.getSourceCode();
         let previousDeclaration = null;
 
@@ -115,9 +120,32 @@ module.exports = {
 
         }
 
+        /**
+         * Calculates number of lines between two nodes. It is assumed that the given `left` node appears before
+         * the given `right` node in the source code. Lines are counted from the end of the `left` node till the
+         * start of the `right` node. If the given nodes are on the same line, it returns `0`, same as if they were
+         * on two consecutive lines.
+         * @param {ASTNode} left node that appears before the given `right` node.
+         * @param {ASTNode} right node that appears after the given `left` node.
+         * @returns {number} number of lines between nodes.
+         */
+        function getNumberOfLinesBetween(left, right) {
+            return Math.max(right.loc.start.line - left.loc.end.line - 1, 0);
+        }
+
         return {
             ImportDeclaration(node) {
                 if (!ignoreDeclarationSort) {
+                    if (
+                        previousDeclaration &&
+                        allowSeparatedGroups &&
+                        getNumberOfLinesBetween(previousDeclaration, node) > 0
+                    ) {
+
+                        // reset declaration sort
+                        previousDeclaration = null;
+                    }
+
                     if (previousDeclaration) {
                         const currentMemberSyntaxGroupIndex = getMemberParameterGroupIndex(node),
                             previousMemberSyntaxGroupIndex = getMemberParameterGroupIndex(previousDeclaration);

package/lib/rules/use-isnan.js

@@ -106,7 +106,7 @@ module.exports = {
          * @returns {void}
          */
         function checkCallExpression(node) {
-            const callee = node.callee;
+            const callee = astUtils.skipChainExpression(node.callee);
 
             if (callee.type === "MemberExpression") {
                 const methodName = astUtils.getStaticPropertyName(callee);