@taiga-ui/eslint-plugin-experience-next 0.450.0 → 0.452.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-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                                                             |     | 🔧  |     |
 | prefer-multi-arg-push               | Combine consecutive `.push()` calls on the same array into a single multi-argument call             | ✅  | 🔧  |     |
@@ -283,6 +284,93 @@ await page.getByLabel('Name').clear();
 
 ---
 
+## no-string-literal-concat
+
+Disallows concatenating string literals with `+`. Adjacent string literals are always mergeable into one — splitting
+them with `+` adds noise without benefit, and multi-line splits are especially easy to miss.
+
+Replaces the built-in `no-useless-concat` rule, which only catches same-line concatenation.
+
+```ts
+// ❌ error
+const msg = 'Hello, ' + 'world!';
+
+// ✅ after autofix
+const msg = 'Hello, world!';
+```
+
+```ts
+// ❌ error — also caught across lines
+it(
+    'returns the last day of month when' +
+        ' the result month has fewer days',
+    () => { ... },
+);
+
+// ✅ after autofix
+it('returns the last day of month when the result month has fewer days', () => {
+    ...
+});
+```
+
+```ts
+// ❌ error — string variables concatenated with +
+const a = 'hello';
+const b = 'world';
+const c = a + b;
+
+// ✅ after autofix
+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` ``) and tagged templates are not flagged by this rule.
+
+---
+
 ## object-single-line
 
 Single-property object literals that fit within `printWidth` characters on one line are collapsed to a single line.

package/index.d.ts

