@futdevpro/dynamo-eslint 1.15.22 → 1.15.28

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

@@ -1,265 +1,265 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Suggest creating interfaces for object types used more than the threshold number of times',
-            recommended: true,
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    threshold: {
-                        type: 'number',
-                        minimum: 2,
-                        default: 3,
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            preferInterface: 'Object type used {{count}} times. Consider creating interface "{{interfaceName}}"}}',
-        },
-        // BFR-ADVENTOR-009 (2. lépcső): a fixer forrás-szöveg-megőrzőre átírva (`sourceCode.getText` per property)
-        // → a komplex/union/qualified/function típusok EXAKT megőrződnek, a generált interface ÉRVÉNYES TS. Ezért
-        // az auto-fix (`fixable:'code'`) VISSZA — a bulk `eslint --fix` biztonságosan futtathatja (nem generál
-        // többé `reference`/`complex` literál-hibát). (1. lépcső: suggestion-degrade, most feloldva.)
-        fixable: 'code',
-    },
-    create(context) {
-        const options = context.options[0] || {};
-        const threshold = options.threshold || 3;
-        const sourceCode = context.sourceCode;
-        // Map to track type signatures and their usages
-        const typeUsages = new Map();
-        const allTypeLiterals = [];
-        /**
-         * Normalize object type to a signature string for comparison
-         */
-        function normalizeObjectType(node) {
-            if (!node || node.type !== 'TSTypeLiteral') {
-                return '';
-            }
-            if (!node.members || !Array.isArray(node.members)) {
-                return '';
-            }
-            // Extract and sort properties
-            const properties = node.members
-                .filter((member) => member.type === 'TSPropertySignature')
-                .map((member) => {
-                const key = member.key?.name || member.key?.value || 'unknown';
-                const type = getTypeString(member.typeAnnotation);
-                const optional = member.optional ? '?' : '';
-                const readonly = member.readonly ? 'readonly ' : '';
-                return `${readonly}${key}${optional}:${type}`;
-            })
-                .sort(); // Sort alphabetically
-            return properties.join(';');
-        }
-        /**
-         * Get string representation of a type annotation
-         */
-        function getTypeString(typeAnnotation) {
-            if (!typeAnnotation || !typeAnnotation.typeAnnotation) {
-                return 'any';
-            }
-            const type = typeAnnotation.typeAnnotation;
-            switch (type.type) {
-                case 'TSStringKeyword':
-                    return 'string';
-                case 'TSNumberKeyword':
-                    return 'number';
-                case 'TSBooleanKeyword':
-                    return 'boolean';
-                case 'TSVoidKeyword':
-                    return 'void';
-                case 'TSNullKeyword':
-                    return 'null';
-                case 'TSUndefinedKeyword':
-                    return 'undefined';
-                case 'TSAnyKeyword':
-                    return 'any';
-                case 'TSUnknownKeyword':
-                    return 'unknown';
-                case 'TSNeverKeyword':
-                    return 'never';
-                case 'TSObjectKeyword':
-                    return 'object';
-                case 'TSLiteralType':
-                    return type.literal?.value?.toString() || 'literal';
-                case 'TSArrayType':
-                    return `${getTypeString({ typeAnnotation: type.elementType })}[]`;
-                case 'TSTypeReference':
-                    return type.typeName?.name || 'reference';
-                case 'TSTypeLiteral':
-                    return normalizeObjectType(type);
-                case 'TSUnionType':
-                    return type.types?.map((t) => getTypeString({ typeAnnotation: t })).join('|') || 'union';
-                case 'TSIntersectionType':
-                    return type.types?.map((t) => getTypeString({ typeAnnotation: t })).join('&') || 'intersection';
-                default:
-                    return 'complex';
-            }
-        }
-        /**
-         * Generate interface name based on context
-         */
-        function generateInterfaceName(signature, usageCount) {
-            // Try to extract meaningful name from signature
-            const properties = signature.split(';');
-            if (properties.length === 1) {
-                const prop = properties[0].split(':')[0].replace('readonly ', '').replace('?', '');
-                if (prop && prop !== 'unknown') {
-                    return `${prop.charAt(0).toUpperCase() + prop.slice(1)}Interface`;
-                }
-            }
-            // Fallback to generic name
-            return `GeneratedInterface${usageCount}`;
-        }
-        /**
-         * Check if interface name conflicts with existing identifiers
-         */
-        function isNameConflict(name) {
-            try {
-                const scope = context.sourceCode.getScope(context.sourceCode.ast);
-                return scope.variables.some(variable => variable.name === name);
-            }
-            catch {
-                return false;
-            }
-        }
-        /**
-         * Generate unique interface name
-         */
-        function generateUniqueInterfaceName(baseName) {
-            let name = baseName;
-            let counter = 1;
-            while (isNameConflict(name)) {
-                name = `${baseName}${counter}`;
-                counter++;
-            }
-            return name;
-        }
-        /**
-         * BFR-ADVENTOR-009 (2. lépcső): az interface-törzs a FORRÁS-SZÖVEGBŐL épül (sourceCode.getText per
-         * member), NEM a lossy normalizált signature-ből → a komplex/union/qualified/function típusok EXAKT
-         * megőrződnek (a korábbi `reference`/`complex`/`union` literál-hibák megszűnnek). A `getText` az eredeti
-         * property-szöveget adja (pl. `onError: (e: Error) => void`); a záró `;`/`,`-t normalizáljuk.
-         */
-        function buildInterfaceBody(node) {
-            const members = Array.isArray(node?.members) ? node.members : [];
-            return members
-                .map((member) => {
-                const text = sourceCode.getText(member).trim().replace(/[;,]\s*$/, '');
-                return `  ${text};`;
-            })
-                .join('\n');
-        }
-        /**
-         * Beszédes interface-név a property-kulcsokból (BFR-ADVENTOR-009): a nem-beszédes, ütköző
-         * `GeneratedInterfaceN` helyett az első 1-3 kulcsból PascalCase + `Params_Interface` (a projekt-konvenció).
-         */
-        function deriveInterfaceName(node) {
-            const members = Array.isArray(node?.members) ? node.members : [];
-            const keys = members
-                .filter((m) => m.type === 'TSPropertySignature')
-                .map((m) => String(m.key?.name ?? m.key?.value ?? ''))
-                .filter((k) => !!k)
-                .slice(0, 3);
-            if (!keys.length) {
-                return 'Generated_Interface';
-            }
-            const pascal = keys
-                .map((k) => k.charAt(0).toUpperCase() + k.slice(1))
-                .join('');
-            return `${pascal}_Interface`;
-        }
-        return {
-            TSTypeLiteral(node, _context, _sourceCode) {
-                try {
-                    const signature = normalizeObjectType(node);
-                    if (!signature) {
-                        return;
-                    }
-                    allTypeLiterals.push(node);
-                    if (!typeUsages.has(signature)) {
-                        typeUsages.set(signature, []);
-                    }
-                    typeUsages.get(signature).push({
-                        node,
-                        signature,
-                    });
-                }
-                catch (error) {
-                    console.error('[prefer-interface-over-duplicate-types] Error in TSTypeLiteral visitor:', error);
-                }
-            },
-            'Program:exit'(node, _context, _sourceCode) {
-                try {
-                    // Process all collected type usages
-                    for (const [signature, usages] of typeUsages) {
-                        if (usages.length >= threshold) {
-                            // beszédes név a property-kulcsokból (ütközés-mentesre pontosítva)
-                            const interfaceName = generateUniqueInterfaceName(deriveInterfaceName(usages[0].node));
-                            // a törzs a FORRÁS-SZÖVEGBŐL (getText) — a komplex/union/qualified típusok EXAKT megőrződnek
-                            const interfaceBody = buildInterfaceBody(usages[0].node);
-                            // Report on each usage
-                            for (const usage of usages) {
-                                context.report({
-                                    node: usage.node,
-                                    messageId: 'preferInterface',
-                                    data: {
-                                        count: usages.length.toString(),
-                                        interfaceName,
-                                    },
-                                    fix(fixer) {
-                                        try {
-                                            const interfaceDeclaration = `interface ${interfaceName} {\n${interfaceBody}\n}`;
-                                            // Find insertion point (after imports, before other code)
-                                            const firstNode = sourceCode.ast.body[0];
-                                            let insertPosition = 0;
-                                            if (firstNode && firstNode.type === 'ImportDeclaration') {
-                                                // Find last import
-                                                let lastImport = firstNode;
-                                                for (const node of sourceCode.ast.body) {
-                                                    if (node.type === 'ImportDeclaration') {
-                                                        lastImport = node;
-                                                    }
-                                                    else {
-                                                        break;
-                                                    }
-                                                }
-                                                insertPosition = lastImport.range[1];
-                                            }
-                                            // Add interface declaration
-                                            const fixes = [
-                                                fixer.insertTextAfterRange([insertPosition, insertPosition], `\n\n${interfaceDeclaration}\n`),
-                                            ];
-                                            // Replace all usages with interface reference
-                                            for (const usage of usages) {
-                                                fixes.push(fixer.replaceText(usage.node, interfaceName));
-                                            }
-                                            return fixes;
-                                        }
-                                        catch (fixError) {
-                                            console.error('[prefer-interface-over-duplicate-types] Error in fix function:', fixError);
-                                            return null;
-                                        }
-                                    },
-                                });
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error('[prefer-interface-over-duplicate-types] Error in Program:exit visitor:', error);
-                }
-            },
-        };
-    },
-};
-exports.default = rule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Suggest creating interfaces for object types used more than the threshold number of times',
+            recommended: true,
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    threshold: {
+                        type: 'number',
+                        minimum: 2,
+                        default: 3,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            preferInterface: 'Object type used {{count}} times. Consider creating interface "{{interfaceName}}"}}',
+        },
+        // BFR-ADVENTOR-009 (2. lépcső): a fixer forrás-szöveg-megőrzőre átírva (`sourceCode.getText` per property)
+        // → a komplex/union/qualified/function típusok EXAKT megőrződnek, a generált interface ÉRVÉNYES TS. Ezért
+        // az auto-fix (`fixable:'code'`) VISSZA — a bulk `eslint --fix` biztonságosan futtathatja (nem generál
+        // többé `reference`/`complex` literál-hibát). (1. lépcső: suggestion-degrade, most feloldva.)
+        fixable: 'code',
+    },
+    create(context) {
+        const options = context.options[0] || {};
+        const threshold = options.threshold || 3;
+        const sourceCode = context.sourceCode;
+        // Map to track type signatures and their usages
+        const typeUsages = new Map();
+        const allTypeLiterals = [];
+        /**
+         * Normalize object type to a signature string for comparison
+         */
+        function normalizeObjectType(node) {
+            if (!node || node.type !== 'TSTypeLiteral') {
+                return '';
+            }
+            if (!node.members || !Array.isArray(node.members)) {
+                return '';
+            }
+            // Extract and sort properties
+            const properties = node.members
+                .filter((member) => member.type === 'TSPropertySignature')
+                .map((member) => {
+                const key = member.key?.name || member.key?.value || 'unknown';
+                const type = getTypeString(member.typeAnnotation);
+                const optional = member.optional ? '?' : '';
+                const readonly = member.readonly ? 'readonly ' : '';
+                return `${readonly}${key}${optional}:${type}`;
+            })
+                .sort(); // Sort alphabetically
+            return properties.join(';');
+        }
+        /**
+         * Get string representation of a type annotation
+         */
+        function getTypeString(typeAnnotation) {
+            if (!typeAnnotation || !typeAnnotation.typeAnnotation) {
+                return 'any';
+            }
+            const type = typeAnnotation.typeAnnotation;
+            switch (type.type) {
+                case 'TSStringKeyword':
+                    return 'string';
+                case 'TSNumberKeyword':
+                    return 'number';
+                case 'TSBooleanKeyword':
+                    return 'boolean';
+                case 'TSVoidKeyword':
+                    return 'void';
+                case 'TSNullKeyword':
+                    return 'null';
+                case 'TSUndefinedKeyword':
+                    return 'undefined';
+                case 'TSAnyKeyword':
+                    return 'any';
+                case 'TSUnknownKeyword':
+                    return 'unknown';
+                case 'TSNeverKeyword':
+                    return 'never';
+                case 'TSObjectKeyword':
+                    return 'object';
+                case 'TSLiteralType':
+                    return type.literal?.value?.toString() || 'literal';
+                case 'TSArrayType':
+                    return `${getTypeString({ typeAnnotation: type.elementType })}[]`;
+                case 'TSTypeReference':
+                    return type.typeName?.name || 'reference';
+                case 'TSTypeLiteral':
+                    return normalizeObjectType(type);
+                case 'TSUnionType':
+                    return type.types?.map((t) => getTypeString({ typeAnnotation: t })).join('|') || 'union';
+                case 'TSIntersectionType':
+                    return type.types?.map((t) => getTypeString({ typeAnnotation: t })).join('&') || 'intersection';
+                default:
+                    return 'complex';
+            }
+        }
+        /**
+         * Generate interface name based on context
+         */
+        function generateInterfaceName(signature, usageCount) {
+            // Try to extract meaningful name from signature
+            const properties = signature.split(';');
+            if (properties.length === 1) {
+                const prop = properties[0].split(':')[0].replace('readonly ', '').replace('?', '');
+                if (prop && prop !== 'unknown') {
+                    return `${prop.charAt(0).toUpperCase() + prop.slice(1)}Interface`;
+                }
+            }
+            // Fallback to generic name
+            return `GeneratedInterface${usageCount}`;
+        }
+        /**
+         * Check if interface name conflicts with existing identifiers
+         */
+        function isNameConflict(name) {
+            try {
+                const scope = context.sourceCode.getScope(context.sourceCode.ast);
+                return scope.variables.some(variable => variable.name === name);
+            }
+            catch {
+                return false;
+            }
+        }
+        /**
+         * Generate unique interface name
+         */
+        function generateUniqueInterfaceName(baseName) {
+            let name = baseName;
+            let counter = 1;
+            while (isNameConflict(name)) {
+                name = `${baseName}${counter}`;
+                counter++;
+            }
+            return name;
+        }
+        /**
+         * BFR-ADVENTOR-009 (2. lépcső): az interface-törzs a FORRÁS-SZÖVEGBŐL épül (sourceCode.getText per
+         * member), NEM a lossy normalizált signature-ből → a komplex/union/qualified/function típusok EXAKT
+         * megőrződnek (a korábbi `reference`/`complex`/`union` literál-hibák megszűnnek). A `getText` az eredeti
+         * property-szöveget adja (pl. `onError: (e: Error) => void`); a záró `;`/`,`-t normalizáljuk.
+         */
+        function buildInterfaceBody(node) {
+            const members = Array.isArray(node?.members) ? node.members : [];
+            return members
+                .map((member) => {
+                const text = sourceCode.getText(member).trim().replace(/[;,]\s*$/, '');
+                return `  ${text};`;
+            })
+                .join('\n');
+        }
+        /**
+         * Beszédes interface-név a property-kulcsokból (BFR-ADVENTOR-009): a nem-beszédes, ütköző
+         * `GeneratedInterfaceN` helyett az első 1-3 kulcsból PascalCase + `Params_Interface` (a projekt-konvenció).
+         */
+        function deriveInterfaceName(node) {
+            const members = Array.isArray(node?.members) ? node.members : [];
+            const keys = members
+                .filter((m) => m.type === 'TSPropertySignature')
+                .map((m) => String(m.key?.name ?? m.key?.value ?? ''))
+                .filter((k) => !!k)
+                .slice(0, 3);
+            if (!keys.length) {
+                return 'Generated_Interface';
+            }
+            const pascal = keys
+                .map((k) => k.charAt(0).toUpperCase() + k.slice(1))
+                .join('');
+            return `${pascal}_Interface`;
+        }
+        return {
+            TSTypeLiteral(node, _context, _sourceCode) {
+                try {
+                    const signature = normalizeObjectType(node);
+                    if (!signature) {
+                        return;
+                    }
+                    allTypeLiterals.push(node);
+                    if (!typeUsages.has(signature)) {
+                        typeUsages.set(signature, []);
+                    }
+                    typeUsages.get(signature).push({
+                        node,
+                        signature,
+                    });
+                }
+                catch (error) {
+                    console.error('[prefer-interface-over-duplicate-types] Error in TSTypeLiteral visitor:', error);
+                }
+            },
+            'Program:exit'(node, _context, _sourceCode) {
+                try {
+                    // Process all collected type usages
+                    for (const [signature, usages] of typeUsages) {
+                        if (usages.length >= threshold) {
+                            // beszédes név a property-kulcsokból (ütközés-mentesre pontosítva)
+                            const interfaceName = generateUniqueInterfaceName(deriveInterfaceName(usages[0].node));
+                            // a törzs a FORRÁS-SZÖVEGBŐL (getText) — a komplex/union/qualified típusok EXAKT megőrződnek
+                            const interfaceBody = buildInterfaceBody(usages[0].node);
+                            // Report on each usage
+                            for (const usage of usages) {
+                                context.report({
+                                    node: usage.node,
+                                    messageId: 'preferInterface',
+                                    data: {
+                                        count: usages.length.toString(),
+                                        interfaceName,
+                                    },
+                                    fix(fixer) {
+                                        try {
+                                            const interfaceDeclaration = `interface ${interfaceName} {\n${interfaceBody}\n}`;
+                                            // Find insertion point (after imports, before other code)
+                                            const firstNode = sourceCode.ast.body[0];
+                                            let insertPosition = 0;
+                                            if (firstNode && firstNode.type === 'ImportDeclaration') {
+                                                // Find last import
+                                                let lastImport = firstNode;
+                                                for (const node of sourceCode.ast.body) {
+                                                    if (node.type === 'ImportDeclaration') {
+                                                        lastImport = node;
+                                                    }
+                                                    else {
+                                                        break;
+                                                    }
+                                                }
+                                                insertPosition = lastImport.range[1];
+                                            }
+                                            // Add interface declaration
+                                            const fixes = [
+                                                fixer.insertTextAfterRange([insertPosition, insertPosition], `\n\n${interfaceDeclaration}\n`),
+                                            ];
+                                            // Replace all usages with interface reference
+                                            for (const usage of usages) {
+                                                fixes.push(fixer.replaceText(usage.node, interfaceName));
+                                            }
+                                            return fixes;
+                                        }
+                                        catch (fixError) {
+                                            console.error('[prefer-interface-over-duplicate-types] Error in fix function:', fixError);
+                                            return null;
+                                        }
+                                    },
+                                });
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error('[prefer-interface-over-duplicate-types] Error in Program:exit visitor:', error);
+                }
+            },
+        };
+    },
+};
+exports.default = rule;
 //# sourceMappingURL=prefer-interface-over-duplicate-types.js.map

package/build/plugin/rules/require-jsdoc-description.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=require-jsdoc-description.d.ts.map