@futdevpro/dynamo-eslint 1.20.3 → 1.20.5

package/src/plugin/rules/angular/no-ngfor-directive.ts

@@ -1,62 +0,0 @@
-import { Rule } from 'eslint';
-
-/** `*ngFor` használat detektálása HTML template-ekben. */
-const NGFOR_REGEX: RegExp = /\*ngFor/g;
-
-/**
- * Adott offset alapján a sor és oszlop kiszámítása az alap szövegből.
- */
-function computeLoc(text: string, index: number): { line: number; column: number } {
-  const before: string = text.substring(0, index);
-  const newlineMatches: RegExpMatchArray | null = before.match(/\n/g);
-  const line: number = (newlineMatches ? newlineMatches.length : 0) + 1;
-  const lastNewline: number = before.lastIndexOf('\n');
-  const column: number = lastNewline === -1 ? index : index - lastNewline - 1;
-  return { line: line, column: column };
-}
-
-/**
- * No-ngFor-directive szabály: Angular template-ekben `*ngFor` helyett `@for` szintaxist használj.
- * CCAP "no-ngfor-directive" review ESLint template-text-scan portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Forbid `*ngFor` directive in Angular templates; use `@for` block syntax instead.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noNgFor: '`*ngFor` direktíva tilos. Használj `@for` block szintaxist.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    const filename: string = context.filename ?? '';
-    if (!filename.endsWith('.html')) {
-      return {};
-    }
-    const text: string = context.sourceCode.text ?? '';
-
-    return {
-      Program(): void {
-        try {
-          const localRegex: RegExp = new RegExp(NGFOR_REGEX.source, 'g');
-          let match: RegExpExecArray | null = localRegex.exec(text);
-          while (match !== null) {
-            const loc: { line: number; column: number } = computeLoc(text, match.index);
-            context.report({
-              loc: { start: loc, end: { line: loc.line, column: loc.column + match[0].length } },
-              messageId: 'noNgFor',
-            });
-            match = localRegex.exec(text);
-          }
-        } catch (error) {
-          console.error('[no-ngfor-directive] Error in Program visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

package/src/plugin/rules/angular/no-ngif-directive.spec.ts

@@ -1,44 +0,0 @@
-import noNgIfDirectiveRule from './no-ngif-directive';
-
-describe('| no-ngif-directive', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noNgIfDirectiveRule.meta?.type).toBe('suggestion');
-    expect(noNgIfDirectiveRule.meta?.messages?.noNgIf).toBeDefined();
-  });
-
-  it('| should skip non-html files', () => {
-    const mockContext: any = { filename: '/x/foo.ts', report: () => {}, options: [], sourceCode: { text: '' } };
-    const result: any = noNgIfDirectiveRule.create(mockContext);
-    expect(result.Program).toBeUndefined();
-  });
-
-  it('| should report `*ngIf`', () => {
-    let reportCount: number = 0;
-    const mockContext: any = {
-      filename: '/x/user.component.html',
-      report: (options: any): void => {
-        if (options.messageId === 'noNgIf') {
-          reportCount += 1;
-        }
-      },
-      options: [],
-      sourceCode: { text: '<div *ngIf="condition">X</div>' },
-    };
-    const rule: any = noNgIfDirectiveRule.create(mockContext);
-    rule.Program();
-    expect(reportCount).toBeGreaterThan(0);
-  });
-
-  it('| should NOT report `@if` block', () => {
-    let reportCount: number = 0;
-    const mockContext: any = {
-      filename: '/x/user.component.html',
-      report: (): void => { reportCount += 1; },
-      options: [],
-      sourceCode: { text: '@if (condition) { <div>X</div> }' },
-    };
-    const rule: any = noNgIfDirectiveRule.create(mockContext);
-    rule.Program();
-    expect(reportCount).toBe(0);
-  });
-});

package/src/plugin/rules/angular/no-ngif-directive.ts

@@ -1,62 +0,0 @@
-import { Rule } from 'eslint';
-
-/** `*ngIf` használat detektálása HTML template-ekben. */
-const NGIF_REGEX: RegExp = /\*ngIf/g;
-
-/**
- * Adott offset alapján a sor és oszlop kiszámítása az alap szövegből.
- */
-function computeLoc(text: string, index: number): { line: number; column: number } {
-  const before: string = text.substring(0, index);
-  const newlineMatches: RegExpMatchArray | null = before.match(/\n/g);
-  const line: number = (newlineMatches ? newlineMatches.length : 0) + 1;
-  const lastNewline: number = before.lastIndexOf('\n');
-  const column: number = lastNewline === -1 ? index : index - lastNewline - 1;
-  return { line: line, column: column };
-}
-
-/**
- * No-ngIf-directive szabály: Angular template-ekben `*ngIf` helyett `@if` szintaxist használj.
- * CCAP "no-ngif-directive" review ESLint template-text-scan portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Forbid `*ngIf` directive in Angular templates; use `@if` block syntax instead.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noNgIf: '`*ngIf` direktíva tilos. Használj `@if` block szintaxist.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    const filename: string = context.filename ?? '';
-    if (!filename.endsWith('.html')) {
-      return {};
-    }
-    const text: string = context.sourceCode.text ?? '';
-
-    return {
-      Program(): void {
-        try {
-          const localRegex: RegExp = new RegExp(NGIF_REGEX.source, 'g');
-          let match: RegExpExecArray | null = localRegex.exec(text);
-          while (match !== null) {
-            const loc: { line: number; column: number } = computeLoc(text, match.index);
-            context.report({
-              loc: { start: loc, end: { line: loc.line, column: loc.column + match[0].length } },
-              messageId: 'noNgIf',
-            });
-            match = localRegex.exec(text);
-          }
-        } catch (error) {
-          console.error('[no-ngif-directive] Error in Program visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

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

@@ -1,190 +0,0 @@
-import explicitTypesRule from './explicit-types';
-
-describe('| explicit-types', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(explicitTypesRule.meta?.type).toBe('suggestion');
-    expect(explicitTypesRule.meta?.docs?.description).toContain('explicit type annotations');
-  });
-
-  it('| should have create function that returns visitor object', () => {
-    const mockContext = {
-      report: () => {},
-    } as any;
-
-    const result = explicitTypesRule.create(mockContext);
-
-    expect(typeof result).toBe('object');
-    expect(typeof result.FunctionDeclaration).toBe('function');
-    expect(typeof result.ArrowFunctionExpression).toBe('function');
-    expect(typeof result.VariableDeclarator).toBe('function');
-    expect(typeof result.PropertyDefinition).toBe('function');
-  });
-
-  it('| should report missing return types on function declarations', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingReturnType');
-        expect(options.data.name).toBe('testFunction');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'FunctionDeclaration' as const,
-      id: { name: 'testFunction' },
-      returnType: null,
-      params: [],
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.FunctionDeclaration(mockNode);
-  });
-
-  it('| should not report when function has return type', () => {
-    const mockContext = {
-      report: (options: any) => {
-        fail('Should not report when function has return type');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'FunctionDeclaration' as const,
-      id: { name: 'testFunction' },
-      returnType: { type: 'TSTypeAnnotation' },
-      params: [],
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.FunctionDeclaration(mockNode);
-  });
-
-  it('| should report missing return types on arrow functions', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingArrowReturnType');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'ArrowFunctionExpression' as const,
-      returnType: null,
-      params: [],
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.ArrowFunctionExpression(mockNode);
-  });
-
-  it('| should report missing types on variable declarations', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingVariableType');
-        expect(options.data.name).toBe('testVar');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'VariableDeclarator' as const,
-      id: { name: 'testVar', typeAnnotation: null },
-      init: null,
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.VariableDeclarator(mockNode);
-  });
-
-  it('| should not report when variable has type annotation', () => {
-    const mockContext = {
-      report: (options: any) => {
-        fail('Should not report when variable has type annotation');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'VariableDeclarator' as const,
-      id: { name: 'testVar', typeAnnotation: { type: 'TSTypeAnnotation' } },
-      init: null,
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.VariableDeclarator(mockNode);
-  });
-
-  it('| should not report when variable has typed initializer', () => {
-    const mockContext = {
-      report: (options: any) => {
-        fail('Should not report when variable has typed initializer');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'VariableDeclarator' as const,
-      id: { name: 'testVar', typeAnnotation: null },
-      init: { type: 'CallExpression' },
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.VariableDeclarator(mockNode);
-  });
-
-  it('| should report missing parameter types', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingParameterType');
-        expect(options.data.name).toBe('param');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'FunctionDeclaration' as const,
-      id: { name: 'testFunction' },
-      returnType: { type: 'TSTypeAnnotation' },
-      params: [
-        { type: 'Identifier', name: 'param', typeAnnotation: null }
-      ],
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.FunctionDeclaration(mockNode);
-  });
-
-  it('| should report missing class property types', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingPropertyType');
-        expect(options.data.name).toBe('property');
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'PropertyDefinition' as const,
-      key: { name: 'property' },
-      typeAnnotation: null,
-      value: null,
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.PropertyDefinition(mockNode);
-  });
-
-  it('| should report missing destructuring types', () => {
-    const mockContext = {
-      report: (options: any) => {
-        expect(options.messageId).toBe('missingDestructuringType');
-      },
-    } as any;
-
-    const objectPatternNode = {
-      type: 'ObjectPattern' as const,
-      typeAnnotation: null,
-    } as any;
-
-    const arrayPatternNode = {
-      type: 'ArrayPattern' as const,
-      typeAnnotation: null,
-    } as any;
-
-    const rule = explicitTypesRule.create(mockContext);
-    rule.ObjectPattern(objectPatternNode);
-    rule.ArrayPattern(arrayPatternNode);
-  });
-});

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

@@ -1,186 +0,0 @@
-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;