@taiga-ui/eslint-plugin-experience-next 0.526.0 → 0.528.0

package/README.md

@@ -75,6 +75,7 @@ from third-party plugins. The exact severities and file globs live in
 | [array-as-const](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/array-as-const.md)                                                                   | Exported array of class references should be marked with `as const`                                             |     | 🔧  |     |
 | [at-compat](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/at-compat.md)                                                                             | Keep built-in `.at()` and indexed access aligned with the TypeScript target                                     | ✅  | 🔧  |     |
 | [attrs-newline](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/attrs-newline.md)                                                                     | Enforce one attribute per line when a start tag spans multiple lines                                            | ✅  | 🔧  |     |
+| [class-accessibility-spacing](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/class-accessibility-spacing.md)                                         | Separate adjacent class members with a blank line when their accessibility group changes                        | ✅  | 🔧  |     |
 | [class-property-naming](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/class-property-naming.md)                                                     | Enforce custom naming for class properties based on their type                                                  |     | 🔧  |     |
 | [decorator-key-sort](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/decorator-key-sort.md)                                                           | Sorts the keys of the object passed to the `@Component/@Injectable/@NgModule/@Pipe` decorator                   | ✅  | 🔧  |     |
 | [element-newline](https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs/element-newline.md)                                                                 | Require line breaks around block-level child nodes in HTML templates                                            | ✅  | 🔧  |     |

package/index.d.ts

@@ -18,6 +18,9 @@ declare const plugin: {
         'attrs-newline': import("eslint").Rule.RuleModule & {
             name: string;
         };
+        'class-accessibility-spacing': import("@typescript-eslint/utils/ts-eslint").RuleModule<"classAccessibilitySpacing", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
         'class-property-naming': import("@typescript-eslint/utils/ts-eslint").RuleModule<"invalidName", [import("./rules/taiga-specific/class-property-naming").RuleConfig[]], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
             name: string;
         };

package/index.esm.js

@@ -465,8 +465,111 @@ const TUI_MEMBER_ORDERING_CONVENTION = [
     '#private-instance-method',
 ];
 
