@futdevpro/dynamo-eslint 1.20.2 → 1.20.5

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

@@ -1,333 +0,0 @@
-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): 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): 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): 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): 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): 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): 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): 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;