@futdevpro/dynamo-eslint 1.15.22 → 1.15.28

package/src/plugin/rules/explicit-types.ts

@@ -1,186 +1,186 @@
-import { Rule } from 'eslint';
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: { 
-      description: 'Enforce explicit type annotations on all TypeScript declarations',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      missingReturnType: 'Function "{{name}}" must have an explicit return type annotation.',
-      missingArrowReturnType: 'Arrow function must have an explicit return type annotation.',
-      missingVariableType: 'Variable "{{name}}" must have an explicit type annotation.',
-      missingParameterType: 'Parameter "{{name}}" must have an explicit type annotation.',
-      missingPropertyType: 'Class property "{{name}}" must have an explicit type annotation.',
-      missingDestructuringType: 'Destructuring assignment must have explicit type annotations.',
-    },
-  },
-  create(context) {
-    return {
-      // Function declarations
-      FunctionDeclaration(node: any) {
-        try {
-          // Check return type
-          if (!node.returnType) {
-            context.report({
-              node: node.id || node,  // Report on function name if available
-              messageId: 'missingReturnType',
-              data: { name: node.id?.name || 'anonymous' },
-            });
-          }
-
-          // Check function parameters with defensive checks
-          if (node.params && Array.isArray(node.params)) {
-            node.params.forEach((param: any) => {
-              try {
-                if (param && param.type === 'Identifier' && !param.typeAnnotation) {
-                  context.report({
-                    node: param,
-                    messageId: 'missingParameterType',
-                    data: { name: param.name || 'unknown' },
-                  });
-                }
-              } catch (paramError) {
-                console.error('[explicit-types] Error processing function parameter:', paramError);
-              }
-            });
-          }
-        } catch (error) {
-          console.error('[explicit-types] Error in FunctionDeclaration visitor:', error);
-        }
-      },
-
-      // Arrow functions
-      ArrowFunctionExpression(node: any) {
-        try {
-          // Check return type
-          if (!node.returnType) {
-            context.report({
-              node: node.params.length > 0 ? node.params[0] : node,  // Report on first param or node
-              messageId: 'missingArrowReturnType',
-            });
-          }
-
-          // Check arrow function parameters with defensive checks
-          if (node.params && Array.isArray(node.params)) {
-            node.params.forEach((param: any) => {
-              try {
-                if (param && param.type === 'Identifier' && !param.typeAnnotation) {
-                  context.report({
-                    node: param,
-                    messageId: 'missingParameterType',
-                    data: { name: param.name || 'unknown' },
-                  });
-                }
-              } catch (paramError) {
-                console.error('[explicit-types] Error processing arrow function parameter:', paramError);
-              }
-            });
-          }
-        } catch (error) {
-          console.error('[explicit-types] Error in ArrowFunctionExpression visitor:', error);
-        }
-      },
-
-      // Variable declarations
-      VariableDeclarator(node: any) {
-        try {
-          // Defensive check for node.id
-          if (!node.id) {
-            return;
-          }
-
-          if (!node.id.typeAnnotation) {
-            // Check if this variable is declared in a for loop
-            let isInForLoop = false;
-            let parent = node.parent;
-
-            while (parent) {
-              if (parent.type === 'ForStatement' || parent.type === 'ForInStatement' || parent.type === 'ForOfStatement') {
-                isInForLoop = true;
-                break;
-              }
-              parent = parent.parent;
-            }
-
-            // Skip if variable is in a for loop
-            if (isInForLoop) {
-              return;
-            }
-
-            // Skip if variable is initialized with a typed value that can be inferred
-            const hasTypedInitializer = node.init && (
-              node.init.type === 'CallExpression' ||
-              node.init.type === 'NewExpression' ||
-              node.init.type === 'ArrayExpression' ||
-              node.init.type === 'ObjectExpression' ||
-              node.init.type === 'Literal'
-            );
-
-            if (!hasTypedInitializer) {
-              context.report({
-                node: node.id,
-                messageId: 'missingVariableType',
-                data: { name: (node.id as any)?.name || 'destructured' },
-              });
-            }
-          }
-        } catch (error) {
-          console.error('[explicit-types] Error in VariableDeclarator visitor:', error);
-        }
-      },
-
-      // Class properties
-      PropertyDefinition(node: any) {
-        try {
-          // Defensive check for node.key
-          if (!node.key) {
-            return;
-          }
-
-          if (!node.typeAnnotation && !node.value) {
-            context.report({
-              node: node.key,
-              messageId: 'missingPropertyType',
-              data: { name: (node.key as any)?.name || 'computed' },
-            });
-          }
-        } catch (error) {
-          console.error('[explicit-types] Error in PropertyDefinition visitor:', error);
-        }
-      },
-
-      // Object destructuring
-      ObjectPattern(node: any) {
-        try {
-          if (!node.typeAnnotation) {
-            context.report({
-              node,
-              messageId: 'missingDestructuringType',
-            });
-          }
-        } catch (error) {
-          console.error('[explicit-types] Error in ObjectPattern visitor:', error);
-        }
-      },
-
-      // Array destructuring
-      ArrayPattern(node: any) {
-        try {
-          if (!node.typeAnnotation) {
-            context.report({
-              node,
-              messageId: 'missingDestructuringType',
-            });
-          }
-        } catch (error) {
-          console.error('[explicit-types] Error in ArrayPattern visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;
+import { Rule } from 'eslint';
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: { 
+      description: 'Enforce explicit type annotations on all TypeScript declarations',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      missingReturnType: 'Function "{{name}}" must have an explicit return type annotation.',
+      missingArrowReturnType: 'Arrow function must have an explicit return type annotation.',
+      missingVariableType: 'Variable "{{name}}" must have an explicit type annotation.',
+      missingParameterType: 'Parameter "{{name}}" must have an explicit type annotation.',
+      missingPropertyType: 'Class property "{{name}}" must have an explicit type annotation.',
+      missingDestructuringType: 'Destructuring assignment must have explicit type annotations.',
+    },
+  },
+  create(context) {
+    return {
+      // Function declarations
+      FunctionDeclaration(node: any) {
+        try {
+          // Check return type
+          if (!node.returnType) {
+            context.report({
+              node: node.id || node,  // Report on function name if available
+              messageId: 'missingReturnType',
+              data: { name: node.id?.name || 'anonymous' },
+            });
+          }
+
+          // Check function parameters with defensive checks
+          if (node.params && Array.isArray(node.params)) {
+            node.params.forEach((param: any) => {
+              try {
+                if (param && param.type === 'Identifier' && !param.typeAnnotation) {
+                  context.report({
+                    node: param,
+                    messageId: 'missingParameterType',
+                    data: { name: param.name || 'unknown' },
+                  });
+                }
+              } catch (paramError) {
+                console.error('[explicit-types] Error processing function parameter:', paramError);
+              }
+            });
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in FunctionDeclaration visitor:', error);
+        }
+      },
+
+      // Arrow functions
+      ArrowFunctionExpression(node: any) {
+        try {
+          // Check return type
+          if (!node.returnType) {
+            context.report({
+              node: node.params.length > 0 ? node.params[0] : node,  // Report on first param or node
+              messageId: 'missingArrowReturnType',
+            });
+          }
+
+          // Check arrow function parameters with defensive checks
+          if (node.params && Array.isArray(node.params)) {
+            node.params.forEach((param: any) => {
+              try {
+                if (param && param.type === 'Identifier' && !param.typeAnnotation) {
+                  context.report({
+                    node: param,
+                    messageId: 'missingParameterType',
+                    data: { name: param.name || 'unknown' },
+                  });
+                }
+              } catch (paramError) {
+                console.error('[explicit-types] Error processing arrow function parameter:', paramError);
+              }
+            });
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in ArrowFunctionExpression visitor:', error);
+        }
+      },
+
+      // Variable declarations
+      VariableDeclarator(node: any) {
+        try {
+          // Defensive check for node.id
+          if (!node.id) {
+            return;
+          }
+
+          if (!node.id.typeAnnotation) {
+            // Check if this variable is declared in a for loop
+            let isInForLoop = false;
+            let parent = node.parent;
+
+            while (parent) {
+              if (parent.type === 'ForStatement' || parent.type === 'ForInStatement' || parent.type === 'ForOfStatement') {
+                isInForLoop = true;
+                break;
+              }
+              parent = parent.parent;
+            }
+
+            // Skip if variable is in a for loop
+            if (isInForLoop) {
+              return;
+            }
+
+            // Skip if variable is initialized with a typed value that can be inferred
+            const hasTypedInitializer = node.init && (
+              node.init.type === 'CallExpression' ||
+              node.init.type === 'NewExpression' ||
+              node.init.type === 'ArrayExpression' ||
+              node.init.type === 'ObjectExpression' ||
+              node.init.type === 'Literal'
+            );
+
+            if (!hasTypedInitializer) {
+              context.report({
+                node: node.id,
+                messageId: 'missingVariableType',
+                data: { name: (node.id as any)?.name || 'destructured' },
+              });
+            }
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in VariableDeclarator visitor:', error);
+        }
+      },
+
+      // Class properties
+      PropertyDefinition(node: any) {
+        try {
+          // Defensive check for node.key
+          if (!node.key) {
+            return;
+          }
+
+          if (!node.typeAnnotation && !node.value) {
+            context.report({
+              node: node.key,
+              messageId: 'missingPropertyType',
+              data: { name: (node.key as any)?.name || 'computed' },
+            });
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in PropertyDefinition visitor:', error);
+        }
+      },
+
+      // Object destructuring
+      ObjectPattern(node: any) {
+        try {
+          if (!node.typeAnnotation) {
+            context.report({
+              node,
+              messageId: 'missingDestructuringType',
+            });
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in ObjectPattern visitor:', error);
+        }
+      },
+
+      // Array destructuring
+      ArrayPattern(node: any) {
+        try {
+          if (!node.typeAnnotation) {
+            context.report({
+              node,
+              messageId: 'missingDestructuringType',
+            });
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in ArrayPattern visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;