@futdevpro/dynamo-eslint 1.15.25 → 1.20.2

package/src/plugin/rules/angular/angular-for-track-logic.ts

@@ -1,88 +1,88 @@
-import { Rule } from 'eslint';
-
-/**
- * `@for (...; track <expr>)` kifejezés keresése — capture group 1: a track expression.
- */
-const FOR_TRACK_REGEX: RegExp = /@for\s*\([^)]*;\s*track\s+([^;)]+)/g;
-
-/**
- * Logika detektáló minták a track kifejezésben.
- * Tiltott: `??`, `||`, `&&`, `()`, `+-*\/`, ternary `?`.
- * Megengedett: egyszerű property access (`item.id`).
- */
-const TRACK_LOGIC_PATTERNS: RegExp[] = [
-  /\?\?/,
-  /\|\|/,
-  /&&/,
-  /\(/,
-  /\)/,
-  /[+\-*/%]/,
-  /\?\s*[^:]/,
-];
-
-/**
- * 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 };
-}
-
-/**
- * Angular-for-track-logic szabály: tilos logika `@for (...; track <expr>)` kifejezésben.
- * CCAP "angular-for-track-logic" review ESLint template-text-scan portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description:
-        'Forbid logic in Angular `@for (...; track <expr>)`; '
-        + 'only direct property access (`item.id`) allowed.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      trackLogic: 'Logika a `@for track` kifejezésben: `track {{expr}}`.',
-    },
-  },
-  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(FOR_TRACK_REGEX.source, 'g');
-          let match: RegExpExecArray | null = localRegex.exec(text);
-          while (match !== null) {
-            const expr: string = match[1].trim();
-            const hasLogic: boolean = TRACK_LOGIC_PATTERNS.some(
-              (p: RegExp): boolean => p.test(expr),
-            );
-            if (hasLogic) {
-              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: 'trackLogic',
-                data: { expr: expr },
-              });
-            }
-            match = localRegex.exec(text);
-          }
-        } catch (error) {
-          console.error('[angular-for-track-logic] Error in Program visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;
+import { Rule } from 'eslint';
+
+/**
+ * `@for (...; track <expr>)` kifejezés keresése — capture group 1: a track expression.
+ */
+const FOR_TRACK_REGEX: RegExp = /@for\s*\([^)]*;\s*track\s+([^;)]+)/g;
+
+/**
+ * Logika detektáló minták a track kifejezésben.
+ * Tiltott: `??`, `||`, `&&`, `()`, `+-*\/`, ternary `?`.
+ * Megengedett: egyszerű property access (`item.id`).
+ */
+const TRACK_LOGIC_PATTERNS: RegExp[] = [
+  /\?\?/,
+  /\|\|/,
+  /&&/,
+  /\(/,
+  /\)/,
+  /[+\-*/%]/,
+  /\?\s*[^:]/,
+];
+
+/**
+ * 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 };
+}
+
+/**
+ * Angular-for-track-logic szabály: tilos logika `@for (...; track <expr>)` kifejezésben.
+ * CCAP "angular-for-track-logic" review ESLint template-text-scan portja.
+ */
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Forbid logic in Angular `@for (...; track <expr>)`; '
+        + 'only direct property access (`item.id`) allowed.',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      trackLogic: 'Logika a `@for track` kifejezésben: `track {{expr}}`.',
+    },
+  },
+  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(FOR_TRACK_REGEX.source, 'g');
+          let match: RegExpExecArray | null = localRegex.exec(text);
+          while (match !== null) {
+            const expr: string = match[1].trim();
+            const hasLogic: boolean = TRACK_LOGIC_PATTERNS.some(
+              (p: RegExp): boolean => p.test(expr),
+            );
+            if (hasLogic) {
+              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: 'trackLogic',
+                data: { expr: expr },
+              });
+            }
+            match = localRegex.exec(text);
+          }
+        } catch (error) {
+          console.error('[angular-for-track-logic] Error in Program visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;

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

@@ -1,89 +1,89 @@
-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);
-  });
-});
+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 +1,125 @@
-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;
+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;