@taiga-ui/eslint-plugin-experience-next 0.451.0 → 0.452.0

package/README.md

@@ -323,8 +323,51 @@ const c = a + b;
 const c = `${a}${b}`;
 ```
 
+When the concatenation is a **direct expression inside a template literal**, the parts are inlined into the outer
+template instead of producing a nested template literal:
+
+```ts
+// ❌ error
+const url = `${base}${path + query}`;
+
+// ✅ after autofix — inlined, no nesting
+const url = `${base}${path}${query}`;
+```
+
+```ts
+// ❌ error — literal concat inside template
+const mask = `${'HH' + ':MM'}`;
+
+// ✅ after autofix
+const mask = `HH:MM`;
+```
+
+When the concatenation appears **inside a method call or other expression** within a template literal, the rule skips it
+to avoid creating unreadable nested template literals like `` `${`${a}${b}`.method()}` ``.
+
+The rule also **flattens already-nested template literals** produced by earlier autofixes or written by hand:
+
+```ts
+// ❌ error
+const s = `${`${dateMode}${dateTimeSeparator}`}HH:MM`;
+
+// ✅ after autofix
+const s = `${dateMode}${dateTimeSeparator}HH:MM`;
+```
+
+Concatenation that uses **inline comments between parts** is intentionally left untouched, as the comments serve as
+documentation:
+
+```ts
+// ✅ not flagged — comments are preserved
+const urlRegex =
+  String.raw`^([a-zA-Z]+:\/\/)?` + // protocol
+  String.raw`([\w-]+\.)+[\w]{2,}` + // domain
+  String.raw`(\/\S*)?$`; // path
+```
+
 > For mixed concatenation (`'prefix' + variable`) use the standard `prefer-template` rule, which is already enabled in
-> `recommended`. Template literals (`` `foo` + `bar` ``) are not flagged by this rule.
+> `recommended`. Template literals (`` `foo` + `bar` ``) and tagged templates are not flagged by this rule.
 
 ---
 

package/index.d.ts

@@ -40,7 +40,7 @@ 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-string-literal-concat': import("@typescript-eslint/utils/ts-eslint").RuleModule<"mergeLiterals" | "useTemplate", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'no-string-literal-concat': import("@typescript-eslint/utils/ts-eslint").RuleModule<"flattenTemplate" | "mergeLiterals" | "useTemplate", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         'object-single-line': import("@typescript-eslint/utils/ts-eslint").RuleModule<"oneLine", [{

package/index.esm.js

@@ -2180,7 +2180,7 @@ function isPlaywrightLocatorType(type) {
 }
 
 const createRule$6 = ESLintUtils.RuleCreator((name) => name);
-function isStringLiteralNode(node) {
+function isStringLiteral(node) {
     return (node.type === AST_NODE_TYPES.Literal &&
         typeof node.value === 'string');
 }
@@ -2212,19 +2212,36 @@ function buildMergedString(parts) {
         .replaceAll(new RegExp(quote, 'g'), `\\${quote}`);
     return `${quote}${escaped}${quote}`;
 }
-function buildTemplateLiteral(parts, getText) {
-    const inner = parts
-        .map((part) => {
-        if (isStringLiteralNode(part)) {
-            return part.value
-                .replaceAll('\\', '\\\\')
-                .replaceAll('`', '\\`')
-                .replaceAll('${', '\\${');
-        }
-        return `\${${getText(part)}}`;
-    })
+function escapeForTemplateLiteral(value) {
+    return value.replaceAll('\\', '\\\\').replaceAll('`', '\\`').replaceAll('${', '\\${');
+}
+function partsToTemplateContent(parts, getText) {
+    return parts
+        .map((part) => isStringLiteral(part)
+        ? escapeForTemplateLiteral(part.value)
+        : `\${${getText(part)}}`)
+        .join('');
+}
+/**
+ * Returns the raw content between the backticks of a TemplateLiteral,
+ * delegating each expression slot to `renderExpr`.
+ */
+function templateContent(template, renderExpr) {
+    return template.quasis
+        .map((quasi, i) => `${quasi.value.raw}${i < template.expressions.length
+        ? renderExpr(template.expressions[i], i)
+        : ''}`)
         .join('');
-    return `\`${inner}\``;
+}
+function hasTemplateLiteralAncestor(node) {
+    let current = node.parent;
+    while (current != null) {
+        if (current.type === AST_NODE_TYPES.TemplateLiteral) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
 }
 const rule$4 = createRule$6({
     create(context) {
@@ -2239,46 +2256,74 @@ const rule$4 = createRule$6({
             // Type checking not available — only literal concatenation will be checked
         }
         function isStringNode(node) {
-            if (isStringLiteralNode(node)) {
+            if (isStringLiteral(node)) {
                 return true;
             }
             if (!parserServices || !checker) {
                 return false;
             }
             const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-            const type = checker.getTypeAtLocation(tsNode);
-            return isStringType(type, checker);
+            return isStringType(checker.getTypeAtLocation(tsNode), checker);
         }
+        const getText = (n) => sourceCode.getText(n);
+        const wrapExpr = (expr) => `\${${getText(expr)}}`;
         return {
             BinaryExpression(node) {
-                if (node.operator !== '+') {
+                if (node.operator !== '+' || !isRootConcat(node)) {
                     return;
                 }
-                if (!isRootConcat(node)) {
+                // Comments between parts serve as inline documentation — preserve them
+                if (sourceCode.getCommentsInside(node).length > 0) {
                     return;
                 }
                 const parts = collectParts(node);
-                const allLiterals = parts.every(isStringLiteralNode);
-                if (allLiterals) {
-                    context.report({
-                        fix(fixer) {
-                            return fixer.replaceText(node, buildMergedString(parts));
-                        },
-                        messageId: 'mergeLiterals',
-                        node,
-                    });
+                if (!parts.every((p) => p.type !== AST_NODE_TYPES.TemplateLiteral && isStringNode(p))) {
                     return;
                 }
-                if (parts.every((part) => part.type !== AST_NODE_TYPES.TemplateLiteral &&
-                    isStringNode(part))) {
+                const allLiterals = parts.every(isStringLiteral);
+                // Direct child of a template expression → inline parts to avoid
+                // nested template literals like `${`${a}${b}`}`
+                if (node.parent.type === AST_NODE_TYPES.TemplateLiteral) {
+                    const template = node.parent;
+                    // Tagged templates: changing quasis/expressions count alters behaviour
+                    if (template.parent.type === AST_NODE_TYPES.TaggedTemplateExpression) {
+                        return;
+                    }
                     context.report({
-                        fix(fixer) {
-                            return fixer.replaceText(node, buildTemplateLiteral(parts, (n) => sourceCode.getText(n)));
-                        },
-                        messageId: 'useTemplate',
+                        fix: (fixer) => fixer.replaceText(template, `\`${templateContent(template, (expr) => (expr === node ? partsToTemplateContent(parts, getText) : wrapExpr(expr)))}\``),
+                        messageId: allLiterals ? 'mergeLiterals' : 'useTemplate',
                         node,
                     });
+                    return;
+                }
+                // Nested inside a template but not direct child — would produce
+                // `${`${a}${b}`.method()}`, so skip
+                if (hasTemplateLiteralAncestor(node)) {
+                    return;
                 }
+                context.report({
+                    fix: (fixer) => fixer.replaceText(node, allLiterals
+                        ? buildMergedString(parts)
+                        : `\`${partsToTemplateContent(parts, getText)}\``),
+                    messageId: allLiterals ? 'mergeLiterals' : 'useTemplate',
+                    node,
+                });
+            },
+            TemplateLiteral(node) {
+                // Tagged templates: changing quasis/expressions count alters behaviour
+                if (node.parent.type === AST_NODE_TYPES.TaggedTemplateExpression) {
+                    return;
+                }
+                node.expressions.forEach((expr, i) => {
+                    if (expr.type === AST_NODE_TYPES.TemplateLiteral &&
+                        expr.parent.type !== AST_NODE_TYPES.TaggedTemplateExpression) {
+                        context.report({
+                            fix: (fixer) => fixer.replaceText(node, `\`${templateContent(node, (e, j) => (j === i ? templateContent(expr, wrapExpr) : wrapExpr(e)))}\``),
+                            messageId: 'flattenTemplate',
+                            node: expr,
+                        });
+                    }
+                });
             },
         };
     },
@@ -2288,6 +2333,7 @@ const rule$4 = createRule$6({
         },
         fixable: 'code',
         messages: {
+            flattenTemplate: 'Flatten nested template literal into its parent.',
             mergeLiterals: 'Merge string literals instead of concatenating them.',
             useTemplate: 'Use a template literal instead of string concatenation.',
         },

package/package.json

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

package/rules/no-string-literal-concat.d.ts

@@ -1,5 +1,5 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-type MessageId = 'mergeLiterals' | 'useTemplate';
+type MessageId = 'flattenTemplate' | 'mergeLiterals' | 'useTemplate';
 export declare const rule: ESLintUtils.RuleModule<MessageId, [], unknown, ESLintUtils.RuleListener> & {
     name: string;
 };