@futdevpro/dynamo-eslint 1.15.25 → 1.20.2

package/src/plugin/rules/ts/no-dynamic-imports.ts

@@ -1,49 +1,49 @@
-import { Rule } from 'eslint';
-
-/**
- * No-dynamic-imports szabály: `import()` és `require()` dinamikus hívás tilos.
- * Minden import a fájl tetején, top-level `import { … } from '…'` formában szerepeljen.
- * CCAP "no-dynamic-imports" review ESLint AST-portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Forbid dynamic `import()` and `require()` calls; all imports must be top-level.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noDynamicImport: 'Dinamikus `import()` hívás tilos. Tedd top-level `import { … } from "…"` formába.',
-      noRequireCall: '`require()` hívás tilos. Használj top-level ES `import` szintaxist.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    return {
-      ImportExpression(node: any): void {
-        try {
-          context.report({
-            node: node,
-            messageId: 'noDynamicImport',
-          });
-        } catch (error) {
-          console.error('[no-dynamic-imports] Error in ImportExpression visitor:', error);
-        }
-      },
-      CallExpression(node: any): void {
-        try {
-          if (node.callee && node.callee.type === 'Identifier' && node.callee.name === 'require') {
-            context.report({
-              node: node,
-              messageId: 'noRequireCall',
-            });
-          }
-        } catch (error) {
-          console.error('[no-dynamic-imports] Error in CallExpression visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;
+import { Rule } from 'eslint';
+
+/**
+ * No-dynamic-imports szabály: `import()` és `require()` dinamikus hívás tilos.
+ * Minden import a fájl tetején, top-level `import { … } from '…'` formában szerepeljen.
+ * CCAP "no-dynamic-imports" review ESLint AST-portja.
+ */
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Forbid dynamic `import()` and `require()` calls; all imports must be top-level.',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      noDynamicImport: 'Dinamikus `import()` hívás tilos. Tedd top-level `import { … } from "…"` formába.',
+      noRequireCall: '`require()` hívás tilos. Használj top-level ES `import` szintaxist.',
+    },
+  },
+  create(context: Rule.RuleContext): Rule.RuleListener {
+    return {
+      ImportExpression(node: any): void {
+        try {
+          context.report({
+            node: node,
+            messageId: 'noDynamicImport',
+          });
+        } catch (error) {
+          console.error('[no-dynamic-imports] Error in ImportExpression visitor:', error);
+        }
+      },
+      CallExpression(node: any): void {
+        try {
+          if (node.callee && node.callee.type === 'Identifier' && node.callee.name === 'require') {
+            context.report({
+              node: node,
+              messageId: 'noRequireCall',
+            });
+          }
+        } catch (error) {
+          console.error('[no-dynamic-imports] Error in CallExpression visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/src/plugin/rules/ts/no-native-browser-dialogs.spec.ts

@@ -1,54 +1,54 @@
-import noNativeBrowserDialogsRule from './no-native-browser-dialogs';
-
-describe('| no-native-browser-dialogs', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noNativeBrowserDialogsRule.meta?.type).toBe('suggestion');
-    expect(noNativeBrowserDialogsRule.meta?.messages?.noNativeDialog).toBeDefined();
-  });
-
-  it('| should report `alert(...)`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noNativeDialog');
-        expect(options.data.name).toBe('alert');
-      },
-      options: [],
-    };
-    const rule: any = noNativeBrowserDialogsRule.create(mockContext);
-    const mockNode: any = { callee: { type: 'Identifier', name: 'alert' } };
-    rule.CallExpression(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report `window.confirm(...)`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.data.name).toBe('window.confirm');
-      },
-      options: [],
-    };
-    const rule: any = noNativeBrowserDialogsRule.create(mockContext);
-    const mockNode: any = {
-      callee: {
-        type: 'MemberExpression',
-        object: { type: 'Identifier', name: 'window' },
-        property: { type: 'Identifier', name: 'confirm' },
-      },
-    };
-    rule.CallExpression(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report unrelated calls', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = { report: () => { reportCalled = true; }, options: [] };
-    const rule: any = noNativeBrowserDialogsRule.create(mockContext);
-    const mockNode: any = { callee: { type: 'Identifier', name: 'doSomething' } };
-    rule.CallExpression(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-});
+import noNativeBrowserDialogsRule from './no-native-browser-dialogs';
+
+describe('| no-native-browser-dialogs', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(noNativeBrowserDialogsRule.meta?.type).toBe('suggestion');
+    expect(noNativeBrowserDialogsRule.meta?.messages?.noNativeDialog).toBeDefined();
+  });
+
+  it('| should report `alert(...)`', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      report: (options: any): void => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noNativeDialog');
+        expect(options.data.name).toBe('alert');
+      },
+      options: [],
+    };
+    const rule: any = noNativeBrowserDialogsRule.create(mockContext);
+    const mockNode: any = { callee: { type: 'Identifier', name: 'alert' } };
+    rule.CallExpression(mockNode);
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report `window.confirm(...)`', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      report: (options: any): void => {
+        reportCalled = true;
+        expect(options.data.name).toBe('window.confirm');
+      },
+      options: [],
+    };
+    const rule: any = noNativeBrowserDialogsRule.create(mockContext);
+    const mockNode: any = {
+      callee: {
+        type: 'MemberExpression',
+        object: { type: 'Identifier', name: 'window' },
+        property: { type: 'Identifier', name: 'confirm' },
+      },
+    };
+    rule.CallExpression(mockNode);
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should not report unrelated calls', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = { report: () => { reportCalled = true; }, options: [] };
+    const rule: any = noNativeBrowserDialogsRule.create(mockContext);
+    const mockNode: any = { callee: { type: 'Identifier', name: 'doSomething' } };
+    rule.CallExpression(mockNode);
+    expect(reportCalled).toBe(false);
+  });
+});

