@taiga-ui/eslint-plugin-experience-next 0.527.0 → 0.529.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

@@ -493,6 +493,11 @@ function hasBlankLine(text) {
     }
     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';
@@ -1247,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',
                 {
@@ -14974,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);
@@ -15189,7 +15229,7 @@ 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);
 }
@@ -216112,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);
@@ -216267,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();
@@ -248073,7 +248111,7 @@ function buildMultilineStartTag(node, sourceText) {
         closing,
     ].join(lineBreak);
 }
-const rule$W = createRule({
+const rule$X = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -248159,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;
 }
@@ -251223,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,
             });
@@ -255580,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;
@@ -256958,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.527.0",
+  "version": "0.529.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/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/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/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

@@ -3,6 +3,7 @@ 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;