+function isSingleLineNode(node) {
+    return node.loc.start.line === node.loc.end.line;
+}
+function isLineBreakCharacter(char) {
+    return char === '\n' || char === '\r';
+}
+function hasCommentLikeText(text) {
+    return text.includes('//') || text.includes('/*');
+}
+function hasBlankLine(text) {
+    let lineBreaks = 0;
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if (char === '\n') {
+            lineBreaks++;
+        }
+        else if (char === '\r') {
+            lineBreaks++;
+            if (text[index + 1] === '\n') {
+                index++;
+            }
+        }
+        if (lineBreaks > 1) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasBlankLineBetweenNodes(text) {
+    const lines = splitLines(text);
+    const linesBetweenNodes = lines.slice(1, -1);
+    return linesBetweenNodes.some((line) => line.trim() === '');
+}
+function getLineBreak(text) {
+    if (text.includes('\r\n')) {
+        return '\r\n';
+    }
+    return text.includes('\r') ? '\r' : '\n';
+}
+function hasLineBreak(text) {
+    for (const char of text) {
+        if (isLineBreakCharacter(char)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getLeadingIndentation(text) {
+    let index = 0;
+    while (index < text.length && (text[index] === ' ' || text[index] === '\t')) {
+        index++;
+    }
+    return text.slice(0, index);
+}
+function getLineStartOffset(text, offset) {
+    let index = offset - 1;
+    while (index >= 0) {
+        const char = text[index];
+        if (isLineBreakCharacter(char)) {
+            return index + 1;
+        }
+        index--;
+    }
+    return 0;
+}
+function getLineEndOffset(text, lineStartOffset) {
+    let index = lineStartOffset;
+    while (index < text.length) {
+        const char = text[index];
+        if (isLineBreakCharacter(char)) {
+            return index;
+        }
+        index++;
+    }
+    return text.length;
+}
+function getNextLineStartOffset(text, offset) {
+    let index = offset;
+    while (index < text.length) {
+        const char = text[index];
+        if (char === '\r') {
+            return text[index + 1] === '\n' ? index + 2 : index + 1;
+        }
+        if (char === '\n') {
+            return index + 1;
+        }
+        index++;
+    }
+    return offset;
+}
+function splitLines(text) {
+    return text.split(/\r\n|\n|\r/);
+}
+function getIndentAtOffset(text, offset) {
+    const lineStart = getLineStartOffset(text, offset);
+    const indent = text.slice(lineStart, offset);
+    return indent.trim() === '' ? indent : '';
+}
+function getSpacingReplacement(sourceCode, betweenText, nextLine, blankLineCount) {
+    const indentation = getLeadingIndentation(sourceCode.lines[nextLine - 1] ?? '');
+    return `${getLineBreak(betweenText).repeat(blankLineCount + 1)}${indentation}`;
+}
+
 function buildAST(text) {
-    const lines = text.split('\n');
+    const lines = splitLines(text);
     const lastLine = lines[lines.length - 1] ?? '';
     return {
         body: [],
@@ -1149,6 +1252,7 @@ var recommended = defineConfig([
             '@angular-eslint/use-lifecycle-interface': 'error',
             '@angular-eslint/use-pipe-transform-interface': 'error',
             '@taiga-ui/experience-next/at-compat': 'error',
+            '@taiga-ui/experience-next/class-accessibility-spacing': 'error',
             '@taiga-ui/experience-next/decorator-key-sort': [
                 'error',
                 {
@@ -14876,6 +14980,40 @@ function getParenthesizedExpression(expression) {
         : null;
 }
 
+function isFieldLikeMember(member) {
+    return (member.type === dist$4.AST_NODE_TYPES.PropertyDefinition ||
+        member.type === dist$4.AST_NODE_TYPES.TSAbstractPropertyDefinition);
+}
+function isAccessorMember(member) {
+    return (member.type === dist$4.AST_NODE_TYPES.MethodDefinition &&
+        (member.kind === 'get' || member.kind === 'set'));
+}
+function isRelevantSpacingClassMember(member) {
+    return isFieldLikeMember(member) || isAccessorMember(member);
+}
+function isAccessibilityClassMember(member) {
+    switch (member.type) {
+        case dist$4.AST_NODE_TYPES.AccessorProperty:
+        case dist$4.AST_NODE_TYPES.MethodDefinition:
+        case dist$4.AST_NODE_TYPES.PropertyDefinition:
+        case dist$4.AST_NODE_TYPES.TSAbstractAccessorProperty:
+        case dist$4.AST_NODE_TYPES.TSAbstractMethodDefinition:
+        case dist$4.AST_NODE_TYPES.TSAbstractPropertyDefinition:
+        case dist$4.AST_NODE_TYPES.TSIndexSignature:
+            return true;
+        default:
+            return false;
+    }
+}
+function isEcmascriptPrivateClassMember(member) {
+    return 'key' in member && member.key.type === dist$4.AST_NODE_TYPES.PrivateIdentifier;
+}
+function getAccessibilityGroup(member) {
+    return isEcmascriptPrivateClassMember(member)
+        ? 'private'
+        : (member.accessibility ?? 'public');
+}
+
 const EQUALITY_OPERATORS = new Set(['!=', '!==', '==', '===']);
 function getChainExpressionRoot(node) {
     const parent = getParentNode(node);
@@ -15091,62 +15229,11 @@ function getMemberExpressionPropertyName(node) {
     return node.computed ? getStaticStringValue(node.property) : null;
 }
 function getClassMemberName(member) {
-    return member.key.type === dist$4.AST_NODE_TYPES.PrivateIdentifier
+    return isEcmascriptPrivateClassMember(member)
         ? null
         : getStaticPropertyName(member.key);
 }
 
-function isSingleLineNode(node) {
-    return node.loc.start.line === node.loc.end.line;
-}
-function hasCommentLikeText(text) {
-    return text.includes('//') || text.includes('/*');
-}
-function hasBlankLine(text) {
-    let lineBreaks = 0;
-    for (let index = 0; index < text.length; index++) {
-        const char = text[index];
-        if (char === '\n') {
-            lineBreaks++;
-        }
-        else if (char === '\r') {
-            lineBreaks++;
-            if (text[index + 1] === '\n') {
-                index++;
-            }
-        }
-        if (lineBreaks > 1) {
-            return true;
-        }
-    }
-    return false;
-}
-function getLineBreak(text) {
-    if (text.includes('\r\n')) {
-        return '\r\n';
-    }
-    return text.includes('\r') ? '\r' : '\n';
-}
-function getLeadingIndentation(text) {
-    let index = 0;
-    while (index < text.length && (text[index] === ' ' || text[index] === '\t')) {
-        index++;
-    }
-    return text.slice(0, index);
-}
-function getLineStartOffset(text, offset) {
-    return text.lastIndexOf('\n', offset - 1) + 1;
-}
-function getIndentAtOffset(text, offset) {
-    const lineStart = getLineStartOffset(text, offset);
-    const indent = text.slice(lineStart, offset);
-    return indent.trim() === '' ? indent : '';
-}
-function getSpacingReplacement(sourceCode, betweenText, nextLine, blankLineCount) {
-    const indentation = getLeadingIndentation(sourceCode.lines[nextLine - 1] ?? '');
-    return `${getLineBreak(betweenText).repeat(blankLineCount + 1)}${indentation}`;
-}
-
 const RULE_DOCS_BASE_URL = 'https://github.com/taiga-family/toolkit/tree/main/projects/eslint-plugin-experience-next/docs';
 const ruleCreator = dist$4.ESLintUtils.RuleCreator((name) => `${RULE_DOCS_BASE_URL}/${name}.md`);
 function createRule(options) {
@@ -216065,12 +216152,10 @@ function getPreferredTemporaryNames(node) {
     ];
 }
 function getClassElementName(member) {
-    if (!('key' in member)) {
-        return null;
+    if (isEcmascriptPrivateClassMember(member)) {
+        return member.key.name;
     }
-    return member.key.type === dist$4.AST_NODE_TYPES.PrivateIdentifier
-        ? member.key.name
-        : getStaticPropertyName(member.key);
+    return 'key' in member ? getStaticPropertyName(member.key) : null;
 }
 function hasClassElementName(classBody, name) {
     return classBody.body.some((member) => getClassElementName(member) === name);
@@ -216220,7 +216305,7 @@ function getLastIndexFix(fixer, sourceCode, node, call) {
     }
     return null;
 }
-const rule$X = createRule({
+const rule$Y = createRule({
     create(context) {
         const typeAwareContext = getTypeAwareRuleContext(context);
         const compilerOptions = typeAwareContext.tsProgram.getCompilerOptions();
@@ -248017,15 +248102,16 @@ function buildMultilineStartTag(node, sourceText) {
     const closing = sourceText
         .slice(lastAttr ? lastAttr.sourceSpan.end.offset : startTag.end.offset, startTag.end.offset)
         .trimStart();
+    const lineBreak = getLineBreak(sourceText);
     return [
         tagStart.trimEnd(),
         ...attrs.map((attr) => sourceText
             .slice(attr.sourceSpan.start.offset, attr.sourceSpan.end.offset)
             .trim()),
         closing,
-    ].join('\n');
+    ].join(lineBreak);
 }
-const rule$W = createRule({
+const rule$X = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -248111,6 +248197,59 @@ const rule$W = createRule({
     },
 });
 
+const rule$W = createRule({
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            ClassBody(node) {
+                for (let index = 0; index < node.body.length - 1; index++) {
+                    const current = node.body[index];
+                    const next = node.body[index + 1];
+                    if (!current ||
+                        !next ||
+                        !isAccessibilityClassMember(current) ||
+                        !isAccessibilityClassMember(next)) {
+                        continue;
+                    }
+                    const accessibilityGroupChanged = getAccessibilityGroup(current) !== getAccessibilityGroup(next);
+                    if (!accessibilityGroupChanged) {
+                        continue;
+                    }
+                    const betweenText = sourceCode.text.slice(current.range[1], next.range[0]);
+                    const missingBlankLine = !hasBlankLineBetweenNodes(betweenText);
+                    if (!missingBlankLine) {
+                        continue;
+                    }
+                    const reportTarget = {
+                        messageId: 'classAccessibilitySpacing',
+                        node: next,
+                    };
+                    if (hasCommentLikeText(betweenText)) {
+                        context.report(reportTarget);
+                        continue;
+                    }
+                    context.report({
+                        ...reportTarget,
+                        fix: (fixer) => fixer.replaceTextRange([current.range[1], next.range[0]], getSpacingReplacement(sourceCode, betweenText, next.loc.start.line, 1)),
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Require a blank line between adjacent class members when their accessibility group changes',
+        },
+        fixable: 'code',
+        messages: {
+            classAccessibilitySpacing: 'Class members with different accessibility groups should be separated by a blank line',
+        },
+        schema: [],
+        type: 'layout',
+    },
+    name: 'class-accessibility-spacing',
+});
+
 function isObject(node) {
     return node?.type === dist$3.AST_NODE_TYPES.ObjectExpression;
 }
@@ -248301,6 +248440,7 @@ const rule$U = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
+            const lineBreak = getLineBreak(context.sourceCode.getText());
             return {
                 Element(rawNode) {
                     const node = rawNode;
@@ -248321,7 +248461,7 @@ const rule$U = createRule({
                             fix: (fixer) => fixer.insertTextBeforeRange([
                                 firstChild.sourceSpan.start.offset,
                                 firstChild.sourceSpan.start.offset,
-                            ], '\n'),
+                            ], lineBreak),
                             loc: sourceSpanToLoc(firstChild.sourceSpan),
                             messageId: MESSAGE_ID$i,
                         });
@@ -248339,7 +248479,7 @@ const rule$U = createRule({
                                 fix: (fixer) => fixer.insertTextAfterRange([
                                     child.sourceSpan.end.offset,
                                     child.sourceSpan.end.offset,
-                                ], '\n'),
+                                ], lineBreak),
                                 loc: sourceSpanToLoc(next.sourceSpan),
                                 messageId: MESSAGE_ID$i,
                             });
@@ -248353,7 +248493,7 @@ const rule$U = createRule({
                             fix: (fixer) => fixer.insertTextAfterRange([
                                 lastChild.sourceSpan.end.offset,
                                 lastChild.sourceSpan.end.offset,
-                            ], '\n'),
+                            ], lineBreak),
                             loc: sourceSpanToLoc(lastChild.sourceSpan),
                             messageId: MESSAGE_ID$i,
                         });
@@ -248644,19 +248784,21 @@ function getAttachedComments(hostObject, properties, sourceCode, comments) {
     return usedComments.size === comments.length ? attached : null;
 }
 function renderFixWithComments(hostObject, sortedProperties, sourceCode, attachedComments) {
+    const lineBreak = getLineBreak(sourceCode.text);
     const objectIndentation = getLineIndentation(sourceCode.text, hostObject.range[0]);
     const propertyIndentation = getPropertyIndentation(hostObject, sortedProperties, sourceCode.text, attachedComments);
-    return `{\n${sortedProperties
+    return `{${lineBreak}${sortedProperties
         .map(({ node }, index) => renderPropertyWithComments(node, attachedComments.get(node), sourceCode, propertyIndentation, index === sortedProperties.length - 1))
-        .join('\n')}\n${objectIndentation}}`;
+        .join(lineBreak)}${lineBreak}${objectIndentation}}`;
 }
 function renderPropertyWithComments(property, attachedComments, sourceCode, propertyIndentation, isLast) {
+    const lineBreak = getLineBreak(sourceCode.text);
     const lines = attachedComments?.leading.map((comment) => `${propertyIndentation}${sourceCode.text.slice(...comment.range)}`) ?? [];
     const trailingComment = attachedComments?.trailing
         ? ` ${sourceCode.text.slice(...attachedComments.trailing.range)}`
         : '';
     lines.push(`${propertyIndentation}${sourceCode.getText(property)}${isLast ? '' : ','}${trailingComment}`);
-    return lines.join('\n');
+    return lines.join(lineBreak);
 }
 function getPropertyIndentation(hostObject, properties, sourceText, attachedComments) {
     for (const { node } of properties) {
@@ -248670,9 +248812,7 @@ function getPropertyIndentation(hostObject, properties, sourceText, attachedComm
 }
 function getLineIndentation(sourceText, offset) {
     let lineStart = offset;
-    while (lineStart > 0 &&
-        sourceText[lineStart - 1] !== '\n' &&
-        sourceText[lineStart - 1] !== '\r') {
+    while (lineStart > 0 && !isLineBreakCharacter(sourceText[lineStart - 1])) {
         lineStart--;
     }
     let indentationEnd = lineStart;
@@ -249382,11 +249522,15 @@ const rule$R = createRule({
         }
         function buildImportRemovalFix(fixer, node) {
             const [start, end] = node.range;
-            const lineStart = sourceCode.text.lastIndexOf('\n', start - 1) + 1;
+            const lineStart = getLineStartOffset(sourceCode.text, start);
             const removeStart = /^\s*$/.test(sourceCode.text.slice(lineStart, start))
                 ? lineStart
                 : start;
-            const removeEnd = sourceCode.text[end] === '\n' ? end + 1 : end;
+            const lineEnd = getLineEndOffset(sourceCode.text, end);
+            const isImportLastStatementOnLine = sourceCode.text.slice(end, lineEnd).trim() === '';
+            const removeEnd = isImportLastStatementOnLine
+                ? getNextLineStartOffset(sourceCode.text, end)
+                : end;
             return [fixer.removeRange([removeStart, removeEnd])];
         }
         function buildDuplicateImportFix(fixer, first, rest) {
@@ -249700,7 +249844,7 @@ const rule$R = createRule({
                 const relPath = computeRelativeImportPath(context.filename, sourceFilePath);
                 newImports.push(`${importPrefix} {${names.join(', ')}} from ${quote}${relPath}${quote}${semi}`);
             }
-            return newImports.join('\n');
+            return newImports.join(getLineBreak(sourceCode.text));
         }
         function checkDefaultImport(node) {
             if ((!checkDefaultImports &&
@@ -250050,17 +250194,18 @@ function getDescriptionNode(node) {
 function prependTokenName(text, name) {
     return `${text.slice(0, 1)}[${name}]: ${text.slice(1)}`;
 }
-function getNgDevModeDeclarationFix(program, fixer) {
+function getNgDevModeDeclarationFix(program, fixer, sourceCode) {
     const lastImport = [...program.body]
         .reverse()
         .find((statement) => statement.type === dist$3.AST_NODE_TYPES.ImportDeclaration);
+    const lineBreak = getLineBreak(sourceCode.text);
     if (lastImport) {
-        return fixer.insertTextAfter(lastImport, '\n\ndeclare const ngDevMode: boolean;');
+        return fixer.insertTextAfter(lastImport, `${lineBreak}${lineBreak}declare const ngDevMode: boolean;`);
     }
     const [firstStatement] = program.body;
     return firstStatement
-        ? fixer.insertTextBefore(firstStatement, 'declare const ngDevMode: boolean;\n\n')
-        : fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
+        ? fixer.insertTextBefore(firstStatement, `declare const ngDevMode: boolean;${lineBreak}${lineBreak}`)
+        : fixer.insertTextBeforeRange([0, 0], `declare const ngDevMode: boolean;${lineBreak}`);
 }
 const rule$Q = createRule({
     create(context) {
@@ -250090,7 +250235,7 @@ const rule$Q = createRule({
                                 shouldAddNgDevModeDeclaration &&
                                 !hasVariableInScope(sourceCode, description, NG_DEV_MODE)) {
                                 shouldAddNgDevModeDeclaration = false;
-                                fixes.unshift(getNgDevModeDeclarationFix(program, fixer));
+                                fixes.unshift(getNgDevModeDeclarationFix(program, fixer, sourceCode));
                             }
                             return fixes;
                         },
@@ -250708,11 +250853,10 @@ function getSinglePropertyRange(text, property) {
         : [property.range[0], property.range[1]];
 }
 function getLineStart(text, index) {
-    return text.lastIndexOf('\n', index - 1) + 1;
+    return getLineStartOffset(text, index);
 }
 function getNextLineStart(text, index) {
-    const lineEnd = text.indexOf('\n', index);
-    return lineEnd === -1 ? index : lineEnd + 1;
+    return getNextLineStartOffset(text, index);
 }
 function hasCommentsInRange(sourceCode, [start, end]) {
     return sourceCode
@@ -251170,40 +251314,78 @@ const rule$H = createRule({
     rule: config$3,
 });
 
+function isClassMemberCandidate(node) {
+    return (node.type === dist$4.AST_NODE_TYPES.MethodDefinition ||
+        node.type === dist$4.AST_NODE_TYPES.PropertyDefinition);
+}
+function isConstructorMember(node) {
+    return node.type === dist$4.AST_NODE_TYPES.MethodDefinition && node.kind === 'constructor';
+}
+function getParameterPropertyName(node) {
+    const { parameter } = node;
+    return parameter.type === dist$4.AST_NODE_TYPES.Identifier
+        ? parameter.name
+        : parameter.left.name;
+}
+function getCandidateName(node) {
+    return node.type === dist$4.AST_NODE_TYPES.TSParameterProperty
+        ? (getParameterPropertyName(node) ?? 'member')
+        : (getStaticPropertyName(node.key) ?? 'member');
+}
+function getCandidateKind(node) {
+    return node.type === dist$4.AST_NODE_TYPES.MethodDefinition ? node.kind : 'property';
+}
+function getFirstNonWhitespaceOffset(text, offset) {
+    let index = offset;
+    while (index < text.length && text[index]?.trim() === '') {
+        index++;
+    }
+    return index;
+}
+function getPublicModifierInsertion(options) {
+    const { node, sourceCode } = options;
+    const lastDecoratorIndex = node.decorators.length - 1;
+    const lastDecorator = node.decorators[lastDecoratorIndex];
+    if (lastDecorator) {
+        const [, end] = lastDecorator.range;
+        const memberStart = getFirstNonWhitespaceOffset(sourceCode.text, end);
+        const hasWhitespaceAfterDecorator = memberStart > end;
+        return {
+            range: [memberStart, memberStart],
+            text: hasWhitespaceAfterDecorator ? 'public ' : ' public ',
+        };
+    }
+    return {
+        range: [node.range[0], node.range[0]],
+        text: 'public ',
+    };
+}
 const rule$G = createRule({
     create(context) {
+        const sourceCode = context.sourceCode;
         const checkImplicitPublic = (node) => {
             const classRef = getEnclosingClass(node);
-            if (!classRef ||
-                node.kind === 'constructor' ||
-                !!node?.accessibility ||
-                node.key?.type === dist$4.AST_NODE_TYPES.PrivateIdentifier) {
+            if (!classRef) {
                 return;
             }
-            const name = node?.key?.name ||
-                node?.parameter?.name ||
-                (node?.key?.type === 'Identifier' ? node.key.name : 'member');
-            let range = node?.parameter?.range ??
-                node?.key?.range ??
-                node?.range ?? [0, 0];
-            if (node.kind === 'set' || node.kind === 'get') {
-                const [start, end] = node.key.range;
-                range = [start - node.kind.length - 1, end - node.kind.length - 1];
-            }
-            else if (node.kind === 'method' && node.key?.object?.name === 'Symbol') {
-                const [start, end] = range;
-                range = [start - 1, end - 1];
-            }
-            if (node.type === 'PropertyDefinition' && node.decorators?.length > 0) {
-                const [, end] = node.decorators[node.decorators.length - 1].range ?? [];
-                range = [end + 1, end + 2];
+            const privateNameCannotBePublic = isClassMemberCandidate(node) && isEcmascriptPrivateClassMember(node);
+            if (isConstructorMember(node) ||
+                Boolean(node.accessibility) ||
+                privateNameCannotBePublic) {
+                return;
             }
             context.report({
                 data: {
-                    kind: node.kind || 'property',
-                    name,
+                    kind: getCandidateKind(node),
+                    name: getCandidateName(node),
+                },
+                fix: (fixer) => {
+                    const { range, text } = getPublicModifierInsertion({
+                        node,
+                        sourceCode,
+                    });
+                    return fixer.insertTextBeforeRange(range, text);
                 },
-                fix: (fixer) => fixer.insertTextBeforeRange(range, ' public '),
                 messageId: 'implicitPublic',
                 node,
             });
@@ -251322,7 +251504,7 @@ const rule$D = createRule({
         return {
             Program(node) {
                 const text = context.sourceCode.getText(node);
-                const lines = text.split('\n');
+                const lines = splitLines(text);
                 for (const [index, line] of lines.entries()) {
                     const trimmed = line.trim();
                     if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';')) {
@@ -251664,11 +251846,12 @@ const rule$B = createRule({
                                     return null;
                                 }
                                 const indent = getIndentAtOffset(sourceCode.text, insertOffset);
+                                const lineBreak = getLineBreak(sourceCode.text);
                                 const declarations = result.lets
                                     .map(({ expression, name }, index) => `${index === 0 ? '' : indent}@let ${name} = ${expression};`)
-                                    .join('\n');
+                                    .join(lineBreak);
                                 return [
-                                    fixer.insertTextBeforeRange([insertOffset, insertOffset], `${declarations}\n${indent}`),
+                                    fixer.insertTextBeforeRange([insertOffset, insertOffset], `${declarations}${lineBreak}${indent}`),
                                     fixer.replaceTextRange([node.sourceSpan.start, node.sourceSpan.end], result.reference),
                                 ];
                             },
@@ -252664,10 +252847,11 @@ const rule$v = createRule({
                     fix(fixer) {
                         const varName = getCalleeName(firstCall);
                         const parentStatement = findParentStatement(node);
+                        const lineBreak = getLineBreak(sourceCode.text);
                         if (parentStatement) {
                             const indent = getStatementIndent$1(parentStatement, sourceCode.text);
                             const fixes = [
-                                fixer.insertTextBefore(parentStatement, `const ${varName} = ${callText};\n\n${indent}`),
+                                fixer.insertTextBefore(parentStatement, `const ${varName} = ${callText};${lineBreak}${lineBreak}${indent}`),
                             ];
                             for (const call of calls) {
                                 fixes.push(fixer.replaceText(getTargetNode(call), varName));
@@ -252694,7 +252878,7 @@ const rule$v = createRule({
                             lastIndex = end;
                         }
                         replacedBody += bodyText.slice(lastIndex);
-                        const newBody = `{\n${innerIndent}const ${varName} = ${callText};\n\n${innerIndent}return ${replacedBody};\n${outerIndent}}`;
+                        const newBody = `{${lineBreak}${innerIndent}const ${varName} = ${callText};${lineBreak}${lineBreak}${innerIndent}return ${replacedBody};${lineBreak}${outerIndent}}`;
                         const bodyRangeStart = arrowBody.range[0];
                         const textBeforeBody = sourceCode.text.slice(0, bodyRangeStart);
                         const whitespaceBeforeBody = /\s*$/.exec(textBeforeBody)?.[0] ?? '';
@@ -253146,6 +253330,10 @@ const rule$s = createUntrackedRule({
     name: 'no-signal-reads-after-await-in-reactive-context',
 });
 
+const CARRIAGE_RETURN = String.fromCharCode(13);
+const LINE_FEED = String.fromCharCode(10);
+const ESCAPED_CARRIAGE_RETURN = String.fromCharCode(92, 114);
+const ESCAPED_LINE_FEED = String.fromCharCode(92, 110);
 function collectParts(node) {
     return node.type === dist$4.AST_NODE_TYPES.BinaryExpression && node.operator === '+'
         ? [...collectParts(node.left), ...collectParts(node.right)]
@@ -253165,8 +253353,8 @@ function buildMergedString(parts) {
     const quote = combined.includes("'") && !combined.includes('"') ? '"' : "'";
     const escaped = combined
         .replaceAll('\\', '\\\\')
-        .replaceAll('\r', String.raw `\r`)
-        .replaceAll('\n', String.raw `\n`)
+        .replaceAll(CARRIAGE_RETURN, ESCAPED_CARRIAGE_RETURN)
+        .replaceAll(LINE_FEED, ESCAPED_LINE_FEED)
         .replaceAll('\t', String.raw `\t`)
         .replaceAll(new RegExp(quote, 'g'), `\\${quote}`);
     return `${quote}${escaped}${quote}`;
@@ -253300,13 +253488,14 @@ function findUntrackedAlias(program) {
  * Builds fixer actions that add `untracked` to an existing `@angular/core` import,
  * or insert a new import declaration when none exists.
  */
-function buildUntrackedImportFixes(program, fixer) {
+function buildUntrackedImportFixes(program, fixer, sourceCode) {
     const coreImport = findRuntimeAngularCoreImport(program);
+    const lineBreak = getLineBreak(sourceCode.text);
     if (!coreImport) {
         const firstStatement = program.body[0];
         return firstStatement
             ? [
-                fixer.insertTextBefore(firstStatement, "import { untracked } from '@angular/core';\n"),
+                fixer.insertTextBefore(firstStatement, `import { untracked } from '@angular/core';${lineBreak}`),
             ]
             : [];
     }
@@ -253321,7 +253510,7 @@ function buildUntrackedImportFixes(program, fixer) {
     return defaultImport
         ? [fixer.insertTextAfter(defaultImport, ', { untracked }')]
         : [
-            fixer.insertTextAfter(coreImport, "\nimport { untracked } from '@angular/core';"),
+            fixer.insertTextAfter(coreImport, `${lineBreak}import { untracked } from '@angular/core';`),
         ];
 }
 /**
@@ -253411,10 +253600,9 @@ function dedent(text, extraSpaces) {
         return text;
     }
     const prefix = ' '.repeat(extraSpaces);
-    return text
-        .split('\n')
+    return splitLines(text)
         .map((line) => (line.startsWith(prefix) ? line.slice(extraSpaces) : line))
-        .join('\n');
+        .join(getLineBreak(text));
 }
 
 function isDirectCallOrNewArgument(node) {
@@ -253617,7 +253805,8 @@ function buildReplacement(untrackedCall, parentStatement, sourceCode) {
         const firstStmtColumn = firstStmt.loc.start.column;
         const extra = firstStmtColumn - parentColumn;
         const indented = stmts.map((s) => dedent(sourceCode.getText(s), extra));
-        return indented.join(`\n${''.padStart(parentColumn)}`);
+        const lineBreak = getLineBreak(sourceCode.text);
+        return indented.join(`${lineBreak}${''.padStart(parentColumn)}`);
     }
     // Expression body: arrow `() => expr` — just emit `expr;`
     return `${sourceCode.getText(body)};`;
@@ -253728,14 +253917,7 @@ const rule$p = createUntrackedRule({
 const rule$o = createRule({
     create(context, [{ printWidth }]) {
         const sourceCode = context.sourceCode;
-        const getLineEndIndex = (lineStartIndex) => {
-            const text = sourceCode.text;
-            const newLineIndex = text.indexOf('\n', lineStartIndex);
-            const rawEndIndex = newLineIndex === -1 ? text.length : newLineIndex;
-            return rawEndIndex > lineStartIndex && text[rawEndIndex - 1] === '\r'
-                ? rawEndIndex - 1
-                : rawEndIndex;
-        };
+        const getLineEndIndex = (lineStartIndex) => getLineEndOffset(sourceCode.text, lineStartIndex);
         const hasAnyCommentsInside = (node) => sourceCode.getCommentsInside(node).length > 0;
         const isTemplateLikeExpression = (expression) => expression.type === dist$3.AST_NODE_TYPES.TemplateLiteral ||
             expression.type === dist$3.AST_NODE_TYPES.TaggedTemplateExpression;
@@ -253847,7 +254029,7 @@ const rule$o = createRule({
                 if (inner.type === dist$3.AST_NODE_TYPES.ObjectExpression &&
                     canInlineObjectExpression(inner)) {
                     const innerText = sourceCode.getText(inner);
-                    return innerText.includes('\n');
+                    return hasLineBreak(innerText);
                 }
             }
             if (value.type === dist$3.AST_NODE_TYPES.ArrowFunctionExpression) {
@@ -253859,7 +254041,7 @@ const rule$o = createRule({
                         if (inner.type === dist$3.AST_NODE_TYPES.ObjectExpression &&
                             canInlineObjectExpression(inner)) {
                             const innerText = sourceCode.getText(inner);
-                            return innerText.includes('\n');
+                            return hasLineBreak(innerText);
                         }
                     }
                 }
@@ -253868,7 +254050,7 @@ const rule$o = createRule({
                     if (bodyExpr.type === dist$3.AST_NODE_TYPES.ObjectExpression &&
                         canInlineObjectExpression(bodyExpr)) {
                         const innerText = sourceCode.getText(bodyExpr);
-                        return innerText.includes('\n');
+                        return hasLineBreak(innerText);
                     }
                 }
             }
@@ -253932,7 +254114,7 @@ const rule$o = createRule({
             ObjectExpression(node) {
                 const originalText = sourceCode.getText(node);
                 if (!canInlineObjectExpression(node) ||
-                    !originalText.includes('\n') ||
+                    !hasLineBreak(originalText) ||
                     hasPendingInnerInlineCandidate(node) ||
                     hasArrowReturningMultiPropObject(node)) {
                     return;
@@ -254306,35 +254488,37 @@ function renderConditionalReturn(ifStatement, consequentExpression, alternateExp
         return inlineReturn;
     }
     const branchIndent = `${indent}    `;
-    return `return ${test}\n${branchIndent}? ${consequent}\n${branchIndent}: ${alternate};`;
+    const lineBreak = getLineBreak(sourceCode.text);
+    return `return ${test}${lineBreak}${branchIndent}? ${consequent}${lineBreak}${branchIndent}: ${alternate};`;
 }
 function renderBooleanTestReturn(ifStatement, sourceCode, strategy) {
     const test = sourceCode.getText(ifStatement.test);
+    const lineBreak = getLineBreak(sourceCode.text);
     if (strategy === 'negate') {
-        if (!test.includes('\n')) {
+        if (!hasLineBreak(test)) {
             const renderedTest = needsParenthesesInBooleanCoercion(ifStatement.test)
                 ? `(${test})`
                 : test;
             return `return !${renderedTest};`;
         }
         const indent = getStatementIndent(ifStatement, sourceCode);
-        return `return !(\n${indent}    ${test}\n${indent});`;
+        return `return !(${lineBreak}${indent}    ${test}${lineBreak}${indent});`;
     }
     if (strategy === 'coerce') {
-        if (!test.includes('\n')) {
+        if (!hasLineBreak(test)) {
             const renderedTest = needsParenthesesInBooleanCoercion(ifStatement.test)
                 ? `(${test})`
                 : test;
             return `return !!${renderedTest};`;
         }
         const indent = getStatementIndent(ifStatement, sourceCode);
-        return `return !!(\n${indent}    ${test}\n${indent});`;
+        return `return !!(${lineBreak}${indent}    ${test}${lineBreak}${indent});`;
     }
-    if (!test.includes('\n')) {
+    if (!hasLineBreak(test)) {
         return `return ${test};`;
     }
     const indent = getStatementIndent(ifStatement, sourceCode);
-    return `return (\n${indent}    ${test}\n${indent});`;
+    return `return (${lineBreak}${indent}    ${test}${lineBreak}${indent});`;
 }
 const rule$m = createRule({
     create(context) {
@@ -254912,7 +255096,7 @@ const rule$i = createUntrackedRule({
                 ? (fixer) => [fixer.replaceText(read, wrapped)]
                 : (fixer) => [
                     fixer.replaceText(read, wrapped),
-                    ...buildUntrackedImportFixes(program, fixer),
+                    ...buildUntrackedImportFixes(program, fixer, sourceCode),
                 ];
         }
         return {
@@ -255051,8 +255235,7 @@ const rule$g = createRule({
                         let openQuoteOffset = valueSpan.start.offset - 1;
                         while (openQuoteOffset >= 0 &&
                             (sourceText[openQuoteOffset] === ' ' ||
-                                sourceText[openQuoteOffset] === '\n' ||
-                                sourceText[openQuoteOffset] === '\r' ||
+                                isLineBreakCharacter(sourceText[openQuoteOffset]) ||
                                 sourceText[openQuoteOffset] === '\t')) {
                             openQuoteOffset--;
                         }
@@ -255063,8 +255246,7 @@ const rule$g = createRule({
                         if (isQuotedAttribute) {
                             while (closeQuoteOffset < sourceText.length &&
                                 (sourceText[closeQuoteOffset] === ' ' ||
-                                    sourceText[closeQuoteOffset] === '\n' ||
-                                    sourceText[closeQuoteOffset] === '\r' ||
+                                    isLineBreakCharacter(sourceText[closeQuoteOffset]) ||
                                     sourceText[closeQuoteOffset] === '\t')) {
                                 closeQuoteOffset++;
                             }
@@ -255121,6 +255303,7 @@ const rule$f = createRule({
     rule: {
         create(context) {
             const sourceText = context.sourceCode.getText();
+            const lineBreak = getLineBreak(sourceText);
             let reported = false;
             return {
                 Element(rawNode) {
@@ -255132,7 +255315,7 @@ const rule$f = createRule({
                     }
                     reported = true;
                     context.report({
-                        fix: (fixer) => fixer.insertTextBeforeRange([0, 0], '<!DOCTYPE html>\n'),
+                        fix: (fixer) => fixer.insertTextBeforeRange([0, 0], `<!DOCTYPE html>${lineBreak}`),
                         loc: sourceSpanToLoc(node.startSourceSpan),
                         messageId: MESSAGE_ID$6,
                     });
@@ -255526,18 +255709,6 @@ const rule$a = createRule({
     name: 'short-tui-imports',
 });
 
-function isFieldLikeMember(member) {
-    return (member.type === dist$4.AST_NODE_TYPES.PropertyDefinition ||
-        member.type === dist$4.AST_NODE_TYPES.TSAbstractPropertyDefinition);
-}
-function isAccessorMember(member) {
-    return (member.type === dist$4.AST_NODE_TYPES.MethodDefinition &&
-        (member.kind === 'get' || member.kind === 'set'));
-}
-function isRelevantSpacingClassMember(member) {
-    return isFieldLikeMember(member) || isAccessorMember(member);
-}
-
 const rule$9 = createRule({
     create(context) {
         const sourceCode = context.sourceCode;
@@ -256766,7 +256937,7 @@ function buildRewrittenImports({ baseImportPath, node, state, symbolToEntryPoint
     if (remainingImportStatement) {
         importStatements.push(remainingImportStatement);
     }
-    return importStatements.join('\n');
+    return importStatements.join(getLineBreak(state.sourceCode.text));
 }
 function buildNamedImportStatement({ importKind, importPath, specifiers, state, }) {
     const importKeyword = importKind === 'type' ? 'import type' : 'import';
@@ -256904,8 +257075,9 @@ const plugin = {
     },
     rules: {
         'array-as-const': rule$5,
-        'at-compat': rule$X,
-        'attrs-newline': rule$W,
+        'at-compat': rule$Y,
+        'attrs-newline': rule$X,
+        'class-accessibility-spacing': rule$W,
         'class-property-naming': rule$4,
         'decorator-key-sort': rule$V,
         'element-newline': rule$U,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taiga-ui/eslint-plugin-experience-next",
-  "version": "0.526.0",
+  "version": "0.528.0",
   "description": "An ESLint plugin to enforce a consistent code styles across taiga-ui projects",
   "homepage": "https://github.com/taiga-family/toolkit#readme",
   "bugs": {
@@ -54,10 +54,10 @@
     "eslint-plugin-unicorn": "64.0.0",
     "eslint-plugin-unused-imports": "4.4.1",
     "globals": "17.6.0",
-    "typescript-eslint": "8.59.1"
+    "typescript-eslint": "8.59.2"
   },
   "devDependencies": {
-    "@typescript-eslint/rule-tester": "8.59.1"
+    "@typescript-eslint/rule-tester": "8.59.2"
   },
   "peerDependencies": {
     "eslint": "^9.39.4"

package/rules/recommended/class-accessibility-spacing.d.ts

@@ -0,0 +1,4 @@
+export declare const rule: import("@typescript-eslint/utils/ts-eslint").RuleModule<"classAccessibilitySpacing", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+    name: string;
+};
+export default rule;

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

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

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

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

package/rules/utils/angular/import-fix-helpers.d.ts

@@ -6,7 +6,7 @@ export declare function findUntrackedAlias(program: TSESTree.Program): string |
  * Builds fixer actions that add `untracked` to an existing `@angular/core` import,
  * or insert a new import declaration when none exists.
  */
-export declare function buildUntrackedImportFixes(program: TSESTree.Program, fixer: RuleFixer): Array<ReturnType<RuleFixer['insertTextBefore']>>;
+export declare function buildUntrackedImportFixes(program: TSESTree.Program, fixer: RuleFixer, sourceCode: SourceCode): Array<ReturnType<RuleFixer['insertTextBefore']>>;
 /**
  * Removes the `untracked` import specifier from `@angular/core`.
  * When it is the last specifier, removes the entire declaration.

package/rules/utils/ast/class-members.d.ts

@@ -1,6 +1,14 @@
 import { type TSESTree } from '@typescript-eslint/utils';
 export { getLeadingIndentation, getLineBreak, getLineStartOffset, hasBlankLine, hasCommentLikeText, isSingleLineNode, } from './spacing';
 export type FieldLikeMember = TSESTree.PropertyDefinition | TSESTree.TSAbstractPropertyDefinition;
+export type AccessibilityGroup = 'private' | 'protected' | 'public';
+export type AccessibilityClassMember = TSESTree.AccessorProperty | TSESTree.MethodDefinition | TSESTree.PropertyDefinition | TSESTree.TSAbstractAccessorProperty | TSESTree.TSAbstractMethodDefinition | TSESTree.TSAbstractPropertyDefinition | TSESTree.TSIndexSignature;
+export type EcmascriptPrivateClassMember = Exclude<AccessibilityClassMember, TSESTree.TSIndexSignature> & {
+    readonly key: TSESTree.PrivateIdentifier;
+};
 export declare function isFieldLikeMember(member: TSESTree.ClassElement): member is FieldLikeMember;
 export declare function isAccessorMember(member: TSESTree.ClassElement): member is TSESTree.MethodDefinition;
 export declare function isRelevantSpacingClassMember(member: TSESTree.ClassElement): member is FieldLikeMember | TSESTree.MethodDefinition;
+export declare function isAccessibilityClassMember(member: TSESTree.ClassElement): member is AccessibilityClassMember;
+export declare function isEcmascriptPrivateClassMember(member: TSESTree.ClassElement): member is EcmascriptPrivateClassMember;
+export declare function getAccessibilityGroup(member: AccessibilityClassMember): AccessibilityGroup;

package/rules/utils/ast/spacing.d.ts

@@ -1,9 +1,15 @@
 import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
 export declare function isSingleLineNode(node: TSESTree.Node): boolean;
+export declare function isLineBreakCharacter(char: string | undefined): boolean;
 export declare function hasCommentLikeText(text: string): boolean;
 export declare function hasBlankLine(text: string): boolean;
+export declare function hasBlankLineBetweenNodes(text: string): boolean;
 export declare function getLineBreak(text: string): string;
+export declare function hasLineBreak(text: string): boolean;
 export declare function getLeadingIndentation(text: string): string;
 export declare function getLineStartOffset(text: string, offset: number): number;
+export declare function getLineEndOffset(text: string, lineStartOffset: number): number;
+export declare function getNextLineStartOffset(text: string, offset: number): number;
+export declare function splitLines(text: string): string[];
 export declare function getIndentAtOffset(text: string, offset: number): string;
 export declare function getSpacingReplacement(sourceCode: Readonly<TSESLint.SourceCode>, betweenText: string, nextLine: number, blankLineCount: number): string;