@futdevpro/dynamo-eslint 1.15.25 → 1.15.28

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;

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

@@ -1,50 +1,50 @@
-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);
-  });
-});
+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 +1,43 @@
-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;
+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;