@taiga-ui/eslint-plugin-experience-next 0.538.0 → 0.540.0

package/README.md

@@ -104,6 +104,7 @@ from third-party plugins. The exact severities and file globs live in
 | [no-playwright-empty-fill](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-playwright-empty-fill.md)                                               | Enforce `clear()` over `fill('')` in Playwright tests                                                           | ✅  | 🔧  |     |
 | [no-project-as-in-ng-template](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-project-as-in-ng-template.md)                                       | `ngProjectAs` has no effect inside `<ng-template>` or dynamic outlets                                           | ✅  |     |     |
 | [no-restricted-attr-values](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-restricted-attr-values.md)                                             | Disallow configured attribute values in Angular templates                                                       |     |     |     |
+| [no-redundant-fs-encoding](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-redundant-fs-encoding.md)                                               | Remove redundant default utf8 encoding from Node.js file write calls                                            | ✅  | 🔧  |     |
 | [no-redundant-type-annotation](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-redundant-type-annotation.md)                                       | Disallow redundant type annotations when the type is already inferred from the initializer                      | ✅  | 🔧  |     |
 | [no-repeated-signal-in-conditional](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-repeated-signal-in-conditional.md)                             | Disallow reading the same nullable Angular signal more than once in a conditional expression                    | ✅  | 🔧  |     |
 | [no-side-effects-in-computed](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/no-side-effects-in-computed.md)                                         | Disallow side effects and effectful helper calls inside Angular `computed()` callbacks                          | ✅  |     |     |

package/configs/utils/get-default-parser-options.d.ts

@@ -0,0 +1 @@
+export declare function getDefaultParserOptions(): Record<string, unknown>;

package/index.d.ts

