@yoo-digital/eslint-plugin-angular 2.0.4 → 2.0.6

package/README.md

@@ -12,15 +12,15 @@ Wrong code is yellow/red underlined in VScode, it can also be raised running : `
 
 This feature consists of **two complementary rules**:
 
-1. **`boolean-attribute-ts`** - TypeScript rule that enforces `booleanAttribute` transform on boolean inputs
-2. **`boolean-attribute-html`** - Template rule that enforces shorthand syntax for `[attr]="true"` bindings
+1. **`boolean-input`** - TypeScript rule that enforces `booleanAttribute` transform on boolean inputs
+2. **`boolean-attribute-shorthand`** - Template rule that enforces shorthand syntax for `[attr]="true"` bindings
 
 ### Setting 
 ```json
 {
   "rules": {
-    "@yoo-digital/eslint-plugin-angular/boolean-attribute-ts": "error",
-    "@yoo-digital/eslint-plugin-angular/boolean-attribute-html": "error"
+    "@yoo-digital/eslint-plugin-angular/boolean-input": "error",
+    "@yoo-digital/eslint-plugin-angular/boolean-attribute-shorthand": "error"
   }
 }
 ```

package/dist/index.d.ts

@@ -3,15 +3,15 @@ export declare const configs: {
     default: {
         plugins: string[];
         rules: {
-            '@yoo-digital/angular/boolean-attribute-html': string;
-            '@yoo-digital/angular/boolean-attribute-ts': string;
+            '@yoo-digital/angular/boolean-attribute-shorthand': string;
+            '@yoo-digital/angular/boolean-input': string;
         };
     };
     recommended: {
         plugins: string[];
         rules: {
-            '@yoo-digital/angular/boolean-attribute-html': string;
-            '@yoo-digital/angular/boolean-attribute-ts': string;
+            '@yoo-digital/angular/boolean-attribute-shorthand': string;
+            '@yoo-digital/angular/boolean-input': string;
         };
     };
 };

package/dist/index.js

@@ -3,22 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.configs = exports.rules = void 0;
 const rules_1 = require("./rules");
 exports.rules = {
-    'boolean-attribute-html': rules_1.preferBooleanAttributeShorthandRule,
-    'boolean-attribute-ts': rules_1.requireBooleanAttributeTransformRule,
+    'boolean-attribute-shorthand': rules_1.preferBooleanAttributeShorthandRule,
+    'boolean-input': rules_1.requireBooleanAttributeTransformRule,
 };
 exports.configs = {
     default: {
         plugins: ['@yoo-digital/eslint-plugin-angular'],
         rules: {
-            '@yoo-digital/angular/boolean-attribute-html': 'warn',
-            '@yoo-digital/angular/boolean-attribute-ts': 'warn',
+            '@yoo-digital/angular/boolean-attribute-shorthand': 'warn',
+            '@yoo-digital/angular/boolean-input': 'warn',
         },
     },
     recommended: {
         plugins: ['@yoo-digital/eslint-plugin-angular'],
         rules: {
-            '@yoo-digital/angular/boolean-attribute-html': 'error',
-            '@yoo-digital/angular/boolean-attribute-ts': 'error',
+            '@yoo-digital/angular/boolean-attribute-shorthand': 'error',
+            '@yoo-digital/angular/boolean-input': 'error',
         },
     },
 };

package/dist/rules/{boolean-attribute-html.d.ts → boolean-attribute-shorthand.d.ts}

@@ -1,6 +1,6 @@
 import type { TSESLint } from '@typescript-eslint/utils';
 type MessageIds = 'preferTrue' | 'suggestTrue';
-export declare const RULE_NAME = "boolean-attribute-html";
+export declare const RULE_NAME = "boolean-attribute-shorthand";
 /**
  * This rule enforces shorthand syntax for boolean inputs bound to true.
  *

package/dist/rules/{boolean-attribute-html.js → boolean-attribute-shorthand.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferBooleanAttributeShorthandRule = exports.RULE_NAME = void 0;
 const utils_1 = require("@angular-eslint/utils");
-exports.RULE_NAME = 'boolean-attribute-html';
+exports.RULE_NAME = 'boolean-attribute-shorthand';
 /**
  * This rule enforces shorthand syntax for boolean inputs bound to true.
  *

package/dist/rules/{boolean-attribute-ts.d.ts → boolean-input.d.ts}

@@ -1,6 +1,6 @@
 import type { TSESLint } from '@typescript-eslint/utils';
 type MessageIds = 'requireTransformDecorator' | 'requireTransformSignal';
-export declare const RULE_NAME = "boolean-attribute-ts";
+export declare const RULE_NAME = "boolean-input";
 /**
  * This rule enforces that boolean @Input() properties and input() signals
  * use the booleanAttribute transform.

package/dist/rules/{boolean-attribute-ts.js → boolean-input.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireBooleanAttributeTransformRule = exports.RULE_NAME = void 0;
-exports.RULE_NAME = 'boolean-attribute-ts';
+exports.RULE_NAME = 'boolean-input';
 /**
  * This rule enforces that boolean @Input() properties and input() signals
  * use the booleanAttribute transform.
@@ -28,44 +28,90 @@ exports.requireBooleanAttributeTransformRule = {
     defaultOptions: [],
     create(context) {
         return {
-            // Handle @Input() decorator syntax
+            // Handle both @Input() decorator syntax and input() signal syntax
             PropertyDefinition(node) {
-                // Check if it's a boolean property with @Input() decorator
-                if (!node.typeAnnotation || node.typeAnnotation.typeAnnotation.type !== 'TSBooleanKeyword') {
-                    return;
-                }
+                // Case 1: Check for @Input() decorator with boolean type
                 const hasInputDecorator = node.decorators?.some((decorator) => decorator.expression.type === 'CallExpression' &&
                     decorator.expression.callee.type === 'Identifier' &&
                     decorator.expression.callee.name === 'Input');
-                if (!hasInputDecorator) {
-                    return;
-                }
-                // Check if it already has transform: booleanAttribute
-                const inputDecorator = node.decorators?.find((decorator) => decorator.expression.type === 'CallExpression' &&
-                    decorator.expression.callee.type === 'Identifier' &&
-                    decorator.expression.callee.name === 'Input');
-                if (inputDecorator?.expression.type === 'CallExpression') {
-                    const args = inputDecorator.expression.arguments;
-                    if (args.length > 0 && args[0].type === 'ObjectExpression') {
-                        const hasTransform = args[0].properties.some((prop) => prop.type === 'Property' &&
-                            prop.key.type === 'Identifier' &&
-                            prop.key.name === 'transform' &&
-                            prop.value.type === 'Identifier' &&
-                            prop.value.name === 'booleanAttribute');
-                        if (hasTransform) {
-                            return; // Already has transform
+                if (hasInputDecorator) {
+                    // Handle @Input() decorator
+                    if (!node.typeAnnotation || node.typeAnnotation.typeAnnotation.type !== 'TSBooleanKeyword') {
+                        return;
+                    }
+                    // Check if it already has transform: booleanAttribute
+                    const inputDecorator = node.decorators?.find((decorator) => decorator.expression.type === 'CallExpression' &&
+                        decorator.expression.callee.type === 'Identifier' &&
+                        decorator.expression.callee.name === 'Input');
+                    if (inputDecorator?.expression.type === 'CallExpression') {
+                        const args = inputDecorator.expression.arguments;
+                        if (args.length > 0 && args[0].type === 'ObjectExpression') {
+                            const hasTransform = args[0].properties.some((prop) => prop.type === 'Property' &&
+                                prop.key.type === 'Identifier' &&
+                                prop.key.name === 'transform' &&
+                                prop.value.type === 'Identifier' &&
+                                prop.value.name === 'booleanAttribute');
+                            if (hasTransform) {
+                                return; // Already has transform
+                            }
                         }
                     }
+                    // Report the issue for @Input()
+                    const propertyName = node.key.type === 'Identifier' ? node.key.name : 'unknown';
+                    context.report({
+                        node: node.key,
+                        messageId: 'requireTransformDecorator',
+                        data: { name: propertyName },
+                    });
+                    return;
                 }
-                // Report the issue
+                // Case 2: Check for input() signal syntax
+                if (!node.value ||
+                    node.value.type !== 'CallExpression' ||
+                    node.value.callee.type !== 'Identifier' ||
+                    node.value.callee.name !== 'input') {
+                    return;
+                }
+                const callExpr = node.value;
+                // Check if it's a boolean input (with or without type arguments)
+                let isBooleanInput = false;
+                if (callExpr.typeArguments && callExpr.typeArguments.params.length > 0) {
+                    const firstTypeParam = callExpr.typeArguments.params[0];
+                    isBooleanInput = firstTypeParam.type === 'TSBooleanKeyword';
+                }
+                if (!isBooleanInput) {
+                    return;
+                }
+                // At this point, we know typeArguments exists and has at least one boolean param
+                const typeArgs = callExpr.typeArguments;
+                // Check if it already has BooleanInput as second type parameter
+                const hasBooleanInput = typeArgs.params.length > 1 &&
+                    typeArgs.params[1].type === 'TSTypeReference' &&
+                    typeArgs.params[1].typeName.type === 'Identifier' &&
+                    typeArgs.params[1].typeName.name === 'BooleanInput';
+                // Check if it already has transform in options
+                const hasTransformOption = callExpr.arguments.length > 1 &&
+                    callExpr.arguments[1].type === 'ObjectExpression' &&
+                    callExpr.arguments[1].properties.some((prop) => prop.type === 'Property' &&
+                        prop.key.type === 'Identifier' &&
+                        prop.key.name === 'transform' &&
+                        prop.value.type === 'Identifier' &&
+                        prop.value.name === 'booleanAttribute');
+                // Both BooleanInput type and transform option are required
+                // Only skip if BOTH are present
+                if (hasBooleanInput && hasTransformOption) {
+                    return; // Already correctly configured
+                }
+                // If we reach here, at least one requirement is missing
+                // Report the issue for input() signal
                 const propertyName = node.key.type === 'Identifier' ? node.key.name : 'unknown';
                 context.report({
                     node: node.key,
-                    messageId: 'requireTransformDecorator',
+                    messageId: 'requireTransformSignal',
                     data: { name: propertyName },
                 });
             },
-            // Handle input() signal syntax
+            // Handle input() signal syntax (standalone variable declarations - rare)
             VariableDeclarator(node) {
                 if (node.init?.type !== 'CallExpression' ||
                     node.init.callee.type !== 'Identifier' ||

package/dist/rules/index.d.ts

@@ -1,2 +1,2 @@
-export { RULE_NAME as BOOLEAN_ATTRIBUTE_HTML_RULE_NAME, preferBooleanAttributeShorthandRule } from './boolean-attribute-html';
-export { RULE_NAME as BOOLEAN_ATTRIBUTE_TS_RULE_NAME, requireBooleanAttributeTransformRule } from './boolean-attribute-ts';
+export { RULE_NAME as BOOLEAN_ATTRIBUTE_SHORTHAND_RULE_NAME, preferBooleanAttributeShorthandRule } from './boolean-attribute-shorthand';
+export { RULE_NAME as BOOLEAN_INPUT_RULE_NAME, requireBooleanAttributeTransformRule } from './boolean-input';

package/dist/rules/index.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireBooleanAttributeTransformRule = exports.BOOLEAN_ATTRIBUTE_TS_RULE_NAME = exports.preferBooleanAttributeShorthandRule = exports.BOOLEAN_ATTRIBUTE_HTML_RULE_NAME = void 0;
-var boolean_attribute_html_1 = require("./boolean-attribute-html");
-Object.defineProperty(exports, "BOOLEAN_ATTRIBUTE_HTML_RULE_NAME", { enumerable: true, get: function () { return boolean_attribute_html_1.RULE_NAME; } });
-Object.defineProperty(exports, "preferBooleanAttributeShorthandRule", { enumerable: true, get: function () { return boolean_attribute_html_1.preferBooleanAttributeShorthandRule; } });
-var boolean_attribute_ts_1 = require("./boolean-attribute-ts");
-Object.defineProperty(exports, "BOOLEAN_ATTRIBUTE_TS_RULE_NAME", { enumerable: true, get: function () { return boolean_attribute_ts_1.RULE_NAME; } });
-Object.defineProperty(exports, "requireBooleanAttributeTransformRule", { enumerable: true, get: function () { return boolean_attribute_ts_1.requireBooleanAttributeTransformRule; } });
+exports.requireBooleanAttributeTransformRule = exports.BOOLEAN_INPUT_RULE_NAME = exports.preferBooleanAttributeShorthandRule = exports.BOOLEAN_ATTRIBUTE_SHORTHAND_RULE_NAME = void 0;
+var boolean_attribute_shorthand_1 = require("./boolean-attribute-shorthand");
+Object.defineProperty(exports, "BOOLEAN_ATTRIBUTE_SHORTHAND_RULE_NAME", { enumerable: true, get: function () { return boolean_attribute_shorthand_1.RULE_NAME; } });
+Object.defineProperty(exports, "preferBooleanAttributeShorthandRule", { enumerable: true, get: function () { return boolean_attribute_shorthand_1.preferBooleanAttributeShorthandRule; } });
+var boolean_input_1 = require("./boolean-input");
+Object.defineProperty(exports, "BOOLEAN_INPUT_RULE_NAME", { enumerable: true, get: function () { return boolean_input_1.RULE_NAME; } });
+Object.defineProperty(exports, "requireBooleanAttributeTransformRule", { enumerable: true, get: function () { return boolean_input_1.requireBooleanAttributeTransformRule; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yoo-digital/eslint-plugin-angular",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "Yoo Digital custom Angular ESLint plugin for enforcing boolean attribute best practices.",
   "type": "commonjs",
   "main": "dist/index.js",