@futdevpro/dynamo-eslint 1.15.25 → 1.15.28

package/src/plugin/rules/import/import-order.ts

@@ -1,197 +1,197 @@
-import { Rule } from 'eslint';
-
-interface ImportGroup {
-  type: 'non-futdevpro' | 'futdevpro' | 'other-modules' | 'same-module';
-  imports: any[];
-}
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: { description: 'Validate import ordering based on Dynamo conventions' },
-    schema: [],
-    messages: {
-      misordered: 'Import statements should be grouped and ordered by convention.',
-      forbiddenNpmPackages: 'Import from "*/../NPM-packages/*" is forbidden. Use "@futdevpro/*" instead.',
-      missingEmptyLine: 'Missing empty line between import groups.',
-      extraEmptyLine: 'Extra empty line detected.',
-    },
-    fixable: 'code',
-  },
-  create(context) {
-    const sourceCode = context.sourceCode;
-    const filename = context.filename;
-
-    function getImportGroup(importNode: any): ImportGroup['type'] {
-      const source = importNode.source.value as string;
-      
-      // Check for forbidden patterns first
-      if (source.includes('/NPM-packages/')) {
-        return 'non-futdevpro'; // Will be flagged as error
-      }
-      
-      if (source.endsWith('.js')) {
-        return 'non-futdevpro'; // Will be flagged as error
-      }
-      
-      // FutDevPro packages
-      if (source.startsWith('@futdevpro/')) {
-        return 'futdevpro';
-      }
-      
-      // Same module (relative imports with specific patterns)
-      if (source.startsWith('./') || source.startsWith('../')) {
-        const pathParts = source.split('/');
-        const upLevels = pathParts.filter(part => part === '..').length;
-        
-        // Same module: up to 3 ".." and starts with "_", or less than 2 ".."
-        if (upLevels <= 2 || (upLevels <= 3 && pathParts.some(part => part.startsWith('_')))) {
-          return 'same-module';
-        }
-        
-        // Other modules
-        return 'other-modules';
-      }
-      
-      // Non-FutDevPro packages
-      return 'non-futdevpro';
-    }
-
-    function validateImportDeclaration(importNode: any) {
-      const source = importNode.source.value as string;
-      
-      // Check for forbidden patterns
-      if (source.includes('/NPM-packages/')) {
-        context.report({
-          node: importNode.source,
-          messageId: 'forbiddenNpmPackages',
-          fix(fixer) {
-            // Replace NPM-packages path with @futdevpro equivalent
-            const newSource = source.replace(/.*\/NPM-packages\/([^\/]+)/, '@futdevpro/$1');
-
-            return fixer.replaceText(importNode.source, `'${newSource}'`);
-          },
-        });
-      }
-      
-      
-    }
-
-    function validateImportOrdering(importNodes: any[]) {
-      if (importNodes.length === 0) return;
-
-      // Group imports
-      const groups: ImportGroup[] = [
-        { type: 'non-futdevpro', imports: [] },
-        { type: 'futdevpro', imports: [] },
-        { type: 'other-modules', imports: [] },
-        { type: 'same-module', imports: [] },
-      ];
-
-      importNodes.forEach(importNode => {
-        const groupType = getImportGroup(importNode);
-        const group = groups.find(g => g.type === groupType);
-
-        if (group) {
-          group.imports.push(importNode);
-        }
-      });
-
-      // Remove empty groups
-      const nonEmptyGroups = groups.filter(group => group.imports.length > 0);
-
-      // Check if imports are in correct order and detect violations
-      let needsReordering = false;
-      let currentGroupIndex = 0;
-
-      for (let i = 0; i < importNodes.length; i++) {
-        const importNode = importNodes[i];
-        const expectedGroupType = getImportGroup(importNode);
-        const expectedGroupIndex = nonEmptyGroups.findIndex(g => g.type === expectedGroupType);
-
-        if (expectedGroupIndex < currentGroupIndex) {
-          needsReordering = true;
-        }
-
-        currentGroupIndex = expectedGroupIndex;
-      }
-
-      // Check empty lines between groups
-      let needsEmptyLineFix = false;
-      for (let i = 0; i < nonEmptyGroups.length - 1; i++) {
-        const currentGroup = nonEmptyGroups[i];
-        const nextGroup = nonEmptyGroups[i + 1];
-        const lastImportOfCurrentGroup = currentGroup.imports[currentGroup.imports.length - 1];
-        const firstImportOfNextGroup = nextGroup.imports[0];
-
-        const lines = sourceCode.getLines();
-        const lastImportLine = lastImportOfCurrentGroup.loc?.end.line || 0;
-        const firstImportLine = firstImportOfNextGroup.loc?.start.line || 0;
-
-        if (firstImportLine - lastImportLine < 2) {
-          needsEmptyLineFix = true;
-        }
-      }
-
-      // If any violations are detected, provide a comprehensive fix
-      if (needsReordering || needsEmptyLineFix) {
-        context.report({
-          node: importNodes[0],
-          messageId: 'misordered',
-          fix(fixer) {
-            // Sort imports within each group alphabetically
-            nonEmptyGroups.forEach(group => {
-              group.imports.sort((a, b) => {
-                const aSource = a.source.value as string;
-                const bSource = b.source.value as string;
-                return aSource.localeCompare(bSource);
-              });
-            });
-
-            // Build the corrected import section
-            const correctedImports: string[] = [];
-            
-            nonEmptyGroups.forEach((group, groupIndex) => {
-              group.imports.forEach(importNode => {
-                const importText = sourceCode.getText(importNode);
-                correctedImports.push(importText);
-              });
-              
-              // Add empty line between groups (except after the last group)
-              if (groupIndex < nonEmptyGroups.length - 1) {
-                correctedImports.push('');
-              }
-            });
-
-            // Calculate the range to replace (from first import to last import)
-            const firstImport = importNodes[0];
-            const lastImport = importNodes[importNodes.length - 1];
-            const startRange = firstImport.range![0];
-            const endRange = lastImport.range![1];
-
-            // Replace the entire import section
-            return fixer.replaceTextRange([startRange, endRange], correctedImports.join('\n'));
-          },
-        });
-      }
-    }
-
-    return {
-      Program(node: any) {
-        const importNodes = node.body.filter(
-          (statement: any) => statement.type === 'ImportDeclaration'
-        );
-
-        // Validate individual import declarations
-        importNodes.forEach(validateImportDeclaration);
-
-        // Validate import ordering
-        validateImportOrdering(importNodes);
-      },
-    };
-  },
-};
-
-export default rule;
-
-
+import { Rule } from 'eslint';
+
+interface ImportGroup {
+  type: 'non-futdevpro' | 'futdevpro' | 'other-modules' | 'same-module';
+  imports: any[];
+}
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: { description: 'Validate import ordering based on Dynamo conventions' },
+    schema: [],
+    messages: {
+      misordered: 'Import statements should be grouped and ordered by convention.',
+      forbiddenNpmPackages: 'Import from "*/../NPM-packages/*" is forbidden. Use "@futdevpro/*" instead.',
+      missingEmptyLine: 'Missing empty line between import groups.',
+      extraEmptyLine: 'Extra empty line detected.',
+    },
+    fixable: 'code',
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const filename = context.filename;
+
+    function getImportGroup(importNode: any): ImportGroup['type'] {
+      const source = importNode.source.value as string;
+      
+      // Check for forbidden patterns first
+      if (source.includes('/NPM-packages/')) {
+        return 'non-futdevpro'; // Will be flagged as error
+      }
+      
+      if (source.endsWith('.js')) {
+        return 'non-futdevpro'; // Will be flagged as error
+      }
+      
+      // FutDevPro packages
+      if (source.startsWith('@futdevpro/')) {
+        return 'futdevpro';
+      }
+      
+      // Same module (relative imports with specific patterns)
+      if (source.startsWith('./') || source.startsWith('../')) {
+        const pathParts = source.split('/');
+        const upLevels = pathParts.filter(part => part === '..').length;
+        
+        // Same module: up to 3 ".." and starts with "_", or less than 2 ".."
+        if (upLevels <= 2 || (upLevels <= 3 && pathParts.some(part => part.startsWith('_')))) {
+          return 'same-module';
+        }
+        
+        // Other modules
+        return 'other-modules';
+      }
+      
+      // Non-FutDevPro packages
+      return 'non-futdevpro';
+    }
+
+    function validateImportDeclaration(importNode: any) {
+      const source = importNode.source.value as string;
+      
+      // Check for forbidden patterns
+      if (source.includes('/NPM-packages/')) {
+        context.report({
+          node: importNode.source,
+          messageId: 'forbiddenNpmPackages',
+          fix(fixer) {
+            // Replace NPM-packages path with @futdevpro equivalent
+            const newSource = source.replace(/.*\/NPM-packages\/([^\/]+)/, '@futdevpro/$1');
+
+            return fixer.replaceText(importNode.source, `'${newSource}'`);
+          },
+        });
+      }
+      
+      
+    }
+
+    function validateImportOrdering(importNodes: any[]) {
+      if (importNodes.length === 0) return;
+
+      // Group imports
+      const groups: ImportGroup[] = [
+        { type: 'non-futdevpro', imports: [] },
+        { type: 'futdevpro', imports: [] },
+        { type: 'other-modules', imports: [] },
+        { type: 'same-module', imports: [] },
+      ];
+
+      importNodes.forEach(importNode => {
+        const groupType = getImportGroup(importNode);
+        const group = groups.find(g => g.type === groupType);
+
+        if (group) {
+          group.imports.push(importNode);
+        }
+      });
+
+      // Remove empty groups
+      const nonEmptyGroups = groups.filter(group => group.imports.length > 0);
+
+      // Check if imports are in correct order and detect violations
+      let needsReordering = false;
+      let currentGroupIndex = 0;
+
+      for (let i = 0; i < importNodes.length; i++) {
+        const importNode = importNodes[i];
+        const expectedGroupType = getImportGroup(importNode);
+        const expectedGroupIndex = nonEmptyGroups.findIndex(g => g.type === expectedGroupType);
+
+        if (expectedGroupIndex < currentGroupIndex) {
+          needsReordering = true;
+        }
+
+        currentGroupIndex = expectedGroupIndex;
+      }
+
+      // Check empty lines between groups
+      let needsEmptyLineFix = false;
+      for (let i = 0; i < nonEmptyGroups.length - 1; i++) {
+        const currentGroup = nonEmptyGroups[i];
+        const nextGroup = nonEmptyGroups[i + 1];
+        const lastImportOfCurrentGroup = currentGroup.imports[currentGroup.imports.length - 1];
+        const firstImportOfNextGroup = nextGroup.imports[0];
+
+        const lines = sourceCode.getLines();
+        const lastImportLine = lastImportOfCurrentGroup.loc?.end.line || 0;
+        const firstImportLine = firstImportOfNextGroup.loc?.start.line || 0;
+
+        if (firstImportLine - lastImportLine < 2) {
+          needsEmptyLineFix = true;
+        }
+      }
+
+      // If any violations are detected, provide a comprehensive fix
+      if (needsReordering || needsEmptyLineFix) {
+        context.report({
+          node: importNodes[0],
+          messageId: 'misordered',
+          fix(fixer) {
+            // Sort imports within each group alphabetically
+            nonEmptyGroups.forEach(group => {
+              group.imports.sort((a, b) => {
+                const aSource = a.source.value as string;
+                const bSource = b.source.value as string;
+                return aSource.localeCompare(bSource);
+              });
+            });
+
+            // Build the corrected import section
+            const correctedImports: string[] = [];
+            
+            nonEmptyGroups.forEach((group, groupIndex) => {
+              group.imports.forEach(importNode => {
+                const importText = sourceCode.getText(importNode);
+                correctedImports.push(importText);
+              });
+              
+              // Add empty line between groups (except after the last group)
+              if (groupIndex < nonEmptyGroups.length - 1) {
+                correctedImports.push('');
+              }
+            });
+
+            // Calculate the range to replace (from first import to last import)
+            const firstImport = importNodes[0];
+            const lastImport = importNodes[importNodes.length - 1];
+            const startRange = firstImport.range![0];
+            const endRange = lastImport.range![1];
+
+            // Replace the entire import section
+            return fixer.replaceTextRange([startRange, endRange], correctedImports.join('\n'));
+          },
+        });
+      }
+    }
+
+    return {
+      Program(node: any) {
+        const importNodes = node.body.filter(
+          (statement: any) => statement.type === 'ImportDeclaration'
+        );
+
+        // Validate individual import declarations
+        importNodes.forEach(validateImportDeclaration);
+
+        // Validate import ordering
+        validateImportOrdering(importNodes);
+      },
+    };
+  },
+};
+
+export default rule;
+
+