package/src/plugin/rules/ts/no-native-browser-dialogs.ts

@@ -1,84 +1,84 @@
-import { Rule } from 'eslint';
-
-/**
- * Tiltott natív browser dialog nevek.
- */
-const NATIVE_DIALOG_NAMES: Set<string> = new Set<string>([
-  'alert',
-  'confirm',
-  'prompt',
-  'showModalDialog',
-]);
-
-/**
- * Globális objektum nevek, amelyeken a dialog hívás detektálandó.
- */
-const GLOBAL_NAMES: Set<string> = new Set<string>([
-  'window',
-  'globalThis',
-  'self',
-  'top',
-  'parent',
-]);
-
-/**
- * No-native-browser-dialogs szabály: tilos a natív `window.alert` / `window.confirm` /
- * `window.prompt` / `showModalDialog` hívás. Helyette shared modal komponens (`S_Modal_Component`)
- * használandó. CCAP "no-native-browser-dialogs" review ESLint AST-portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Forbid native blocking browser dialogs (`alert`, `confirm`, `prompt`, `showModalDialog`); '
-        + 'use shared modal component instead.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noNativeDialog:
-        'Natív browser dialog `{{name}}` tilos. '
-        + 'Használj shared modal komponenst (pl. `S_Modal_Component` / `app-s-modal`).',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    return {
-      CallExpression(node: any): void {
-        try {
-          const callee: any = node.callee;
-          if (!callee) {
-            return;
-          }
-          if (callee.type === 'Identifier' && NATIVE_DIALOG_NAMES.has(callee.name)) {
-            context.report({
-              node: node,
-              messageId: 'noNativeDialog',
-              data: { name: callee.name },
-            });
-            return;
-          }
-          if (
-            callee.type === 'MemberExpression'
-            && callee.object
-            && callee.object.type === 'Identifier'
-            && GLOBAL_NAMES.has(callee.object.name)
-            && callee.property
-            && callee.property.type === 'Identifier'
-            && NATIVE_DIALOG_NAMES.has(callee.property.name)
-          ) {
-            context.report({
-              node: node,
-              messageId: 'noNativeDialog',
-              data: { name: `${callee.object.name}.${callee.property.name}` },
-            });
-          }
-        } catch (error) {
-          console.error('[no-native-browser-dialogs] Error in CallExpression visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;
+import { Rule } from 'eslint';
+
+/**
+ * Tiltott natív browser dialog nevek.
+ */
+const NATIVE_DIALOG_NAMES: Set<string> = new Set<string>([
+  'alert',
+  'confirm',
+  'prompt',
+  'showModalDialog',
+]);
+
+/**
+ * Globális objektum nevek, amelyeken a dialog hívás detektálandó.
+ */
+const GLOBAL_NAMES: Set<string> = new Set<string>([
+  'window',
+  'globalThis',
+  'self',
+  'top',
+  'parent',
+]);
+
+/**
+ * No-native-browser-dialogs szabály: tilos a natív `window.alert` / `window.confirm` /
+ * `window.prompt` / `showModalDialog` hívás. Helyette shared modal komponens (`S_Modal_Component`)
+ * használandó. CCAP "no-native-browser-dialogs" review ESLint AST-portja.
+ */
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Forbid native blocking browser dialogs (`alert`, `confirm`, `prompt`, `showModalDialog`); '
+        + 'use shared modal component instead.',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      noNativeDialog:
+        'Natív browser dialog `{{name}}` tilos. '
+        + 'Használj shared modal komponenst (pl. `S_Modal_Component` / `app-s-modal`).',
+    },
+  },
+  create(context: Rule.RuleContext): Rule.RuleListener {
+    return {
+      CallExpression(node: any): void {
+        try {
+          const callee: any = node.callee;
+          if (!callee) {
+            return;
+          }
+          if (callee.type === 'Identifier' && NATIVE_DIALOG_NAMES.has(callee.name)) {
+            context.report({
+              node: node,
+              messageId: 'noNativeDialog',
+              data: { name: callee.name },
+            });
+            return;
+          }
+          if (
+            callee.type === 'MemberExpression'
+            && callee.object
+            && callee.object.type === 'Identifier'
+            && GLOBAL_NAMES.has(callee.object.name)
+            && callee.property
+            && callee.property.type === 'Identifier'
+            && NATIVE_DIALOG_NAMES.has(callee.property.name)
+          ) {
+            context.report({
+              node: node,
+              messageId: 'noNativeDialog',
+              data: { name: `${callee.object.name}.${callee.property.name}` },
+            });
+          }
+        } catch (error) {
+          console.error('[no-native-browser-dialogs] Error in CallExpression visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/src/plugin/rules/ts/no-plain-function-export.spec.ts

@@ -1,72 +1,72 @@
-import noPlainFunctionExportRule from './no-plain-function-export';
-
-describe('| no-plain-function-export', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noPlainFunctionExportRule.meta?.type).toBe('suggestion');
-    expect(noPlainFunctionExportRule.meta?.messages?.noFunctionExport).toBeDefined();
-    expect(noPlainFunctionExportRule.meta?.messages?.noConstFunctionExport).toBeDefined();
-  });
-
-  it('| should skip spec files', () => {
-    const mockContext: any = { filename: '/x/foo.spec.ts', report: () => {}, options: [] };
-    const result: any = noPlainFunctionExportRule.create(mockContext);
-    expect(result.ExportNamedDeclaration).toBeUndefined();
-  });
-
-  it('| should report `export function fn`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/foo.ts',
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noFunctionExport');
-      },
-      options: [],
-    };
-    const rule: any = noPlainFunctionExportRule.create(mockContext);
-    const mockNode: any = {
-      declaration: { type: 'FunctionDeclaration', id: { name: 'helperFn' } },
-    };
-    rule.ExportNamedDeclaration(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report `export const fn = () => …`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/foo.ts',
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noConstFunctionExport');
-      },
-      options: [],
-    };
-    const rule: any = noPlainFunctionExportRule.create(mockContext);
-    const mockNode: any = {
-      declaration: {
-        type: 'VariableDeclaration',
-        declarations: [
-          { id: { name: 'helperFn' }, init: { type: 'ArrowFunctionExpression' } },
-        ],
-      },
-    };
-    rule.ExportNamedDeclaration(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report `export const data = { … }`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = { filename: '/x/foo.ts', report: () => { reportCalled = true; }, options: [] };
-    const rule: any = noPlainFunctionExportRule.create(mockContext);
-    const mockNode: any = {
-      declaration: {
-        type: 'VariableDeclaration',
-        declarations: [
-          { id: { name: 'data' }, init: { type: 'ObjectExpression' } },
-        ],
-      },
-    };
-    rule.ExportNamedDeclaration(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-});
+import noPlainFunctionExportRule from './no-plain-function-export';
+
+describe('| no-plain-function-export', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(noPlainFunctionExportRule.meta?.type).toBe('suggestion');
+    expect(noPlainFunctionExportRule.meta?.messages?.noFunctionExport).toBeDefined();
+    expect(noPlainFunctionExportRule.meta?.messages?.noConstFunctionExport).toBeDefined();
+  });
+
+  it('| should skip spec files', () => {
+    const mockContext: any = { filename: '/x/foo.spec.ts', report: () => {}, options: [] };
+    const result: any = noPlainFunctionExportRule.create(mockContext);
+    expect(result.ExportNamedDeclaration).toBeUndefined();
+  });
+
+  it('| should report `export function fn`', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/foo.ts',
+      report: (options: any): void => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noFunctionExport');
+      },
+      options: [],
+    };
+    const rule: any = noPlainFunctionExportRule.create(mockContext);
+    const mockNode: any = {
+      declaration: { type: 'FunctionDeclaration', id: { name: 'helperFn' } },
+    };
+    rule.ExportNamedDeclaration(mockNode);
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report `export const fn = () => …`', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/foo.ts',
+      report: (options: any): void => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noConstFunctionExport');
+      },
+      options: [],
+    };
+    const rule: any = noPlainFunctionExportRule.create(mockContext);
+    const mockNode: any = {
+      declaration: {
+        type: 'VariableDeclaration',
+        declarations: [
+          { id: { name: 'helperFn' }, init: { type: 'ArrowFunctionExpression' } },
+        ],
+      },
+    };
+    rule.ExportNamedDeclaration(mockNode);
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should not report `export const data = { … }`', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = { filename: '/x/foo.ts', report: () => { reportCalled = true; }, options: [] };
+    const rule: any = noPlainFunctionExportRule.create(mockContext);
+    const mockNode: any = {
+      declaration: {
+        type: 'VariableDeclaration',
+        declarations: [
+          { id: { name: 'data' }, init: { type: 'ObjectExpression' } },
+        ],
+      },
+    };
+    rule.ExportNamedDeclaration(mockNode);
+    expect(reportCalled).toBe(false);
+  });
+});