@@ -18,28 +18,31 @@ declare const plugin: {
         'flat-exports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"spreadArrays", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'injection-token-description': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalid-injection-token-description", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'injection-token-description': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalid-injection-token-description", readonly unknown[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'no-deep-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"no-deep-imports", [{
+        'no-deep-imports': import("@typescript-eslint/utils/ts-eslint").RuleModule<"no-deep-imports", {
             currentProject: string;
             deepImport: string;
             ignoreImports: string[];
             importDeclaration: string;
             projectName: string;
-        }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        }[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
-        'no-deep-imports-to-indexed-packages': import("@typescript-eslint/utils/ts-eslint").RuleModule<"deepImport", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'no-deep-imports-to-indexed-packages': import("@typescript-eslint/utils/ts-eslint").RuleModule<"deepImport", readonly unknown[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         'no-href-with-router-link': import("eslint").Rule.RuleModule;
-        'no-implicit-public': import("@typescript-eslint/utils/ts-eslint").RuleModule<"implicitPublic", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+        'no-implicit-public': import("@typescript-eslint/utils/ts-eslint").RuleModule<"implicitPublic", readonly unknown[], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };
         '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<"flattenTemplate" | "mergeLiterals" | "useTemplate", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'object-single-line': import("@typescript-eslint/utils/ts-eslint").RuleModule<"oneLine", [{
             printWidth: number;
         }], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {

package/index.esm.js

@@ -87,23 +87,25 @@ var htmlEslint = defineConfig([
                         String.raw `\[style\.border-top(\.[a-z]+)?\]`,
                         String.raw `\[style\.border-bottom(\.[a-z]+)?\]`,
                     ],
-                    message: 'Use logical CSS properties instead of directional properties. Replace:\n' +
-                        '• left → inset-inline-start\n' +
-                        '• right → inset-inline-end\n' +
-                        '• top → inset-block-start\n' +
-                        '• bottom → inset-block-end\n' +
-                        '• margin-left → margin-inline-start\n' +
-                        '• margin-right → margin-inline-end\n' +
-                        '• margin-top → margin-block-start\n' +
-                        '• margin-bottom → margin-block-end\n' +
-                        '• padding-left → padding-inline-start\n' +
-                        '• padding-right → padding-inline-end\n' +
-                        '• padding-top → padding-block-start\n' +
-                        '• padding-bottom → padding-block-end\n' +
-                        '• border-left → border-inline-start\n' +
-                        '• border-right → border-inline-end\n' +
-                        '• border-top → border-block-start\n' +
-                        '• border-bottom → border-block-end',
+                    message: `
+Use logical CSS properties instead of directional properties. Replace:
+• left → inset-inline-start
+• right → inset-inline-end
+• top → inset-block-start
+• bottom → inset-block-end
+• margin-left → margin-inline-start
+• margin-right → margin-inline-end
+• margin-top → margin-block-start
+• margin-bottom → margin-block-end
+• padding-left → padding-inline-start
+• padding-right → padding-inline-end
+• padding-top → padding-block-start
+• padding-bottom → padding-block-end
+• border-left → border-inline-start
+• border-right → border-inline-end
+• border-top → border-block-start
+• border-bottom → border-block-end
+`,
                     tagPatterns: ['.*'],
                 },
             ],
@@ -346,6 +348,7 @@ var recommended = defineConfig([
             ],
             '@stylistic/quotes': ['error', 'single', { avoidEscape: true }],
             '@stylistic/type-annotation-spacing': 'error',
+            '@taiga-ui/experience-next/no-string-literal-concat': 'error',
             '@typescript-eslint/adjacent-overload-signatures': 'off',
             '@typescript-eslint/array-type': [
                 'error',
@@ -706,7 +709,6 @@ var recommended = defineConfig([
             ],
             'no-return-assign': ['error', 'always'],
             'no-unneeded-ternary': 'error',
-            'no-useless-concat': 'error',
             'no-useless-escape': 'error',
             'no-useless-rename': [
                 'error',
@@ -777,6 +779,7 @@ var recommended = defineConfig([
             'sonarjs/no-identical-functions': 'error',
             'sonarjs/no-inverted-boolean-check': 'error',
             'spaced-comment': ['error', 'always', { markers: ['/'] }],
+            'template-curly-spacing': ['error', 'never'],
             'unicorn/consistent-empty-array-spread': 'error',
             'unicorn/escape-case': 'error',
             'unicorn/filename-case': ['error', { case: 'kebabCase' }],
@@ -907,6 +910,7 @@ var recommended = defineConfig([
                 'error',
                 { decorators: ['Component', 'Directive', 'NgModule', 'Pipe'] },
             ],
+            'no-multi-str': 'error',
             'rxjs/no-compat': 'error',
             'rxjs/no-connectable': 'error',
             'rxjs/no-cyclic-action': 'error',
@@ -1313,8 +1317,8 @@ function intersect(a, b) {
     return a.some((type) => origin.has(type));
 }
 
-const createRule$c = ESLintUtils.RuleCreator((name) => name);
-var classPropertyNaming = createRule$c({
+const createRule$d = ESLintUtils.RuleCreator((name) => name);
+var classPropertyNaming = createRule$d({
     create(context, [configs]) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1347,8 +1351,8 @@ var classPropertyNaming = createRule$c({
             },
         };
     },
-    defaultOptions: [[]],
     meta: {
+        defaultOptions: [[]],
         docs: {
             description: 'Enforce custom naming for class properties based on their type.',
         },
@@ -1483,9 +1487,9 @@ function isExternalPureTuple(typeChecker, type) {
     return typeArgs.every((item) => isClassType(item));
 }
 
-const createRule$b = ESLintUtils.RuleCreator((name) => name);
+const createRule$c = ESLintUtils.RuleCreator((name) => name);
 const MESSAGE_ID$5 = 'spreadArrays';
-var flatExports = createRule$b({
+var flatExports = createRule$c({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const typeChecker = parserServices.program.getTypeChecker();
@@ -1595,7 +1599,6 @@ var flatExports = createRule$b({
             },
         };
     },
-    defaultOptions: [],
     meta: {
         docs: {
             description: 'Ensure exported const tuples contain spread arrays in pure entity chains.',
@@ -1612,8 +1615,8 @@ var flatExports = createRule$b({
 
 const MESSAGE_ID$4 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
-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) {
         return {
             'NewExpression[callee.name="InjectionToken"]'(node) {
@@ -1651,7 +1654,6 @@ const rule$7 = createRule$a({
             },
         };
     },
-    defaultOptions: [],
     meta: {
         docs: { description: ERROR_MESSAGE$3 },
         fixable: 'code',
@@ -1681,8 +1683,8 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const createRule$9 = ESLintUtils.RuleCreator((name) => name);
-const rule$6 = createRule$9({
+const createRule$a = ESLintUtils.RuleCreator((name) => name);
+const rule$7 = createRule$a({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -1730,8 +1732,8 @@ const rule$6 = createRule$9({
             },
         };
     },
-    defaultOptions: [DEFAULT_OPTIONS],
     meta: {
+        defaultOptions: [DEFAULT_OPTIONS],
         docs: { description: ERROR_MESSAGE$2 },
         fixable: 'code',
         messages: { [MESSAGE_ID$3]: ERROR_MESSAGE$2 },
@@ -1769,13 +1771,13 @@ const rule$6 = createRule$9({
     name: 'no-deep-imports',
 });
 
-const createRule$8 = ESLintUtils.RuleCreator((name) => name);
+const createRule$9 = 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$8({
+var noDeepImportsToIndexedPackages = createRule$9({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -1923,7 +1925,6 @@ var noDeepImportsToIndexedPackages = createRule$8({
             },
         };
     },
-    defaultOptions: [],
     meta: {
         docs: {
             description: 'Disallow deep imports only when package root index.ts (or index.d.ts) re-exports that subpath, and the package is marked by ng-package.json or package.json',
@@ -2018,8 +2019,8 @@ const config = {
     },
 };
 
-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 checkImplicitPublic = (node) => {
             const classRef = getClass(node);
@@ -2069,7 +2070,6 @@ const rule$5 = createRule$7({
             },
         };
     },
-    defaultOptions: [],
     meta: {
         docs: {
             description: 'Require explicit `public` modifier for class members and parameter properties',
@@ -2091,8 +2091,8 @@ function getClass(node) {
     return getClass(node.parent);
 }
 
-const createRule$6 = ESLintUtils.RuleCreator((name) => name);
-const rule$4 = createRule$6({
+const createRule$7 = ESLintUtils.RuleCreator((name) => name);
+const rule$5 = createRule$7({
     create(context) {
         const services = ESLintUtils.getParserServices(context);
         const checker = services.program.getTypeChecker();
@@ -2129,7 +2129,6 @@ const rule$4 = createRule$6({
             },
         };
     },
-    defaultOptions: [],
     meta: {
         docs: {
             description: "Enforce Playwright clear() instead of fill('') for emptying fields",
@@ -2180,6 +2179,170 @@ function isPlaywrightLocatorType(type) {
     });
 }
 
+const createRule$6 = ESLintUtils.RuleCreator((name) => name);
+function isStringLiteral(node) {
+    return (node.type === AST_NODE_TYPES.Literal &&
+        typeof node.value === 'string');
+}
+function collectParts(node) {
+    if (node.type === AST_NODE_TYPES.BinaryExpression && node.operator === '+') {
+        return [...collectParts(node.left), ...collectParts(node.right)];
+    }
+    return [node];
+}
+function isRootConcat(node) {
+    const { parent } = node;
+    return (parent.type !== AST_NODE_TYPES.BinaryExpression ||
+        parent.operator !== '+');
+}
+function isStringType(type, checker) {
+    if (type.isUnion()) {
+        return type.types.every((t) => isStringType(t, checker));
+    }
+    return type.isStringLiteral() || checker.typeToString(type) === 'string';
+}
+function buildMergedString(parts) {
+    const combined = parts.map((p) => p.value).join('');
+    const quote = combined.includes("'") && !combined.includes('"') ? '"' : "'";
+    const escaped = combined
+        .replaceAll('\\', '\\\\')
+        .replaceAll('\r', String.raw `\r`)
+        .replaceAll('\n', String.raw `\n`)
+        .replaceAll('\t', String.raw `\t`)
+        .replaceAll(new RegExp(quote, 'g'), `\\${quote}`);
+    return `${quote}${escaped}${quote}`;
+}
+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('');
+}
+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) {
+        const { sourceCode } = context;
+        let parserServices = null;
+        let checker = null;
+        try {
+            parserServices = ESLintUtils.getParserServices(context);
+            checker = parserServices.program.getTypeChecker();
+        }
+        catch {
+            // Type checking not available — only literal concatenation will be checked
+        }
+        function isStringNode(node) {
+            if (isStringLiteral(node)) {
+                return true;
+            }
+            if (!parserServices || !checker) {
+                return false;
+            }
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            return isStringType(checker.getTypeAtLocation(tsNode), checker);
+        }
+        const getText = (n) => sourceCode.getText(n);
+        const wrapExpr = (expr) => `\${${getText(expr)}}`;
+        return {
+            BinaryExpression(node) {
+                if (node.operator !== '+' || !isRootConcat(node)) {
+                    return;
+                }
+                // Comments between parts serve as inline documentation — preserve them
+                if (sourceCode.getCommentsInside(node).length > 0) {
+                    return;
+                }
+                const parts = collectParts(node);
+                if (!parts.every((p) => p.type !== AST_NODE_TYPES.TemplateLiteral && isStringNode(p))) {
+                    return;
+                }
+                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) => 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,
+                        });
+                    }
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow string concatenation. Merge adjacent string literals into one; use template literals for string variables.',
+        },
+        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.',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'no-string-literal-concat',
+});
+
 const createRule$5 = ESLintUtils.RuleCreator((name) => name);
 const rule$3 = createRule$5({
     create(context, [{ printWidth }]) {
@@ -2440,8 +2603,8 @@ const rule$3 = createRule$5({
             },
         };
     },
-    defaultOptions: [{ printWidth: 90 }],
     meta: {
+        defaultOptions: [{ printWidth: 90 }],
         docs: {
             description: 'Enforce single-line formatting for single-property objects when possible (Prettier-friendly)',
         },
@@ -2526,13 +2689,13 @@ var preferDeepImports = createRule$4({
             },
         };
     },
-    defaultOptions: [
-        {
-            importFilter: [],
-            strict: false,
-        },
-    ],
     meta: {
+        defaultOptions: [
+            {
+                importFilter: [],
+                strict: false,
+            },
+        ],
         docs: { description: ERROR_MESSAGE },
         fixable: 'code',
         messages: { [MESSAGE_ID$1]: ERROR_MESSAGE },
@@ -2889,7 +3052,6 @@ const rule$2 = createRule$3({
             },
         };
     },
-    defaultOptions: [],
     meta: {
         docs: {
             description: 'Enforce combining consecutive .push() calls on the same array into a single call.',
@@ -3041,13 +3203,13 @@ const rule$1 = createRule$2({
             },
         };
     },
-    defaultOptions: [
-        {
-            decorators: DEFAULT_DECORATORS,
-            exceptions: DEFAULT_EXCEPTIONS,
-        },
-    ],
     meta: {
+        defaultOptions: [
+            {
+                decorators: DEFAULT_DECORATORS,
+                exceptions: DEFAULT_EXCEPTIONS,
+            },
+        ],
         docs: {
             description: 'Shorten TuiXxxComponent / TuiYyyDirective in Angular metadata (supports configurable decorators and exceptions).',
         },
@@ -3244,8 +3406,8 @@ var standaloneImportsSort = createRule$1({
             },
         };
     },
-    defaultOptions: [{ decorators: ['Component', 'Directive', 'NgModule', 'Pipe'] }],
     meta: {
+        defaultOptions: [{ decorators: ['Component', 'Directive', 'NgModule', 'Pipe'] }],
         docs: { description: 'Sort Angular standalone imports inside decorators.' },
         fixable: 'code',
         messages: { incorrectOrder: 'Order in imports should be [{{expected}}]' },
@@ -3351,7 +3513,6 @@ const rule = createRule({
             },
         };
     },
-    defaultOptions: [],
     meta: {
         docs: {
             description: `Ensures that keys and values are valid in a ${DOC_EXAMPLE_INTERFACE_NAME} interface.`,
@@ -3379,12 +3540,13 @@ const plugin = {
         'class-property-naming': classPropertyNaming,
         'decorator-key-sort': config$1,
         'flat-exports': flatExports,
-        'injection-token-description': rule$7,
-        'no-deep-imports': rule$6,
+        'injection-token-description': rule$8,
+        'no-deep-imports': rule$7,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,
         'no-href-with-router-link': config,
-        'no-implicit-public': rule$5,
-        'no-playwright-empty-fill': rule$4,
+        'no-implicit-public': rule$6,
+        'no-playwright-empty-fill': rule$5,
+        'no-string-literal-concat': rule$4,
         'object-single-line': rule$3,
         'prefer-deep-imports': preferDeepImports,
         'prefer-multi-arg-push': rule$2,

package/package.json

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

package/rules/injection-token-description.d.ts

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

package/rules/no-deep-imports-to-indexed-packages.d.ts

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

package/rules/no-deep-imports.d.ts

@@ -1,11 +1,11 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-export declare const rule: ESLintUtils.RuleModule<"no-deep-imports", [{
+export declare const rule: ESLintUtils.RuleModule<"no-deep-imports", {
     currentProject: string;
     deepImport: string;
     ignoreImports: string[];
     importDeclaration: string;
     projectName: string;
-}], unknown, ESLintUtils.RuleListener> & {
+}[], unknown, ESLintUtils.RuleListener> & {
     name: string;
 };
 export default rule;

package/rules/no-implicit-public.d.ts

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

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

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