package/src/plugin/rules/import/no-import-type.spec.ts

@@ -1,69 +1,69 @@
-import noImportTypeRule from './no-import-type';
-
-describe('| no-import-type', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noImportTypeRule.meta?.type).toBe('suggestion');
-    expect(noImportTypeRule.meta?.docs?.description).toContain('import type');
-    expect(noImportTypeRule.meta?.fixable).toBe('code');
-  });
-
-  it('| should have create function that returns object with ImportDeclaration method', () => {
-    const mockContext = {
-      sourceCode: { 
-        getText: (node: any) => 'import type { SomeType } from \'./some-file\';',
-      },
-      report: () => {},
-    } as any;
-
-    const result = noImportTypeRule.create(mockContext);
-
-    expect(typeof result).toBe('object');
-    expect(typeof result.ImportDeclaration).toBe('function');
-  });
-
-  it('| should detect forbidden import type usage', () => {
-    const mockContext = {
-      sourceCode: { 
-        getText: (node: any) => 'import type { SomeType } from \'./some-file\';',
-      },
-      report: (options: any) => {
-        expect(options.messageId).toBe('forbiddenImportType');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'ImportDeclaration',
-      importKind: 'type',
-      loc: { start: { line: 1 }, end: { line: 1 } },
-    } as any;
-
-    const rule = noImportTypeRule.create(mockContext);
-
-    rule.ImportDeclaration(mockNode);
-  });
-
-  it('| should not report errors for regular imports', () => {
-    const mockContext = {
-      sourceCode: { 
-        getText: (node: any) => 'import { SomeType } from \'./some-file\';',
-      },
-      report: (options: any) => {
-        // Should not be called for regular imports
-        fail('Should not report errors for regular imports');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'ImportDeclaration',
-      importKind: 'value',
-      loc: { start: { line: 1 }, end: { line: 1 } },
-    } as any;
-
-    const rule = noImportTypeRule.create(mockContext);
-
-    rule.ImportDeclaration(mockNode);
-    
-    // If we get here without the report function being called, the test passes
-    expect(true).toBe(true);
-  });
-});
+import noImportTypeRule from './no-import-type';
+
+describe('| no-import-type', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(noImportTypeRule.meta?.type).toBe('suggestion');
+    expect(noImportTypeRule.meta?.docs?.description).toContain('import type');
+    expect(noImportTypeRule.meta?.fixable).toBe('code');
+  });
+
+  it('| should have create function that returns object with ImportDeclaration method', () => {
+    const mockContext = {
+      sourceCode: { 
+        getText: (node: any) => 'import type { SomeType } from \'./some-file\';',
+      },
+      report: () => {},
+    } as any;
+
+    const result = noImportTypeRule.create(mockContext);
+
+    expect(typeof result).toBe('object');
+    expect(typeof result.ImportDeclaration).toBe('function');
+  });
+
+  it('| should detect forbidden import type usage', () => {
+    const mockContext = {
+      sourceCode: { 
+        getText: (node: any) => 'import type { SomeType } from \'./some-file\';',
+      },
+      report: (options: any) => {
+        expect(options.messageId).toBe('forbiddenImportType');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ImportDeclaration',
+      importKind: 'type',
+      loc: { start: { line: 1 }, end: { line: 1 } },
+    } as any;
+
+    const rule = noImportTypeRule.create(mockContext);
+
+    rule.ImportDeclaration(mockNode);
+  });
+
+  it('| should not report errors for regular imports', () => {
+    const mockContext = {
+      sourceCode: { 
+        getText: (node: any) => 'import { SomeType } from \'./some-file\';',
+      },
+      report: (options: any) => {
+        // Should not be called for regular imports
+        fail('Should not report errors for regular imports');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ImportDeclaration',
+      importKind: 'value',
+      loc: { start: { line: 1 }, end: { line: 1 } },
+    } as any;
+
+    const rule = noImportTypeRule.create(mockContext);
+
+    rule.ImportDeclaration(mockNode);
+    
+    // If we get here without the report function being called, the test passes
+    expect(true).toBe(true);
+  });
+});