package/src/plugin/rules/ts/no-plain-function-export.ts

@@ -1,73 +1,73 @@
-import { Rule } from 'eslint';
-
-/**
- * No-plain-function-export szabály: tilos top-level `export function fn()` és
- * `export const fn = () => …` arrow/function deklaráció.
- * Megosztott logika static `_Util` / `UtilService` osztály metódusokban kell legyen.
- * CCAP "no-plain-function-export" review ESLint AST-portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Forbid top-level `export function` and `export const fn = () => …`; '
-        + 'use static methods on `_Util` / `UtilService` classes.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noFunctionExport:
-        'Top-level `export function {{name}}` tilos. '
-        + 'Tedd static metódusba `_Util` / `UtilService` osztályon belül.',
-      noConstFunctionExport:
-        'Top-level `export const {{name}} = () => …` tilos. '
-        + 'Tedd static metódusba `_Util` / `UtilService` osztályon belül.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    const filename: string = context.filename ?? '';
-    if (filename.endsWith('.spec.ts') || filename.endsWith('.test.ts')) {
-      return {};
-    }
-
-    return {
-      ExportNamedDeclaration(node: any): void {
-        try {
-          const decl: any = node.declaration;
-          if (!decl) {
-            return;
-          }
-          if (decl.type === 'FunctionDeclaration' && decl.id && decl.id.name) {
-            context.report({
-              node: decl,
-              messageId: 'noFunctionExport',
-              data: { name: decl.id.name },
-            });
-            return;
-          }
-          if (decl.type === 'VariableDeclaration' && Array.isArray(decl.declarations)) {
-            for (const declarator of decl.declarations) {
-              const init: any = declarator.init;
-              if (!init) {
-                continue;
-              }
-              if (init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression') {
-                const name: string = (declarator.id && declarator.id.name) ? declarator.id.name : 'anonymous';
-                context.report({
-                  node: declarator,
-                  messageId: 'noConstFunctionExport',
-                  data: { name: name },
-                });
-              }
-            }
-          }
-        } catch (error) {
-          console.error('[no-plain-function-export] Error in ExportNamedDeclaration visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;
+import { Rule } from 'eslint';
+
+/**
+ * No-plain-function-export szabály: tilos top-level `export function fn()` és
+ * `export const fn = () => …` arrow/function deklaráció.
+ * Megosztott logika static `_Util` / `UtilService` osztály metódusokban kell legyen.
+ * CCAP "no-plain-function-export" review ESLint AST-portja.
+ */
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Forbid top-level `export function` and `export const fn = () => …`; '
+        + 'use static methods on `_Util` / `UtilService` classes.',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      noFunctionExport:
+        'Top-level `export function {{name}}` tilos. '
+        + 'Tedd static metódusba `_Util` / `UtilService` osztályon belül.',
+      noConstFunctionExport:
+        'Top-level `export const {{name}} = () => …` tilos. '
+        + 'Tedd static metódusba `_Util` / `UtilService` osztályon belül.',
+    },
+  },
+  create(context: Rule.RuleContext): Rule.RuleListener {
+    const filename: string = context.filename ?? '';
+    if (filename.endsWith('.spec.ts') || filename.endsWith('.test.ts')) {
+      return {};
+    }
+
+    return {
+      ExportNamedDeclaration(node: any): void {
+        try {
+          const decl: any = node.declaration;
+          if (!decl) {
+            return;
+          }
+          if (decl.type === 'FunctionDeclaration' && decl.id && decl.id.name) {
+            context.report({
+              node: decl,
+              messageId: 'noFunctionExport',
+              data: { name: decl.id.name },
+            });
+            return;
+          }
+          if (decl.type === 'VariableDeclaration' && Array.isArray(decl.declarations)) {
+            for (const declarator of decl.declarations) {
+              const init: any = declarator.init;
+              if (!init) {
+                continue;
+              }
+              if (init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression') {
+                const name: string = (declarator.id && declarator.id.name) ? declarator.id.name : 'anonymous';
+                context.report({
+                  node: declarator,
+                  messageId: 'noConstFunctionExport',
+                  data: { name: name },
+                });
+              }
+            }
+          }
+        } catch (error) {
+          console.error('[no-plain-function-export] Error in ExportNamedDeclaration visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;