@taiga-ui/eslint-plugin-experience-next 0.455.0 → 0.457.0

package/README.md

@@ -49,6 +49,7 @@ export default [
 | no-href-with-router-link            | Do not use href and routerLink attributes together on the same element                              |     | 🔧  |     |
 | no-implicit-public                  | Require explicit `public` modifier for class members and parameter properties                       | ✅  | 🔧  |     |
 | no-playwright-empty-fill            | Enforce `clear()` over `fill('')` in Playwright tests                                               | ✅  | 🔧  |     |
+| no-redundant-type-annotation        | Disallow redundant type annotations when the type is already inferred from the initializer          | ✅  | 🔧  |     |
 | no-string-literal-concat            | Disallow string literal concatenation; merge adjacent literals into one                             | ✅  | 🔧  |     |
 | object-single-line                  | Enforce single-line formatting for single-property objects when it fits `printWidth`                | ✅  | 🔧  |     |
 | prefer-deep-imports                 | Allow deep imports of Taiga UI packages                                                             |     | 🔧  |     |
@@ -501,6 +502,42 @@ Spread elements are placed after named identifiers.
 
 ---
 
+## no-redundant-type-annotation
+
+Disallow explicit type annotations on class properties and variable declarations when TypeScript can already infer the
+same type from the initializer. Requires type information (`parserOptions.project`).
+
+Works well in combination with `unused-imports/no-unused-imports` or `@typescript-eslint/no-unused-vars`, which will
+then clean up any import that is no longer referenced after the annotation is removed.
+
+```ts
+// ❌ error — type is already inferred from inject()
+private readonly options: TuiInputNumberOptions = inject(TUI_INPUT_NUMBER_OPTIONS);
+
+// ✅ after autofix
+private readonly options = inject(TUI_INPUT_NUMBER_OPTIONS);
+```
+
+```ts
+// ❌ error — variable declaration
+const service: MyService = inject(MyService);
+
+// ✅ after autofix
+const service = inject(MyService);
+```
+
+The rule does **not** report when the annotation intentionally widens or changes the type:
+
+```ts
+// ✅ ok — annotation widens Dog to Animal
+x: Animal = new Dog();
+
+// ✅ ok — annotation adds null to the union
+x: MyService | null = inject(MyService);
+```
+
+---
+
 ## strict-tui-doc-example
 
 Validates that properties of a `TuiDocExample`-typed object have keys matching known file-type names (`TypeScript`,

package/index.d.ts

@@ -40,6 +40,9 @@ declare const plugin: {
         'no-playwright-empty-fill': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useClear", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
+        'no-redundant-type-annotation': import("@typescript-eslint/utils/ts-eslint").RuleModule<"redundantTypeAnnotation", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'no-string-literal-concat': import("@typescript-eslint/utils/ts-eslint").RuleModule<"flattenTemplate" | "mergeLiterals" | "useTemplate", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

package/index.esm.js

@@ -29,7 +29,7 @@ import tseslint from 'typescript-eslint';
 import { createRequire } from 'node:module';
 import { globSync } from 'glob';
 import { ESLintUtils, AST_NODE_TYPES } from '@typescript-eslint/utils';
-import ts from 'typescript';
+import ts, { isCallExpression } from 'typescript';
 import { AST_NODE_TYPES as AST_NODE_TYPES$1 } from '@typescript-eslint/types';
 import path from 'node:path';
 
@@ -916,6 +916,7 @@ var recommended = defineConfig([
             ],
             '@taiga-ui/experience-next/no-deep-imports-to-indexed-packages': 'error',
             '@taiga-ui/experience-next/no-implicit-public': 'error',
+            '@taiga-ui/experience-next/no-redundant-type-annotation': 'error',
             '@taiga-ui/experience-next/object-single-line': ['error', { printWidth: 90 }],
             '@taiga-ui/experience-next/prefer-multi-arg-push': 'error',
             '@taiga-ui/experience-next/short-tui-imports': 'error',
@@ -1329,8 +1330,8 @@ function intersect(a, b) {
     return a.some((type) => origin.has(type));
 }
 
-const createRule$d = ESLintUtils.RuleCreator((name) => name);
-var classPropertyNaming = createRule$d({
+const createRule$e = ESLintUtils.RuleCreator((name) => name);
+var classPropertyNaming = createRule$e({
     create(context, [configs]) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1499,9 +1500,9 @@ function isExternalPureTuple(typeChecker, type) {
     return typeArgs.every((item) => isClassType(item));
 }
 
-const createRule$c = ESLintUtils.RuleCreator((name) => name);
+const createRule$d = ESLintUtils.RuleCreator((name) => name);
 const MESSAGE_ID$5 = 'spreadArrays';
-var flatExports = createRule$c({
+var flatExports = createRule$d({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1627,8 +1628,8 @@ var flatExports = createRule$c({
 
 const MESSAGE_ID$4 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
-const createRule$b = ESLintUtils.RuleCreator((name) => name);
-const rule$8 = createRule$b({
+const createRule$c = ESLintUtils.RuleCreator((name) => name);
+const rule$9 = createRule$c({
     create(context) {
         return {
             'NewExpression[callee.name="InjectionToken"]'(node) {
@@ -1695,8 +1696,8 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const createRule$a = ESLintUtils.RuleCreator((name) => name);
-const rule$7 = createRule$a({
+const createRule$b = ESLintUtils.RuleCreator((name) => name);
+const rule$8 = createRule$b({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -1783,13 +1784,13 @@ const rule$7 = createRule$a({
     name: 'no-deep-imports',
 });
 
-const createRule$9 = ESLintUtils.RuleCreator((name) => name);
+const createRule$a = ESLintUtils.RuleCreator((name) => name);
 const resolveCacheByOptions = new WeakMap();
 const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-var noDeepImportsToIndexedPackages = createRule$9({
+var noDeepImportsToIndexedPackages = createRule$a({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -2031,8 +2032,8 @@ const config = {
     },
 };
 
-const createRule$8 = ESLintUtils.RuleCreator((name) => name);
-const rule$6 = createRule$8({
+const createRule$9 = ESLintUtils.RuleCreator((name) => name);
+const rule$7 = createRule$9({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getClass(node);
@@ -2103,8 +2104,8 @@ function getClass(node) {
     return getClass(node.parent);
 }
 
-const createRule$7 = ESLintUtils.RuleCreator((name) => name);
-const rule$5 = createRule$7({
+const createRule$8 = ESLintUtils.RuleCreator((name) => name);
+const rule$6 = createRule$8({
     create(context) {
         const services = ESLintUtils.getParserServices(context);
         const checker = services.program.getTypeChecker();
@@ -2191,6 +2192,68 @@ function isPlaywrightLocatorType(type) {
     });
 }
 
+const createRule$7 = ESLintUtils.RuleCreator((name) => name);
+const rule$5 = createRule$7({
+    create(context) {
+        const parserServices = ESLintUtils.getParserServices(context);
+        const typeChecker = parserServices.program.getTypeChecker();
+        function check(node, typeAnnotation, value) {
+            if (!typeAnnotation || !value) {
+                return;
+            }
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const tsValueNode = parserServices.esTreeNodeToTSNodeMap.get(value);
+            const declaredType = typeChecker.getTypeAtLocation(tsNode);
+            const inferredType = typeChecker.getTypeAtLocation(tsValueNode);
+            if (typeChecker.typeToString(declaredType) !==
+                typeChecker.typeToString(inferredType)) {
+                return;
+            }
+            // If the initializer is a call to a generic function with no explicit
+            // type arguments, the type parameters may be inferred from the
+            // contextual return type provided by this annotation. Removing the
+            // annotation could change the inferred type (e.g., T → unknown).
+            if (isCallExpression(tsValueNode) && !tsValueNode.typeArguments?.length) {
+                const sig = typeChecker.getResolvedSignature(tsValueNode);
+                const decl = sig?.declaration;
+                if (decl && 'typeParameters' in decl && decl.typeParameters?.length) {
+                    return;
+                }
+            }
+            context.report({
+                fix(fixer) {
+                    return fixer.remove(typeAnnotation);
+                },
+                messageId: 'redundantTypeAnnotation',
+                node: typeAnnotation,
+            });
+        }
+        return {
+            PropertyDefinition(node) {
+                check(node, node.typeAnnotation, node.value);
+            },
+            VariableDeclarator(node) {
+                if (node.id.type !== AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                check(node, node.id.typeAnnotation, node.init);
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow redundant type annotations when the type is already inferred from the initializer',
+        },
+        fixable: 'code',
+        messages: {
+            redundantTypeAnnotation: 'Type annotation is redundant — the type is already inferred from the initializer',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'no-redundant-type-annotation',
+});
+
 const createRule$6 = ESLintUtils.RuleCreator((name) => name);
 function isStringLiteral(node) {
     return (node.type === AST_NODE_TYPES.Literal &&
@@ -3552,12 +3615,13 @@ const plugin = {
         'class-property-naming': classPropertyNaming,
         'decorator-key-sort': config$1,
         'flat-exports': flatExports,
-        'injection-token-description': rule$8,
-        'no-deep-imports': rule$7,
+        'injection-token-description': rule$9,
+        'no-deep-imports': rule$8,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,
         'no-href-with-router-link': config,
-        'no-implicit-public': rule$6,
-        'no-playwright-empty-fill': rule$5,
+        'no-implicit-public': rule$7,
+        'no-playwright-empty-fill': rule$6,
+        'no-redundant-type-annotation': rule$5,
         'no-string-literal-concat': rule$4,
         'object-single-line': rule$3,
         'prefer-deep-imports': preferDeepImports,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.455.0",
+  "version": "0.457.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "repository": {
     "type": "git",

package/rules/no-redundant-type-annotation.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const rule: ESLintUtils.RuleModule<"redundantTypeAnnotation", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default rule;

package/rules/short-tui-imports.d.ts

@@ -10,7 +10,7 @@ export type Options = [
     }
 ];
 export type MessageIds = 'replaceTuiImport';
-export declare const MESSAGE_ID: MessageIds;
+export declare const MESSAGE_ID = "replaceTuiImport";
 export declare const rule: ESLintUtils.RuleModule<"replaceTuiImport", Options, unknown, ESLintUtils.RuleListener> & {
     name: string;
 };