@stylistic/eslint-plugin - npm Package Compare versions

Comparing version 2.12.1 to 2.13.0

dist/rules/array-bracket-spacing.js

@@ -129,11 +129,11 @@ 'use strict';
       if (utils.isTokenOnSameLine(first, second)) {
-        if (openingBracketMustBeSpaced && !sourceCode.isSpaceBetweenTokens(first, second))
+        if (openingBracketMustBeSpaced && !sourceCode.isSpaceBetween(first, second))
           reportRequiredBeginningSpace(node, first);
-        if (!openingBracketMustBeSpaced && sourceCode.isSpaceBetweenTokens(first, second))
+        if (!openingBracketMustBeSpaced && sourceCode.isSpaceBetween(first, second))
           reportNoBeginningSpace(node, first);
       }
       if (first !== penultimate && utils.isTokenOnSameLine(penultimate, last)) {
-        if (closingBracketMustBeSpaced && !sourceCode.isSpaceBetweenTokens(penultimate, last))
+        if (closingBracketMustBeSpaced && !sourceCode.isSpaceBetween(penultimate, last))
           reportRequiredEndingSpace(node, last);
-        if (!closingBracketMustBeSpaced && sourceCode.isSpaceBetweenTokens(penultimate, last))
+        if (!closingBracketMustBeSpaced && sourceCode.isSpaceBetween(penultimate, last))
           reportNoEndingSpace(node, last);
@@ -140,0 +140,0 @@ }

dist/rules/block-spacing.js

@@ -42,3 +42,3 @@ 'use strict';
     function isValid(left, right) {
-      return !utils.isTokenOnSameLine(left, right) || sourceCode.isSpaceBetweenTokens(left, right) === always;
+      return !utils.isTokenOnSameLine(left, right) || sourceCode.isSpaceBetween(left, right) === always;
     }
@@ -45,0 +45,0 @@ function checkSpacingInsideBraces(node) {

dist/rules/computed-property-spacing.js

@@ -107,6 +107,6 @@ 'use strict';
           if (propertyNameMustBeSpaced) {
-            if (!sourceCode.isSpaceBetweenTokens(before, first) && utils.isTokenOnSameLine(before, first))
+            if (!sourceCode.isSpaceBetween(before, first) && utils.isTokenOnSameLine(before, first))
               reportRequiredBeginningSpace(node, before);
           } else {
-            if (sourceCode.isSpaceBetweenTokens(before, first))
+            if (sourceCode.isSpaceBetween(before, first))
               reportNoBeginningSpace(node, before, first);
@@ -117,6 +117,6 @@ }
           if (propertyNameMustBeSpaced) {
-            if (!sourceCode.isSpaceBetweenTokens(last, after) && utils.isTokenOnSameLine(last, after))
+            if (!sourceCode.isSpaceBetween(last, after) && utils.isTokenOnSameLine(last, after))
               reportRequiredEndingSpace(node, after);
           } else {
-            if (sourceCode.isSpaceBetweenTokens(last, after))
+            if (sourceCode.isSpaceBetween(last, after))
               reportNoEndingSpace(node, after, last);
@@ -123,0 +123,0 @@ }

dist/rules/indent-binary-ops.js

@@ -80,2 +80,11 @@ 'use strict';
     }
