@futdevpro/dynamo-eslint 1.15.22 → 1.15.28

package/build/plugin/rules/prefer-enum-over-string-union.js

@@ -1,290 +1,290 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const rule = {
-    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 = context.options[0] || {};
-        const minValues = options.minValues || 3;
-        const allowTypeAliases = options.allowTypeAliases || false;
-        /**
-         * Check if a union type is composed solely of string literals
-         */
-        function isStringLiteralUnion(node) {
-            if (node.type !== 'TSUnionType') {
-                return false;
-            }
-            if (!node.types || !Array.isArray(node.types)) {
-                return false;
-            }
-            return node.types.every((type) => type.type === 'TSLiteralType' &&
-                typeof type.literal?.value === 'string');
-        }
-        /**
-         * Check if a property is an Angular component input
-         */
-        function isAngularInput(node) {
-            try {
-                // Check for @Input() decorator (old style)
-                if (node.decorators && Array.isArray(node.decorators)) {
-                    const hasInputDecorator = node.decorators.some((decorator) => {
-                        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) {
-            if (node.type !== 'TSUnionType' || !node.types) {
-                return false;
-            }
-            const stringLiteralCount = node.types.filter((type) => type.type === 'TSLiteralType' &&
-                typeof type.literal?.value === 'string').length;
-            return stringLiteralCount >= minValues;
-        }
-        /**
-         * Generate enum name suggestion based on context
-         */
-        function generateEnumName(node, parent) {
-            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) {
-            if (node.type !== 'TSUnionType' || !node.types) {
-                return [];
-            }
-            return node.types
-                .filter((type) => type.type === 'TSLiteralType' &&
-                typeof type.literal?.value === 'string')
-                .map((type) => {
-                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, parent, unionNode) {
-            const stringLiteralCount = unionNode.types.filter((type) => 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, _context, _sourceCode) {
-                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, _context, _sourceCode) {
-                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, _context, _sourceCode) {
-                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, _context, _sourceCode) {
-                try {
-                    if (node.params && Array.isArray(node.params)) {
-                        node.params.forEach((param) => {
-                            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, _context, _sourceCode) {
-                try {
-                    if (node.params && Array.isArray(node.params)) {
-                        node.params.forEach((param) => {
-                            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, _context, _sourceCode) {
-                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, _context, _sourceCode) {
-                try {
-                    if (node.params && Array.isArray(node.params)) {
-                        node.params.forEach((param) => {
-                            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);
-                }
-            },
-        };
-    },
-};
-exports.default = rule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    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 = context.options[0] || {};
+        const minValues = options.minValues || 3;
+        const allowTypeAliases = options.allowTypeAliases || false;
+        /**
+         * Check if a union type is composed solely of string literals
+         */
+        function isStringLiteralUnion(node) {
+            if (node.type !== 'TSUnionType') {
+                return false;
+            }
+            if (!node.types || !Array.isArray(node.types)) {
+                return false;
+            }
+            return node.types.every((type) => type.type === 'TSLiteralType' &&
+                typeof type.literal?.value === 'string');
+        }
+        /**
+         * Check if a property is an Angular component input
+         */
+        function isAngularInput(node) {
+            try {
+                // Check for @Input() decorator (old style)
+                if (node.decorators && Array.isArray(node.decorators)) {
+                    const hasInputDecorator = node.decorators.some((decorator) => {
+                        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) {
+            if (node.type !== 'TSUnionType' || !node.types) {
+                return false;
+            }
+            const stringLiteralCount = node.types.filter((type) => type.type === 'TSLiteralType' &&
+                typeof type.literal?.value === 'string').length;
+            return stringLiteralCount >= minValues;
+        }
+        /**
+         * Generate enum name suggestion based on context
+         */
+        function generateEnumName(node, parent) {
+            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) {
+            if (node.type !== 'TSUnionType' || !node.types) {
+                return [];
+            }
+            return node.types
+                .filter((type) => type.type === 'TSLiteralType' &&
+                typeof type.literal?.value === 'string')
+                .map((type) => {
+                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, parent, unionNode) {
+            const stringLiteralCount = unionNode.types.filter((type) => 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, _context, _sourceCode) {
+                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, _context, _sourceCode) {
+                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, _context, _sourceCode) {
+                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, _context, _sourceCode) {
+                try {
+                    if (node.params && Array.isArray(node.params)) {
+                        node.params.forEach((param) => {
+                            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, _context, _sourceCode) {
+                try {
+                    if (node.params && Array.isArray(node.params)) {
+                        node.params.forEach((param) => {
+                            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, _context, _sourceCode) {
+                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, _context, _sourceCode) {
+                try {
+                    if (node.params && Array.isArray(node.params)) {
+                        node.params.forEach((param) => {
+                            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);
+                }
+            },
+        };
+    },
+};
+exports.default = rule;
 //# sourceMappingURL=prefer-enum-over-string-union.js.map

package/build/plugin/rules/prefer-interface-over-duplicate-types.d.ts

@@ -1,4 +1,4 @@
-import { Rule } from 'eslint';
-declare const rule: Rule.RuleModule;
-export default rule;
+import { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;
 //# sourceMappingURL=prefer-interface-over-duplicate-types.d.ts.map