@typescript-eslint/eslint-plugin 8.48.1-alpha.1 → 8.48.1-alpha.10

package/dist/rules/consistent-type-exports.js

@@ -80,16 +80,18 @@ exports.default = (0, util_1.createRule)({
          * can't be resolved.
          */
         function isSymbolTypeBased(symbol) {
-            while (symbol && symbol.flags & ts.SymbolFlags.Alias) {
-                symbol = checker.getAliasedSymbol(symbol);
-                if (symbol.getDeclarations()?.find(ts.isTypeOnlyImportOrExportDeclaration)) {
-                    return true;
-                }
-            }
             if (!symbol || checker.isUnknownSymbol(symbol)) {
                 return undefined;
             }
-            return !(symbol.flags & ts.SymbolFlags.Value);
+            if (symbol.getDeclarations()?.some(ts.isTypeOnlyImportOrExportDeclaration)) {
+                return true;
+            }
+            if (symbol.flags & ts.SymbolFlags.Value) {
+                return false;
+            }
+            return symbol.flags & ts.SymbolFlags.Alias
+                ? isSymbolTypeBased(checker.getImmediateAliasedSymbol(symbol))
+                : true;
         }
         return {
             ExportAllDeclaration(node) {

package/dist/rules/no-base-to-string.js

@@ -89,7 +89,8 @@ exports.default = (0, util_1.createRule)({
     ],
     create(context, [option]) {
         const services = (0, util_1.getParserServices)(context);
-        const checker = services.program.getTypeChecker();
+        const { program } = services;
+        const checker = program.getTypeChecker();
         const ignoredTypeNames = option.ignoredTypeNames ?? [];
         function checkExpression(node, type) {
             if (node.type === utils_1.AST_NODE_TYPES.Literal) {
@@ -171,22 +172,6 @@ exports.default = (0, util_1.createRule)({
             }
             return Usefulness.Always;
         }
-        function hasBaseTypes(type) {
-            return (tsutils.isObjectType(type) &&
-                tsutils.isObjectFlagSet(type, ts.ObjectFlags.Interface | ts.ObjectFlags.Class));
-        }
-        function isIgnoredTypeOrBase(type, seen = new Set()) {
-            if (seen.has(type)) {
-                return false;
-            }
-            seen.add(type);
-            const typeName = (0, util_1.getTypeName)(checker, type);
-            return (ignoredTypeNames.includes(typeName) ||
-                (hasBaseTypes(type) &&
-                    checker
-                        .getBaseTypes(type)
-                        .some(base => isIgnoredTypeOrBase(base, seen))));
-        }
         function collectToStringCertainty(type, visited) {
             if (visited.has(type)) {
                 // don't report if this is a self referencing array or tuple type
@@ -213,7 +198,7 @@ exports.default = (0, util_1.createRule)({
                 ignoredTypeNames.includes(symbol.name)) {
                 return Usefulness.Always;
             }
-            if (isIgnoredTypeOrBase(type)) {
+            if ((0, util_1.matchesTypeOrBaseType)(services, type => ignoredTypeNames.includes((0, util_1.getTypeName)(checker, type)), type)) {
                 return Usefulness.Always;
             }
             if (type.isIntersection()) {

package/dist/rules/restrict-template-expressions.js

@@ -112,7 +112,7 @@ exports.default = (0, util_1.createRule)({
                 return innerType.types.some(recursivelyCheckType);
             }
             return ((0, util_1.isTypeFlagSet)(innerType, typescript_1.TypeFlags.StringLike) ||
-                (0, type_utils_1.typeMatchesSomeSpecifier)(innerType, allow, program) ||
+                (0, util_1.matchesTypeOrBaseType)(services, type => (0, type_utils_1.typeMatchesSomeSpecifier)(type, allow, program), innerType) ||
                 enabledOptionTesters.some(({ tester }) => tester(innerType, checker, recursivelyCheckType)));
         }
     },

package/dist/util/baseTypeUtils.d.ts

@@ -0,0 +1,13 @@
+import type { ParserServicesWithTypeInformation } from '@typescript-eslint/utils';
+import type { InterfaceType, Type } from 'typescript';
+export declare function hasBaseTypes(type: Type): type is InterfaceType;
+/**
+ * Recursively checks if a type or any of its base types matches the provided
+ * matcher function.
+ * @param services Parser services with type information
+ * @param matcher Function to test if a type matches the desired criteria
+ * @param type The type to check
+ * @param seen Set of already visited types to prevent infinite recursion
+ * @returns `true` if the type or any of its base types match the matcher
+ */
+export declare function matchesTypeOrBaseType(services: ParserServicesWithTypeInformation, matcher: (type: Type) => boolean, type: Type, seen?: Set<Type>): boolean;

package/dist/util/baseTypeUtils.js

@@ -0,0 +1,75 @@
+"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.hasBaseTypes = hasBaseTypes;
+exports.matchesTypeOrBaseType = matchesTypeOrBaseType;
+const ts_api_utils_1 = require("ts-api-utils");
+const tsutils = __importStar(require("ts-api-utils"));
+const ts = __importStar(require("typescript"));
+function getBaseTypesForType(checker, type) {
+    if (!tsutils.isObjectType(type)) {
+        return [];
+    }
+    const interfaceTarget = tsutils.isTypeReference(type) ? type.target : type;
+    const interfaceType = tsutils.isObjectFlagSet(interfaceTarget, ts.ObjectFlags.Interface | ts.ObjectFlags.Class) && interfaceTarget;
+    if (!interfaceType) {
+        return [];
+    }
+    return checker.getBaseTypes(interfaceType);
+}
+function hasBaseTypes(type) {
+    return ((0, ts_api_utils_1.isObjectType)(type) &&
+        (0, ts_api_utils_1.isObjectFlagSet)(type, ts.ObjectFlags.Interface | ts.ObjectFlags.Class));
+}
+/**
+ * Recursively checks if a type or any of its base types matches the provided
+ * matcher function.
+ * @param services Parser services with type information
+ * @param matcher Function to test if a type matches the desired criteria
+ * @param type The type to check
+ * @param seen Set of already visited types to prevent infinite recursion
+ * @returns `true` if the type or any of its base types match the matcher
+ */
+function matchesTypeOrBaseType(services, matcher, type, seen = new Set()) {
+    if (seen.has(type)) {
+        return false;
+    }
+    seen.add(type);
+    if (matcher(type)) {
+        return true;
+    }
+    const checker = services.program.getTypeChecker();
+    return getBaseTypesForType(checker, type).some(base => matchesTypeOrBaseType(services, matcher, base, seen));
+}

package/dist/util/index.d.ts

@@ -1,5 +1,6 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
 export * from './astUtils';
+export * from './baseTypeUtils';
 export * from './collectUnusedVariables';
 export * from './createRule';
 export * from './getFixOrSuggest';

package/dist/util/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NullThrowsReasons = exports.nullThrows = exports.isObjectNotArray = exports.getParserServices = exports.deepMerge = exports.applyDefault = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 __exportStar(require("./astUtils"), exports);
+__exportStar(require("./baseTypeUtils"), exports);
 __exportStar(require("./collectUnusedVariables"), exports);
 __exportStar(require("./createRule"), exports);
 __exportStar(require("./getFixOrSuggest"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.48.1-alpha.1",
+  "version": "8.48.1-alpha.10",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -59,10 +59,10 @@
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.48.1-alpha.1",
-    "@typescript-eslint/type-utils": "8.48.1-alpha.1",
-    "@typescript-eslint/utils": "8.48.1-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.48.1-alpha.1",
+    "@typescript-eslint/scope-manager": "8.48.1-alpha.10",
+    "@typescript-eslint/type-utils": "8.48.1-alpha.10",
+    "@typescript-eslint/utils": "8.48.1-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.48.1-alpha.10",
     "graphemer": "^1.4.0",
     "ignore": "^7.0.0",
     "natural-compare": "^1.4.0",
@@ -71,8 +71,8 @@
   "devDependencies": {
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.48.1-alpha.1",
-    "@typescript-eslint/rule-tester": "8.48.1-alpha.1",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.48.1-alpha.10",
+    "@typescript-eslint/rule-tester": "8.48.1-alpha.10",
     "@vitest/coverage-v8": "^3.1.3",
     "ajv": "^6.12.6",
     "cross-fetch": "*",
@@ -92,7 +92,7 @@
     "vitest": "^3.1.3"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^8.48.1-alpha.1",
+    "@typescript-eslint/parser": "^8.48.1-alpha.10",
     "eslint": "^8.57.0 || ^9.0.0",
     "typescript": ">=4.8.4 <6.0.0"
   },