@typescript-eslint/eslint-plugin 8.67.1-alpha.20 → 8.67.1-alpha.22

package/dist/rules/enum-utils/shared.d.ts

@@ -19,6 +19,11 @@ export declare function getEnumLiterals(type: ts.Type): ts.LiteralType[];
  * - T extends Fruit --> [Fruit]
  */
 export declare function getEnumTypes(typeChecker: ts.TypeChecker, type: ts.Type): ts.Type[];
+/**
+ * @returns Whether two types compare unsafely because an enum value is being
+ * compared against a non-enum value of the same primitive kind.
+ */
+export declare function isMismatchedEnumComparisonTypes(typeChecker: ts.TypeChecker, leftType: ts.Type, rightType: ts.Type): boolean;
 /**
  * Returns the enum key that matches the given literal node, or null if none
  * match. For example:

package/dist/rules/enum-utils/shared.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEnumLiterals = getEnumLiterals;
 exports.getEnumTypes = getEnumTypes;
+exports.isMismatchedEnumComparisonTypes = isMismatchedEnumComparisonTypes;
 exports.getEnumKeyForLiteral = getEnumKeyForLiteral;
 const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));
@@ -81,6 +82,72 @@ function getEnumLiterals(type) {
 function getEnumTypes(typeChecker, type) {
     return getEnumLiterals(type).map(type => getBaseEnumType(typeChecker, type));
 }
+/**
+ * @returns Whether two types compare unsafely because an enum value is being
+ * compared against a non-enum value of the same primitive kind.
+ */
+function isMismatchedEnumComparisonTypes(typeChecker, leftType, rightType) {
+    // Allow comparisons that don't have anything to do with enums:
+    //
+    // ```ts
+    // 1 === 2;
+    // ```
+    const leftEnumTypes = getEnumTypes(typeChecker, leftType);
+    const rightEnumTypes = new Set(getEnumTypes(typeChecker, rightType));
+    if (leftEnumTypes.length === 0 && rightEnumTypes.size === 0) {
+        return false;
+    }
+    // Allow comparisons that share an enum type:
+    //
+    // ```ts
+    // Fruit.Apple === Fruit.Banana;
+    // ```
+    for (const leftEnumType of leftEnumTypes) {
+        if (rightEnumTypes.has(leftEnumType)) {
+            return false;
+        }
+    }
+    // We need to split the type into the union type parts in order to find
+    // valid enum comparisons like:
+    //
+    // ```ts
+    // declare const something: Fruit | Vegetable;
+    // something === Fruit.Apple;
+    // ```
+    const leftTypeParts = tsutils.unionConstituents(leftType);
+    const rightTypeParts = tsutils.unionConstituents(rightType);
+    // If a type exists in both sides, we consider this comparison safe:
+    //
+    // ```ts
+    // declare const fruit: Fruit.Apple | 0;
+    // fruit === 0;
+    // ```
+    for (const leftTypePart of leftTypeParts) {
+        if (rightTypeParts.includes(leftTypePart)) {
+            return false;
+        }
+    }
+    return (typeViolates(leftTypeParts, rightType) ||
+        typeViolates(rightTypeParts, leftType));
+}
+/**
+ * @returns Whether the right type is an unsafe comparison against any left type.
+ */
+function typeViolates(leftTypeParts, rightType) {
+    const leftEnumValueTypes = new Set(leftTypeParts.map(getEnumValueType));
+    return ((leftEnumValueTypes.has(ts.TypeFlags.Number) && (0, util_1.isNumberLike)(rightType)) ||
+        (leftEnumValueTypes.has(ts.TypeFlags.String) && (0, util_1.isStringLike)(rightType)));
+}
+/**
+ * @returns What type a type's enum value is (number or string), if either.
+ */
+function getEnumValueType(type) {
+    return tsutils.isTypeFlagSet(type, ts.TypeFlags.EnumLike)
+        ? tsutils.isTypeFlagSet(type, ts.TypeFlags.NumberLiteral)
+            ? ts.TypeFlags.Number
+            : ts.TypeFlags.String
+        : undefined;
+}
 /**
  * Returns the enum key that matches the given literal node, or null if none
  * match. For example:

package/dist/rules/no-empty-object-type.js

@@ -72,15 +72,19 @@ exports.default = (0, util_1.createRule)({
                         return;
                     }
                     const scope = context.sourceCode.getScope(node);
-                    const mergedWithClassDeclaration = scope.set
+                    const mergedWithOtherDeclaration = scope.set
                         .get(node.id.name)
-                        ?.defs.some(def => def.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration);
+                        ?.defs.some(def => def.node !== node &&
+                        (def.node.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+                            def.node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration));
+                    const isDefaultExport = node.parent.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration;
+                    const shouldSuggest = !mergedWithOtherDeclaration && !isDefaultExport;
                     if (extend.length === 0) {
                         context.report({
                             node: node.id,
                             messageId: 'noEmptyInterface',
                             data: { option: 'allowInterfaces' },
-                            ...(!mergedWithClassDeclaration && {
+                            ...(shouldSuggest && {
                                 suggest: ['object', 'unknown'].map(replacement => ({
                                     messageId: 'replaceEmptyInterface',
                                     data: { replacement },
@@ -99,7 +103,7 @@ exports.default = (0, util_1.createRule)({
                     context.report({
                         node: node.id,
                         messageId: 'noEmptyInterfaceWithSuper',
-                        ...(!mergedWithClassDeclaration && {
+                        ...(shouldSuggest && {
                             suggest: [
                                 {
                                     messageId: 'replaceEmptyInterfaceWithSuper',

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

@@ -64,18 +64,6 @@ exports.default = (0, util_1.createRule)({
     create(context) {
         const services = (0, util_1.getParserServices)(context);
         const checker = services.program.getTypeChecker();
-        function isStringLike(type) {
-            return (0, util_1.isTypeFlagSet)(type, ts.TypeFlags.StringLike);
-        }
-        function isUnderlyingTypeString(type) {
-            if (type.isUnion()) {
-                return type.types.every(isStringLike);
-            }
-            if (type.isIntersection()) {
-                return type.types.some(isStringLike);
-            }
-            return isStringLike(type);
-        }
         function isEnumMemberType(type) {
             return tsutils.typeConstituents(type).some(t => {
                 const symbol = t.getSymbol();
@@ -315,7 +303,7 @@ exports.default = (0, util_1.createRule)({
                 if (isTrivialInterpolation(node) &&
                     !hasCommentsBetweenQuasi(node.quasis[0], node.quasis[1])) {
                     const { constraintType } = (0, util_1.getConstraintInfo)(checker, services.getTypeAtLocation(node.expressions[0]));
-                    if (constraintType && isUnderlyingTypeString(constraintType)) {
+                    if (constraintType && (0, util_1.isStringLike)(constraintType)) {
                         reportSingleInterpolation(node);
                         return;
                     }
@@ -331,7 +319,7 @@ exports.default = (0, util_1.createRule)({
                     const { constraintType, isTypeParameter } = (0, util_1.getConstraintInfo)(checker, services.getTypeAtLocation(node.types[0]));
                     if (constraintType &&
                         !isTypeParameter &&
-                        isUnderlyingTypeString(constraintType) &&
+                        (0, util_1.isStringLike)(constraintType) &&
                         !isEnumMemberType(constraintType)) {
                         reportSingleInterpolation(node);
                         return;

package/dist/rules/no-unsafe-argument.js

@@ -37,96 +37,6 @@ const utils_1 = require("@typescript-eslint/utils");
 const tsutils = __importStar(require("ts-api-utils"));
 const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
-var RestTypeKind;
-(function (RestTypeKind) {
-    RestTypeKind[RestTypeKind["Array"] = 0] = "Array";
-    RestTypeKind[RestTypeKind["Tuple"] = 1] = "Tuple";
-    RestTypeKind[RestTypeKind["Other"] = 2] = "Other";
-})(RestTypeKind || (RestTypeKind = {}));
-class FunctionSignature {
-    paramTypes;
-    restType;
-    hasConsumedArguments = false;
-    parameterTypeIndex = 0;
-    constructor(paramTypes, restType) {
-        this.paramTypes = paramTypes;
-        this.restType = restType;
-    }
-    static create(checker, tsNode) {
-        const signature = checker.getResolvedSignature(tsNode);
-        if (!signature) {
-            return null;
-        }
-        const paramTypes = [];
-        let restType = null;
-        const parameters = signature.getParameters();
-        for (let i = 0; i < parameters.length; i += 1) {
-            const param = parameters[i];
-            const type = checker.getTypeOfSymbolAtLocation(param, tsNode);
-            const decl = param.getDeclarations()?.[0];
-            if (decl && (0, util_1.isRestParameterDeclaration)(decl)) {
-                // is a rest param
-                if (checker.isArrayType(type)) {
-                    restType = {
-                        type: checker.getTypeArguments(type)[0],
-                        index: i,
-                        kind: RestTypeKind.Array,
-                    };
-                }
-                else if (checker.isTupleType(type)) {
-                    restType = {
-                        index: i,
-                        kind: RestTypeKind.Tuple,
-                        typeArguments: checker.getTypeArguments(type),
-                    };
-                }
-                else {
-                    restType = {
-                        type,
-                        index: i,
-                        kind: RestTypeKind.Other,
-                    };
-                }
-                break;
-            }
-            paramTypes.push(type);
-        }
-        return new this(paramTypes, restType);
-    }
-    consumeRemainingArguments() {
-        this.hasConsumedArguments = true;
-    }
-    getNextParameterType() {
-        const index = this.parameterTypeIndex;
-        this.parameterTypeIndex += 1;
-        if (index >= this.paramTypes.length || this.hasConsumedArguments) {
-            if (this.restType == null) {
-                return null;
-            }
-            switch (this.restType.kind) {
-                case RestTypeKind.Tuple: {
-                    const typeArguments = this.restType.typeArguments;
-                    if (this.hasConsumedArguments) {
-                        // all types consumed by a rest - just assume it's the last type
-                        // there is one edge case where this is wrong, but we ignore it because
-                        // it's rare and really complicated to handle
-                        // eg: function foo(...a: [number, ...string[], number])
-                        return typeArguments[typeArguments.length - 1];
-                    }
-                    const typeIndex = index - this.restType.index;
-                    if (typeIndex >= typeArguments.length) {
-                        return typeArguments[typeArguments.length - 1];
-                    }
-                    return typeArguments[typeIndex];
-                }
-                case RestTypeKind.Array:
-                case RestTypeKind.Other:
-                    return this.restType.type;
-            }
-        }
-        return this.paramTypes[index];
-    }
-}
 exports.default = (0, util_1.createRule)({
     name: 'no-unsafe-argument',
     meta: {
@@ -176,7 +86,7 @@ exports.default = (0, util_1.createRule)({
                 return;
             }
             const tsNode = services.esTreeNodeToTSNodeMap.get(node);
-            const signature = (0, util_1.nullThrows)(FunctionSignature.create(checker, tsNode), 'Expected to a signature resolved');
+            const signature = util_1.FunctionSignature.create(checker, tsNode);
             if (node.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression) {
                 // Consumes the first parameter (TemplateStringsArray) of the function called with TaggedTemplateExpression.
                 signature.getNextParameterType();

package/dist/rules/no-unsafe-enum-comparison.js

@@ -1,74 +1,7 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-const tsutils = __importStar(require("ts-api-utils"));
-const ts = __importStar(require("typescript"));
 const util_1 = require("../util");
 const shared_1 = require("./enum-utils/shared");
-/**
- * @returns Whether the right type is an unsafe comparison against any left type.
- */
-function typeViolates(leftTypeParts, rightType) {
-    const leftEnumValueTypes = new Set(leftTypeParts.map(getEnumValueType));
-    return ((leftEnumValueTypes.has(ts.TypeFlags.Number) && isNumberLike(rightType)) ||
-        (leftEnumValueTypes.has(ts.TypeFlags.String) && isStringLike(rightType)));
-}
-function isNumberLike(type) {
-    return tsutils
-        .unionConstituents(type)
-        .every(unionPart => tsutils
-        .intersectionConstituents(unionPart)
-        .some(intersectionPart => tsutils.isTypeFlagSet(intersectionPart, ts.TypeFlags.Number | ts.TypeFlags.NumberLike)));
-}
-function isStringLike(type) {
-    return tsutils
-        .unionConstituents(type)
-        .every(unionPart => tsutils
-        .intersectionConstituents(unionPart)
-        .some(intersectionPart => tsutils.isTypeFlagSet(intersectionPart, ts.TypeFlags.String | ts.TypeFlags.StringLike)));
-}
-/**
- * @returns What type a type's enum value is (number or string), if either.
- */
-function getEnumValueType(type) {
-    return tsutils.isTypeFlagSet(type, ts.TypeFlags.EnumLike)
-        ? tsutils.isTypeFlagSet(type, ts.TypeFlags.NumberLiteral)
-            ? ts.TypeFlags.Number
-            : ts.TypeFlags.String
-        : undefined;
-}
 exports.default = (0, util_1.createRule)({
     name: 'no-unsafe-enum-comparison',
     meta: {
@@ -90,55 +23,11 @@ exports.default = (0, util_1.createRule)({
     create(context) {
         const parserServices = (0, util_1.getParserServices)(context);
         const typeChecker = parserServices.program.getTypeChecker();
-        function isMismatchedComparison(leftType, rightType) {
-            // Allow comparisons that don't have anything to do with enums:
-            //
-            // ```ts
-            // 1 === 2;
-            // ```
-            const leftEnumTypes = (0, shared_1.getEnumTypes)(typeChecker, leftType);
-            const rightEnumTypes = new Set((0, shared_1.getEnumTypes)(typeChecker, rightType));
-            if (leftEnumTypes.length === 0 && rightEnumTypes.size === 0) {
-                return false;
-            }
-            // Allow comparisons that share an enum type:
-            //
-            // ```ts
-            // Fruit.Apple === Fruit.Banana;
-            // ```
-            for (const leftEnumType of leftEnumTypes) {
-                if (rightEnumTypes.has(leftEnumType)) {
-                    return false;
-                }
-            }
-            // We need to split the type into the union type parts in order to find
-            // valid enum comparisons like:
-            //
-            // ```ts
-            // declare const something: Fruit | Vegetable;
-            // something === Fruit.Apple;
-            // ```
-            const leftTypeParts = tsutils.unionConstituents(leftType);
-            const rightTypeParts = tsutils.unionConstituents(rightType);
-            // If a type exists in both sides, we consider this comparison safe:
-            //
-            // ```ts
-            // declare const fruit: Fruit.Apple | 0;
-            // fruit === 0;
-            // ```
-            for (const leftTypePart of leftTypeParts) {
-                if (rightTypeParts.includes(leftTypePart)) {
-                    return false;
-                }
-            }
-            return (typeViolates(leftTypeParts, rightType) ||
-                typeViolates(rightTypeParts, leftType));
-        }
         return {
             'BinaryExpression[operator=/^[<>!=]?={0,2}$/]'(node) {
                 const leftType = parserServices.getTypeAtLocation(node.left);
                 const rightType = parserServices.getTypeAtLocation(node.right);
-                if (isMismatchedComparison(leftType, rightType)) {
+                if ((0, shared_1.isMismatchedEnumComparisonTypes)(typeChecker, leftType, rightType)) {
                     context.report({
                         node,
                         messageId: 'mismatchedCondition',
@@ -180,7 +69,7 @@ exports.default = (0, util_1.createRule)({
                 const { parent } = node;
                 const leftType = parserServices.getTypeAtLocation(parent.discriminant);
                 const rightType = parserServices.getTypeAtLocation(node.test);
-                if (isMismatchedComparison(leftType, rightType)) {
+                if ((0, shared_1.isMismatchedEnumComparisonTypes)(typeChecker, leftType, rightType)) {
                     context.report({
                         node,
                         messageId: 'mismatchedCase',

package/dist/util/FunctionSignature.d.ts

@@ -0,0 +1,15 @@
+import * as ts from 'typescript';
+/**
+ * Tracks checking the parameters of a single function signature.
+ * This allows rules to "consume" parameters and check for unsafe comparisons.
+ */
+export declare class FunctionSignature {
+    private readonly paramTypes;
+    private readonly restType;
+    private hasConsumedArguments;
+    private parameterTypeIndex;
+    private constructor();
+    static create(checker: ts.TypeChecker, tsNode: ts.CallLikeExpression): FunctionSignature;
+    consumeRemainingArguments(): void;
+    getNextParameterType(): ts.Type | null;
+}

package/dist/util/FunctionSignature.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionSignature = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const ts = __importStar(require("typescript"));
+const misc_1 = require("./misc");
+const { nullThrows } = utils_1.ESLintUtils;
+var RestTypeKind;
+(function (RestTypeKind) {
+    RestTypeKind[RestTypeKind["Array"] = 0] = "Array";
+    RestTypeKind[RestTypeKind["Other"] = 1] = "Other";
+    RestTypeKind[RestTypeKind["Tuple"] = 2] = "Tuple";
+})(RestTypeKind || (RestTypeKind = {}));
+/**
+ * Tracks checking the parameters of a single function signature.
+ * This allows rules to "consume" parameters and check for unsafe comparisons.
+ */
+class FunctionSignature {
+    paramTypes;
+    restType;
+    hasConsumedArguments = false;
+    parameterTypeIndex = 0;
+    constructor(paramTypes, restType) {
+        this.paramTypes = paramTypes;
+        this.restType = restType;
+    }
+    static create(checker, tsNode) {
+        // getResolvedSignature only returns undefined for nodes outside the parse
+        // tree, and tsNode always comes from the AST node map.
+        const signature = nullThrows(checker.getResolvedSignature(tsNode), 'Expected the call-like node to resolve to a signature.');
+        const paramTypes = [];
+        let restType = null;
+        const parameters = signature.getParameters();
+        for (let index = 0; index < parameters.length; index += 1) {
+            const param = parameters[index];
+            const declaration = param.getDeclarations()?.[0];
+            const type = checker.getTypeOfSymbolAtLocation(param, tsNode);
+            const constrainedType = checker.getBaseConstraintOfType(type) ?? type;
+            if (declaration && (0, misc_1.isRestParameterDeclaration)(declaration)) {
+                if (checker.isTupleType(constrainedType)) {
+                    restType = {
+                        index,
+                        kind: RestTypeKind.Tuple,
+                        typeArguments: checker.getTypeArguments(constrainedType),
+                    };
+                }
+                else {
+                    const elementType = checker.getIndexTypeOfType(constrainedType, ts.IndexKind.Number);
+                    restType = elementType
+                        ? { index, kind: RestTypeKind.Array, type: elementType }
+                        : { index, kind: RestTypeKind.Other, type: constrainedType };
+                }
+                break;
+            }
+            paramTypes.push(type);
+        }
+        return new FunctionSignature(paramTypes, restType);
+    }
+    consumeRemainingArguments() {
+        this.hasConsumedArguments = true;
+    }
+    getNextParameterType() {
+        const index = this.parameterTypeIndex;
+        this.parameterTypeIndex += 1;
+        if (index >= this.paramTypes.length || this.hasConsumedArguments) {
+            if (this.restType == null) {
+                return null;
+            }
+            switch (this.restType.kind) {
+                case RestTypeKind.Tuple: {
+                    const { typeArguments } = this.restType;
+                    if (this.hasConsumedArguments) {
+                        return typeArguments[typeArguments.length - 1];
+                    }
+                    const typeIndex = index - this.restType.index;
+                    if (typeIndex >= typeArguments.length) {
+                        return typeArguments[typeArguments.length - 1];
+                    }
+                    return typeArguments[typeIndex];
+                }
+                case RestTypeKind.Array:
+                case RestTypeKind.Other:
+                    return this.restType.type;
+            }
+        }
+        return this.paramTypes[index];
+    }
+}
+exports.FunctionSignature = FunctionSignature;
+//# sourceMappingURL=FunctionSignature.js.map

package/dist/util/baseTypeUtils.d.ts

@@ -1,6 +1,8 @@
 import type { ParserServicesWithTypeInformation } from '@typescript-eslint/utils';
 import type { InterfaceType, Type } from 'typescript';
 export declare function hasBaseTypes(type: Type): type is InterfaceType;
+export declare function isNumberLike(type: Type): boolean;
+export declare function isStringLike(type: Type): boolean;
 /**
  * Recursively checks if a type or any of its base types matches the provided
  * matcher function.

package/dist/util/baseTypeUtils.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasBaseTypes = hasBaseTypes;
+exports.isNumberLike = isNumberLike;
+exports.isStringLike = isStringLike;
 exports.matchesTypeOrBaseType = matchesTypeOrBaseType;
 const ts_api_utils_1 = require("ts-api-utils");
 const tsutils = __importStar(require("ts-api-utils"));
@@ -53,6 +55,20 @@ function hasBaseTypes(type) {
     return ((0, ts_api_utils_1.isObjectType)(type) &&
         (0, ts_api_utils_1.isObjectFlagSet)(type, ts.ObjectFlags.Interface | ts.ObjectFlags.Class));
 }
+function isNumberLike(type) {
+    return tsutils
+        .unionConstituents(type)
+        .every(unionPart => tsutils
+        .intersectionConstituents(unionPart)
+        .some(intersectionPart => tsutils.isTypeFlagSet(intersectionPart, ts.TypeFlags.NumberLike)));
+}
+function isStringLike(type) {
+    return tsutils
+        .unionConstituents(type)
+        .every(unionPart => tsutils
+        .intersectionConstituents(unionPart)
+        .some(intersectionPart => tsutils.isTypeFlagSet(intersectionPart, ts.TypeFlags.StringLike)));
+}
 /**
  * Recursively checks if a type or any of its base types matches the provided
  * matcher function.

package/dist/util/index.d.ts

@@ -3,6 +3,7 @@ export * from './astUtils';
 export * from './baseTypeUtils';
 export * from './collectUnusedVariables';
 export * from './createRule';
+export * from './FunctionSignature';
 export * from './getBaseTypesOfClassMember';
 export * from './getFixOrSuggest';
 export * from './getFunctionHeadLoc';

package/dist/util/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./astUtils"), exports);
 __exportStar(require("./baseTypeUtils"), exports);
 __exportStar(require("./collectUnusedVariables"), exports);
 __exportStar(require("./createRule"), exports);
+__exportStar(require("./FunctionSignature"), exports);
 __exportStar(require("./getBaseTypesOfClassMember"), exports);
 __exportStar(require("./getFixOrSuggest"), exports);
 __exportStar(require("./getFunctionHeadLoc"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.67.1-alpha.20",
+  "version": "8.67.1-alpha.22",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -47,10 +47,10 @@
   ],
   "dependencies": {
     "@eslint-community/regexpp": "^4.12.2",
-    "@typescript-eslint/scope-manager": "8.67.1-alpha.20",
-    "@typescript-eslint/type-utils": "8.67.1-alpha.20",
-    "@typescript-eslint/utils": "8.67.1-alpha.20",
-    "@typescript-eslint/visitor-keys": "8.67.1-alpha.20",
+    "@typescript-eslint/scope-manager": "8.67.1-alpha.22",
+    "@typescript-eslint/type-utils": "8.67.1-alpha.22",
+    "@typescript-eslint/utils": "8.67.1-alpha.22",
+    "@typescript-eslint/visitor-keys": "8.67.1-alpha.22",
     "ignore": "^7.0.5",
     "natural-compare": "^1.4.0",
     "ts-api-utils": "^2.5.0"
@@ -60,8 +60,8 @@
     "@types/mdast": "^4.0.4",
     "@types/natural-compare": "^1.4.3",
     "@types/react": "^18.3.21",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.67.1-alpha.20",
-    "@typescript-eslint/rule-tester": "8.67.1-alpha.20",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.67.1-alpha.22",
+    "@typescript-eslint/rule-tester": "8.67.1-alpha.22",
     "@typescript/native": "npm:typescript@^7.0.2",
     "@vitest/coverage-v8": "^4.0.18",
     "ajv": "^6.12.6",
@@ -81,7 +81,7 @@
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.67.1-alpha.20",
+    "@typescript-eslint/parser": "^8.67.1-alpha.22",
     "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
     "typescript": ">=4.8.4 <6.1.0"
   },