@plugjs/eslint-plugin 0.2.20 → 0.2.21

package/bundles/stylistic-eslint-plugin.cjs

@@ -2906,6 +2906,290 @@ var require_computed_property_spacing = __commonJS({
   }
 });
 
+// node_modules/@stylistic/eslint-plugin/dist/rules/curly-newline.js
+var require_curly_newline = __commonJS({
+  "node_modules/@stylistic/eslint-plugin/dist/rules/curly-newline.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils();
+    require("eslint-visitor-keys");
+    require("espree");
+    require("estraverse");
+    var commonProperties = {
+      multiline: {
+        type: "boolean"
+      },
+      minElements: {
+        type: "integer",
+        minimum: 0
+      },
+      consistent: {
+        type: "boolean"
+      }
+    };
+    var optionValueSchema = {
+      oneOf: [
+        {
+          type: "string",
+          enum: ["always", "never"]
+        },
+        {
+          type: "object",
+          properties: commonProperties,
+          additionalProperties: false
+        }
+      ]
+    };
+    var Specialization = /* @__PURE__ */ ((Specialization2) => {
+      Specialization2["IfStatementConsequent"] = "IfStatementConsequent";
+      Specialization2["IfStatementAlternative"] = "IfStatementAlternative";
+      Specialization2["DoWhileStatement"] = "DoWhileStatement";
+      Specialization2["ForInStatement"] = "ForInStatement";
+      Specialization2["ForOfStatement"] = "ForOfStatement";
+      Specialization2["ForStatement"] = "ForStatement";
+      Specialization2["WhileStatement"] = "WhileStatement";
+      Specialization2["SwitchStatement"] = "SwitchStatement";
+      Specialization2["SwitchCase"] = "SwitchCase";
+      Specialization2["TryStatementBlock"] = "TryStatementBlock";
+      Specialization2["TryStatementHandler"] = "TryStatementHandler";
+      Specialization2["TryStatementFinalizer"] = "TryStatementFinalizer";
+      Specialization2["BlockStatement"] = "BlockStatement";
+      Specialization2["ArrowFunctionExpression"] = "ArrowFunctionExpression";
+      Specialization2["FunctionDeclaration"] = "FunctionDeclaration";
+      Specialization2["FunctionExpression"] = "FunctionExpression";
+      Specialization2["Property"] = "Property";
+      Specialization2["ClassBody"] = "ClassBody";
+      Specialization2["StaticBlock"] = "StaticBlock";
+      Specialization2["WithStatement"] = "WithStatement";
+      Specialization2["TSEnumBody"] = "TSEnumBody";
+      Specialization2["TSInterfaceBody"] = "TSInterfaceBody";
+      Specialization2["TSModuleBlock"] = "TSModuleBlock";
+      return Specialization2;
+    })(Specialization || {});
+    var presets = {
+      default: { multiline: false, minElements: Number.POSITIVE_INFINITY, consistent: true },
+      always: { multiline: false, minElements: 0, consistent: false },
+      never: { multiline: false, minElements: Number.POSITIVE_INFINITY, consistent: false }
+    };
+    function normalizeOptionValue(value) {
+      if (value === "always") {
+        return presets.always;
+      }
+      if (value === "never") {
+        return presets.never;
+      }
+      if (value) {
+        return {
+          consistent: !!value.consistent,
+          minElements: value.minElements ?? Number.POSITIVE_INFINITY,
+          multiline: !!value.multiline
+        };
+      }
+      return presets.default;
+    }
+    function normalizeOptions(options) {
+      const value = normalizeOptionValue(options);
+      return Object.fromEntries(
+        Object.entries(Specialization).map(([k]) => [
+          k,
+          typeof options === "object" && options != null && k in options ? normalizeOptionValue(options[k]) : value
+        ])
+      );
+    }
+    var curlyNewline = utils.createRule({
+      name: "curly-newline",
+      package: "plus",
+      meta: {
+        type: "layout",
+        docs: {
+          description: "Enforce consistent line breaks after opening and before closing braces"
+        },
+        fixable: "whitespace",
+        schema: [
+          {
+            oneOf: [
+              {
+                type: "string",
+                enum: ["always", "never"]
+              },
+              {
+                type: "object",
+                properties: {
+                  ...Object.fromEntries(Object.entries(Specialization).map(([k]) => [k, optionValueSchema])),
+                  ...commonProperties
+                },
+                additionalProperties: false
+              }
+            ]
+          }
+        ],
+        messages: {
+          unexpectedLinebreakBeforeClosingBrace: "Unexpected line break before this closing brace.",
+          unexpectedLinebreakAfterOpeningBrace: "Unexpected line break after this opening brace.",
+          expectedLinebreakBeforeClosingBrace: "Expected a line break before this closing brace.",
+          expectedLinebreakAfterOpeningBrace: "Expected a line break after this opening brace."
+        }
+      },
+      create(context) {
+        const sourceCode = context.sourceCode;
+        const normalizedOptions = normalizeOptions(context.options[0]);
+        function check(node, specialization) {
+          const options = normalizedOptions[specialization];
+          let openBrace;
+          let closeBrace;
+          let elementCount;
+          switch (node.type) {
+            case "SwitchStatement":
+              closeBrace = sourceCode.getLastToken(node);
+              openBrace = sourceCode.getTokenBefore(node.cases.length ? node.cases[0] : closeBrace);
+              elementCount = node.cases.length;
+              break;
+            case "StaticBlock":
+              openBrace = sourceCode.getFirstToken(node, (token) => token.value === "{");
+              closeBrace = sourceCode.getLastToken(node);
+              elementCount = node.body.length;
+              break;
+            case "TSEnumBody":
+              openBrace = sourceCode.getFirstToken(node);
+              closeBrace = sourceCode.getLastToken(node);
+              elementCount = node.members.length;
+              break;
+            default:
+              openBrace = sourceCode.getFirstToken(node);
+              closeBrace = sourceCode.getLastToken(node);
+              elementCount = node.body.length;
+          }
+          let first = sourceCode.getTokenAfter(openBrace, { includeComments: true });
+          let last = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
+          const needsLineBreaks = elementCount >= options.minElements || options.multiline && elementCount > 0 && first.loc.start.line !== last.loc.end.line;
+          const hasCommentsFirstToken = utils.isCommentToken(first);
+          const hasCommentsLastToken = utils.isCommentToken(last);
+          first = sourceCode.getTokenAfter(openBrace);
+          last = sourceCode.getTokenBefore(closeBrace);
+          if (needsLineBreaks) {
+            if (utils.isTokenOnSameLine(openBrace, first)) {
+              context.report({
+                messageId: "expectedLinebreakAfterOpeningBrace",
+                node,
+                loc: openBrace.loc,
+                fix(fixer) {
+                  if (hasCommentsFirstToken)
+                    return null;
+                  return fixer.insertTextAfter(openBrace, "\n");
+                }
+              });
+            }
+            if (utils.isTokenOnSameLine(last, closeBrace)) {
+              context.report({
+                messageId: "expectedLinebreakBeforeClosingBrace",
+                node,
+                loc: closeBrace.loc,
+                fix(fixer) {
+                  if (hasCommentsLastToken)
+                    return null;
+                  return fixer.insertTextBefore(closeBrace, "\n");
+                }
+              });
+            }
+          } else {
+            const consistent = options.consistent;
+            const hasLineBreakBetweenOpenBraceAndFirst = !utils.isTokenOnSameLine(openBrace, first);
+            const hasLineBreakBetweenCloseBraceAndLast = !utils.isTokenOnSameLine(last, closeBrace);
+            if (!consistent && hasLineBreakBetweenOpenBraceAndFirst || consistent && hasLineBreakBetweenOpenBraceAndFirst && !hasLineBreakBetweenCloseBraceAndLast) {
+              context.report({
+                messageId: "unexpectedLinebreakAfterOpeningBrace",
+                node,
+                loc: openBrace.loc,
+                fix(fixer) {
+                  if (hasCommentsFirstToken)
+                    return null;
+                  return fixer.removeRange([
+                    openBrace.range[1],
+                    first.range[0]
+                  ]);
+                }
+              });
+            }
+            if (!consistent && hasLineBreakBetweenCloseBraceAndLast || consistent && !hasLineBreakBetweenOpenBraceAndFirst && hasLineBreakBetweenCloseBraceAndLast) {
+              context.report({
+                messageId: "unexpectedLinebreakBeforeClosingBrace",
+                node,
+                loc: closeBrace.loc,
+                fix(fixer) {
+                  if (hasCommentsLastToken)
+                    return null;
+                  return fixer.removeRange([
+                    last.range[1],
+                    closeBrace.range[0]
+                  ]);
+                }
+              });
+            }
+          }
+        }
+        function checkBlockLike(node) {
+          check(node, node.type);
+        }
+        return {
+          BlockStatement(node) {
+            const { parent } = node;
+            switch (parent.type) {
+              case "DoWhileStatement":
+              case "ForInStatement":
+              case "ForOfStatement":
+              case "ForStatement":
+              case "WhileStatement":
+              case "ArrowFunctionExpression":
+              case "FunctionDeclaration":
+              case "WithStatement":
+                check(node, parent.type);
+                break;
+              case "FunctionExpression":
+                if (parent.parent.type === "Property" && parent.parent.method) {
+                  check(node, "Property");
+                } else {
+                  check(node, parent.type);
+                }
+                break;
+              case "IfStatement":
+                if (node === parent.consequent) {
+                  check(node, "IfStatementConsequent");
+                }
+                if (node === parent.alternate) {
+                  check(node, "IfStatementAlternative");
+                }
+                break;
+              case "TryStatement":
+                if (node === parent.block) {
+                  check(node, "TryStatementBlock");
+                }
+                if (node === parent.finalizer) {
+                  check(node, "TryStatementFinalizer");
+                }
+                break;
+              case "CatchClause":
+                check(node, "TryStatementHandler");
+                break;
+              default:
+                if (parent.type === "SwitchCase" && parent.consequent.length === 1) {
+                  check(node, "SwitchCase");
+                } else {
+                  check(node, "BlockStatement");
+                }
+            }
+          },
+          SwitchStatement: checkBlockLike,
+          ClassBody: checkBlockLike,
+          StaticBlock: checkBlockLike,
+          TSEnumBody: checkBlockLike,
+          TSInterfaceBody: checkBlockLike,
+          TSModuleBlock: checkBlockLike
+        };
+      }
+    });
+    module2.exports = curlyNewline;
+  }
+});
+
 // node_modules/@stylistic/eslint-plugin/dist/rules/dot-location.js
 var require_dot_location = __commonJS({
   "node_modules/@stylistic/eslint-plugin/dist/rules/dot-location.js"(exports2, module2) {
@@ -4738,21 +5022,24 @@ var require_indent = __commonJS({
               const previousQuasi = node.quasis[index2];
               const nextQuasi = node.quasis[index2 + 1];
               const tokenToAlignFrom = previousQuasi.loc.start.line === previousQuasi.loc.end.line ? sourceCode.getFirstToken(previousQuasi) : null;
-              let indentOffset = 1;
-              let nextQuasiStartIndent = 0;
-              if (!tokenToAlignFrom) {
-                const tokenBeforeText = sourceCode.text.slice(previousQuasi.range[1] - previousQuasi.loc.end.column, previousQuasi.range[1] - 2).split("");
-                if (tokenBeforeText.every((char) => char === " " || char === "	")) {
-                  const numSpaces = tokenBeforeText.filter((char) => char !== "	").length;
-                  const numTabs = tokenBeforeText.filter((char) => char === "	").length;
-                  indentOffset = numTabs + Math.ceil(numSpaces / (indentType === "tab" ? options.tabLength : indentSize)) + 1;
-                }
+              const startsOnSameLine = previousQuasi.loc.end.line === expression.loc.start.line;
+              const endsOnSameLine = nextQuasi.loc.start.line === expression.loc.end.line;
+              if (tokenToAlignFrom || endsOnSameLine && !startsOnSameLine) {
+                offsets.setDesiredOffsets([previousQuasi.range[1], nextQuasi.range[0]], tokenToAlignFrom, 1);
+                offsets.setDesiredOffset(sourceCode.getFirstToken(nextQuasi), tokenToAlignFrom, 0);
+                return;
               }
-              if (nextQuasi.loc.start.line !== expression.loc.end.line) {
-                nextQuasiStartIndent = Math.max(indentOffset - 1, 0);
+              const tokenBeforeText = sourceCode.text.slice(previousQuasi.range[1] - previousQuasi.loc.end.column, previousQuasi.range[1] - 2).split("");
+              let numIndentation = tokenBeforeText.findIndex((char) => char !== " " && char !== "	");
+              if (numIndentation === -1) {
+                numIndentation = tokenBeforeText.length;
               }
-              offsets.setDesiredOffsets([previousQuasi.range[1], nextQuasi.range[0]], tokenToAlignFrom, indentOffset);
-              offsets.setDesiredOffset(sourceCode.getFirstToken(nextQuasi), tokenToAlignFrom, nextQuasiStartIndent);
+              const numSpaces = tokenBeforeText.slice(0, numIndentation).filter((char) => char === " ").length;
+              const numTabs = numIndentation - numSpaces;
+              const indentOffset = numTabs + Math.ceil(numSpaces / (indentType === "tab" ? options.tabLength : indentSize));
+              const innerIndentation = endsOnSameLine ? indentOffset : indentOffset + 1;
+              offsets.setDesiredOffsets([previousQuasi.range[1], nextQuasi.range[0]], tokenToAlignFrom, innerIndentation);
+              offsets.setDesiredOffset(sourceCode.getFirstToken(nextQuasi), tokenToAlignFrom, indentOffset);
             });
           },
           VariableDeclaration(node) {
@@ -5071,6 +5358,7 @@ ${indent2}${p1}`);
         // typescript docs and playground use 4 space indent
         4,
         {
+          // TODO: Stage 2: Set to `0` can pass test cases, but it will change the behavior
           // typescript docs indent the case from the switch
           // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-1-8.html#example-4
           SwitchCase: 1,
@@ -5877,7 +6165,13 @@ var require_jsx_closing_tag_location = __commonJS({
     require("estraverse");
     var messages = {
       onOwnLine: "Closing tag of a multiline JSX expression must be on its own line.",
-      matchIndent: "Expected closing tag to match indentation of opening."
+      matchIndent: "Expected closing tag to match indentation of opening.",
+      alignWithOpening: "Expected closing tag to be aligned with the line containing the opening tag"
+    };
+    var DEFAULT_LOCATION = "tag-aligned";
+    var MESSAGE_LOCATION = {
+      "tag-aligned": "matchIndent",
+      "line-aligned": "alignWithOpening"
     };
     var jsxClosingTagLocation = utils.createRule({
       name: "jsx-closing-tag-location",
@@ -5889,28 +6183,53 @@ var require_jsx_closing_tag_location = __commonJS({
         },
         fixable: "whitespace",
         messages,
-        schema: []
+        schema: [{
+          anyOf: [
+            {
+              type: "string",
+              enum: ["tag-aligned", "line-aligned"],
+              default: DEFAULT_LOCATION
+            }
+          ]
+        }]
       },
+      defaultOptions: [
+        DEFAULT_LOCATION
+      ],
       create(context) {
+        const option = context.options[0] || DEFAULT_LOCATION;
+        function getIndentation(openingStartOfLine, opening) {
+          if (option === "line-aligned")
+            return openingStartOfLine.column;
+          else
+            return opening.loc.start.column;
+        }
         function handleClosingElement(node) {
           if (!node.parent)
             return;
-          let opening;
-          if ("openingFragment" in node.parent)
-            opening = node.parent.openingFragment;
-          if ("openingElement" in node.parent)
-            opening = node.parent.openingElement;
+          const sourceCode = context.sourceCode;
+          const opening = "openingFragment" in node.parent ? node.parent.openingFragment : node.parent.openingElement;
+          const openingLoc = sourceCode.getFirstToken(opening).loc.start;
+          const openingLine = sourceCode.lines[openingLoc.line - 1];
+          const openingStartOfLine = {
+            column: /^\s*/.exec(openingLine)?.[0].length,
+            line: openingLoc.line
+          };
           if (opening.loc.start.line === node.loc.start.line)
             return;
-          if (opening.loc.start.column === node.loc.start.column)
+          if (opening.loc.start.column === node.loc.start.column && option === "tag-aligned") {
             return;
-          const messageId = utils.isNodeFirstInLine(context, node) ? "matchIndent" : "onOwnLine";
+          }
+          if (openingStartOfLine.column === node.loc.start.column && option === "line-aligned") {
+            return;
+          }
+          const messageId = utils.isNodeFirstInLine(context, node) ? MESSAGE_LOCATION[option] : "onOwnLine";
           context.report({
             node,
             messageId,
             loc: node.loc,
             fix(fixer) {
-              const indent = new Array(opening.loc.start.column + 1).join(" ");
+              const indent = new Array((getIndentation(openingStartOfLine, opening) || 0) + 1).join(" ");
               if (utils.isNodeFirstInLine(context, node)) {
                 return fixer.replaceTextRange(
                   [node.range[0] - node.loc.start.column, node.range[0]],
@@ -13146,7 +13465,7 @@ var require_no_extra_parens = __commonJS({
               }
             });
           }
-          if (node.arguments.length === 1 && sourceCode.getTokenAfter(node.callee, astUtils.isOpeningParenToken) !== sourceCode.getTokenBefore(node.arguments[0], astUtils.isOpeningParenToken)) {
+          if (node.typeArguments && node.arguments.length === 1 && sourceCode.getTokenAfter(node.callee, astUtils.isOpeningParenToken) !== sourceCode.getTokenBefore(node.arguments[0], astUtils.isOpeningParenToken)) {
             return rule({
               ...node,
               arguments: [
@@ -13174,20 +13493,11 @@ var require_no_extra_parens = __commonJS({
         }
         const overrides = {
           ArrayExpression(node) {
-            node.elements.forEach((element, index2) => {
-              if (astUtils.isTypeAssertion(element)) {
-                return rules.ArrayExpression({
-                  ...node,
-                  elements: [
-                    ...node.elements.slice(0, index2),
-                    {
-                      ...element,
-                      type: utils$1.AST_NODE_TYPES.FunctionExpression
-                    },
-                    ...node.elements.slice(index2 + 1)
-                  ]
-                });
-              }
+            return rules.ArrayExpression({
+              ...node,
+              elements: node.elements.map(
+                (element) => astUtils.isTypeAssertion(element) ? { ...element, type: utils$1.AST_NODE_TYPES.FunctionExpression } : element
+              )
             });
           },
           ArrowFunctionExpression(node) {
@@ -13331,7 +13641,12 @@ var require_no_extra_parens = __commonJS({
               return rules.ThrowStatement(node);
           },
           "UnaryExpression": unaryUpdateExpression,
-          "UpdateExpression": unaryUpdateExpression,
+          UpdateExpression(node) {
+            if (astUtils.isTypeAssertion(node.argument)) {
+              return unaryUpdateExpression(node);
+            }
+            return rules.UpdateExpression(node);
+          },
           // VariableDeclarator
           VariableDeclarator(node) {
             if (astUtils.isTypeAssertion(node.init)) {
@@ -15853,6 +16168,7 @@ var require_padding_line_between_statements = __commonJS({
           if (!node.parent || ![
             utils.AST_NODE_TYPES.BlockStatement,
             utils.AST_NODE_TYPES.Program,
+            utils.AST_NODE_TYPES.StaticBlock,
             utils.AST_NODE_TYPES.SwitchCase,
             utils.AST_NODE_TYPES.SwitchStatement,
             utils.AST_NODE_TYPES.TSInterfaceBody,
@@ -15877,12 +16193,14 @@ var require_padding_line_between_statements = __commonJS({
           "Program": enterScope,
           "BlockStatement": enterScope,
           "SwitchStatement": enterScope,
+          "StaticBlock": enterScope,
           "TSInterfaceBody": enterScope,
           "TSModuleBlock": enterScope,
           "TSTypeLiteral": enterScope,
           "Program:exit": exitScope,
           "BlockStatement:exit": exitScope,
           "SwitchStatement:exit": exitScope,
+          "StaticBlock:exit": exitScope,
           "TSInterfaceBody:exit": exitScope,
           "TSModuleBlock:exit": exitScope,
           "TSTypeLiteral:exit": exitScope,
@@ -16391,7 +16709,7 @@ var require_quotes = __commonJS({
             if (allowTemplateLiterals || quoteOption === "backtick" || isUsingFeatureOfTemplateLiteral(node)) {
               return;
             }
-            if (avoidEscape && sourceCode.getText(node).includes(settings.quote))
+            if (allowTemplateLiterals && avoidEscape && sourceCode.getText(node).includes(settings.quote))
               return;
             context.report({
               node,
@@ -16447,7 +16765,7 @@ var require_quotes = __commonJS({
               return node === parent.id;
             case utils$1.AST_NODE_TYPES.TSAbstractPropertyDefinition:
             case utils$1.AST_NODE_TYPES.PropertyDefinition:
-              return node === parent.key;
+              return parent.key === node && !parent.computed;
             case utils$1.AST_NODE_TYPES.TSLiteralType:
               return parent.parent?.type === utils$1.AST_NODE_TYPES.TSImportType;
             default:
@@ -17365,8 +17683,8 @@ var require_space_before_function_paren = __commonJS({
           }
         ],
         messages: {
-          unexpected: "Unexpected space before function parentheses.",
-          missing: "Missing space before function parentheses."
+          unexpectedSpace: "Unexpected space before function parentheses.",
+          missingSpace: "Missing space before function parentheses."
         }
       },
       defaultOptions: ["always"],
@@ -17413,14 +17731,22 @@ var require_space_before_function_paren = __commonJS({
                 start: leftToken.loc.end,
                 end: rightToken.loc.start
               },
-              messageId: "unexpected",
-              fix: (fixer) => fixer.removeRange([leftToken.range[1], rightToken.range[0]])
+              messageId: "unexpectedSpace",
+              fix: (fixer) => {
+                const comments = sourceCode.getCommentsBefore(rightToken);
+                if (comments.some((comment) => comment.type === "Line"))
+                  return null;
+                return fixer.replaceTextRange(
+                  [leftToken.range[1], rightToken.range[0]],
+                  comments.reduce((text, comment) => text + sourceCode.getText(comment), "")
+                );
+              }
             });
           } else if (!hasSpacing && functionConfig === "always" && (!node.typeParameters || node.id)) {
             context.report({
               node,
               loc: rightToken.loc,
-              messageId: "missing",
+              messageId: "missingSpace",
               fix: (fixer) => fixer.insertTextAfter(leftToken, " ")
             });
           }
@@ -17729,6 +18055,7 @@ var require_space_infix_ops = __commonJS({
           LogicalExpression: checkBinary,
           ConditionalExpression: checkConditional,
           VariableDeclarator: checkVar,
+          // TODO: Stage 3: Overridden by ts version, can delete directly
           PropertyDefinition(node) {
             if (!node.value)
               return;
@@ -17765,9 +18092,10 @@ var require_space_infix_ops = __commonJS({
       create(context) {
         const rules = baseRule.create(context);
         const sourceCode = context.sourceCode;
-        function report(operator) {
+        function report(node, operator) {
           context.report({
-            node: operator,
+            node,
+            loc: operator.loc,
             messageId: "missingSpace",
             data: {
               operator: operator.value
@@ -17788,7 +18116,7 @@ var require_space_infix_ops = __commonJS({
         function isSpaceChar(token) {
           return token.type === utils$1.AST_TOKEN_TYPES.Punctuator && /^[=?:]$/.test(token.value);
         }
-        function checkAndReportAssignmentSpace(leftNode, rightNode) {
+        function checkAndReportAssignmentSpace(node, leftNode, rightNode) {
           if (!rightNode || !leftNode)
             return;
           const operator = sourceCode.getFirstTokenBetween(
@@ -17799,15 +18127,15 @@ var require_space_infix_ops = __commonJS({
           const prev = sourceCode.getTokenBefore(operator);
           const next = sourceCode.getTokenAfter(operator);
           if (!sourceCode.isSpaceBetween(prev, operator) || !sourceCode.isSpaceBetween(operator, next)) {
-            report(operator);
+            report(node, operator);
           }
         }
         function checkForEnumAssignmentSpace(node) {
-          checkAndReportAssignmentSpace(node.id, node.initializer);
+          checkAndReportAssignmentSpace(node, node.id, node.initializer);
         }
         function checkForPropertyDefinitionAssignmentSpace(node) {
           const leftNode = node.optional && !node.typeAnnotation ? sourceCode.getTokenAfter(node.key) : node.typeAnnotation ?? node.key;
-          checkAndReportAssignmentSpace(leftNode, node.value);
+          checkAndReportAssignmentSpace(node, leftNode, node.value);
         }
         function checkForTypeAnnotationSpace(typeAnnotation) {
           const types = typeAnnotation.types;
@@ -17821,20 +18149,21 @@ var require_space_infix_ops = __commonJS({
               const prev = sourceCode.getTokenBefore(operator);
               const next = sourceCode.getTokenAfter(operator);
               if (!sourceCode.isSpaceBetween(prev, operator) || !sourceCode.isSpaceBetween(operator, next)) {
-                report(operator);
+                report(typeAnnotation, operator);
               }
             }
           });
         }
         function checkForTypeAliasAssignment(node) {
           checkAndReportAssignmentSpace(
+            node,
             node.typeParameters ?? node.id,
             node.typeAnnotation
           );
         }
         function checkForTypeConditional(node) {
-          checkAndReportAssignmentSpace(node.extendsType, node.trueType);
-          checkAndReportAssignmentSpace(node.trueType, node.falseType);
+          checkAndReportAssignmentSpace(node, node.extendsType, node.trueType);
+          checkAndReportAssignmentSpace(node, node.trueType, node.falseType);
         }
         return {
           ...rules,
@@ -19257,6 +19586,7 @@ var require_configs = __commonJS({
     var commaSpacing = require_comma_spacing();
     var commaStyle = require_comma_style();
     var computedPropertySpacing = require_computed_property_spacing();
+    var curlyNewline = require_curly_newline();
     var dotLocation = require_dot_location();
     var eolLast = require_eol_last();
     var functionCallArgumentNewline = require_function_call_argument_newline();
@@ -19352,6 +19682,7 @@ var require_configs = __commonJS({
       "comma-spacing": commaSpacing,
       "comma-style": commaStyle,
       "computed-property-spacing": computedPropertySpacing,
+      "curly-newline": curlyNewline,
       "dot-location": dotLocation,
       "eol-last": eolLast,
       "func-call-spacing": functionCallSpacing,
@@ -19486,6 +19817,7 @@ var require_configs = __commonJS({
           offsetTernaryExpressions: true,
           outerIIFEBody: 1,
           SwitchCase: 1,
+          tabLength: indent2 === "tab" ? 4 : indent2,
           VariableDeclarator: 1
         }],
         "@stylistic/indent-binary-ops": ["error", indent2],
@@ -19733,6 +20065,12 @@ var require_configs = __commonJS({
       }
     };
     var recommendedExtends = /* @__PURE__ */ customize({ flat: false });
+    var allConfigsIgnore = [
+      // Exclude all JSX rules
+      /^jsx-/,
+      // https://github.com/eslint-stylistic/eslint-stylistic/pull/548
+      /^curly-newline$/
+    ];
     var configs2 = {
       /**
        * Disable all legacy rules from `eslint`, `@typescript-eslint` and `eslint-plugin-react`
@@ -19755,11 +20093,11 @@ var require_configs = __commonJS({
       /**
        * Enable all rules, in Flat Config Format
        */
-      "all-flat": utils.createAllConfigs(plugin, "@stylistic", true, (name) => !name.startsWith("jsx-")),
+      "all-flat": utils.createAllConfigs(plugin, "@stylistic", true, (name) => !allConfigsIgnore.some((re) => re.test(name))),
       /**
        * Enable all rules, in Legacy Config Format
        */
-      "all-extends": utils.createAllConfigs(plugin, "@stylistic", false, (name) => !name.startsWith("jsx-")),
+      "all-extends": utils.createAllConfigs(plugin, "@stylistic", false, (name) => !allConfigsIgnore.some((re) => re.test(name))),
       /**
        * @deprecated Use `recommended-extends` instead
        */
@@ -19789,6 +20127,7 @@ require_comma_dangle();
 require_comma_spacing();
 require_comma_style();
 require_computed_property_spacing();
+require_curly_newline();
 require_dot_location();
 require_eol_last();
 require_function_call_argument_newline();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plugjs/eslint-plugin",
-  "version": "0.2.20",
+  "version": "0.2.21",
   "description": "Shared ESLint configurations and extras",
   "main": "./index.mjs",
   "type": "module",
@@ -10,7 +10,7 @@
     "build": "eslint"
   },
   "peerDependencies": {
-    "eslint": "^9.11.1"
+    "eslint": "^9.12.0"
   },
   "files": [
     "*.md",
@@ -35,13 +35,13 @@
   },
   "homepage": "https://github.com/plugjs/eslint-plugin#readme",
   "dependencies": {
-    "@eslint/js": "9.11.1",
+    "@eslint/js": "9.12.0",
     "@nolyfill/is-core-module": "1.0.39",
-    "@typescript-eslint/utils": "8.8.0",
+    "@typescript-eslint/utils": "8.8.1",
     "debug": "4.3.7",
     "doctrine": "3.0.0",
     "enhanced-resolve": "5.17.1",
-    "eslint": "9.11.1",
+    "eslint": "9.12.0",
     "eslint-module-utils": "2.12.0",
     "eslint-plugin-unicorn": "56.0.0",
     "eslint-visitor-keys": "4.1.0",
@@ -49,7 +49,7 @@
     "estraverse": "5.3.0",
     "fast-glob": "3.3.2",
     "get-tsconfig": "4.8.1",
-    "globals": "15.10.0",
+    "globals": "15.11.0",
     "is-bun-module": "1.2.1",
     "is-core-module": "2.15.1",
     "is-glob": "4.0.3",
@@ -59,7 +59,7 @@
     "semver": "7.6.3",
     "stable-hash": "0.0.4",
     "tslib": "2.7.0",
-    "typescript": "5.6.2",
-    "typescript-eslint": "8.8.0"
+    "typescript": "5.6.3",
+    "typescript-eslint": "8.8.1"
   }
 }