+    function isTypeKeywordOfNode(typeToken, node) {
+      while (node.parent) {
+        node = node.parent;
+        if (node.type === "TSTypeAliasDeclaration" && context.sourceCode.getTokenBefore(node.id) === typeToken) {
+          return true;
+        }
+      }
+      return false;
+    }
     function handler(node, right) {
@@ -99,3 +108,3 @@ if (node.loc.start.line === node.loc.end.line)
       const lastTokenOfLineLeft = lastTokenOfLine(tokenLeft.loc.start.line);
-      const needAdditionIndent = firstTokenOfLineLeft?.type === "Keyword" && !["typeof", "instanceof", "this"].includes(firstTokenOfLineLeft.value) || firstTokenOfLineLeft?.type === "Identifier" && firstTokenOfLineLeft.value === "type" && node.parent?.type === "TSTypeAliasDeclaration" || [":", "[", "(", "<", "="].includes(lastTokenOfLineLeft?.value || "") || ["[", "(", "=>", ":"].includes(tokenBeforeAll?.value || "") && firstTokenOfLineLeft?.loc.start.line === tokenBeforeAll?.loc.start.line || ["||", "&&"].includes(lastTokenOfLineLeft?.value || "") && node.loc.start.line === tokenLeft.loc.start.line && node.loc.start.column !== getIndentOfLine(node.loc.start.line).length;
+      const needAdditionIndent = firstTokenOfLineLeft?.type === "Keyword" && !["typeof", "instanceof", "this"].includes(firstTokenOfLineLeft.value) || firstTokenOfLineLeft?.type === "Identifier" && firstTokenOfLineLeft.value === "type" && isTypeKeywordOfNode(firstTokenOfLineLeft, node) || [":", "[", "(", "<"].concat(utils.ASSIGNMENT_OPERATOR).includes(lastTokenOfLineLeft?.value || "") || ["[", "(", "=>", ":"].concat(utils.ASSIGNMENT_OPERATOR).includes(tokenBeforeAll?.value || "") && firstTokenOfLineLeft?.loc.start.line === tokenBeforeAll?.loc.start.line || ["||", "&&"].includes(lastTokenOfLineLeft?.value || "") && node.loc.start.line === tokenLeft.loc.start.line && node.loc.start.column !== getIndentOfLine(node.loc.start.line).length;
       const needSubtractionIndent = lastTokenOfLineLeft?.value === ")" && isGreaterThanCloseBracketOfLine(tokenLeft.loc.start.line) && !["]", ")", "}"].includes(firstTokenOfLineLeft?.value || "");
@@ -102,0 +111,0 @@ const indentLeft = getIndentOfLine(tokenLeft.loc.start.line);

dist/rules/jsx-curly-spacing.js

@@ -275,7 +275,7 @@ 'use strict';
       if (spacing === SPACING.always) {
-        if (!sourceCode.isSpaceBetweenTokens(first, second))
+        if (!sourceCode.isSpaceBetween(first, second))
           reportRequiredBeginningSpace(node, first);
         else if (!config.allowMultiline && isMultiline(first, second))
           reportNoBeginningNewline(node, first, spacing);
-        if (!sourceCode.isSpaceBetweenTokens(penultimate, last))
+        if (!sourceCode.isSpaceBetween(penultimate, last))
           reportRequiredEndingSpace(node, last);
@@ -288,3 +288,3 @@ else if (!config.allowMultiline && isMultiline(penultimate, last))
             reportNoBeginningNewline(node, first, spacing);
-        } else if (sourceCode.isSpaceBetweenTokens(first, second)) {
+        } else if (sourceCode.isSpaceBetween(first, second)) {
           reportNoBeginningSpace(node, first);
@@ -295,3 +295,3 @@ }
             reportNoEndingNewline(node, last, spacing);
-        } else if (sourceCode.isSpaceBetweenTokens(penultimate, last)) {
+        } else if (sourceCode.isSpaceBetween(penultimate, last)) {
           reportNoEndingSpace(node, last);
@@ -298,0 +298,0 @@ }

dist/rules/jsx-equals-spacing.js

@@ -40,4 +40,4 @@ 'use strict';
           const equalToken = sourceCode.getTokenAfter(attrNode.name);
