@futdevpro/dynamo-eslint 1.15.25 → 1.15.28

package/build/plugin/rules/explicit-types.js

@@ -1,179 +1,179 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const rule = {
-    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) {
-                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) => {
-                            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) {
-                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) => {
-                            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) {
-                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?.name || 'destructured' },
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error('[explicit-types] Error in VariableDeclarator visitor:', error);
-                }
-            },
-            // Class properties
-            PropertyDefinition(node) {
-                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?.name || 'computed' },
-                        });
-                    }
-                }
-                catch (error) {
-                    console.error('[explicit-types] Error in PropertyDefinition visitor:', error);
-                }
-            },
-            // Object destructuring
-            ObjectPattern(node) {
-                try {
-                    if (!node.typeAnnotation) {
-                        context.report({
-                            node,
-                            messageId: 'missingDestructuringType',
-                        });
-                    }
-                }
-                catch (error) {
-                    console.error('[explicit-types] Error in ObjectPattern visitor:', error);
-                }
-            },
-            // Array destructuring
-            ArrayPattern(node) {
-                try {
-                    if (!node.typeAnnotation) {
-                        context.report({
-                            node,
-                            messageId: 'missingDestructuringType',
-                        });
-                    }
-                }
-                catch (error) {
-                    console.error('[explicit-types] Error in ArrayPattern visitor:', error);
-                }
-            },
-        };
-    },
-};
-exports.default = rule;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule = {
+    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) {
+                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) => {
+                            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) {
+                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) => {
+                            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) {
+                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?.name || 'destructured' },
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error('[explicit-types] Error in VariableDeclarator visitor:', error);
+                }
+            },
+            // Class properties
+            PropertyDefinition(node) {
+                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?.name || 'computed' },
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error('[explicit-types] Error in PropertyDefinition visitor:', error);
+                }
+            },
+            // Object destructuring
+            ObjectPattern(node) {
+                try {
+                    if (!node.typeAnnotation) {
+                        context.report({
+                            node,
+                            messageId: 'missingDestructuringType',
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error('[explicit-types] Error in ObjectPattern visitor:', error);
+                }
+            },
+            // Array destructuring
+            ArrayPattern(node) {
+                try {
+                    if (!node.typeAnnotation) {
+                        context.report({
+                            node,
+                            messageId: 'missingDestructuringType',
+                        });
+                    }
+                }
+                catch (error) {
+                    console.error('[explicit-types] Error in ArrayPattern visitor:', error);
+                }
+            },
+        };
+    },
+};
+exports.default = rule;
 //# sourceMappingURL=explicit-types.js.map

package/build/plugin/rules/import/import-order.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=import-order.d.ts.map