@@ -123,6 +123,9 @@ declare const plugin: {
         'no-project-as-in-ng-template': import("eslint").Rule.RuleModule & {
             name: string;
         };
+        'no-redundant-fs-encoding': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noRedundantFsEncoding", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'no-redundant-type-annotation': import("@typescript-eslint/utils/ts-eslint").RuleModule<"redundantTypeAnnotation", [({
             ignoreTupleContextualTyping?: boolean;
         } | undefined)?], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {

package/index.esm.js

@@ -599,9 +599,33 @@ var npmrcParser = /*#__PURE__*/Object.freeze({
 });
 
 const require$2 = createRequire(import.meta.url);
+function projectJsonExist(filename) {
+    try {
+        const path = require$2('node:path').resolve(filename);
+        return require$2('node:fs').existsSync(path) ? path : '';
+    }
+    catch {
+        return '';
+    }
+}
+
+function getDefaultParserOptions() {
+    const tsconfig = projectJsonExist('tsconfig.eslint.json');
+    if (tsconfig) {
+        return { project: [tsconfig] };
+    }
+    return projectJsonExist('tsconfig.json')
+        ? {
+            projectService: true,
+            tsconfigRootDir: process.cwd(),
+        }
+        : { projectService: false };
+}
+
+const require$1 = createRequire(import.meta.url);
 function getAngularVersion() {
     try {
-        const { major } = require$2('@angular/cli').VERSION;
+        const { major } = require$1('@angular/cli').VERSION;
         return Number.parseInt(major, 10);
     }
     catch {
@@ -618,25 +642,7 @@ const modernAngularRules = {
     templateLiteral: 19,
 };
 
-const require$1 = createRequire(import.meta.url);
-function projectJsonExist(filename) {
-    try {
-        const path = require$1('node:path').resolve(filename);
-        return require$1('node:fs').existsSync(path) ? path : '';
-    }
-    catch {
-        return '';
-    }
-}
-
 const ALL_TS_JS_FILES = ['**/*.{js,mjs,ts,cjs,tsx,jsx}'];
-const tsconfig = projectJsonExist('tsconfig.eslint.json');
-const parserOptions$1 = tsconfig
-    ? { project: [tsconfig] }
-    : {
-        projectService: true,
-        tsconfigRootDir: process.cwd(),
-    };
 var recommended = defineConfig([
     progress.configs['recommended-ci'],
     {
@@ -698,7 +704,7 @@ var recommended = defineConfig([
                 errorOnUnknownASTType: true,
                 sourceType: 'module',
                 warnOnUnsupportedTypeScriptVersion: false,
-                ...parserOptions$1,
+                ...getDefaultParserOptions(),
             },
         },
         settings: {
@@ -931,6 +937,7 @@ var recommended = defineConfig([
             '@typescript-eslint/prefer-destructuring': 'off',
             '@typescript-eslint/prefer-find': 'error',
             '@typescript-eslint/prefer-for-of': 'error',
+            '@typescript-eslint/prefer-function-type': 'off',
             '@typescript-eslint/prefer-includes': 'error',
             '@typescript-eslint/prefer-nullish-coalescing': 'off', // TODO: ['error', {ignorePrimitives: {boolean: true, number: true, string: true}}]
             '@typescript-eslint/prefer-optional-chain': 'error',
@@ -1319,6 +1326,7 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-implicit-public': 'error',
             '@taiga-ui/experience-next/no-import-assertions': 'error',
             '@taiga-ui/experience-next/no-infinite-loop': 'error',
+            '@taiga-ui/experience-next/no-redundant-fs-encoding': 'error',
             '@taiga-ui/experience-next/no-redundant-type-annotation': 'error',
             '@taiga-ui/experience-next/no-repeated-signal-in-conditional': 'error',
             '@taiga-ui/experience-next/no-side-effects-in-computed': 'error',
@@ -15661,7 +15669,7 @@ function getLastIndexFix(fixer, sourceCode, node, call) {
     }
     return null;
 }
-const rule$Y = createRule({
+const rule$Z = createRule({
     create(context) {
         const typeAwareContext = getTypeAwareRuleContext(context);
         const compilerOptions = typeAwareContext.tsProgram.getCompilerOptions();
@@ -47467,7 +47475,7 @@ function buildMultilineStartTag(node, sourceText) {
         closing,
     ].join(lineBreak);
 }
-const rule$X = createRule({
+const rule$Y = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -47553,7 +47561,7 @@ const rule$X = createRule({
     },
 });
 
-const rule$W = createRule({
+const rule$X = createRule({
     create(context) {
         const sourceCode = context.sourceCode;
         return {
@@ -47656,7 +47664,7 @@ function sameOrder(a, b) {
     return a.length === b.length && a.every((value, index) => value === b[index]);
 }
 
-const rule$V = createRule({
+const rule$W = createRule({
     create(context, [order]) {
         const decorators = new Set(Object.keys(order));
         return {
@@ -47792,7 +47800,7 @@ function getNodeLabel(node) {
     }
     return node instanceof dist.TmplAstBoundText ? 'binding' : 'text';
 }
-const rule$U = createRule({
+const rule$V = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
@@ -47932,7 +47940,7 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const rule$T = createRule({
+const rule$U = createRule({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -48263,7 +48271,7 @@ const config$4 = {
         type: 'suggestion',
     },
 };
-const rule$S = createRule({
+const rule$T = createRule({
     name: 'html-logical-properties',
     rule: config$4,
 });
@@ -48841,7 +48849,7 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     }
     return hasSafeRuntimeUsage;
 }
-const rule$R = createRule({
+const rule$S = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode, tsProgram } = getTypeAwareRuleContext(context);
         const checkCycles = context.options[0]?.checkCycles ?? true;
@@ -49563,7 +49571,7 @@ function getNgDevModeDeclarationFix(program, fixer, sourceCode) {
         ? fixer.insertTextBefore(firstStatement, `declare const ngDevMode: boolean;${lineBreak}${lineBreak}`)
         : fixer.insertTextBeforeRange([0, 0], `declare const ngDevMode: boolean;${lineBreak}`);
 }
-const rule$Q = createRule({
+const rule$R = createRule({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -49612,7 +49620,7 @@ const rule$Q = createRule({
     name: 'injection-token-description',
 });
 
-const rule$P = createRule({
+const rule$Q = createRule({
     create(context) {
         const { sourceCode } = context;
         const namespaceImports = new Map();
@@ -49707,7 +49715,7 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const rule$O = createRule({
+const rule$P = createRule({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -49799,7 +49807,7 @@ const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-const rule$N = createRule({
+const rule$O = createRule({
     create(context) {
         const parserServices = dist$4.ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -49993,13 +50001,13 @@ const noDuplicateAttributesRule = angular.templatePlugin.rules?.['no-duplicate-a
 if (!noDuplicateAttributesRule) {
     throw new Error('angular-eslint template rule "no-duplicate-attributes" is not available');
 }
-const rule$M = createRule({
+const rule$N = createRule({
     name: 'no-duplicate-attrs',
     rule: noDuplicateAttributesRule,
 });
 
 const MESSAGE_ID$e = 'duplicateId';
-const rule$L = createRule({
+const rule$M = createRule({
     name: 'no-duplicate-id',
     rule: {
         create(context) {
@@ -50057,7 +50065,7 @@ function getTrackingKey(node) {
         ? 'link[rel=canonical]'
         : null;
 }
-const rule$K = createRule({
+const rule$L = createRule({
     name: 'no-duplicate-in-head',
     rule: {
         create(context) {
@@ -50113,7 +50121,7 @@ const rule$K = createRule({
 });
 
 const COMPONENT_DECORATORS = new Set(['Component']);
-const rule$J = createRule({
+const rule$K = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -50592,7 +50600,7 @@ const ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL = 'https://angular.dev/guide/signals#r
 const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#reactive-context-and-async-operations';
 const createUntrackedRule = createRule;
 
-const rule$I = createUntrackedRule({
+const rule$J = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -50665,7 +50673,7 @@ const config$3 = {
         type: 'problem',
     },
 };
-const rule$H = createRule({
+const rule$I = createRule({
     name: 'no-href-with-router-link',
     rule: config$3,
 });
@@ -50716,7 +50724,7 @@ function getPublicModifierInsertion(options) {
         text: 'public ',
     };
 }
-const rule$G = createRule({
+const rule$H = createRule({
     create(context) {
         const sourceCode = context.sourceCode;
         const checkImplicitPublic = (node) => {
@@ -50770,7 +50778,7 @@ const rule$G = createRule({
     name: 'no-implicit-public',
 });
 
-const rule$F = createRule({
+const rule$G = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -50810,7 +50818,7 @@ function isInfiniteLoopLiteral(node) {
 function isInfiniteLoopTest(test) {
     return test == null || isInfiniteLoopLiteral(test);
 }
-const rule$E = createRule({
+const rule$F = createRule({
     create(context) {
         return {
             DoWhileStatement(node) {
@@ -50855,7 +50863,7 @@ const rule$E = createRule({
 });
 
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$D = createRule({
+const rule$E = createRule({
     create(context) {
         return {
             Program(node) {
@@ -50947,7 +50955,7 @@ function getAvailableLabelParent(stack, node, labelsWithControl) {
         ? parent
         : null;
 }
-const rule$C = createRule({
+const rule$D = createRule({
     name: 'no-nested-interactive',
     rule: {
         create(context) {
@@ -51168,7 +51176,7 @@ function createLetFixes(node, baseName, unavailableNames, text) {
         reference: name,
     };
 }
-const rule$B = createRule({
+const rule$C = createRule({
     name: 'no-nested-ternary-in-template',
     rule: {
         create(context) {
@@ -51706,7 +51714,7 @@ const OBSOLETE_HTML_ATTRS = {
 };
 
 const MESSAGE_ID$9 = 'obsolete';
-const rule$A = createRule({
+const rule$B = createRule({
     name: 'no-obsolete-attrs',
     rule: {
         create(context) {
@@ -51784,7 +51792,7 @@ const OBSOLETE_HTML_TAGS = new Set([
 ]);
 
 const MESSAGE_ID$8 = 'unexpected';
-const rule$z = createRule({
+const rule$A = createRule({
     name: 'no-obsolete-tags',
     rule: {
         create(context) {
@@ -51811,7 +51819,7 @@ const rule$z = createRule({
     },
 });
 
-const rule$y = createRule({
+const rule$z = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         return {
@@ -51955,11 +51963,175 @@ const config$2 = {
         type: 'problem',
     },
 };
-const rule$x = createRule({
+const rule$y = createRule({
     name: 'no-project-as-in-ng-template',
     rule: config$2,
 });
 
+function getCommaAfter(sourceCode, node) {
+    const token = sourceCode.getTokenAfter(node);
+    return token?.value === ',' ? token : null;
+}
+function getCommaBefore(sourceCode, node) {
+    const token = sourceCode.getTokenBefore(node);
+    return token?.value === ',' ? token : null;
+}
+function removeStandaloneLine(sourceCode, fixer, node) {
+    const lineStart = getLineStartOffset(sourceCode.text, node.range[0]);
+    const nextLineStart = getNextLineStartOffset(sourceCode.text, node.range[1]);
+    return fixer.removeRange([lineStart, nextLineStart]);
+}
+function isStandaloneListItem(node, previousNode, nextNode) {
+    const startsOwnLine = previousNode === null || previousNode.loc.end.line < node.loc.start.line;
+    const endsOwnLine = nextNode === null || nextNode.loc.start.line > node.loc.end.line;
+    return startsOwnLine && endsOwnLine;
+}
+function removeCommaSeparatedNode(sourceCode, fixer, node, previousNode, nextNode) {
+    if (isStandaloneListItem(node, previousNode, nextNode)) {
+        return removeStandaloneLine(sourceCode, fixer, node);
+    }
+    const commaAfter = getCommaAfter(sourceCode, node);
+    if (nextNode && commaAfter) {
+        return fixer.removeRange([node.range[0], nextNode.range[0]]);
+    }
+    const commaBefore = getCommaBefore(sourceCode, node);
+    if (commaBefore) {
+        return fixer.removeRange([
+            commaBefore.range[0],
+            commaAfter?.range[1] ?? node.range[1],
+        ]);
+    }
+    return commaAfter ? fixer.removeRange([node.range[0], commaAfter.range[1]]) : null;
+}
+
+const WRITE_METHODS = new Set([
+    'appendFile',
+    'appendFileSync',
+    'writeFile',
+    'writeFileSync',
+]);
+const FS_NAMESPACE_NAMES = new Set(['fs', 'fsPromises']);
+function isWriteMethod(name) {
+    return name !== null && WRITE_METHODS.has(name);
+}
+function isFsNamespaceObject(node) {
+    if (node.type === dist$4.AST_NODE_TYPES.Identifier) {
+        return FS_NAMESPACE_NAMES.has(node.name);
+    }
+    if (node.type !== dist$4.AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const isFsPromisesNamespace = node.object.type === dist$4.AST_NODE_TYPES.Identifier &&
+        node.object.name === 'fs' &&
+        getMemberExpressionPropertyName(node) === 'promises';
+    return isFsPromisesNamespace;
+}
+function getWriteMethodName(callee) {
+    if (callee.type === dist$4.AST_NODE_TYPES.Identifier) {
+        return callee.name;
+    }
+    return callee.type === dist$4.AST_NODE_TYPES.MemberExpression &&
+        isFsNamespaceObject(callee.object)
+        ? getMemberExpressionPropertyName(callee)
+        : null;
+}
+function isRedundantUtf8Encoding(node) {
+    const value = getStaticStringValue(node);
+    if (value === null) {
+        return false;
+    }
+    const normalizedValue = value.toLowerCase();
+    return normalizedValue === 'utf8' || normalizedValue === 'utf-8';
+}
+function hasSpreadProperty(node) {
+    return node.properties.some((property) => property.type === dist$4.AST_NODE_TYPES.SpreadElement);
+}
+function findRedundantEncodingProperty(node) {
+    if (hasSpreadProperty(node)) {
+        return null;
+    }
+    const encodingProperties = node.properties.filter((property) => property.type === dist$4.AST_NODE_TYPES.Property &&
+        getObjectPropertyName(property) === 'encoding');
+    if (encodingProperties.length !== 1) {
+        return null;
+    }
+    const encodingProperty = encodingProperties[0];
+    return encodingProperty && isRedundantUtf8Encoding(encodingProperty.value)
+        ? encodingProperty
+        : null;
+}
+function getObjectPropertyFix(sourceCode, fixer, objectExpression, property) {
+    const propertyIndex = objectExpression.properties.indexOf(property);
+    const previousProperty = objectExpression.properties[propertyIndex - 1] ?? null;
+    const nextProperty = objectExpression.properties[propertyIndex + 1] ?? null;
+    return removeCommaSeparatedNode(sourceCode, fixer, property, previousProperty, nextProperty);
+}
+function getOptionsArgumentFix(sourceCode, fixer, callExpression, options) {
+    const argumentIndex = callExpression.arguments.indexOf(options);
+    const previousArgument = callExpression.arguments[argumentIndex - 1] ?? null;
+    const nextArgument = callExpression.arguments[argumentIndex + 1] ?? null;
+    return removeCommaSeparatedNode(sourceCode, fixer, options, previousArgument, nextArgument);
+}
+const rule$x = createRule({
+    create(context) {
+        const { sourceCode } = context;
+        function reportRedundantEncodingArgument(callExpression, encodingArgument) {
+            context.report({
+                fix(fixer) {
+                    return getOptionsArgumentFix(sourceCode, fixer, callExpression, encodingArgument);
+                },
+                messageId: 'noRedundantFsEncoding',
+                node: encodingArgument,
+            });
+        }
+        function reportRedundantEncodingProperty(callExpression, options, encodingProperty) {
+            context.report({
+                fix(fixer) {
+                    const hasOnlyEncodingProperty = options.properties.length === 1;
+                    return hasOnlyEncodingProperty
+                        ? getOptionsArgumentFix(sourceCode, fixer, callExpression, options)
+                        : getObjectPropertyFix(sourceCode, fixer, options, encodingProperty);
+                },
+                messageId: 'noRedundantFsEncoding',
+                node: encodingProperty,
+            });
+        }
+        return {
+            CallExpression(node) {
+                if (!isWriteMethod(getWriteMethodName(node.callee))) {
+                    return;
+                }
+                const options = node.arguments[2];
+                if (!options || options.type === dist$4.AST_NODE_TYPES.SpreadElement) {
+                    return;
+                }
+                if (options.type !== dist$4.AST_NODE_TYPES.ObjectExpression) {
+                    if (isRedundantUtf8Encoding(options)) {
+                        reportRedundantEncodingArgument(node, options);
+                    }
+                    return;
+                }
+                const encodingProperty = findRedundantEncodingProperty(options);
+                if (encodingProperty) {
+                    reportRedundantEncodingProperty(node, options, encodingProperty);
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow redundant default utf8 encoding in Node.js file write calls.',
+        },
+        fixable: 'code',
+        messages: {
+            noRedundantFsEncoding: 'Remove redundant utf8 encoding. Node.js file write methods use utf8 by default for string data.',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'no-redundant-fs-encoding',
+});
+
 function collectArrayExpressions(node) {
     const result = [];
     if (node.type === dist$4.AST_NODE_TYPES.ArrayExpression) {
@@ -56434,36 +56606,37 @@ const plugin = {
     },
     rules: {
         'array-as-const': rule$5,
-        'at-compat': rule$Y,
-        'attrs-newline': rule$X,
-        'class-accessibility-spacing': rule$W,
+        'at-compat': rule$Z,
+        'attrs-newline': rule$Y,
+        'class-accessibility-spacing': rule$X,
         'class-property-naming': rule$4,
-        'decorator-key-sort': rule$V,
-        'element-newline': rule$U,
+        'decorator-key-sort': rule$W,
+        'element-newline': rule$V,
         'flat-exports': rule$3,
-        'host-attributes-sort': rule$T,
-        'html-logical-properties': rule$S,
-        'import-integrity': rule$R,
-        'injection-token-description': rule$Q,
-        'no-commonjs-import-patterns': rule$P,
-        'no-deep-imports': rule$O,
-        'no-deep-imports-to-indexed-packages': rule$N,
-        'no-duplicate-attrs': rule$M,
-        'no-duplicate-id': rule$L,
-        'no-duplicate-in-head': rule$K,
-        'no-empty-style-metadata': rule$J,
-        'no-fully-untracked-effect': rule$I,
-        'no-href-with-router-link': rule$H,
-        'no-implicit-public': rule$G,
-        'no-import-assertions': rule$F,
-        'no-infinite-loop': rule$E,
-        'no-legacy-peer-deps': rule$D,
-        'no-nested-interactive': rule$C,
-        'no-nested-ternary-in-template': rule$B,
-        'no-obsolete-attrs': rule$A,
-        'no-obsolete-tags': rule$z,
-        'no-playwright-empty-fill': rule$y,
-        'no-project-as-in-ng-template': rule$x,
+        'host-attributes-sort': rule$U,
+        'html-logical-properties': rule$T,
+        'import-integrity': rule$S,
+        'injection-token-description': rule$R,
+        'no-commonjs-import-patterns': rule$Q,
+        'no-deep-imports': rule$P,
+        'no-deep-imports-to-indexed-packages': rule$O,
+        'no-duplicate-attrs': rule$N,
+        'no-duplicate-id': rule$M,
+        'no-duplicate-in-head': rule$L,
+        'no-empty-style-metadata': rule$K,
+        'no-fully-untracked-effect': rule$J,
+        'no-href-with-router-link': rule$I,
+        'no-implicit-public': rule$H,
+        'no-import-assertions': rule$G,
+        'no-infinite-loop': rule$F,
+        'no-legacy-peer-deps': rule$E,
+        'no-nested-interactive': rule$D,
+        'no-nested-ternary-in-template': rule$C,
+        'no-obsolete-attrs': rule$B,
+        'no-obsolete-tags': rule$A,
+        'no-playwright-empty-fill': rule$z,
+        'no-project-as-in-ng-template': rule$y,
+        'no-redundant-fs-encoding': rule$x,
         'no-redundant-type-annotation': rule$w,
         'no-repeated-signal-in-conditional': rule$v,
         'no-restricted-attr-values': rule$2,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.538.0",
+  "version": "0.540.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "homepage": "https://github.com/taiga-family/toolkit#readme",
   "bugs": {

package/rules/recommended/no-redundant-fs-encoding.d.ts

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

package/rules/utils/ast/comma-separated.d.ts

@@ -0,0 +1,3 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+export type CommaSeparatedNode = TSESTree.Expression | TSESTree.Property | TSESTree.SpreadElement;
+export declare function removeCommaSeparatedNode(sourceCode: Readonly<TSESLint.SourceCode>, fixer: TSESLint.RuleFixer, node: CommaSeparatedNode, previousNode: CommaSeparatedNode | null, nextNode: CommaSeparatedNode | null): TSESLint.RuleFix | null;