-          const spacedBefore = sourceCode.isSpaceBetweenTokens(attrNode.name, equalToken);
-          const spacedAfter = sourceCode.isSpaceBetweenTokens(equalToken, attrNode.value);
+          const spacedBefore = sourceCode.isSpaceBetween(attrNode.name, equalToken);
+          const spacedAfter = sourceCode.isSpaceBetween(equalToken, attrNode.value);
           if (config === "never") {
@@ -44,0 +44,0 @@ if (spacedBefore) {

dist/rules/jsx-one-expression-per-line.js

@@ -129,6 +129,8 @@ 'use strict';
           const spaceBetweenPrev = () => {
-            return (prevChild.type === "Literal" || prevChild.type === "JSXText") && prevChild.raw.endsWith(" ") || (child.type === "Literal" || child.type === "JSXText") && child.raw.startsWith(" ") || context.sourceCode.isSpaceBetweenTokens(prevChild, child);
+            const tokenBetweenNodes = context.sourceCode.getTokensBetween(prevChild, child)[0];
+            return (prevChild.type === "Literal" || prevChild.type === "JSXText") && prevChild.raw.endsWith(" ") || (child.type === "Literal" || child.type === "JSXText") && child.raw.startsWith(" ") || utils.isWhiteSpaces(tokenBetweenNodes?.value);
           };
           const spaceBetweenNext = () => {
-            return (nextChild.type === "Literal" || nextChild.type === "JSXText") && nextChild.raw.startsWith(" ") || (child.type === "Literal" || child.type === "JSXText") && child.raw.endsWith(" ") || context.sourceCode.isSpaceBetweenTokens(child, nextChild);
+            const tokenBetweenNodes = context.sourceCode.getTokensBetween(child, nextChild)[0];
+            return (nextChild.type === "Literal" || nextChild.type === "JSXText") && nextChild.raw.startsWith(" ") || (child.type === "Literal" || child.type === "JSXText") && child.raw.endsWith(" ") || utils.isWhiteSpaces(tokenBetweenNodes?.value);
           };
@@ -135,0 +137,0 @@ const source = context.sourceCode.getText(child);

dist/rules/jsx-tag-spacing.js

@@ -27,3 +27,3 @@ 'use strict';
     const lastTokens = sourceCode.getLastTokens(node, 2);
-    adjacent = !sourceCode.isSpaceBetweenTokens(lastTokens[0], lastTokens[1]);
+    adjacent = !sourceCode.isSpaceBetween(lastTokens[0], lastTokens[1]);
     if (option === "never") {
@@ -58,3 +58,3 @@ if (!adjacent) {
     const firstTokens = sourceCode.getFirstTokens(node, 2);
-    adjacent = !sourceCode.isSpaceBetweenTokens(firstTokens[0], firstTokens[1]);
+    adjacent = !sourceCode.isSpaceBetween(firstTokens[0], firstTokens[1]);
     if (option === "never") {
@@ -108,3 +108,3 @@ if (!adjacent) {
     return;
-  const adjacent = !sourceCode.isSpaceBetweenTokens(leftToken, closingSlash);
+  const adjacent = !sourceCode.isSpaceBetween(leftToken, closingSlash);
   if ((option === "always" || option === "proportional-always") && adjacent) {
@@ -138,3 +138,3 @@ context.report({
   }
-  const adjacent = !sourceCode.isSpaceBetweenTokens(openingToken, node.name);
+  const adjacent = !sourceCode.isSpaceBetween(openingToken, node.name);
   if (option === "never" || option === "allow-multiline") {
@@ -188,3 +188,3 @@ if (!adjacent) {
       return;
-    const adjacent = !sourceCode.isSpaceBetweenTokens(leftToken, closingToken);
+    const adjacent = !sourceCode.isSpaceBetween(leftToken, closingToken);
     if (option === "never" && !adjacent) {
@@ -191,0 +191,0 @@ context.report({

dist/rules/key-spacing.js

@@ -10,2 +10,12 @@ 'use strict';
 
+const listeningNodes = [
+  "ObjectExpression",
+  "ObjectPattern",
+  "ImportDeclaration",
+  "ExportNamedDeclaration",
+  "ExportAllDeclaration",
+  "TSTypeLiteral",
+  "TSInterfaceBody",
+  "ClassBody"
+];
 function containsLineTerminator(str) {
@@ -73,2 +83,3 @@ return utils.LINEBREAK_MATCHER.test(str);
   }
+  toOptions.ignoredNodes = fromOptions.ignoredNodes || [];
   return toOptions;
@@ -127,2 +138,9 @@ }
               type: "boolean"
+            },
+            ignoredNodes: {
+              type: "array",
+              items: {
+                type: "string",
+                enum: listeningNodes
+              }
             }
@@ -271,2 +289,3 @@ },
     const alignmentOptions = ruleOptions.align || null;
+    const ignoredNodes = ruleOptions.ignoredNodes;
     const sourceCode = context.sourceCode;
@@ -429,2 +448,4 @@ function isKeyValueProperty(property) {
     function verifySpacing(node, lineOptions) {
+      if (ignoredNodes.includes(node.parent.type))
+        return;
       const actual = getPropertyWhitespace(node);
@@ -451,2 +472,4 @@ if (actual) {
     function verifyImportAttributes(node) {
+      if (ignoredNodes.includes(node.type))
+        return;
       if (!node.attributes)
@@ -464,2 +487,4 @@ return;
         ObjectExpression(node) {
+          if (ignoredNodes.includes(node.type))
+            return;
           if (isSingleLine(node))
@@ -511,2 +536,3 @@ verifyListSpacing(node.properties.filter(isKeyValueProperty), singleLineOptions);
     const options = _options || {};
+    const ignoredNodes = options.ignoredNodes || [];
     const sourceCode = context.sourceCode;
@@ -680,2 +706,4 @@ const baseRules = baseRule.create(context);
     function validateBody(body) {
+      if (ignoredNodes.includes(body.type))
+        return;
       const isSingleLine = body.loc.start.line === body.loc.end.line;
@@ -682,0 +710,0 @@ const members = body.type === utils$1.AST_NODE_TYPES.TSTypeLiteral ? body.members : body.body;

dist/rules/keyword-spacing.js

@@ -76,3 +76,3 @@ 'use strict';
       const prevToken = sourceCode.getTokenBefore(token);
-      if (prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && utils.isTokenOnSameLine(prevToken, token) && !sourceCode.isSpaceBetweenTokens(prevToken, token)) {
+      if (prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && utils.isTokenOnSameLine(prevToken, token) && !sourceCode.isSpaceBetween(prevToken, token)) {
         context.report({
@@ -91,3 +91,3 @@ loc: token.loc,
       const prevToken = sourceCode.getTokenBefore(token);
-      if (prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && utils.isTokenOnSameLine(prevToken, token) && sourceCode.isSpaceBetweenTokens(prevToken, token)) {
+      if (prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && utils.isTokenOnSameLine(prevToken, token) && sourceCode.isSpaceBetween(prevToken, token)) {
         context.report({
@@ -106,3 +106,3 @@ loc: { start: prevToken.loc.end, end: token.loc.start },
       const nextToken = sourceCode.getTokenAfter(token);
-      if (nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && utils.isTokenOnSameLine(token, nextToken) && !sourceCode.isSpaceBetweenTokens(token, nextToken)) {
+      if (nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && utils.isTokenOnSameLine(token, nextToken) && !sourceCode.isSpaceBetween(token, nextToken)) {
         context.report({
@@ -121,3 +121,3 @@ loc: token.loc,
       const nextToken = sourceCode.getTokenAfter(token);
-      if (nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && utils.isTokenOnSameLine(token, nextToken) && sourceCode.isSpaceBetweenTokens(token, nextToken)) {
+      if (nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && utils.isTokenOnSameLine(token, nextToken) && sourceCode.isSpaceBetween(token, nextToken)) {
         context.report({
@@ -124,0 +124,0 @@ loc: { start: token.loc.end, end: nextToken.loc.start },

dist/rules/no-extra-parens.js

@@ -51,3 +51,4 @@ 'use strict';
                 enforceForFunctionPrototypeMethods: { type: "boolean" },
-                allowParensAfterCommentPattern: { type: "string" }
+                allowParensAfterCommentPattern: { type: "string" },
+                nestedConditionalExpressions: { type: "boolean" }
               },
@@ -81,2 +82,3 @@ additionalProperties: false
     const ALLOW_PARENS_AFTER_COMMENT_PATTERN = ALL_NODES && context.options[1] && context.options[1].allowParensAfterCommentPattern;
+    const ALLOW_NESTED_TERNARY = ALL_NODES && context.options[1] && context.options[1].nestedConditionalExpressions === false;
     const PRECEDENCE_OF_ASSIGNMENT_EXPR = precedence({ type: "AssignmentExpression" });
@@ -186,3 +188,3 @@ const PRECEDENCE_OF_UPDATE_EXPR = precedence({ type: "UpdateExpression" });
       const tokenBeforeRightParen = sourceCode.getLastToken(node);
-      return rightParenToken && tokenAfterRightParen && !sourceCode.isSpaceBetweenTokens(rightParenToken, tokenAfterRightParen) && !utils.canTokensBeAdjacent(tokenBeforeRightParen, tokenAfterRightParen);
+      return rightParenToken && tokenAfterRightParen && !sourceCode.isSpaceBetween(rightParenToken, tokenAfterRightParen) && !utils.canTokensBeAdjacent(tokenBeforeRightParen, tokenAfterRightParen);
     }
@@ -421,9 +423,9 @@ function isIIFE(node) {
         const availableTypes = /* @__PURE__ */ new Set(["BinaryExpression", "LogicalExpression"]);
-        if (!(EXCEPT_COND_TERNARY && availableTypes.has(node.test.type)) && !isCondAssignException(node) && hasExcessParensWithPrecedence(node.test, precedence({ type: "LogicalExpression", operator: "||" }))) {
+        if (!(EXCEPT_COND_TERNARY && availableTypes.has(node.test.type)) && !(ALLOW_NESTED_TERNARY && ["ConditionalExpression"].includes(node.test.type)) && !isCondAssignException(node) && hasExcessParensWithPrecedence(node.test, precedence({ type: "LogicalExpression", operator: "||" }))) {
           report(node.test);
         }
-        if (!(EXCEPT_COND_TERNARY && availableTypes.has(node.consequent.type)) && hasExcessParensWithPrecedence(node.consequent, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+        if (!(EXCEPT_COND_TERNARY && availableTypes.has(node.consequent.type)) && !(ALLOW_NESTED_TERNARY && ["ConditionalExpression"].includes(node.consequent.type)) && hasExcessParensWithPrecedence(node.consequent, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
           report(node.consequent);
         }
-        if (!(EXCEPT_COND_TERNARY && availableTypes.has(node.alternate.type)) && hasExcessParensWithPrecedence(node.alternate, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
+        if (!(EXCEPT_COND_TERNARY && availableTypes.has(node.alternate.type)) && !(ALLOW_NESTED_TERNARY && ["ConditionalExpression"].includes(node.alternate.type)) && hasExcessParensWithPrecedence(node.alternate, PRECEDENCE_OF_ASSIGNMENT_EXPR)) {
           report(node.alternate);
@@ -430,0 +432,0 @@ }

dist/rules/no-whitespace-before-property.js

@@ -59,3 +59,3 @@ 'use strict';
         }
-        if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken))
+        if (sourceCode.isSpaceBetween(leftToken, rightToken))
           reportError(node, leftToken, rightToken);
@@ -62,0 +62,0 @@ }

dist/rules/object-curly-spacing.js

@@ -112,3 +112,3 @@ 'use strict';
         if (utils.isTokenOnSameLine(first, second)) {
-          const firstSpaced = sourceCode.isSpaceBetweenTokens(first, second);
+          const firstSpaced = sourceCode.isSpaceBetween(first, second);
           if (options.spaced && !firstSpaced)
@@ -123,3 +123,3 @@ reportRequiredBeginningSpace(node, first);
           const closingCurlyBraceMustBeSpaced = options.arraysInObjectsException && penultimateType === "ArrayExpression" || options.objectsInObjectsException && (penultimateType === "ObjectExpression" || penultimateType === "ObjectPattern") ? !options.spaced : options.spaced;
-          const lastSpaced = sourceCode.isSpaceBetweenTokens(penultimate, last);
+          const lastSpaced = sourceCode.isSpaceBetween(penultimate, last);
           if (closingCurlyBraceMustBeSpaced && !lastSpaced)
@@ -126,0 +126,0 @@ reportRequiredEndingSpace(node, last);

dist/rules/padded-blocks.js

@@ -8,2 +8,3 @@ 'use strict';
 
+const OPTION_ENUMS = ["always", "never", "start", "end"];
 var paddedBlocks = utils.createRule({
@@ -23,3 +24,3 @@ name: "padded-blocks",
             type: "string",
-            enum: ["always", "never"]
+            enum: OPTION_ENUMS
           },
@@ -31,11 +32,11 @@ {
                 type: "string",
-                enum: ["always", "never"]
+                enum: OPTION_ENUMS
               },
               switches: {
                 type: "string",
-                enum: ["always", "never"]
+                enum: OPTION_ENUMS
               },
               classes: {
                 type: "string",
-                enum: ["always", "never"]
+                enum: OPTION_ENUMS
               }
@@ -59,4 +60,4 @@ },
     messages: {
-      alwaysPadBlock: "Block must be padded by blank lines.",
-      neverPadBlock: "Block must not be padded by blank lines."
+      missingPadBlock: "Block must be padded by blank lines.",
+      extraPadBlock: "Block must not be padded by blank lines."
     }
@@ -69,16 +70,9 @@ },
     if (typeof typeOptions === "string") {
-      const shouldHavePadding = typeOptions === "always";
-      options.blocks = shouldHavePadding;
-      options.switches = shouldHavePadding;
-      options.classes = shouldHavePadding;
+      options.blocks = typeOptions;
+      options.switches = typeOptions;
+      options.classes = typeOptions;
     } else {
-      if (Object.prototype.hasOwnProperty.call(typeOptions, "blocks"))
-        options.blocks = typeOptions.blocks === "always";
-      if (Object.prototype.hasOwnProperty.call(typeOptions, "switches"))
-        options.switches = typeOptions.switches === "always";
-      if (Object.prototype.hasOwnProperty.call(typeOptions, "classes"))
-        options.classes = typeOptions.classes === "always";
+      Object.assign(options, typeOptions);
     }
-    if (Object.prototype.hasOwnProperty.call(exceptOptions, "allowSingleLineBlocks"))
-      options.allowSingleLineBlocks = exceptOptions.allowSingleLineBlocks === true;
+    exceptOptions.allowSingleLineBlocks ?? (exceptOptions.allowSingleLineBlocks = false);
     const sourceCode = context.sourceCode;
@@ -139,6 +133,7 @@ function getOpenBrace(node) {
       const blockHasBottomPadding = isPaddingBetweenTokens(lastBlockToken, tokenAfterLast);
-      if (options.allowSingleLineBlocks && utils.isTokenOnSameLine(tokenBeforeFirst, tokenAfterLast))
+      if (exceptOptions.allowSingleLineBlocks && utils.isTokenOnSameLine(tokenBeforeFirst, tokenAfterLast))
         return;
-      if (requirePaddingFor(node)) {
-        if (!blockHasTopPadding) {
+      const requiredPadding = requirePaddingFor(node);
+      if (blockHasTopPadding) {
+        if (requiredPadding === "never" || requiredPadding === "end") {
           context.report({
@@ -151,35 +146,38 @@ node,
             fix(fixer) {
-              return fixer.insertTextAfter(tokenBeforeFirst, "\n");
+              return fixer.replaceTextRange([tokenBeforeFirst.range[1], firstBlockToken.range[0] - firstBlockToken.loc.start.column], "\n");
             },
-            messageId: "alwaysPadBlock"
+            messageId: "extraPadBlock"
           });
         }
-        if (!blockHasBottomPadding) {
+      } else {
+        if (requiredPadding === "always" || requiredPadding === "start") {
           context.report({
             node,
             loc: {
-              end: tokenAfterLast.loc.start,
-              start: lastBlockToken.loc.end
+              start: tokenBeforeFirst.loc.start,
+              end: firstBlockToken.loc.start
             },
             fix(fixer) {
-              return fixer.insertTextBefore(tokenAfterLast, "\n");
+              return fixer.insertTextAfter(tokenBeforeFirst, "\n");
             },
-            messageId: "alwaysPadBlock"
+            messageId: "missingPadBlock"
           });
         }
-      } else {
-        if (blockHasTopPadding) {
+      }
+      if (blockHasBottomPadding) {
+        if (requiredPadding === "never" || requiredPadding === "start") {
           context.report({
             node,
             loc: {
-              start: tokenBeforeFirst.loc.start,
-              end: firstBlockToken.loc.start
+              end: tokenAfterLast.loc.start,
+              start: lastBlockToken.loc.end
             },
+            messageId: "extraPadBlock",
             fix(fixer) {
-              return fixer.replaceTextRange([tokenBeforeFirst.range[1], firstBlockToken.range[0] - firstBlockToken.loc.start.column], "\n");
-            },
-            messageId: "neverPadBlock"
+              return fixer.replaceTextRange([lastBlockToken.range[1], tokenAfterLast.range[0] - tokenAfterLast.loc.start.column], "\n");
+            }
           });
         }
-        if (blockHasBottomPadding) {
+      } else {
+        if (requiredPadding === "always" || requiredPadding === "end") {
           context.report({
@@ -191,6 +189,6 @@ node,
             },
-            messageId: "neverPadBlock",
             fix(fixer) {
-              return fixer.replaceTextRange([lastBlockToken.range[1], tokenAfterLast.range[0] - tokenAfterLast.loc.start.column], "\n");
-            }
+              return fixer.insertTextBefore(tokenAfterLast, "\n");
+            },
+            messageId: "missingPadBlock"
           });
@@ -197,0 +195,0 @@ }

dist/rules/rest-spread-spacing.js

@@ -34,3 +34,3 @@ 'use strict';
       const nextToken = sourceCode.getTokenAfter(operator);
-      const hasWhitespace = sourceCode.isSpaceBetweenTokens(operator, nextToken);
+      const hasWhitespace = sourceCode.isSpaceBetween(operator, nextToken);
       let type;
@@ -37,0 +37,0 @@ switch (node.type) {

dist/rules/semi-spacing.js

@@ -51,7 +51,7 @@ 'use strict';
       const tokenBefore = sourceCode.getTokenBefore(token);
-      return tokenBefore && utils.isTokenOnSameLine(tokenBefore, token) && sourceCode.isSpaceBetweenTokens(tokenBefore, token);
+      return tokenBefore && utils.isTokenOnSameLine(tokenBefore, token) && sourceCode.isSpaceBetween(tokenBefore, token);
     }
     function hasTrailingSpace(token) {
       const tokenAfter = sourceCode.getTokenAfter(token);
-      return tokenAfter && utils.isTokenOnSameLine(token, tokenAfter) && sourceCode.isSpaceBetweenTokens(token, tokenAfter);
+      return tokenAfter && utils.isTokenOnSameLine(token, tokenAfter) && sourceCode.isSpaceBetween(token, tokenAfter);
     }
@@ -58,0 +58,0 @@ function isLastTokenInCurrentLine(token) {

dist/rules/space-before-blocks.js

@@ -85,3 +85,3 @@ 'use strict';
       if (precedingToken && !isConflicted(precedingToken, node) && utils.isTokenOnSameLine(precedingToken, node)) {
-        const hasSpace = sourceCode.isSpaceBetweenTokens(precedingToken, node);
+        const hasSpace = sourceCode.isSpaceBetween(precedingToken, node);
         let requireSpace;
@@ -88,0 +88,0 @@ let requireNoSpace;

dist/rules/space-in-parens.js

@@ -95,3 +95,3 @@ 'use strict';
     function openerMissingSpace(openingParenToken, tokenAfterOpeningParen) {
-      if (sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen))
+      if (sourceCode.isSpaceBetween(openingParenToken, tokenAfterOpeningParen))
         return false;
@@ -109,3 +109,3 @@ if (!options.empty && utils.isClosingParenToken(tokenAfterOpeningParen))
         return false;
-      if (!sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen))
+      if (!sourceCode.isSpaceBetween(openingParenToken, tokenAfterOpeningParen))
         return false;
@@ -117,3 +117,3 @@ if (ALWAYS)
     function closerMissingSpace(tokenBeforeClosingParen, closingParenToken) {
-      if (sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken))
+      if (sourceCode.isSpaceBetween(tokenBeforeClosingParen, closingParenToken))
         return false;
@@ -129,3 +129,3 @@ if (!options.empty && utils.isOpeningParenToken(tokenBeforeClosingParen))
         return false;
-      if (!sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken))
+      if (!sourceCode.isSpaceBetween(tokenBeforeClosingParen, closingParenToken))
         return false;
@@ -132,0 +132,0 @@ if (ALWAYS)

dist/rules/space-infix-ops.js

@@ -42,3 +42,3 @@ 'use strict';
       const next = sourceCode.getTokenAfter(operator);
-      if (!sourceCode.isSpaceBetweenTokens(prev, operator) || !sourceCode.isSpaceBetweenTokens(operator, next))
+      if (!sourceCode.isSpaceBetween(prev, operator) || !sourceCode.isSpaceBetween(operator, next))
         return operator;
@@ -109,3 +109,3 @@ return null;
         const rightToken = sourceCode.getTokenAfter(operatorToken);
-        if (!sourceCode.isSpaceBetweenTokens(leftToken, operatorToken) || !sourceCode.isSpaceBetweenTokens(operatorToken, rightToken)) {
+        if (!sourceCode.isSpaceBetween(leftToken, operatorToken) || !sourceCode.isSpaceBetween(operatorToken, rightToken)) {
           report(node, operatorToken);
@@ -112,0 +112,0 @@ }

dist/rules/switch-colon-spacing.js

@@ -40,3 +40,3 @@ 'use strict';
     function isValidSpacing(left, right, expected) {
-      return utils.isClosingBraceToken(right) || !utils.isTokenOnSameLine(left, right) || sourceCode.isSpaceBetweenTokens(left, right) === expected;
+      return utils.isClosingBraceToken(right) || !utils.isTokenOnSameLine(left, right) || sourceCode.isSpaceBetween(left, right) === expected;
     }
@@ -43,0 +43,0 @@ function commentsExistBetween(left, right) {

dist/rules/template-tag-spacing.js

@@ -34,3 +34,3 @@ 'use strict';
       const literalToken = sourceCode.getFirstToken(node.quasi);
-      const hasWhitespace = sourceCode.isSpaceBetweenTokens(tagToken, literalToken);
+      const hasWhitespace = sourceCode.isSpaceBetween(tagToken, literalToken);
       if (never && hasWhitespace) {
@@ -37,0 +37,0 @@ context.report({

dist/rules/yield-star-spacing.js

@@ -56,3 +56,3 @@ 'use strict';
     function checkSpacing(side, leftToken, rightToken) {
-      if (sourceCode.isSpaceBetweenTokens(leftToken, rightToken) !== mode[side]) {
+      if (sourceCode.isSpaceBetween(leftToken, rightToken) !== mode[side]) {
         const after = leftToken.value === "*";
@@ -59,0 +59,0 @@ const spaceRequired = mode[side];

dist/utils.js

@@ -38,2 +38,3 @@ 'use strict';
 const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN = /^(?:[^\\]|\\.)*\\(?:[1-9]|0\d)/su;
+const ASSIGNMENT_OPERATOR = ["=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "^=", "&=", "**=", "||=", "&&=", "??="];
 function createGlobalLinebreakMatcher() {
@@ -820,2 +821,3 @@ return new RegExp(LINEBREAK_MATCHER.source, "gu");
 
+exports.ASSIGNMENT_OPERATOR = ASSIGNMENT_OPERATOR;
 exports.COMMENTS_IGNORE_PATTERN = COMMENTS_IGNORE_PATTERN;
@@ -822,0 +824,0 @@ exports.FixTracker = FixTracker;

package.json

 {
   "name": "@stylistic/eslint-plugin",
   "type": "commonjs",
-  "version": "2.12.1",
+  "version": "2.13.0",
   "author": "Anthony Fu <[e-mail]>",
@@ -6,0 +6,0 @@ "license": "MIT",

No alert changes

Improved metrics

Total package byte prevSize

812779

increased by0.23%

Lines of code

23024

increased by0.23%

No dependency changes