@futdevpro/dynamo-eslint 1.15.22 → 1.15.28

package/src/plugin/rules/prefer-enum-over-string-union.ts

@@ -1,334 +1,334 @@
-import { Rule } from 'eslint';
-
-interface RuleOptions {
-  minValues?: number;
-  allowTypeAliases?: boolean;
-}
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Suggest using enums instead of union types of string literals',
-      recommended: true,
-    },
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          minValues: {
-            type: 'number',
-            minimum: 2,
-            default: 3,
-          },
-          allowTypeAliases: {
-            type: 'boolean',
-            default: false,
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      preferEnum: 'Consider using an enum instead of a union type of {{count}} string literals.',
-    },
-    fixable: 'code',
-  },
-  create(context) {
-    const options: RuleOptions = context.options[0] || {};
-    const minValues: number = options.minValues || 3;
-    const allowTypeAliases: boolean = options.allowTypeAliases || false;
-
-    /**
-     * Check if a union type is composed solely of string literals
-     */
-    function isStringLiteralUnion(node: any): boolean {
-      if (node.type !== 'TSUnionType') {
-        return false;
-      }
-
-      if (!node.types || !Array.isArray(node.types)) {
-        return false;
-      }
-
-      return node.types.every((type: any) => 
-        type.type === 'TSLiteralType' && 
-        typeof type.literal?.value === 'string'
-      );
-    }
-
-    /**
-     * Check if a property is an Angular component input
-     */
-    function isAngularInput(node: any): boolean {
-      try {
-        // Check for @Input() decorator (old style)
-        if (node.decorators && Array.isArray(node.decorators)) {
-          const hasInputDecorator = node.decorators.some((decorator: any) => {
-            const expression = decorator.expression;
-
-            return expression?.type === 'CallExpression' && 
-                   expression.callee?.name === 'Input';
-          });
-
-          if (hasInputDecorator) {
-            return true;
-          }
-        }
-
-        // Check for input() or input.required() signal (new style)
-        if (node.value?.type === 'CallExpression') {
-          const callee = node.value.callee;
-
-          // Direct call: input()
-          if (callee?.name === 'input') {
-            return true;
-          }
-
-          // Member call: input.required()
-          if (callee?.object?.name === 'input' && callee?.property?.name === 'required') {
-            return true;
-          }
-        }
-
-        return false;
-      } catch (error) {
-        console.error('[prefer-enum-over-string-union] Error checking Angular input:', error);
-
-        return false;
-      }
-    }
-
-    /**
-     * Check if a union type meets the minimum threshold
-     */
-    function meetsThreshold(node: any): boolean {
-      if (node.type !== 'TSUnionType' || !node.types) {
-        return false;
-      }
-
-      const stringLiteralCount = node.types.filter((type: any) => 
-        type.type === 'TSLiteralType' && 
-        typeof type.literal?.value === 'string'
-      ).length;
-
-      return stringLiteralCount >= minValues;
-    }
-
-    /**
-     * Generate enum name suggestion based on context
-     */
-    function generateEnumName(node: any, parent: any): string {
-      try {
-        // For type aliases, use the type name
-        if (parent?.type === 'TSTypeAliasDeclaration' && parent.id?.name) {
-          return parent.id.name;
-        }
-
-        // For properties, use property name + "Enum"
-        if (node.type === 'TSPropertySignature' && node.key?.name) {
-          return `${node.key.name.charAt(0).toUpperCase() + node.key.name.slice(1)}Enum`;
-        }
-
-        // For class properties, use property name + "Enum"
-        if (parent?.type === 'PropertyDefinition' && parent.key?.name) {
-          return `${parent.key.name.charAt(0).toUpperCase() + parent.key.name.slice(1)}Enum`;
-        }
-
-        // Default fallback
-        return 'StatusEnum';
-      } catch (error) {
-        console.error('[prefer-enum-over-string-union] Error generating enum name:', error);
-
-        return 'StatusEnum';
-      }
-    }
-
-    /**
-     * Generate enum values from string literals
-     */
-    function generateEnumValues(node: any): string[] {
-      if (node.type !== 'TSUnionType' || !node.types) {
-        return [];
-      }
-
-      return node.types
-        .filter((type: any) => 
-          type.type === 'TSLiteralType' && 
-          typeof type.literal?.value === 'string'
-        )
-        .map((type: any) => {
-          const value = type.literal.value;
-
-          // Convert to PascalCase for enum key
-          return value
-            .split(/[-_\s]+/)
-            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-            .join('');
-        });
-    }
-
-    /**
-     * Report violation with enum suggestion
-     */
-    function reportViolation(node: any, parent: any, unionNode: any): void {
-      const stringLiteralCount = unionNode.types.filter((type: any) => 
-        type.type === 'TSLiteralType' && 
-        typeof type.literal?.value === 'string'
-      ).length;
-
-      const enumName = generateEnumName(node, parent);
-      const enumValues = generateEnumValues(unionNode);
-
-      context.report({
-        node: unionNode,
-        messageId: 'preferEnum',
-        data: {
-          count: stringLiteralCount.toString(),
-        },
-        fix(fixer) {
-          try {
-            const enumDeclaration = `enum ${enumName} {\n  ${enumValues.map((key, index) => {
-              const value = unionNode.types[index].literal.value;
-
-              return `${key} = '${value}'`;
-            }).join(',\n  ')}\n}`;
-
-            // For type aliases, replace the entire declaration
-            if (parent?.type === 'TSTypeAliasDeclaration') {
-              const typeText = context.sourceCode.getText(parent);
-              const newText = typeText.replace(/=.*/, `= ${enumName};`);
-
-              return fixer.replaceText(parent, newText);
-            }
-
-            // For other cases, suggest enum creation (no auto-fix for now)
-            return null;
-          } catch (fixError) {
-            console.error('[prefer-enum-over-string-union] Error in fix function:', fixError);
-
-            return null;
-          }
-        },
-      });
-    }
-
-    return {
-      // Type aliases
-      TSTypeAliasDeclaration(node: any, _context?: any, _sourceCode?: any): void {
-        try {
-          if (allowTypeAliases) {
-            return;
-          }
-
-          if (isStringLiteralUnion(node.typeAnnotation) && meetsThreshold(node.typeAnnotation)) {
-            reportViolation(node.typeAnnotation, node, node.typeAnnotation);
-          }
-        } catch (error) {
-          console.error('[prefer-enum-over-string-union] Error in TSTypeAliasDeclaration visitor:', error);
-        }
-      },
-
-      // Interface/type properties
-      TSPropertySignature(node: any, _context?: any, _sourceCode?: any): void {
-        try {
-          if (isAngularInput(node)) {
-            return;
-          }
-
-          if (node.typeAnnotation && 
-              isStringLiteralUnion(node.typeAnnotation.typeAnnotation) && 
-              meetsThreshold(node.typeAnnotation.typeAnnotation)) {
-            reportViolation(node, node.parent, node.typeAnnotation.typeAnnotation);
-          }
-        } catch (error) {
-          console.error('[prefer-enum-over-string-union] Error in TSPropertySignature visitor:', error);
-        }
-      },
-
-      // Class properties
-      PropertyDefinition(node: any, _context?: any, _sourceCode?: any): void {
-        try {
-          if (isAngularInput(node)) {
-            return;
-          }
-
-          if (node.typeAnnotation && 
-              isStringLiteralUnion(node.typeAnnotation.typeAnnotation) && 
-              meetsThreshold(node.typeAnnotation.typeAnnotation)) {
-            reportViolation(node, node.parent, node.typeAnnotation.typeAnnotation);
-          }
-        } catch (error) {
-          console.error('[prefer-enum-over-string-union] Error in PropertyDefinition visitor:', error);
-        }
-      },
-
-      // Function parameters
-      FunctionDeclaration(node: any, _context?: any, _sourceCode?: any): void {
-        try {
-          if (node.params && Array.isArray(node.params)) {
-            node.params.forEach((param: any) => {
-              if (param.typeAnnotation && 
-                  isStringLiteralUnion(param.typeAnnotation.typeAnnotation) && 
-                  meetsThreshold(param.typeAnnotation.typeAnnotation)) {
-                reportViolation(param, node, param.typeAnnotation.typeAnnotation);
-              }
-            });
-          }
-        } catch (error) {
-          console.error('[prefer-enum-over-string-union] Error in FunctionDeclaration visitor:', error);
-        }
-      },
-
-      // Arrow function parameters
-      ArrowFunctionExpression(node: any, _context?: any, _sourceCode?: any): void {
-        try {
-          if (node.params && Array.isArray(node.params)) {
-            node.params.forEach((param: any) => {
-              if (param.typeAnnotation && 
-                  isStringLiteralUnion(param.typeAnnotation.typeAnnotation) && 
-                  meetsThreshold(param.typeAnnotation.typeAnnotation)) {
-                reportViolation(param, node, param.typeAnnotation.typeAnnotation);
-              }
-            });
-          }
-        } catch (error) {
-          console.error('[prefer-enum-over-string-union] Error in ArrowFunctionExpression visitor:', error);
-        }
-      },
-
-      // Variable declarations
-      VariableDeclarator(node: any, _context?: any, _sourceCode?: any): void {
-        try {
-          if (node.typeAnnotation && 
-              isStringLiteralUnion(node.typeAnnotation.typeAnnotation) && 
-              meetsThreshold(node.typeAnnotation.typeAnnotation)) {
-            reportViolation(node, node.parent, node.typeAnnotation.typeAnnotation);
-          }
-        } catch (error) {
-          console.error('[prefer-enum-over-string-union] Error in VariableDeclarator visitor:', error);
-        }
-      },
-
-      // Method signatures
-      TSMethodSignature(node: any, _context?: any, _sourceCode?: any): void {
-        try {
-          if (node.params && Array.isArray(node.params)) {
-            node.params.forEach((param: any) => {
-              if (param.typeAnnotation && 
-                  isStringLiteralUnion(param.typeAnnotation.typeAnnotation) && 
-                  meetsThreshold(param.typeAnnotation.typeAnnotation)) {
-                reportViolation(param, node, param.typeAnnotation.typeAnnotation);
-              }
-            });
-          }
-        } catch (error) {
-          console.error('[prefer-enum-over-string-union] Error in TSMethodSignature visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;
+import { Rule } from 'eslint';
+
+interface RuleOptions {
+  minValues?: number;
+  allowTypeAliases?: boolean;
+}
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Suggest using enums instead of union types of string literals',
+      recommended: true,
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          minValues: {
+            type: 'number',
+            minimum: 2,
+            default: 3,
+          },
+          allowTypeAliases: {
+            type: 'boolean',
+            default: false,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      preferEnum: 'Consider using an enum instead of a union type of {{count}} string literals.',
+    },
+    fixable: 'code',
+  },
+  create(context) {
+    const options: RuleOptions = context.options[0] || {};
+    const minValues: number = options.minValues || 3;
+    const allowTypeAliases: boolean = options.allowTypeAliases || false;
+
+    /**
+     * Check if a union type is composed solely of string literals
+     */
+    function isStringLiteralUnion(node: any): boolean {
+      if (node.type !== 'TSUnionType') {
+        return false;
+      }
+
+      if (!node.types || !Array.isArray(node.types)) {
+        return false;
+      }
+
+      return node.types.every((type: any) => 
+        type.type === 'TSLiteralType' && 
+        typeof type.literal?.value === 'string'
+      );
+    }
+
+    /**
+     * Check if a property is an Angular component input
+     */
+    function isAngularInput(node: any): boolean {
+      try {
+        // Check for @Input() decorator (old style)
+        if (node.decorators && Array.isArray(node.decorators)) {
+          const hasInputDecorator = node.decorators.some((decorator: any) => {
+            const expression = decorator.expression;
+
+            return expression?.type === 'CallExpression' && 
+                   expression.callee?.name === 'Input';
+          });
+
+          if (hasInputDecorator) {
+            return true;
+          }
+        }
+
+        // Check for input() or input.required() signal (new style)
+        if (node.value?.type === 'CallExpression') {
+          const callee = node.value.callee;
+
+          // Direct call: input()
+          if (callee?.name === 'input') {
+            return true;
+          }
+
+          // Member call: input.required()
+          if (callee?.object?.name === 'input' && callee?.property?.name === 'required') {
+            return true;
+          }
+        }
+
+        return false;
+      } catch (error) {
+        console.error('[prefer-enum-over-string-union] Error checking Angular input:', error);
+
+        return false;
+      }
+    }
+
+    /**
+     * Check if a union type meets the minimum threshold
+     */
+    function meetsThreshold(node: any): boolean {
+      if (node.type !== 'TSUnionType' || !node.types) {
+        return false;
+      }
+
+      const stringLiteralCount = node.types.filter((type: any) => 
+        type.type === 'TSLiteralType' && 
+        typeof type.literal?.value === 'string'
+      ).length;
+
+      return stringLiteralCount >= minValues;
+    }
+
+    /**
+     * Generate enum name suggestion based on context
+     */
+    function generateEnumName(node: any, parent: any): string {
+      try {
+        // For type aliases, use the type name
+        if (parent?.type === 'TSTypeAliasDeclaration' && parent.id?.name) {
+          return parent.id.name;
+        }
+
+        // For properties, use property name + "Enum"
+        if (node.type === 'TSPropertySignature' && node.key?.name) {
+          return `${node.key.name.charAt(0).toUpperCase() + node.key.name.slice(1)}Enum`;
+        }
+
+        // For class properties, use property name + "Enum"
+        if (parent?.type === 'PropertyDefinition' && parent.key?.name) {
+          return `${parent.key.name.charAt(0).toUpperCase() + parent.key.name.slice(1)}Enum`;
+        }
+
+        // Default fallback
+        return 'StatusEnum';
+      } catch (error) {
+        console.error('[prefer-enum-over-string-union] Error generating enum name:', error);
+
+        return 'StatusEnum';
+      }
+    }
+
+    /**
+     * Generate enum values from string literals
+     */
+    function generateEnumValues(node: any): string[] {
+      if (node.type !== 'TSUnionType' || !node.types) {
+        return [];
+      }
+
+      return node.types
+        .filter((type: any) => 
+          type.type === 'TSLiteralType' && 
+          typeof type.literal?.value === 'string'
+        )
+        .map((type: any) => {
+          const value = type.literal.value;
+
+          // Convert to PascalCase for enum key
+          return value
+            .split(/[-_\s]+/)
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join('');
+        });
+    }
+
+    /**
+     * Report violation with enum suggestion
+     */
+    function reportViolation(node: any, parent: any, unionNode: any): void {
+      const stringLiteralCount = unionNode.types.filter((type: any) => 
+        type.type === 'TSLiteralType' && 
+        typeof type.literal?.value === 'string'
+      ).length;
+
+      const enumName = generateEnumName(node, parent);
+      const enumValues = generateEnumValues(unionNode);
+
+      context.report({
+        node: unionNode,
+        messageId: 'preferEnum',
+        data: {
+          count: stringLiteralCount.toString(),
+        },
+        fix(fixer) {
+          try {
+            const enumDeclaration = `enum ${enumName} {\n  ${enumValues.map((key, index) => {
+              const value = unionNode.types[index].literal.value;
+
+              return `${key} = '${value}'`;
+            }).join(',\n  ')}\n}`;
+
+            // For type aliases, replace the entire declaration
+            if (parent?.type === 'TSTypeAliasDeclaration') {
+              const typeText = context.sourceCode.getText(parent);
+              const newText = typeText.replace(/=.*/, `= ${enumName};`);
+
+              return fixer.replaceText(parent, newText);
+            }
+
+            // For other cases, suggest enum creation (no auto-fix for now)
+            return null;
+          } catch (fixError) {
+            console.error('[prefer-enum-over-string-union] Error in fix function:', fixError);
+
+            return null;
+          }
+        },
+      });
+    }
+
+    return {
+      // Type aliases
+      TSTypeAliasDeclaration(node: any, _context?: any, _sourceCode?: any): void {
+        try {
+          if (allowTypeAliases) {
+            return;
+          }
+
+          if (isStringLiteralUnion(node.typeAnnotation) && meetsThreshold(node.typeAnnotation)) {
+            reportViolation(node.typeAnnotation, node, node.typeAnnotation);
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in TSTypeAliasDeclaration visitor:', error);
+        }
+      },
+
+      // Interface/type properties
+      TSPropertySignature(node: any, _context?: any, _sourceCode?: any): void {
+        try {
+          if (isAngularInput(node)) {
+            return;
+          }
+
+          if (node.typeAnnotation && 
+              isStringLiteralUnion(node.typeAnnotation.typeAnnotation) && 
+              meetsThreshold(node.typeAnnotation.typeAnnotation)) {
+            reportViolation(node, node.parent, node.typeAnnotation.typeAnnotation);
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in TSPropertySignature visitor:', error);
+        }
+      },
+
+      // Class properties
+      PropertyDefinition(node: any, _context?: any, _sourceCode?: any): void {
+        try {
+          if (isAngularInput(node)) {
+            return;
+          }
+
+          if (node.typeAnnotation && 
+              isStringLiteralUnion(node.typeAnnotation.typeAnnotation) && 
+              meetsThreshold(node.typeAnnotation.typeAnnotation)) {
+            reportViolation(node, node.parent, node.typeAnnotation.typeAnnotation);
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in PropertyDefinition visitor:', error);
+        }
+      },
+
+      // Function parameters
+      FunctionDeclaration(node: any, _context?: any, _sourceCode?: any): void {
+        try {
+          if (node.params && Array.isArray(node.params)) {
+            node.params.forEach((param: any) => {
+              if (param.typeAnnotation && 
+                  isStringLiteralUnion(param.typeAnnotation.typeAnnotation) && 
+                  meetsThreshold(param.typeAnnotation.typeAnnotation)) {
+                reportViolation(param, node, param.typeAnnotation.typeAnnotation);
+              }
+            });
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in FunctionDeclaration visitor:', error);
+        }
+      },
+
+      // Arrow function parameters
+      ArrowFunctionExpression(node: any, _context?: any, _sourceCode?: any): void {
+        try {
+          if (node.params && Array.isArray(node.params)) {
+            node.params.forEach((param: any) => {
+              if (param.typeAnnotation && 
+                  isStringLiteralUnion(param.typeAnnotation.typeAnnotation) && 
+                  meetsThreshold(param.typeAnnotation.typeAnnotation)) {
+                reportViolation(param, node, param.typeAnnotation.typeAnnotation);
+              }
+            });
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in ArrowFunctionExpression visitor:', error);
+        }
+      },
+
+      // Variable declarations
+      VariableDeclarator(node: any, _context?: any, _sourceCode?: any): void {
+        try {
+          if (node.typeAnnotation && 
+              isStringLiteralUnion(node.typeAnnotation.typeAnnotation) && 
+              meetsThreshold(node.typeAnnotation.typeAnnotation)) {
+            reportViolation(node, node.parent, node.typeAnnotation.typeAnnotation);
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in VariableDeclarator visitor:', error);
+        }
+      },
+
+      // Method signatures
+      TSMethodSignature(node: any, _context?: any, _sourceCode?: any): void {
+        try {
+          if (node.params && Array.isArray(node.params)) {
+            node.params.forEach((param: any) => {
+              if (param.typeAnnotation && 
+                  isStringLiteralUnion(param.typeAnnotation.typeAnnotation) && 
+                  meetsThreshold(param.typeAnnotation.typeAnnotation)) {
+                reportViolation(param, node, param.typeAnnotation.typeAnnotation);
+              }
+            });
+          }
+        } catch (error) {
+          console.error('[prefer-enum-over-string-union] Error in TSMethodSignature visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;