@futdevpro/dynamo-eslint 1.15.25 → 1.15.28

package/build/plugin/rules/no-getter-logic.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=no-getter-logic.d.ts.map

package/build/plugin/rules/no-getter-logic.js

@@ -1,195 +1,195 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Check if a node type is allowed in getter (simple property mapping only)
- */
-function isAllowedNodeType(nodeType) {
-    const allowedTypes = [
-        'ReturnStatement',
-        'MemberExpression',
-        'Identifier',
-        'ThisExpression',
-        'Literal',
-        'BlockStatement',
-        'ExpressionStatement',
-    ];
-    return allowedTypes.includes(nodeType);
-}
-/**
- * Check if a node type is explicitly forbidden (logic, calculations, function calls,
- * block-level control flow, variable declarations).
- * CCAP "no-getter-logic"-megerősítés: tilos `if/for/while/switch/try` és helyi `const/let`.
- */
-function isForbiddenNodeType(nodeType) {
-    const forbiddenTypes = [
-        'CallExpression',
-        'BinaryExpression',
-        'UnaryExpression',
-        'ConditionalExpression',
-        'LogicalExpression',
-        'AssignmentExpression',
-        'UpdateExpression',
-        'NewExpression',
-        'YieldExpression',
-        'AwaitExpression',
-        'TaggedTemplateExpression',
-        'TemplateLiteral',
-        'SequenceExpression',
-        'SpreadElement',
-        'RestElement',
-        // Block-level control flow — getter csak közvetlen property mapping lehet.
-        'IfStatement',
-        'ForStatement',
-        'ForInStatement',
-        'ForOfStatement',
-        'WhileStatement',
-        'DoWhileStatement',
-        'SwitchStatement',
-        'TryStatement',
-        'ThrowStatement',
-        // Lokális változó deklaráció — több-utasításos getter tilos.
-        'VariableDeclaration',
-    ];
-    return forbiddenTypes.includes(nodeType);
-}
-/**
- * Recursively check if a node contains only allowed patterns
- * Returns true if forbidden node is found
- */
-function containsForbiddenNode(node) {
-    if (!node || typeof node !== 'object') {
-        return false;
-    }
-    // Check current node type
-    if (node.type && isForbiddenNodeType(node.type)) {
-        return true;
-    }
-    // Special handling for MemberExpression - allow property access but check nested calls
-    if (node.type === 'MemberExpression') {
-        // Check if this is a function call disguised as property access
-        // This will be caught by parent CallExpression, so we just check children
-        if (node.object && containsForbiddenNode(node.object)) {
-            return true;
-        }
-        if (node.property && containsForbiddenNode(node.property)) {
-            return true;
-        }
-        // Allow computed property access like [index] but check the index expression
-        if (node.computed && node.property && containsForbiddenNode(node.property)) {
-            return true;
-        }
-        return false;
-    }
-    // Special handling for ReturnStatement - check the argument
-    if (node.type === 'ReturnStatement') {
-        if (node.argument && containsForbiddenNode(node.argument)) {
-            return true;
-        }
-        return false;
-    }
-    // Special handling for BlockStatement - check all statements.
-    // CCAP-megerősítés: 1-nél több statement (az utolsó return-en kívül) tilos.
-    if (node.type === 'BlockStatement') {
-        if (node.body && Array.isArray(node.body)) {
-            // Több mint egy statement → többszörös utasítás → tilos.
-            if (node.body.length > 1) {
-                return true;
-            }
-            for (const statement of node.body) {
-                if (containsForbiddenNode(statement)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    // Special handling for ExpressionStatement - check the expression
-    if (node.type === 'ExpressionStatement') {
-        if (node.expression && containsForbiddenNode(node.expression)) {
-            return true;
-        }
-        return false;
-    }
-    // For other node types, recursively check all properties
-    for (const key in node) {
-        if (key === 'parent' || key === 'range' || key === 'loc') {
-            continue; // Skip parent references and location data
-        }
-        const value = node[key];
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                if (containsForbiddenNode(item)) {
-                    return true;
-                }
-            }
-        }
-        else if (value && typeof value === 'object') {
-            if (containsForbiddenNode(value)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * Get getter name for error message
- */
-function getGetterName(node) {
-    try {
-        if (node.key && node.key.name) {
-            return node.key.name;
-        }
-        if (node.key && node.key.type === 'Identifier') {
-            return node.key.name || 'unknown';
-        }
-        return 'unknown';
-    }
-    catch (error) {
-        console.error('[no-getter-logic] Error in getGetterName:', error);
-        return 'unknown';
-    }
-}
-const rule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            description: 'Getters should only contain simple property mappings, no logic, calculations, or function calls',
-            recommended: true,
-        },
-        schema: [],
-        messages: {
-            noLogic: 'Getter "{{name}}" should only contain simple property mappings, no logic, calculations, or function calls.',
-        },
-    },
-    create(context) {
-        return {
-            MethodDefinition(node, _context, _sourceCode) {
-                try {
-                    // Only check getters
-                    if (node.kind !== 'get') {
-                        return;
-                    }
-                    // Check if getter has a body
-                    if (!node.value || !node.value.body) {
-                        return;
-                    }
-                    const body = node.value.body;
-                    // Check for forbidden nodes in the getter body
-                    if (containsForbiddenNode(body)) {
-                        const getterName = getGetterName(node);
-                        context.report({
-                            node: body,
-                            messageId: 'noLogic',
-                            data: { name: getterName },
-                        });
-                    }
-                }
-                catch (error) {
-                    console.error('[no-getter-logic] Error in MethodDefinition visitor:', error);
-                }
-            },
-        };
-    },
-};
-exports.default = rule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Check if a node type is allowed in getter (simple property mapping only)
+ */
+function isAllowedNodeType(nodeType) {
+    const allowedTypes = [
+        'ReturnStatement',
+        'MemberExpression',
+        'Identifier',
+        'ThisExpression',
+        'Literal',
+        'BlockStatement',
+        'ExpressionStatement',
+    ];
+    return allowedTypes.includes(nodeType);
+}
+/**
+ * Check if a node type is explicitly forbidden (logic, calculations, function calls,
+ * block-level control flow, variable declarations).
+ * CCAP "no-getter-logic"-megerősítés: tilos `if/for/while/switch/try` és helyi `const/let`.
+ */
+function isForbiddenNodeType(nodeType) {
+    const forbiddenTypes = [
+        'CallExpression',
+        'BinaryExpression',
+        'UnaryExpression',
+        'ConditionalExpression',
+        'LogicalExpression',
+        'AssignmentExpression',
+        'UpdateExpression',
+        'NewExpression',
+        'YieldExpression',
+        'AwaitExpression',
+        'TaggedTemplateExpression',
+        'TemplateLiteral',
+        'SequenceExpression',
+        'SpreadElement',
+        'RestElement',
+        // Block-level control flow — getter csak közvetlen property mapping lehet.
+        'IfStatement',
+        'ForStatement',
+        'ForInStatement',
+        'ForOfStatement',
+        'WhileStatement',
+        'DoWhileStatement',
+        'SwitchStatement',
+        'TryStatement',
+        'ThrowStatement',
+        // Lokális változó deklaráció — több-utasításos getter tilos.
+        'VariableDeclaration',
+    ];
+    return forbiddenTypes.includes(nodeType);
+}
+/**
+ * Recursively check if a node contains only allowed patterns
+ * Returns true if forbidden node is found
+ */
+function containsForbiddenNode(node) {
+    if (!node || typeof node !== 'object') {
+        return false;
+    }
+    // Check current node type
+    if (node.type && isForbiddenNodeType(node.type)) {
+        return true;
+    }
+    // Special handling for MemberExpression - allow property access but check nested calls
+    if (node.type === 'MemberExpression') {
+        // Check if this is a function call disguised as property access
+        // This will be caught by parent CallExpression, so we just check children
+        if (node.object && containsForbiddenNode(node.object)) {
+            return true;
+        }
+        if (node.property && containsForbiddenNode(node.property)) {
+            return true;
+        }
+        // Allow computed property access like [index] but check the index expression
+        if (node.computed && node.property && containsForbiddenNode(node.property)) {
+            return true;
+        }
+        return false;
+    }
+    // Special handling for ReturnStatement - check the argument
+    if (node.type === 'ReturnStatement') {
+        if (node.argument && containsForbiddenNode(node.argument)) {
+            return true;
+        }
+        return false;
+    }
+    // Special handling for BlockStatement - check all statements.
+    // CCAP-megerősítés: 1-nél több statement (az utolsó return-en kívül) tilos.
+    if (node.type === 'BlockStatement') {
+        if (node.body && Array.isArray(node.body)) {
+            // Több mint egy statement → többszörös utasítás → tilos.
+            if (node.body.length > 1) {
+                return true;
+            }
+            for (const statement of node.body) {
+                if (containsForbiddenNode(statement)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    // Special handling for ExpressionStatement - check the expression
+    if (node.type === 'ExpressionStatement') {
+        if (node.expression && containsForbiddenNode(node.expression)) {
+            return true;
+        }
+        return false;
+    }
+    // For other node types, recursively check all properties
+    for (const key in node) {
+        if (key === 'parent' || key === 'range' || key === 'loc') {
+            continue; // Skip parent references and location data
+        }
+        const value = node[key];
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (containsForbiddenNode(item)) {
+                    return true;
+                }
+            }
+        }
+        else if (value && typeof value === 'object') {
+            if (containsForbiddenNode(value)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Get getter name for error message
+ */
+function getGetterName(node) {
+    try {
+        if (node.key && node.key.name) {
+            return node.key.name;
+        }
+        if (node.key && node.key.type === 'Identifier') {
+            return node.key.name || 'unknown';
+        }
+        return 'unknown';
+    }
+    catch (error) {
+        console.error('[no-getter-logic] Error in getGetterName:', error);
+        return 'unknown';
+    }
+}
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Getters should only contain simple property mappings, no logic, calculations, or function calls',
+            recommended: true,
+        },
+        schema: [],
+        messages: {
+            noLogic: 'Getter "{{name}}" should only contain simple property mappings, no logic, calculations, or function calls.',
+        },
+    },
+    create(context) {
+        return {
+            MethodDefinition(node, _context, _sourceCode) {
+                try {
+                    // Only check getters
+                    if (node.kind !== 'get') {
+                        return;
+                    }
+                    // Check if getter has a body
+                    if (!node.value || !node.value.body) {
+                        return;
+                    }
+                    const body = node.value.body;
+                    // Check for forbidden nodes in the getter body
+                    if (containsForbiddenNode(body)) {
+                        const getterName = getGetterName(node);
+                        context.report({
+                            node: body,
+                            messageId: 'noLogic',
+                            data: { name: getterName },
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error('[no-getter-logic] Error in MethodDefinition visitor:', error);
+                }
+            },
+        };
+    },
+};
+exports.default = rule;
 //# sourceMappingURL=no-getter-logic.js.map

package/build/plugin/rules/prefer-enum-over-string-union.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-enum-over-string-union.d.ts.map