package/src/plugin/rules/import/no-import-type.ts

@@ -1,46 +1,46 @@
-import { Rule } from 'eslint';
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: { description: 'Forbid use of "import type" syntax' },
-    schema: [],
-    messages: {
-      forbiddenImportType: 'Use of "import type" is forbidden.',
-    },
-    fixable: 'code',
-  },
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    return {
-      ImportDeclaration(node: any) {
-        try {
-          // Check for import type usage
-          if (node.importKind === 'type') {
-            context.report({
-              node,
-              messageId: 'forbiddenImportType',
-              fix(fixer) {
-                try {
-                  // Remove 'type' keyword
-                  const importText = sourceCode.getText(node);
-                  const newImportText = importText.replace(/import\s+type\s+/, 'import ');
-
-                  return fixer.replaceText(node, newImportText);
-                } catch (fixError) {
-                  console.error('[no-import-type] Error in fix function:', fixError);
-                  return null;
-                }
-              },
-            });
-          }
-        } catch (error) {
-          console.error('[no-import-type] Error in ImportDeclaration visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;
+import { Rule } from 'eslint';
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: { description: 'Forbid use of "import type" syntax' },
+    schema: [],
+    messages: {
+      forbiddenImportType: 'Use of "import type" is forbidden.',
+    },
+    fixable: 'code',
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      ImportDeclaration(node: any) {
+        try {
+          // Check for import type usage
+          if (node.importKind === 'type') {
+            context.report({
+              node,
+              messageId: 'forbiddenImportType',
+              fix(fixer) {
+                try {
+                  // Remove 'type' keyword
+                  const importText = sourceCode.getText(node);
+                  const newImportText = importText.replace(/import\s+type\s+/, 'import ');
+
+                  return fixer.replaceText(node, newImportText);
+                } catch (fixError) {
+                  console.error('[no-import-type] Error in fix function:', fixError);
+                  return null;
+                }
+              },
+            });
+          }
+        } catch (error) {
+          console.error('[no-import-type] Error in ImportDeclaration visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;