@futdevpro/dynamo-eslint 1.20.2 → 1.20.5

package/src/plugin/rules/angular/effect-signal-loop.spec.ts

@@ -1,89 +0,0 @@
-import effectSignalLoopRule from './effect-signal-loop';
-
-describe('| effect-signal-loop', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(effectSignalLoopRule.meta?.type).toBe('problem');
-    expect(effectSignalLoopRule.meta?.messages?.effectSignalLoop).toBeDefined();
-  });
-
-  it('| should report when same signal is read AND written in effect', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('effectSignalLoop');
-        expect(options.data.signalName).toBe('count_$');
-      },
-      options: [],
-    };
-    const rule: any = effectSignalLoopRule.create(mockContext);
-    const mockNode: any = {
-      callee: { type: 'Identifier', name: 'effect' },
-      arguments: [
-        {
-          type: 'ArrowFunctionExpression',
-          body: {
-            type: 'BlockStatement',
-            body: [
-              {
-                type: 'ExpressionStatement',
-                expression: {
-                  type: 'CallExpression',
-                  callee: { type: 'Identifier', name: 'count_$' },
-                  arguments: [],
-                },
-              },
-              {
-                type: 'ExpressionStatement',
-                expression: {
-                  type: 'CallExpression',
-                  callee: {
-                    type: 'MemberExpression',
-                    object: { type: 'Identifier', name: 'count_$' },
-                    property: { type: 'Identifier', name: 'set' },
-                  },
-                  arguments: [{ type: 'Literal', value: 1 }],
-                },
-              },
-            ],
-          },
-        },
-      ],
-    };
-    rule.CallExpression(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report when only reading a signal', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = { report: () => { reportCalled = true; }, options: [] };
-    const rule: any = effectSignalLoopRule.create(mockContext);
-    const mockNode: any = {
-      callee: { type: 'Identifier', name: 'effect' },
-      arguments: [
-        {
-          type: 'ArrowFunctionExpression',
-          body: {
-            type: 'CallExpression',
-            callee: { type: 'Identifier', name: 'count_$' },
-            arguments: [],
-          },
-        },
-      ],
-    };
-    rule.CallExpression(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should ignore non-effect calls', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = { report: () => { reportCalled = true; }, options: [] };
-    const rule: any = effectSignalLoopRule.create(mockContext);
-    const mockNode: any = {
-      callee: { type: 'Identifier', name: 'computed' },
-      arguments: [],
-    };
-    rule.CallExpression(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-});

package/src/plugin/rules/angular/effect-signal-loop.ts

@@ -1,125 +0,0 @@
-import { Rule } from 'eslint';
-
-/**
- * Adott AST node alá tartozó signal olvasások / írások begyűjtése.
- * Olvasás: `something_$()` hívás (callee Identifier `*_$` névvel vagy
- *   MemberExpression `.foo_$()` property-vel).
- * Írás: `something_$.set(...)` vagy `something_$.update(...)`.
- */
-function collectSignals(
-  rootNode: any,
-  reads: Set<string>,
-  writes: Set<string>,
-): void {
-  if (!rootNode || typeof rootNode !== 'object') {
-    return;
-  }
-
-  if (rootNode.type === 'CallExpression') {
-    const callee: any = rootNode.callee;
-    // Signal olvasás: `name_$()` direkt hívás (Identifier callee)
-    if (callee && callee.type === 'Identifier' && /_\$$/.test(callee.name)) {
-      reads.add(callee.name);
-    }
-    // Signal olvasás: `this.name_$()` vagy `obj.name_$()`
-    if (
-      callee
-      && callee.type === 'MemberExpression'
-      && callee.property
-      && callee.property.type === 'Identifier'
-      && /_\$$/.test(callee.property.name)
-    ) {
-      reads.add(callee.property.name);
-    }
-    // Signal írás: `name_$.set(...)` / `name_$.update(...)`
-    if (
-      callee
-      && callee.type === 'MemberExpression'
-      && callee.property
-      && callee.property.type === 'Identifier'
-      && (callee.property.name === 'set' || callee.property.name === 'update')
-    ) {
-      const obj: any = callee.object;
-      if (obj && obj.type === 'Identifier' && /_\$$/.test(obj.name)) {
-        writes.add(obj.name);
-      }
-      if (
-        obj
-        && obj.type === 'MemberExpression'
-        && obj.property
-        && obj.property.type === 'Identifier'
-        && /_\$$/.test(obj.property.name)
-      ) {
-        writes.add(obj.property.name);
-      }
-    }
-  }
-
-  for (const key in rootNode) {
-    if (key === 'parent' || key === 'loc' || key === 'range') {
-      continue;
-    }
-    const value: any = rootNode[key];
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        collectSignals(item, reads, writes);
-      }
-    } else if (value && typeof value === 'object' && typeof value.type === 'string') {
-      collectSignals(value, reads, writes);
-    }
-  }
-}
-
-/**
- * Effect-signal-loop szabály: detektálja azt az `effect(...)` hívást ami
- * ugyanazt a signal-t olvassa (dependency-ként) és írja (`.set` / `.update`).
- * Ez végtelen loop-ot okozna, mert a write újra triggereli az effect-et.
- * CCAP "effect-signal-loop" review ESLint AST-portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Detect `effect()` callbacks that read and write the same signal — infinite loop risk.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      effectSignalLoop:
-        'Effect-signal loop: `{{signalName}}` olvasva ÉS írva (.set/.update) ugyanabban az `effect()`-ben. '
-        + 'Végtelen újrafutás veszélye — a signal-írás újra triggereli az effect-et.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    return {
-      CallExpression(node: any): void {
-        try {
-          const callee: any = node.callee;
-          if (!callee || callee.type !== 'Identifier' || callee.name !== 'effect') {
-            return;
-          }
-          const firstArg: any = node.arguments && node.arguments[0];
-          if (!firstArg) {
-            return;
-          }
-          const reads: Set<string> = new Set<string>();
-          const writes: Set<string> = new Set<string>();
-          collectSignals(firstArg, reads, writes);
-          for (const signalName of writes) {
-            if (reads.has(signalName)) {
-              context.report({
-                node: node,
-                messageId: 'effectSignalLoop',
-                data: { signalName: signalName },
-              });
-            }
-          }
-        } catch (error) {
-          console.error('[effect-signal-loop] Error in CallExpression visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

package/src/plugin/rules/angular/no-async-ngoninit.spec.ts

@@ -1,50 +0,0 @@
-import noAsyncNgOnInitRule from './no-async-ngoninit';
-
-describe('| no-async-ngoninit', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noAsyncNgOnInitRule.meta?.type).toBe('suggestion');
-    expect(noAsyncNgOnInitRule.meta?.messages?.noAsyncNgOnInit).toBeDefined();
-  });
-
-  it('| should report `async ngOnInit`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noAsyncNgOnInit');
-      },
-      options: [],
-    };
-    const rule: any = noAsyncNgOnInitRule.create(mockContext);
-    const mockNode: any = {
-      key: { type: 'Identifier', name: 'ngOnInit' },
-      value: { async: true },
-    };
-    rule.MethodDefinition(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report sync `ngOnInit`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = { report: () => { reportCalled = true; }, options: [] };
-    const rule: any = noAsyncNgOnInitRule.create(mockContext);
-    const mockNode: any = {
-      key: { type: 'Identifier', name: 'ngOnInit' },
-      value: { async: false },
-    };
-    rule.MethodDefinition(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should not report unrelated async methods', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = { report: () => { reportCalled = true; }, options: [] };
-    const rule: any = noAsyncNgOnInitRule.create(mockContext);
-    const mockNode: any = {
-      key: { type: 'Identifier', name: 'loadData' },
-      value: { async: true },
-    };
-    rule.MethodDefinition(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-});

package/src/plugin/rules/angular/no-async-ngoninit.ts

@@ -1,43 +0,0 @@
-import { Rule } from 'eslint';
-
-/**
- * No-async-ngOnInit szabály: `ngOnInit` metódus nem lehet `async`.
- * Angular nem várja le az `async ngOnInit`-et — ez néma hibát okoz.
- * CCAP "no-async-ngoninit" review ESLint AST-portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Forbid `async ngOnInit` in Angular components — Angular does not await it.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noAsyncNgOnInit:
-        '`async ngOnInit` tilos — Angular nem várja le. '
-        + 'Tedd a logikát egy külön `async` privát metódusba és hívd meg `ngOnInit`-ből.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    return {
-      MethodDefinition(node: any): void {
-        try {
-          if (!node.key || node.key.type !== 'Identifier' || node.key.name !== 'ngOnInit') {
-            return;
-          }
-          if (node.value && node.value.async === true) {
-            context.report({
-              node: node.key,
-              messageId: 'noAsyncNgOnInit',
-            });
-          }
-        } catch (error) {
-          console.error('[no-async-ngoninit] Error in MethodDefinition visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

package/src/plugin/rules/angular/no-component-direct-api.spec.ts

@@ -1,78 +0,0 @@
-import noComponentDirectApiRule from './no-component-direct-api';
-
-describe('| no-component-direct-api', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noComponentDirectApiRule.meta?.type).toBe('suggestion');
-    expect(noComponentDirectApiRule.meta?.messages?.noApiServiceImport).toBeDefined();
-    expect(noComponentDirectApiRule.meta?.messages?.noHttpClientImport).toBeDefined();
-  });
-
-  it('| should skip non-component files', () => {
-    const mockContext: any = { filename: '/x/foo.ts', report: () => {}, options: [] };
-    const result: any = noComponentDirectApiRule.create(mockContext);
-    expect(result.ImportDeclaration).toBeUndefined();
-  });
-
-  it('| should report `*ApiService` import in component', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.component.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'noApiServiceImport') {
-          reportCalled = true;
-          expect(options.data.names).toBe('User_ApiService');
-        }
-      },
-      options: [],
-    };
-    const rule: any = noComponentDirectApiRule.create(mockContext);
-    const mockNode: any = {
-      source: { value: './user.api-service' },
-      specifiers: [
-        { type: 'ImportSpecifier', imported: { name: 'User_ApiService' } },
-      ],
-    };
-    rule.ImportDeclaration(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report `HttpClient` import in component', () => {
-    let httpReported: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.component.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'noHttpClientImport') {
-          httpReported = true;
-        }
-      },
-      options: [],
-    };
-    const rule: any = noComponentDirectApiRule.create(mockContext);
-    const mockNode: any = {
-      source: { value: '@angular/common/http' },
-      specifiers: [
-        { type: 'ImportSpecifier', imported: { name: 'HttpClient' } },
-      ],
-    };
-    rule.ImportDeclaration(mockNode);
-    expect(httpReported).toBe(true);
-  });
-
-  it('| should not report data-service import in component', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.component.ts',
-      report: () => { reportCalled = true; },
-      options: [],
-    };
-    const rule: any = noComponentDirectApiRule.create(mockContext);
-    const mockNode: any = {
-      source: { value: './user.data-service' },
-      specifiers: [
-        { type: 'ImportSpecifier', imported: { name: 'User_DataService' } },
-      ],
-    };
-    rule.ImportDeclaration(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-});

package/src/plugin/rules/angular/no-component-direct-api.ts

@@ -1,82 +0,0 @@
-import { Rule } from 'eslint';
-
-/** ApiService class név regex – `_ApiService` vagy `ApiService` végződésű class. */
-const API_SERVICE_NAME_REGEX: RegExp = /\w+(?:_)?ApiService$/;
-
-/**
- * No-component-direct-api szabály: `*.component.ts` fájlok nem importálhatnak közvetlenül
- * `*ApiService` class-okat vagy `HttpClient`-et. Single Source of Truth elv – data-service
- * vagy control-service réteg kötelező.
- * CCAP "no-component-direct-api" review ESLint AST-portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Components must not directly import `*ApiService` or `HttpClient`; '
-        + 'use data-service / control-service layer (Single Source of Truth).',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noApiServiceImport:
-        'Komponens közvetlenül importál ApiService class-t: `{{names}}`. '
-        + 'Használj data-service-t vagy control-service-t (Single Source of Truth).',
-      noHttpClientImport:
-        'Komponens közvetlenül importálja a `HttpClient`-et. '
-        + 'Használj api-service / data-service / control-service réteget.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    const filename: string = context.filename ?? '';
-    if (!filename.endsWith('.component.ts')) {
-      return {};
-    }
-
-    return {
-      ImportDeclaration(node: any): void {
-        try {
-          const source: string = (node.source && typeof node.source.value === 'string')
-            ? node.source.value
-            : '';
-          const apiServiceNames: string[] = [];
-          let hasHttpClient: boolean = false;
-
-          for (const specifier of node.specifiers ?? []) {
-            if (specifier.type !== 'ImportSpecifier') {
-              continue;
-            }
-            const importedName: string = (specifier.imported && specifier.imported.name)
-              ? specifier.imported.name
-              : '';
-            if (importedName === 'HttpClient' && source === '@angular/common/http') {
-              hasHttpClient = true;
-            }
-            if (API_SERVICE_NAME_REGEX.test(importedName)) {
-              apiServiceNames.push(importedName);
-            }
-          }
-
-          if (apiServiceNames.length > 0) {
-            context.report({
-              node: node,
-              messageId: 'noApiServiceImport',
-              data: { names: apiServiceNames.join(', ') },
-            });
-          }
-          if (hasHttpClient) {
-            context.report({
-              node: node,
-              messageId: 'noHttpClientImport',
-            });
-          }
-        } catch (error) {
-          console.error('[no-component-direct-api] Error in ImportDeclaration visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

package/src/plugin/rules/angular/no-method-call-in-template.spec.ts

@@ -1,63 +0,0 @@
-import noMethodCallInTemplateRule from './no-method-call-in-template';
-
-describe('| no-method-call-in-template', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noMethodCallInTemplateRule.meta?.type).toBe('suggestion');
-    expect(noMethodCallInTemplateRule.meta?.messages?.interpolationCall).toBeDefined();
-    expect(noMethodCallInTemplateRule.meta?.messages?.propertyBindingCall).toBeDefined();
-    expect(noMethodCallInTemplateRule.meta?.messages?.blockCall).toBeDefined();
-  });
-
-  it('| should skip non-html files', () => {
-    const mockContext: any = { filename: '/x/foo.ts', report: () => {}, options: [], sourceCode: { text: '' } };
-    const result: any = noMethodCallInTemplateRule.create(mockContext);
-    expect(result.Program).toBeUndefined();
-  });
-
-  it('| should report interpolation method call `{{ getName() }}`', () => {
-    let reportCount: number = 0;
-    const mockContext: any = {
-      filename: '/x/user.component.html',
-      report: (options: any): void => {
-        if (options.messageId === 'interpolationCall') {
-          reportCount += 1;
-        }
-      },
-      options: [],
-      sourceCode: { text: '<div>{{ getName() }}</div>' },
-    };
-    const rule: any = noMethodCallInTemplateRule.create(mockContext);
-    rule.Program();
-    expect(reportCount).toBeGreaterThan(0);
-  });
-
-  it('| should NOT report signal call `{{ name_$() }}`', () => {
-    let reportCount: number = 0;
-    const mockContext: any = {
-      filename: '/x/user.component.html',
-      report: (): void => { reportCount += 1; },
-      options: [],
-      sourceCode: { text: '<div>{{ name_$() }}</div>' },
-    };
-    const rule: any = noMethodCallInTemplateRule.create(mockContext);
-    rule.Program();
-    expect(reportCount).toBe(0);
-  });
-
-  it('| should report `@if (isActive())` block call', () => {
-    let blockReported: boolean = false;
-    const mockContext: any = {
-      filename: '/x/user.component.html',
-      report: (options: any): void => {
-        if (options.messageId === 'blockCall') {
-          blockReported = true;
-        }
-      },
-      options: [],
-      sourceCode: { text: '@if (isActive()) { <span>X</span> }' },
-    };
-    const rule: any = noMethodCallInTemplateRule.create(mockContext);
-    rule.Program();
-    expect(blockReported).toBe(true);
-  });
-});

package/src/plugin/rules/angular/no-method-call-in-template.ts

@@ -1,89 +0,0 @@
-import { Rule } from 'eslint';
-
-/**
- * Interpoláció metódushívás regex: `{{ ... method() ... }}`. Signal hívás (`_$()`) kizárva.
- * Capture group 1: a hívott metódus neve.
- */
-const INTERPOLATION_CALL_REGEX: RegExp =
-  /\{\{[^}]*\b([a-zA-Z_$][a-zA-Z0-9_$]*(?<!_\$))\s*\([^)]*\)[^}]*\}\}/g;
-
-/**
- * Property binding metódushívás regex: `[attr]="method()"`. Esemény binding `(event)="..."` kizárva.
- */
-const PROPERTY_BINDING_CALL_REGEX: RegExp =
-  /\[[^\]]+\]="[^"]*\b[a-zA-Z_$][a-zA-Z0-9_$]*(?<!_\$)\s*\([^)]*\)[^"]*"/g;
-
-/**
- * Angular block (`@if`, `@switch`, `@case`, `@else if`) metódushívás regex.
- */
-const BLOCK_CALL_REGEX: RegExp =
-  /@(?:if|switch|case|else if)\s*\([^)]*\b[a-zA-Z_$][a-zA-Z0-9_$]*(?<!_\$)\s*\([^)]*\)/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-method-call-in-template szabály: Angular template-ekben tilos metódust hívni
- * adat megjelenítéshez. Megengedett: signal `mySignal_$()` és esemény `(click)="handler()"`.
- * CCAP "no-method-call-in-template" review ESLint port (template parser source-text scan).
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Forbid method calls in Angular templates for data display; '
-        + 'use signals / computed / pipes instead. Event bindings `(click)="..."` allowed.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      interpolationCall: 'Metódushívás interpolációban: `{{ method() }}`. Használj signal-t vagy pipe-ot.',
-      propertyBindingCall: 'Metódushívás property bindingban. Használj signal-t vagy computed-t.',
-      blockCall: 'Metódushívás Angular block direktívában (`@if` / `@switch`). Használj signal-t vagy computed-t.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    const filename: string = context.filename ?? '';
-    if (!filename.endsWith('.html')) {
-      return {};
-    }
-    const text: string = context.sourceCode.text ?? '';
-
-    function reportMatches(regex: RegExp, messageId: string): void {
-      const localRegex: RegExp = new RegExp(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: messageId,
-        });
-        match = localRegex.exec(text);
-      }
-    }
-
-    return {
-      Program(): void {
-        try {
-          reportMatches(INTERPOLATION_CALL_REGEX, 'interpolationCall');
-          reportMatches(PROPERTY_BINDING_CALL_REGEX, 'propertyBindingCall');
-          reportMatches(BLOCK_CALL_REGEX, 'blockCall');
-        } catch (error) {
-          console.error('[no-method-call-in-template] Error in Program visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

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

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