@typescript-eslint/eslint-plugin 8.61.1-alpha.3 → 8.61.1-alpha.4

package/dist/rules/no-unnecessary-boolean-literal-compare.js

@@ -163,11 +163,11 @@ exports.default = (0, util_1.createRule)({
                     typeof against.value !== 'boolean') {
                     continue;
                 }
-                const { value: literalBooleanInComparison } = against;
+                const booleanLiteral = against.value ? 'true' : 'false';
                 const negated = !comparisonType.isPositive;
                 return {
+                    booleanLiteral,
                     expression,
-                    literalBooleanInComparison,
                     negated,
                 };
             }
@@ -183,11 +183,11 @@ exports.default = (0, util_1.createRule)({
                     return;
                 }
                 if (comparison.expressionIsNullableBoolean) {
-                    if (comparison.literalBooleanInComparison &&
+                    if (comparison.booleanLiteral === 'true' &&
                         options.allowComparingNullableBooleansToTrue) {
                         return;
                     }
-                    if (!comparison.literalBooleanInComparison &&
+                    if (comparison.booleanLiteral === 'false' &&
                         options.allowComparingNullableBooleansToFalse) {
                         return;
                     }
@@ -195,7 +195,7 @@ exports.default = (0, util_1.createRule)({
                 context.report({
                     node,
                     messageId: comparison.expressionIsNullableBoolean
-                        ? comparison.literalBooleanInComparison
+                        ? comparison.booleanLiteral === 'true'
                             ? comparison.negated
                                 ? 'comparingNullableToTrueNegated'
                                 : 'comparingNullableToTrueDirect'
@@ -203,30 +203,36 @@ exports.default = (0, util_1.createRule)({
                         : comparison.negated
                             ? 'negated'
                             : 'direct',
-                    *fix(fixer) {
-                        // 1. isUnaryNegation - parent negation
-                        // 2. literalBooleanInComparison - is compared to literal boolean
-                        // 3. negated - is expression negated
-                        const isUnaryNegation = nodeIsUnaryNegation(node.parent);
-                        const shouldNegate = comparison.negated !== comparison.literalBooleanInComparison;
-                        const mutatedNode = isUnaryNegation ? node.parent : node;
-                        yield fixer.replaceText(mutatedNode, context.sourceCode.getText(comparison.expression));
-                        // if `isUnaryNegation === literalBooleanInComparison === !negated` is true - negate the expression
-                        if (shouldNegate === isUnaryNegation) {
-                            yield fixer.insertTextBefore(mutatedNode, '!');
-                            // if the expression `exp` is not a strong precedence node, wrap it in parentheses
-                            if (!(0, util_1.isStrongPrecedenceNode)(comparison.expression)) {
-                                yield fixer.insertTextBefore(mutatedNode, '(');
-                                yield fixer.insertTextAfter(mutatedNode, ')');
+                    fix(fixer) {
+                        const isWrappedInUnaryNegation = nodeIsUnaryNegation(node.parent);
+                        const mutatedNode = isWrappedInUnaryNegation ? node.parent : node;
+                        // Whether the truth table of the overall expression being replaced
+                        // is negated, _ignoring the nullish cases_.
+                        const isOverallNegated = booleanXor(isWrappedInUnaryNegation, comparison.negated, comparison.booleanLiteral === 'false');
+                        // we'll build up the replacement text from the compared expression outwards.
+                        let replacementText = context.sourceCode.getText(comparison.expression);
+                        let mayNeedParentheses = !(0, util_1.isStrongPrecedenceNode)(comparison.expression);
+                        // In maybeNullish === false, nullish values have the same truth table
+                        // as `true`.
+                        if (comparison.expressionIsNullableBoolean &&
+                            comparison.booleanLiteral === 'false') {
+                            if (mayNeedParentheses) {
+                                replacementText = parenthesize(replacementText);
                             }
+                            replacementText = `${replacementText} ?? true`;
+                            mayNeedParentheses = true;
                         }
-                        // if the expression `exp` is nullable, and we're not comparing to `true`, insert `?? true`
-                        if (comparison.expressionIsNullableBoolean &&
-                            !comparison.literalBooleanInComparison) {
-                            // provide the default `true`
-                            yield fixer.insertTextBefore(mutatedNode, '(');
-                            yield fixer.insertTextAfter(mutatedNode, ' ?? true)');
+                        if (isOverallNegated) {
+                            if (mayNeedParentheses) {
+                                replacementText = parenthesize(replacementText);
+                            }
+                            replacementText = `!${replacementText}`;
+                            mayNeedParentheses = false;
                         }
+                        if (mayNeedParentheses && (0, util_1.isWeakPrecedenceParent)(mutatedNode)) {
+                            replacementText = parenthesize(replacementText);
+                        }
+                        return fixer.replaceText(mutatedNode, replacementText);
                     },
                 });
             },
@@ -259,3 +265,10 @@ function getEqualsKind(operator) {
             return undefined;
     }
 }
+function booleanXor(arg0, ...args) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-conversion
+    return args.reduce((acc, curr) => acc !== Boolean(curr), Boolean(arg0));
+}
+function parenthesize(text) {
+    return `(${text})`;
+}

package/dist/rules/no-unnecessary-template-expression.js

@@ -357,5 +357,5 @@ function isWhitespace(x) {
     return /^\s*$/.test(x);
 }
 function startsWithNewLine(x) {
-    return x.startsWith('\n') || x.startsWith('\r\n');
+    return utils_1.ASTUtils.LINEBREAK_MATCHER.exec(x)?.index === 0;
 }

package/dist/rules/no-unnecessary-type-assertion.js

@@ -565,10 +565,29 @@ exports.default = (0, util_1.createRule)({
                         token.value === '<'), util_1.NullThrowsReasons.MissingToken('<', 'type annotation'));
                     const closingAngleBracket = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.typeAnnotation, token => token.type === utils_1.AST_TOKEN_TYPES.Punctuator &&
                         token.value === '>'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation'));
-                    return fixer.removeRange([
+                    // Removing the angle-bracketed type can leave a bare object
+                    // literal in a position where `{` is parsed as a block (concise
+                    // arrow body, or the start of an expression statement). Wrap the
+                    // result in parentheses to preserve the original expression
+                    // semantics.
+                    const needsParens = node.expression.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                        ((node.parent.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+                            node.parent.body === node) ||
+                            node.parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement) &&
+                        !(0, util_1.isParenthesized)(node, context.sourceCode) &&
+                        !(0, util_1.isParenthesized)(node.expression, context.sourceCode);
+                    const fixes = [];
+                    if (needsParens) {
+                        fixes.push(fixer.insertTextBefore(node, '('));
+                    }
+                    fixes.push(fixer.removeRange([
                         openingAngleBracket.range[0],
                         closingAngleBracket.range[1],
-                    ]);
+                    ]));
+                    if (needsParens) {
+                        fixes.push(fixer.insertTextAfter(node, ')'));
+                    }
+                    return fixes;
                 }
                 const asToken = (0, util_1.nullThrows)(context.sourceCode.getTokenAfter(node.expression, token => token.type === utils_1.AST_TOKEN_TYPES.Identifier && token.value === 'as'), util_1.NullThrowsReasons.MissingToken('>', 'type annotation'));
                 const tokenBeforeAs = (0, util_1.nullThrows)(context.sourceCode.getTokenBefore(asToken, {

package/dist/util/getWrappingFixer.d.ts

@@ -39,4 +39,8 @@ export declare function getMovedNodeCode(params: {
  * Check if a node will always have the same precedence if its parent changes.
  */
 export declare function isStrongPrecedenceNode(innerNode: TSESTree.Node): boolean;
+/**
+ * Check if a node's parent could have different precedence if the node changes.
+ */
+export declare function isWeakPrecedenceParent(node: TSESTree.Node): boolean;
 export {};

package/dist/util/getWrappingFixer.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getWrappingFixer = getWrappingFixer;
 exports.getMovedNodeCode = getMovedNodeCode;
 exports.isStrongPrecedenceNode = isStrongPrecedenceNode;
+exports.isWeakPrecedenceParent = isWeakPrecedenceParent;
 const utils_1 = require("@typescript-eslint/utils");
 /**
  * Wraps node with some code. Adds parentheses as necessary.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.61.1-alpha.3",
+  "version": "8.61.1-alpha.4",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -52,10 +52,10 @@
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0",
-    "@typescript-eslint/type-utils": "8.61.1-alpha.3",
-    "@typescript-eslint/scope-manager": "8.61.1-alpha.3",
-    "@typescript-eslint/visitor-keys": "8.61.1-alpha.3",
-    "@typescript-eslint/utils": "8.61.1-alpha.3"
+    "@typescript-eslint/scope-manager": "8.61.1-alpha.4",
+    "@typescript-eslint/type-utils": "8.61.1-alpha.4",
+    "@typescript-eslint/utils": "8.61.1-alpha.4",
+    "@typescript-eslint/visitor-keys": "8.61.1-alpha.4"
   },
   "devDependencies": {
     "@types/json-schema": "^7.0.15",
@@ -79,13 +79,13 @@
     "typescript": ">=4.8.4 <6.1.0",
     "unist-util-visit": "^5.0.0",
     "vitest": "^4.0.18",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.61.1-alpha.3",
-    "@typescript-eslint/rule-tester": "8.61.1-alpha.3"
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.61.1-alpha.4",
+    "@typescript-eslint/rule-tester": "8.61.1-alpha.4"
   },
   "peerDependencies": {
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0",
-    "@typescript-eslint/parser": "^8.61.1-alpha.3"
+    "@typescript-eslint/parser": "^8.61.1-alpha.4"
   },
   "funding": {
     "type": "opencollective",