@typescript-eslint/eslint-plugin 8.31.2-alpha.7 → 8.32.0

package/dist/rules/unbound-method.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unbound-method.d.ts","sourceRoot":"","sources":["../../src/rules/unbound-method.ts"],"names":[],"mappings":"AAkBA,UAAU,MAAM;IACd,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,8BAA8B,CAAC;;AAiFpE,wBA0KG"}
+{"version":3,"file":"unbound-method.d.ts","sourceRoot":"","sources":["../../src/rules/unbound-method.ts"],"names":[],"mappings":"AAkBA,UAAU,MAAM;IACd,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC;AAE/B,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,8BAA8B,CAAC;;AAiFpE,wBA4KG"}

package/dist/rules/unbound-method.js

@@ -215,8 +215,8 @@ exports.default = (0, util_1.createRule)({
                         }
                     }
                     for (const intersectionPart of tsutils
-                        .unionTypeParts(services.getTypeAtLocation(node))
-                        .flatMap(unionPart => tsutils.intersectionTypeParts(unionPart))) {
+                        .unionConstituents(services.getTypeAtLocation(node))
+                        .flatMap(unionPart => tsutils.intersectionConstituents(unionPart))) {
                         const reported = checkIfMethodAndReport(property.key, intersectionPart.getProperty(property.key.name));
                         if (reported) {
                             break;

package/dist/rules/use-unknown-in-catch-callback-variable.js

@@ -63,7 +63,7 @@ exports.default = (0, util_1.createRule)({
         const { esTreeNodeToTSNodeMap, program } = (0, util_1.getParserServices)(context);
         const checker = program.getTypeChecker();
         function isFlaggableHandlerType(type) {
-            for (const unionPart of tsutils.unionTypeParts(type)) {
+            for (const unionPart of tsutils.unionConstituents(type)) {
                 const callSignatures = tsutils.getCallSignaturesOfType(unionPart);
                 if (callSignatures.length === 0) {
                     // Ignore any non-function components to the type. Those are not this rule's problem.

package/dist/util/getWrappingFixer.d.ts

@@ -16,10 +16,10 @@ interface WrappingFixerParams {
      * Receives multiple arguments if there are multiple innerNodes.
      * E.g. ``code => `${code} != null` ``
      */
-    wrap: (...code: string[]) => string;
+    wrap?: (...code: string[]) => string;
 }
 /**
- * Wraps node with some code. Adds parenthesis as necessary.
+ * Wraps node with some code. Adds parentheses as necessary.
  * @returns Fixer which adds the specified code and parens if necessary.
  */
 export declare function getWrappingFixer(params: WrappingFixerParams): (fixer: TSESLint.RuleFixer) => TSESLint.RuleFix;
@@ -36,7 +36,7 @@ export declare function getMovedNodeCode(params: {
     sourceCode: Readonly<TSESLint.SourceCode>;
 }): string;
 /**
- * Check if a node will always have the same precedence if it's parent changes.
+ * Check if a node will always have the same precedence if its parent changes.
  */
 export declare function isStrongPrecedenceNode(innerNode: TSESTree.Node): boolean;
 export {};

package/dist/util/getWrappingFixer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getWrappingFixer.d.ts","sourceRoot":"","sources":["../../src/util/getWrappingFixer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAQnE,UAAU,mBAAmB;IAC3B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAC5C,kCAAkC;IAClC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC;IACpB,mBAAmB;IACnB,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC1C;;;;OAIG;IACH,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;CACrC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,mBAAmB,GAC1B,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,KAAK,QAAQ,CAAC,OAAO,CA2CjD;AACD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC/B,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC1B,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;CAC3C,GAAG,MAAM,CAeT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAcxE"}
+{"version":3,"file":"getWrappingFixer.d.ts","sourceRoot":"","sources":["../../src/util/getWrappingFixer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAQnE,UAAU,mBAAmB;IAC3B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAC5C,kCAAkC;IAClC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC;IACpB,mBAAmB;IACnB,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC1C;;;;OAIG;IACH,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC;CACtC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,mBAAmB,GAC1B,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,KAAK,QAAQ,CAAC,OAAO,CA+CjD;AACD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC/B,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC;IAC1B,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;CAC3C,GAAG,MAAM,CAeT;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,QAAQ,CAAC,IAAI,GAAG,OAAO,CAcxE"}

package/dist/util/getWrappingFixer.js

@@ -5,7 +5,7 @@ exports.getMovedNodeCode = getMovedNodeCode;
 exports.isStrongPrecedenceNode = isStrongPrecedenceNode;
 const utils_1 = require("@typescript-eslint/utils");
 /**
- * Wraps node with some code. Adds parenthesis as necessary.
+ * Wraps node with some code. Adds parentheses as necessary.
  * @returns Fixer which adds the specified code and parens if necessary.
  */
 function getWrappingFixer(params) {
@@ -25,6 +25,9 @@ function getWrappingFixer(params) {
             }
             return code;
         });
+        if (!wrap) {
+            return fixer.replaceText(node, innerCodes.join(''));
+        }
         // do the wrapping
         let code = wrap(...innerCodes);
         // check the outer expression's precedence
@@ -63,7 +66,7 @@ function getMovedNodeCode(params) {
     return `(${code})`;
 }
 /**
- * Check if a node will always have the same precedence if it's parent changes.
+ * Check if a node will always have the same precedence if its parent changes.
  */
 function isStrongPrecedenceNode(innerNode) {
     return (innerNode.type === utils_1.AST_NODE_TYPES.Literal ||

package/dist/util/isArrayMethodCallWithPredicate.js

@@ -58,7 +58,7 @@ function isArrayMethodCallWithPredicate(context, services, node) {
     const checker = services.program.getTypeChecker();
     const type = (0, type_utils_1.getConstrainedTypeAtLocation)(services, node.callee.object);
     return tsutils
-        .unionTypeParts(type)
-        .flatMap(part => tsutils.intersectionTypeParts(part))
+        .unionConstituents(type)
+        .flatMap(part => tsutils.intersectionConstituents(part))
         .some(t => checker.isArrayType(t) || checker.isTupleType(t));
 }

package/dist/util/promiseUtils.d.ts

@@ -0,0 +1,28 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';
+/**
+ * Parses a syntactically possible `Promise.then()` call. Does not check the
+ * type of the callee.
+ */
+export declare function parseThenCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
+    onFulfilled?: TSESTree.Expression | undefined;
+    onRejected?: TSESTree.Expression | undefined;
+    object: TSESTree.Expression;
+} | undefined;
+/**
+ * Parses a syntactically possible `Promise.catch()` call. Does not check the
+ * type of the callee.
+ */
+export declare function parseCatchCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
+    onRejected?: TSESTree.Expression | undefined;
+    object: TSESTree.Expression;
+} | undefined;
+/**
+ * Parses a syntactically possible `Promise.finally()` call. Does not check the
+ * type of the callee.
+ */
+export declare function parseFinallyCall(node: TSESTree.CallExpression, context: RuleContext<string, unknown[]>): {
+    object: TSESTree.Expression;
+    onFinally?: TSESTree.Expression | undefined;
+} | undefined;
+//# sourceMappingURL=promiseUtils.d.ts.map

package/dist/util/promiseUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promiseUtils.d.ts","sourceRoot":"","sources":["../../src/util/promiseUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAMtE;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,WAAW,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC9C,UAAU,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC7C,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;CAC7B,GACD,SAAS,CAqCZ;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,UAAU,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;IAC7C,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;CAC7B,GACD,SAAS,CAuBZ;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,QAAQ,CAAC,cAAc,EAC7B,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,GAErC;IACE,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;IAC5B,SAAS,CAAC,EAAE,QAAQ,CAAC,UAAU,GAAG,SAAS,CAAC;CAC7C,GACD,SAAS,CAsBZ"}

package/dist/util/promiseUtils.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseThenCall = parseThenCall;
+exports.parseCatchCall = parseCatchCall;
+exports.parseFinallyCall = parseFinallyCall;
+const utils_1 = require("@typescript-eslint/utils");
+const misc_1 = require("./misc");
+/**
+ * Parses a syntactically possible `Promise.then()` call. Does not check the
+ * type of the callee.
+ */
+function parseThenCall(node, context) {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
+        if (methodName === 'then') {
+            if (node.arguments.length >= 1) {
+                if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    return {
+                        object: node.callee.object,
+                    };
+                }
+                if (node.arguments.length >= 2) {
+                    if (node.arguments[1].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                        return {
+                            object: node.callee.object,
+                            onFulfilled: node.arguments[0],
+                        };
+                    }
+                    return {
+                        object: node.callee.object,
+                        onFulfilled: node.arguments[0],
+                        onRejected: node.arguments[1],
+                    };
+                }
+                return {
+                    object: node.callee.object,
+                    onFulfilled: node.arguments[0],
+                };
+            }
+            return {
+                object: node.callee.object,
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * Parses a syntactically possible `Promise.catch()` call. Does not check the
+ * type of the callee.
+ */
+function parseCatchCall(node, context) {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
+        if (methodName === 'catch') {
+            if (node.arguments.length >= 1) {
+                if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    return {
+                        object: node.callee.object,
+                    };
+                }
+                return {
+                    object: node.callee.object,
+                    onRejected: node.arguments[0],
+                };
+            }
+            return {
+                object: node.callee.object,
+            };
+        }
+    }
+    return undefined;
+}
+/**
+ * Parses a syntactically possible `Promise.finally()` call. Does not check the
+ * type of the callee.
+ */
+function parseFinallyCall(node, context) {
+    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const methodName = (0, misc_1.getStaticMemberAccessValue)(node.callee, context);
+        if (methodName === 'finally') {
+            if (node.arguments.length >= 1) {
+                if (node.arguments[0].type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                    return {
+                        object: node.callee.object,
+                    };
+                }
+                return {
+                    object: node.callee.object,
+                    onFinally: node.arguments[0],
+                };
+            }
+            return {
+                object: node.callee.object,
+            };
+        }
+    }
+    return undefined;
+}

package/dist/util/truthinessUtils.js

@@ -41,18 +41,18 @@ const getValueOfLiteralType_1 = require("./getValueOfLiteralType");
 const isTruthyLiteral = (type) => tsutils.isTrueLiteralType(type) ||
     (type.isLiteral() && !!(0, getValueOfLiteralType_1.getValueOfLiteralType)(type));
 const isPossiblyFalsy = (type) => tsutils
-    .unionTypeParts(type)
+    .unionConstituents(type)
     // Intersections like `string & {}` can also be possibly falsy,
     // requiring us to look into the intersection.
-    .flatMap(type => tsutils.intersectionTypeParts(type))
+    .flatMap(type => tsutils.intersectionConstituents(type))
     // PossiblyFalsy flag includes literal values, so exclude ones that
     // are definitely truthy
     .filter(t => !isTruthyLiteral(t))
     .some(type => tsutils.isTypeFlagSet(type, ts.TypeFlags.PossiblyFalsy));
 exports.isPossiblyFalsy = isPossiblyFalsy;
 const isPossiblyTruthy = (type) => tsutils
-    .unionTypeParts(type)
-    .map(type => tsutils.intersectionTypeParts(type))
+    .unionConstituents(type)
+    .map(type => tsutils.intersectionConstituents(type))
     .some(intersectionParts => 
 // It is possible to define intersections that are always falsy,
 // like `"" & { __brand: string }`.

package/docs/rules/no-unnecessary-type-conversion.mdx

@@ -0,0 +1,79 @@
+---
+description: 'Disallow conversion idioms when they do not change the type or value of the expression.'
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-unnecessary-type-conversion** for documentation.
+
+JavaScript provides several commonly used idioms to convert values to a specific type:
+
+- Primitive coercion (e.g. `Boolean(value)`, `String(value)`): using a built-in primitive function
+- String concatenation (e.g. `value + ''`): turning a value into a string
+- Unary coercion (e.g. `+value`, `!!value`): using a built-in operator
+- The `.toString()` method defined on many types
+
+These conversions are unnecessary if the value is already of that type.
+
+## Examples
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts
+String('123');
+'123'.toString();
+'' + '123';
+'123' + '';
+
+Number(123);
++123;
+~~123;
+
+Boolean(true);
+!!true;
+
+BigInt(BigInt(1));
+
+let str = '123';
+str += '';
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts
+function foo(bar: string | number) {
+  String(bar);
+  bar.toString();
+  '' + bar;
+  bar + '';
+
+  Number(bar);
+  +bar;
+  ~~bar;
+
+  Boolean(bar);
+  !!bar;
+
+  BigInt(1);
+
+  bar += '';
+}
+```
+
+</TabItem>
+</Tabs>
+
+## When Not To Use It
+
+If you don't care about having no-op type conversions in your code, then you can turn off this rule.
+If you have types which are not accurate, then this rule might cause you to remove conversions that you actually do need.
+
+## Related To
+
+- [no-unnecessary-type-assertion](./no-unnecessary-type-assertion.mdx)
+- [no-useless-template-literals](./no-useless-template-literals.mdx)

package/docs/rules/only-throw-error.mdx

@@ -123,6 +123,11 @@ interface Options {
     | string
   )[];
 
+  /**
+   * Whether to allow rethrowing caught values that are not `Error` objects.
+   */
+  allowRethrowing?: boolean;
+
   /**
    * Whether to always allow throwing values typed as `any`.
    */
@@ -136,6 +141,7 @@ interface Options {
 
 const defaultOptions: Options = {
   allow: [],
+  allowRethrowing: false,
   allowThrowingAny: true,
   allowThrowingUnknown: true,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.31.2-alpha.7",
+  "version": "8.32.0",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -50,40 +50,39 @@
   ],
   "scripts": {
     "build": "tsc -b tsconfig.build.json",
-    "clean": "tsc -b tsconfig.build.json --clean",
-    "postclean": "rimraf dist && rimraf coverage",
+    "clean": "rimraf dist/ coverage/",
     "format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
     "generate:breaking-changes": "tsx tools/generate-breaking-changes.mts",
     "generate:configs": "npx nx generate-configs repo",
     "lint": "npx nx lint",
     "test": "vitest --run --config=$INIT_CWD/vitest.config.mts",
-    "test-single": "vitest --run --config=$INIT_CWD/vitest.config.mts",
+    "test-single": "vitest --run --config=$INIT_CWD/vitest.config.mts --no-coverage",
     "check-types": "npx nx typecheck"
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.31.2-alpha.7",
-    "@typescript-eslint/type-utils": "8.31.2-alpha.7",
-    "@typescript-eslint/utils": "8.31.2-alpha.7",
-    "@typescript-eslint/visitor-keys": "8.31.2-alpha.7",
+    "@typescript-eslint/scope-manager": "8.32.0",
+    "@typescript-eslint/type-utils": "8.32.0",
+    "@typescript-eslint/utils": "8.32.0",
+    "@typescript-eslint/visitor-keys": "8.32.0",
     "graphemer": "^1.4.0",
     "ignore": "^5.3.1",
     "natural-compare": "^1.4.0",
-    "ts-api-utils": "^2.0.1"
+    "ts-api-utils": "^2.1.0"
   },
   "devDependencies": {
     "@types/marked": "^5.0.2",
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.31.2-alpha.7",
-    "@typescript-eslint/rule-tester": "8.31.2-alpha.7",
-    "@vitest/coverage-v8": "^3.1.1",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.32.0",
+    "@typescript-eslint/rule-tester": "8.32.0",
+    "@vitest/coverage-v8": "^3.1.2",
     "ajv": "^6.12.6",
     "cross-fetch": "*",
     "eslint": "*",
     "json-schema": "*",
     "markdown-table": "^3.0.3",
-    "marked": "^5.1.2",
+    "marked": "^15.0.0",
     "mdast-util-from-markdown": "^2.0.0",
     "mdast-util-mdx": "^3.0.0",
     "micromark-extension-mdxjs": "^3.0.0",
@@ -93,7 +92,7 @@
     "tsx": "*",
     "typescript": "*",
     "unist-util-visit": "^5.0.0",
-    "vitest": "^3.1.1"
+    "vitest": "^3.1.2"
   },
   "peerDependencies": {
     "@typescript-eslint/parser": "^8.0.0 || ^8.0.0-alpha.0",