Overview - Typescript-eslint

7 days30 days

Latest CI Pipeline Executions

Fuzzy

Succeeded
main
bf3eda04 feat(eslint-plugin): [no-loop-func] support `using` / `await using` declarations and deprecate the rule (#12500) * test(eslint-plugin): add additional test cases for resource management in no-loop-func rule * refactor(no-loop-func): deprecate rule in favor of ESLint core rule * refactor(no-loop-func): simplify type inference for options and message IDs * fix(eslint-plugin): [no-loop-func] treat / as safe bindings and deprecate the rule
by 송재욱
Succeeded
main
bf3eda04 feat(eslint-plugin): [no-loop-func] support `using` / `await using` declarations and deprecate the rule (#12500) * test(eslint-plugin): add additional test cases for resource management in no-loop-func rule * refactor(no-loop-func): deprecate rule in favor of ESLint core rule * refactor(no-loop-func): simplify type inference for options and message IDs * fix(eslint-plugin): [no-loop-func] treat / as safe bindings and deprecate the rule
by 송재욱
Succeeded
main
bf3eda04 feat(eslint-plugin): [no-loop-func] support `using` / `await using` declarations and deprecate the rule (#12500) * test(eslint-plugin): add additional test cases for resource management in no-loop-func rule * refactor(no-loop-func): deprecate rule in favor of ESLint core rule * refactor(no-loop-func): simplify type inference for options and message IDs * fix(eslint-plugin): [no-loop-func] treat / as safe bindings and deprecate the rule
by 송재욱
Succeeded
main
0493f53f fix(eslint-plugin): [no-unnecessary-type-assertion] parenthesize object literal at left edge of expression statement (#12443) * fix(eslint-plugin): [no-unnecessary-type-assertion] parenthesize object literal at left edge of expression statement When a `<T>{ ... }` assertion sits at the left edge of a larger expression statement (binary/logical/conditional/sequence operand, including nested ones), removing the angle brackets left a leading `{` that the parser reads as a block — producing invalid output or silently changing semantics. Generalize the existing concise-arrow-body / bare-statement check with an `isAtExpressionStatementStart` helper that walks up the ancestors keeping the node as the statement's leading token (via source-position comparison), so the fixer wraps the object literal in parentheses in those positions too. A leading keyword/operator (e.g. `new`) shifts the start, so those are correctly left untouched, and an already-parenthesized ancestor needs no extra parentheses. * test(eslint-plugin): [no-unnecessary-type-assertion] cover left-edge object-literal assertion fixes Add invalid cases for #12418 where `<T>{ ... }` is at the left edge of an expression statement (binary, logical, conditional, sequence and nested binary), a parenthesized-sequence case that must not be double-wrapped, and a right-operand case that must be left unwrapped. * test(eslint-plugin): [no-unnecessary-type-assertion] wrap left-edge sequence snippet in noFormat prettier rewrites the bare `<T>{ ... }, foo();` statement by adding parentheses, which the internal plugin-test-formatting rule flags in CI. Wrap it in noFormat to keep the intentionally-unparenthesized left-edge sequence so the case still exercises the fixer. * fix(eslint-plugin): [no-unnecessary-type-assertion] detect leading `{`/`function`/`class` token instead of object literal The assertion binds looser than member access, so its operand can be a member expression (e.g. `<number>{ a: 1 as number }.a`) whose leading token is `{`, `function`, or `class` — each of which leads the statement after the fix and is parsed as a block / function or class declaration. Key off the first operand token rather than `node.expression` being an `ObjectExpression`, which also subsumes the previous parenthesized-operand guard. * test(eslint-plugin): [no-unnecessary-type-assertion] cover member-access operands led by `{`/`function`/`class` Add invalid cases where the assertion wraps a member expression whose first token is `{`, `function`, or `class`, confirming the operand is parenthesized so the fix output stays a valid expression statement. * refactor(eslint-plugin): [no-unnecessary-type-assertion] split left-edge detection into statement/arrow helpers and traverse arrow bodies Address review feedback: - Separate the two distinct concerns into `isAtExpressionStatementStart` and `isAtArrowFunctionBodyStart`, and compute `needsParens` from explicit `breaksExpressionStatement` / `breaksArrowFunctionBody` flags. - Traverse left-edge ancestors for concise arrow bodies too, so cases like `() => <number>{ a: 1 as number }.a + b` are parenthesized. - Drop the redundant `isParenthesized` check from the statement walk: a wrapping `(` shifts a parent's start, so the existing left-edge position check already ends the walk (the `(<T>{ ... }, 1)` case demonstrates this). The arrow walk keeps the check, since an arrow's range starts at its parameters and so can't detect a wrapping `(`. * test(eslint-plugin): [no-unnecessary-type-assertion] cover concise arrow body left-edge assertion Add a case where the object-literal assertion leads a concise arrow body through a binary operand, so the fix must parenthesize it to avoid the `{` being parsed as a block body.
by 송재욱
Succeeded
main
bf3eda04 feat(eslint-plugin): [no-loop-func] support `using` / `await using` declarations and deprecate the rule (#12500) * test(eslint-plugin): add additional test cases for resource management in no-loop-func rule * refactor(no-loop-func): deprecate rule in favor of ESLint core rule * refactor(no-loop-func): simplify type inference for options and message IDs * fix(eslint-plugin): [no-loop-func] treat / as safe bindings and deprecate the rule
by 송재욱
Succeeded
main
0493f53f fix(eslint-plugin): [no-unnecessary-type-assertion] parenthesize object literal at left edge of expression statement (#12443) * fix(eslint-plugin): [no-unnecessary-type-assertion] parenthesize object literal at left edge of expression statement When a `<T>{ ... }` assertion sits at the left edge of a larger expression statement (binary/logical/conditional/sequence operand, including nested ones), removing the angle brackets left a leading `{` that the parser reads as a block — producing invalid output or silently changing semantics. Generalize the existing concise-arrow-body / bare-statement check with an `isAtExpressionStatementStart` helper that walks up the ancestors keeping the node as the statement's leading token (via source-position comparison), so the fixer wraps the object literal in parentheses in those positions too. A leading keyword/operator (e.g. `new`) shifts the start, so those are correctly left untouched, and an already-parenthesized ancestor needs no extra parentheses. * test(eslint-plugin): [no-unnecessary-type-assertion] cover left-edge object-literal assertion fixes Add invalid cases for #12418 where `<T>{ ... }` is at the left edge of an expression statement (binary, logical, conditional, sequence and nested binary), a parenthesized-sequence case that must not be double-wrapped, and a right-operand case that must be left unwrapped. * test(eslint-plugin): [no-unnecessary-type-assertion] wrap left-edge sequence snippet in noFormat prettier rewrites the bare `<T>{ ... }, foo();` statement by adding parentheses, which the internal plugin-test-formatting rule flags in CI. Wrap it in noFormat to keep the intentionally-unparenthesized left-edge sequence so the case still exercises the fixer. * fix(eslint-plugin): [no-unnecessary-type-assertion] detect leading `{`/`function`/`class` token instead of object literal The assertion binds looser than member access, so its operand can be a member expression (e.g. `<number>{ a: 1 as number }.a`) whose leading token is `{`, `function`, or `class` — each of which leads the statement after the fix and is parsed as a block / function or class declaration. Key off the first operand token rather than `node.expression` being an `ObjectExpression`, which also subsumes the previous parenthesized-operand guard. * test(eslint-plugin): [no-unnecessary-type-assertion] cover member-access operands led by `{`/`function`/`class` Add invalid cases where the assertion wraps a member expression whose first token is `{`, `function`, or `class`, confirming the operand is parenthesized so the fix output stays a valid expression statement. * refactor(eslint-plugin): [no-unnecessary-type-assertion] split left-edge detection into statement/arrow helpers and traverse arrow bodies Address review feedback: - Separate the two distinct concerns into `isAtExpressionStatementStart` and `isAtArrowFunctionBodyStart`, and compute `needsParens` from explicit `breaksExpressionStatement` / `breaksArrowFunctionBody` flags. - Traverse left-edge ancestors for concise arrow bodies too, so cases like `() => <number>{ a: 1 as number }.a + b` are parenthesized. - Drop the redundant `isParenthesized` check from the statement walk: a wrapping `(` shifts a parent's start, so the existing left-edge position check already ends the walk (the `(<T>{ ... }, 1)` case demonstrates this). The arrow walk keeps the check, since an arrow's range starts at its parameters and so can't detect a wrapping `(`. * test(eslint-plugin): [no-unnecessary-type-assertion] cover concise arrow body left-edge assertion Add a case where the object-literal assertion leads a concise arrow body through a binary operand, so the fix must parenthesize it to avoid the `{` being parsed as a block body.
by 송재욱
Succeeded
main
bf3eda04 feat(eslint-plugin): [no-loop-func] support `using` / `await using` declarations and deprecate the rule (#12500) * test(eslint-plugin): add additional test cases for resource management in no-loop-func rule * refactor(no-loop-func): deprecate rule in favor of ESLint core rule * refactor(no-loop-func): simplify type inference for options and message IDs * fix(eslint-plugin): [no-loop-func] treat / as safe bindings and deprecate the rule
by 송재욱
Failed
main
08dd4272 fix(eslint-plugin): [class-literal-property-style] preserve type annotations and don't drop decorators (#12617) * fix: enhance class-literal-property-style rule * fix: improve getter style suggestion in class-literal-property-style rule
by 송재욱
Succeeded
main
8826d0eb fix(eslint-plugin): [no-useless-default-assignment] don't report defaults used by other overloads (#12607) * fix: improve default parameter handling in no-useless-default-assignment rule * fix: use isRestParameterDeclaration helper --------- Co-authored-by: Evyatar Daud <32631382+StyleShit@users.noreply.github.com>
by 송재욱
Succeeded
main
7aecc1c4 fix(eslint-plugin): [prefer-nullish-coalescing] handle shadowed Boolean calls (#12591) fix(eslint-plugin): update prefer-nullish-coalescing rule to use ASTUtils for variable lookup Co-authored-by: Evyatar Daud <32631382+StyleShit@users.noreply.github.com>
by 송재욱
Succeeded
main
7aecc1c4 fix(eslint-plugin): [prefer-nullish-coalescing] handle shadowed Boolean calls (#12591) fix(eslint-plugin): update prefer-nullish-coalescing rule to use ASTUtils for variable lookup Co-authored-by: Evyatar Daud <32631382+StyleShit@users.noreply.github.com>
by 송재욱
Succeeded
fix/12605
478e04c4 Merge 46e343b5d53eb38c38179c9ac6a5fbabf4e54127 into 7aecc1c44e60bc4b47402ce63a79587746766d9f
by 송재욱
Succeeded
main
5ffa7604 fix(eslint-plugin): [no-unnecessary-type-conversion] ignore shadowed built-ins (#12590) * feat: enhance no-unnecessary-type-conversion rule with additional test cases * fix: formatting --------- Co-authored-by: Evyatar Daud <32631382+StyleShit@users.noreply.github.com>
by 송재욱
Succeeded
fix/12524
cf2eb46e Merge 2bd1472024971c884046a4bde5a7ff0b4275e499 into 5ffa76049a0dd6c73ba9c0a7e8388ab1324f740f
by 송재욱
Succeeded
fix/12522
3f146551 Merge ec32c01a937b070d229dfbfaa10e69cdd1a9152b into 9cacdd4bebdb0bb650f09cd01d15a81abd4735b3
by 송재욱
Succeeded
main
0493f53f fix(eslint-plugin): [no-unnecessary-type-assertion] parenthesize object literal at left edge of expression statement (#12443) * fix(eslint-plugin): [no-unnecessary-type-assertion] parenthesize object literal at left edge of expression statement When a `<T>{ ... }` assertion sits at the left edge of a larger expression statement (binary/logical/conditional/sequence operand, including nested ones), removing the angle brackets left a leading `{` that the parser reads as a block — producing invalid output or silently changing semantics. Generalize the existing concise-arrow-body / bare-statement check with an `isAtExpressionStatementStart` helper that walks up the ancestors keeping the node as the statement's leading token (via source-position comparison), so the fixer wraps the object literal in parentheses in those positions too. A leading keyword/operator (e.g. `new`) shifts the start, so those are correctly left untouched, and an already-parenthesized ancestor needs no extra parentheses. * test(eslint-plugin): [no-unnecessary-type-assertion] cover left-edge object-literal assertion fixes Add invalid cases for #12418 where `<T>{ ... }` is at the left edge of an expression statement (binary, logical, conditional, sequence and nested binary), a parenthesized-sequence case that must not be double-wrapped, and a right-operand case that must be left unwrapped. * test(eslint-plugin): [no-unnecessary-type-assertion] wrap left-edge sequence snippet in noFormat prettier rewrites the bare `<T>{ ... }, foo();` statement by adding parentheses, which the internal plugin-test-formatting rule flags in CI. Wrap it in noFormat to keep the intentionally-unparenthesized left-edge sequence so the case still exercises the fixer. * fix(eslint-plugin): [no-unnecessary-type-assertion] detect leading `{`/`function`/`class` token instead of object literal The assertion binds looser than member access, so its operand can be a member expression (e.g. `<number>{ a: 1 as number }.a`) whose leading token is `{`, `function`, or `class` — each of which leads the statement after the fix and is parsed as a block / function or class declaration. Key off the first operand token rather than `node.expression` being an `ObjectExpression`, which also subsumes the previous parenthesized-operand guard. * test(eslint-plugin): [no-unnecessary-type-assertion] cover member-access operands led by `{`/`function`/`class` Add invalid cases where the assertion wraps a member expression whose first token is `{`, `function`, or `class`, confirming the operand is parenthesized so the fix output stays a valid expression statement. * refactor(eslint-plugin): [no-unnecessary-type-assertion] split left-edge detection into statement/arrow helpers and traverse arrow bodies Address review feedback: - Separate the two distinct concerns into `isAtExpressionStatementStart` and `isAtArrowFunctionBodyStart`, and compute `needsParens` from explicit `breaksExpressionStatement` / `breaksArrowFunctionBody` flags. - Traverse left-edge ancestors for concise arrow bodies too, so cases like `() => <number>{ a: 1 as number }.a + b` are parenthesized. - Drop the redundant `isParenthesized` check from the statement walk: a wrapping `(` shifts a parent's start, so the existing left-edge position check already ends the walk (the `(<T>{ ... }, 1)` case demonstrates this). The arrow walk keeps the check, since an arrow's range starts at its parameters and so can't detect a wrapping `(`. * test(eslint-plugin): [no-unnecessary-type-assertion] cover concise arrow body left-edge assertion Add a case where the object-literal assertion leads a concise arrow body through a binary operand, so the fix must parenthesize it to avoid the `{` being parsed as a block body.
by 송재욱
Succeeded
main
bf3eda04 feat(eslint-plugin): [no-loop-func] support `using` / `await using` declarations and deprecate the rule (#12500) * test(eslint-plugin): add additional test cases for resource management in no-loop-func rule * refactor(no-loop-func): deprecate rule in favor of ESLint core rule * refactor(no-loop-func): simplify type inference for options and message IDs * fix(eslint-plugin): [no-loop-func] treat / as safe bindings and deprecate the rule
by 송재욱
Succeeded
main
0493f53f fix(eslint-plugin): [no-unnecessary-type-assertion] parenthesize object literal at left edge of expression statement (#12443) * fix(eslint-plugin): [no-unnecessary-type-assertion] parenthesize object literal at left edge of expression statement When a `<T>{ ... }` assertion sits at the left edge of a larger expression statement (binary/logical/conditional/sequence operand, including nested ones), removing the angle brackets left a leading `{` that the parser reads as a block — producing invalid output or silently changing semantics. Generalize the existing concise-arrow-body / bare-statement check with an `isAtExpressionStatementStart` helper that walks up the ancestors keeping the node as the statement's leading token (via source-position comparison), so the fixer wraps the object literal in parentheses in those positions too. A leading keyword/operator (e.g. `new`) shifts the start, so those are correctly left untouched, and an already-parenthesized ancestor needs no extra parentheses. * test(eslint-plugin): [no-unnecessary-type-assertion] cover left-edge object-literal assertion fixes Add invalid cases for #12418 where `<T>{ ... }` is at the left edge of an expression statement (binary, logical, conditional, sequence and nested binary), a parenthesized-sequence case that must not be double-wrapped, and a right-operand case that must be left unwrapped. * test(eslint-plugin): [no-unnecessary-type-assertion] wrap left-edge sequence snippet in noFormat prettier rewrites the bare `<T>{ ... }, foo();` statement by adding parentheses, which the internal plugin-test-formatting rule flags in CI. Wrap it in noFormat to keep the intentionally-unparenthesized left-edge sequence so the case still exercises the fixer. * fix(eslint-plugin): [no-unnecessary-type-assertion] detect leading `{`/`function`/`class` token instead of object literal The assertion binds looser than member access, so its operand can be a member expression (e.g. `<number>{ a: 1 as number }.a`) whose leading token is `{`, `function`, or `class` — each of which leads the statement after the fix and is parsed as a block / function or class declaration. Key off the first operand token rather than `node.expression` being an `ObjectExpression`, which also subsumes the previous parenthesized-operand guard. * test(eslint-plugin): [no-unnecessary-type-assertion] cover member-access operands led by `{`/`function`/`class` Add invalid cases where the assertion wraps a member expression whose first token is `{`, `function`, or `class`, confirming the operand is parenthesized so the fix output stays a valid expression statement. * refactor(eslint-plugin): [no-unnecessary-type-assertion] split left-edge detection into statement/arrow helpers and traverse arrow bodies Address review feedback: - Separate the two distinct concerns into `isAtExpressionStatementStart` and `isAtArrowFunctionBodyStart`, and compute `needsParens` from explicit `breaksExpressionStatement` / `breaksArrowFunctionBody` flags. - Traverse left-edge ancestors for concise arrow bodies too, so cases like `() => <number>{ a: 1 as number }.a + b` are parenthesized. - Drop the redundant `isParenthesized` check from the statement walk: a wrapping `(` shifts a parent's start, so the existing left-edge position check already ends the walk (the `(<T>{ ... }, 1)` case demonstrates this). The arrow walk keeps the check, since an arrow's range starts at its parameters and so can't detect a wrapping `(`. * test(eslint-plugin): [no-unnecessary-type-assertion] cover concise arrow body left-edge assertion Add a case where the object-literal assertion leads a concise arrow body through a binary operand, so the fix must parenthesize it to avoid the `{` being parsed as a block body.
by 송재욱
Succeeded
main
bf3eda04 feat(eslint-plugin): [no-loop-func] support `using` / `await using` declarations and deprecate the rule (#12500) * test(eslint-plugin): add additional test cases for resource management in no-loop-func rule * refactor(no-loop-func): deprecate rule in favor of ESLint core rule * refactor(no-loop-func): simplify type inference for options and message IDs * fix(eslint-plugin): [no-loop-func] treat / as safe bindings and deprecate the rule
by 송재욱
Succeeded
main
0493f53f fix(eslint-plugin): [no-unnecessary-type-assertion] parenthesize object literal at left edge of expression statement (#12443) * fix(eslint-plugin): [no-unnecessary-type-assertion] parenthesize object literal at left edge of expression statement When a `<T>{ ... }` assertion sits at the left edge of a larger expression statement (binary/logical/conditional/sequence operand, including nested ones), removing the angle brackets left a leading `{` that the parser reads as a block — producing invalid output or silently changing semantics. Generalize the existing concise-arrow-body / bare-statement check with an `isAtExpressionStatementStart` helper that walks up the ancestors keeping the node as the statement's leading token (via source-position comparison), so the fixer wraps the object literal in parentheses in those positions too. A leading keyword/operator (e.g. `new`) shifts the start, so those are correctly left untouched, and an already-parenthesized ancestor needs no extra parentheses. * test(eslint-plugin): [no-unnecessary-type-assertion] cover left-edge object-literal assertion fixes Add invalid cases for #12418 where `<T>{ ... }` is at the left edge of an expression statement (binary, logical, conditional, sequence and nested binary), a parenthesized-sequence case that must not be double-wrapped, and a right-operand case that must be left unwrapped. * test(eslint-plugin): [no-unnecessary-type-assertion] wrap left-edge sequence snippet in noFormat prettier rewrites the bare `<T>{ ... }, foo();` statement by adding parentheses, which the internal plugin-test-formatting rule flags in CI. Wrap it in noFormat to keep the intentionally-unparenthesized left-edge sequence so the case still exercises the fixer. * fix(eslint-plugin): [no-unnecessary-type-assertion] detect leading `{`/`function`/`class` token instead of object literal The assertion binds looser than member access, so its operand can be a member expression (e.g. `<number>{ a: 1 as number }.a`) whose leading token is `{`, `function`, or `class` — each of which leads the statement after the fix and is parsed as a block / function or class declaration. Key off the first operand token rather than `node.expression` being an `ObjectExpression`, which also subsumes the previous parenthesized-operand guard. * test(eslint-plugin): [no-unnecessary-type-assertion] cover member-access operands led by `{`/`function`/`class` Add invalid cases where the assertion wraps a member expression whose first token is `{`, `function`, or `class`, confirming the operand is parenthesized so the fix output stays a valid expression statement. * refactor(eslint-plugin): [no-unnecessary-type-assertion] split left-edge detection into statement/arrow helpers and traverse arrow bodies Address review feedback: - Separate the two distinct concerns into `isAtExpressionStatementStart` and `isAtArrowFunctionBodyStart`, and compute `needsParens` from explicit `breaksExpressionStatement` / `breaksArrowFunctionBody` flags. - Traverse left-edge ancestors for concise arrow bodies too, so cases like `() => <number>{ a: 1 as number }.a + b` are parenthesized. - Drop the redundant `isParenthesized` check from the statement walk: a wrapping `(` shifts a parent's start, so the existing left-edge position check already ends the walk (the `(<T>{ ... }, 1)` case demonstrates this). The arrow walk keeps the check, since an arrow's range starts at its parameters and so can't detect a wrapping `(`. * test(eslint-plugin): [no-unnecessary-type-assertion] cover concise arrow body left-edge assertion Add a case where the object-literal assertion leads a concise arrow body through a binary operand, so the fix must parenthesize it to avoid the `{` being parsed as a block body.
by 송재욱