@futdevpro/dynamo-eslint 1.15.22 → 1.15.28

package/src/plugin/rules/ts/one-export-per-file.spec.ts

@@ -1,64 +1,64 @@
-import oneExportPerFileRule from './one-export-per-file';
-
-describe('| one-export-per-file', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(oneExportPerFileRule.meta?.type).toBe('suggestion');
-    expect(oneExportPerFileRule.meta?.messages?.tooManyExports).toBeDefined();
-  });
-
-  it('| should skip .const.ts (exception pattern)', () => {
-    const mockContext: any = { filename: '/x/foo.const.ts', report: () => {}, options: [] };
-    const result: any = oneExportPerFileRule.create(mockContext);
-    expect(result.Program).toBeUndefined();
-  });
-
-  it('| should skip .data-model.ts (DataModel + DataParams allowed)', () => {
-    const mockContext: any = { filename: '/x/user.data-model.ts', report: () => {}, options: [] };
-    const result: any = oneExportPerFileRule.create(mockContext);
-    expect(result.Program).toBeUndefined();
-  });
-
-  it('| should skip .spec.ts files', () => {
-    const mockContext: any = { filename: '/x/foo.spec.ts', report: () => {}, options: [] };
-    const result: any = oneExportPerFileRule.create(mockContext);
-    expect(result.Program).toBeUndefined();
-  });
-
-  it('| should not report when file has 1 export', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/foo.ts',
-      report: () => { reportCalled = true; },
-      options: [],
-    };
-    const rule: any = oneExportPerFileRule.create(mockContext);
-    const mockProgram: any = {
-      body: [
-        { type: 'ExportNamedDeclaration', declaration: { type: 'FunctionDeclaration' } },
-      ],
-    };
-    rule.Program(mockProgram);
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should report when file has 2+ exports', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/foo.ts',
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('tooManyExports');
-      },
-      options: [],
-    };
-    const rule: any = oneExportPerFileRule.create(mockContext);
-    const mockProgram: any = {
-      body: [
-        { type: 'ExportNamedDeclaration', declaration: { type: 'ClassDeclaration' } },
-        { type: 'ExportNamedDeclaration', declaration: { type: 'FunctionDeclaration' } },
-      ],
-    };
-    rule.Program(mockProgram);
-    expect(reportCalled).toBe(true);
-  });
-});
+import oneExportPerFileRule from './one-export-per-file';
+
+describe('| one-export-per-file', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(oneExportPerFileRule.meta?.type).toBe('suggestion');
+    expect(oneExportPerFileRule.meta?.messages?.tooManyExports).toBeDefined();
+  });
+
+  it('| should skip .const.ts (exception pattern)', () => {
+    const mockContext: any = { filename: '/x/foo.const.ts', report: () => {}, options: [] };
+    const result: any = oneExportPerFileRule.create(mockContext);
+    expect(result.Program).toBeUndefined();
+  });
+
+  it('| should skip .data-model.ts (DataModel + DataParams allowed)', () => {
+    const mockContext: any = { filename: '/x/user.data-model.ts', report: () => {}, options: [] };
+    const result: any = oneExportPerFileRule.create(mockContext);
+    expect(result.Program).toBeUndefined();
+  });
+
+  it('| should skip .spec.ts files', () => {
+    const mockContext: any = { filename: '/x/foo.spec.ts', report: () => {}, options: [] };
+    const result: any = oneExportPerFileRule.create(mockContext);
+    expect(result.Program).toBeUndefined();
+  });
+
+  it('| should not report when file has 1 export', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/foo.ts',
+      report: () => { reportCalled = true; },
+      options: [],
+    };
+    const rule: any = oneExportPerFileRule.create(mockContext);
+    const mockProgram: any = {
+      body: [
+        { type: 'ExportNamedDeclaration', declaration: { type: 'FunctionDeclaration' } },
+      ],
+    };
+    rule.Program(mockProgram);
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should report when file has 2+ exports', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/foo.ts',
+      report: (options: any): void => {
+        reportCalled = true;
+        expect(options.messageId).toBe('tooManyExports');
+      },
+      options: [],
+    };
+    const rule: any = oneExportPerFileRule.create(mockContext);
+    const mockProgram: any = {
+      body: [
+        { type: 'ExportNamedDeclaration', declaration: { type: 'ClassDeclaration' } },
+        { type: 'ExportNamedDeclaration', declaration: { type: 'FunctionDeclaration' } },
+      ],
+    };
+    rule.Program(mockProgram);
+    expect(reportCalled).toBe(true);
+  });
+});

package/src/plugin/rules/ts/one-export-per-file.ts

@@ -1,77 +1,77 @@
-import { Rule } from 'eslint';
-
-/**
- * Kivétel fájl-minták – ezekben megengedett több export.
- * CCAP konvenció: `*.const.ts`, `*.type-enum.ts`, `*.interface.ts`, DataModel + DataParams.
- */
-const MULTI_EXPORT_EXCEPTION_PATTERNS: RegExp[] = [
-  /\.const\.ts$/,
-  /\.type-enum\.ts$/,
-  /\.interface\.ts$/,
-  /\.data-model\.ts$/,
-  /\.control-model\.ts$/,
-];
-
-/**
- * One-export-per-file szabály: nem-kivétel fájlokban max 1 exportált
- * class/interface/enum/type/function deklaráció lehet.
- * CCAP "one-export-per-file" review ESLint AST-portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Limit to one exported class/interface/enum/type/function per file (with named exceptions).',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      tooManyExports:
-        '{{count}} export deklaráció a fájlban (max 1). Vegyél ki minden további exportot külön fájlba.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    const filename: string = context.filename ?? '';
-    if (MULTI_EXPORT_EXCEPTION_PATTERNS.some((p: RegExp): boolean => p.test(filename))) {
-      return {};
-    }
-    if (filename.endsWith('.spec.ts') || filename.endsWith('.test.ts') || filename.endsWith('.d.ts')) {
-      return {};
-    }
-
-    return {
-      Program(node: any): void {
-        try {
-          const exportNodes: any[] = [];
-          for (const statement of node.body) {
-            if (statement.type === 'ExportNamedDeclaration' && statement.declaration) {
-              const decl: any = statement.declaration;
-              if (
-                decl.type === 'ClassDeclaration'
-                || decl.type === 'TSInterfaceDeclaration'
-                || decl.type === 'TSEnumDeclaration'
-                || decl.type === 'TSTypeAliasDeclaration'
-                || decl.type === 'FunctionDeclaration'
-              ) {
-                exportNodes.push(statement);
-              }
-            } else if (statement.type === 'ExportDefaultDeclaration') {
-              exportNodes.push(statement);
-            }
-          }
-          if (exportNodes.length > 1) {
-            context.report({
-              node: exportNodes[1],
-              messageId: 'tooManyExports',
-              data: { count: String(exportNodes.length) },
-            });
-          }
-        } catch (error) {
-          console.error('[one-export-per-file] Error in Program visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;
+import { Rule } from 'eslint';
+
+/**
+ * Kivétel fájl-minták – ezekben megengedett több export.
+ * CCAP konvenció: `*.const.ts`, `*.type-enum.ts`, `*.interface.ts`, DataModel + DataParams.
+ */
+const MULTI_EXPORT_EXCEPTION_PATTERNS: RegExp[] = [
+  /\.const\.ts$/,
+  /\.type-enum\.ts$/,
+  /\.interface\.ts$/,
+  /\.data-model\.ts$/,
+  /\.control-model\.ts$/,
+];
+
+/**
+ * One-export-per-file szabály: nem-kivétel fájlokban max 1 exportált
+ * class/interface/enum/type/function deklaráció lehet.
+ * CCAP "one-export-per-file" review ESLint AST-portja.
+ */
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Limit to one exported class/interface/enum/type/function per file (with named exceptions).',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      tooManyExports:
+        '{{count}} export deklaráció a fájlban (max 1). Vegyél ki minden további exportot külön fájlba.',
+    },
+  },
+  create(context: Rule.RuleContext): Rule.RuleListener {
+    const filename: string = context.filename ?? '';
+    if (MULTI_EXPORT_EXCEPTION_PATTERNS.some((p: RegExp): boolean => p.test(filename))) {
+      return {};
+    }
+    if (filename.endsWith('.spec.ts') || filename.endsWith('.test.ts') || filename.endsWith('.d.ts')) {
+      return {};
+    }
+
+    return {
+      Program(node: any): void {
+        try {
+          const exportNodes: any[] = [];
+          for (const statement of node.body) {
+            if (statement.type === 'ExportNamedDeclaration' && statement.declaration) {
+              const decl: any = statement.declaration;
+              if (
+                decl.type === 'ClassDeclaration'
+                || decl.type === 'TSInterfaceDeclaration'
+                || decl.type === 'TSEnumDeclaration'
+                || decl.type === 'TSTypeAliasDeclaration'
+                || decl.type === 'FunctionDeclaration'
+              ) {
+                exportNodes.push(statement);
+              }
+            } else if (statement.type === 'ExportDefaultDeclaration') {
+              exportNodes.push(statement);
+            }
+          }
+          if (exportNodes.length > 1) {
+            context.report({
+              node: exportNodes[1],
+              messageId: 'tooManyExports',
+              data: { count: String(exportNodes.length) },
+            });
+          }
+        } catch (error) {
+          console.error('[one-export-per-file] Error in Program visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/src/scripts/dynamo-fix.ts

@@ -1,172 +1,172 @@
-#!/usr/bin/env node
-/**
- * @fileoverview Dynamo ESLint Auto-Fix Script
- * 
- * This script runs ESLint with auto-fix capabilities on TypeScript files across the project.
- * It processes all .ts and .tsx files, applies Dynamo-specific rules, and automatically
- * fixes issues where possible.
- * 
- * @usage
- * ```bash
- * dynamo-fix
- * ```
- * 
- * @example
- * ```bash
- * # Fix all TypeScript files in the project
- * npx dynamo-fix
- * 
- * # Or run via npm script
- * npm run fix
- * ```
- * 
- * @author Future Development Program Ltd.
- * @version 1.14.3
- */
-
-import fg from 'fast-glob';
-import { ESLint } from 'eslint';
-import { writeFileSync } from 'fs';
-
-/**
- * Result of fixing a single file
- */
-interface FixResult {
-  /** Path to the file that was processed */
-  file: string;
-  /** Whether the file was actually modified */
-  fixed: boolean;
-  /** Number of errors found in the file */
-  errors: number;
-  /** Number of warnings found in the file */
-  warnings: number;
-  /** Number of fixes applied to the file */
-  fixes: number;
-}
-
-/**
- * Fixes a single TypeScript file using ESLint with auto-fix capabilities
- * 
- * @param filePath - Path to the TypeScript file to fix
- * @returns Promise that resolves to a FixResult object containing fix statistics
- * 
- * @example
- * ```typescript
- * const result = await fixFile('./src/components/Button.tsx');
- * console.log(`Fixed ${result.fixes} issues in ${result.file}`);
- * ```
- */
-async function fixFile(filePath: string): Promise<FixResult> {
-  // Configure ESLint with Dynamo-specific rules and auto-fix enabled
-  const eslint = new ESLint({
-    baseConfig: [
-      { ignores: [ 'build/**', 'dist/**', 'node_modules/**' ] },
-      {
-        files: [ '**/*.{ts,tsx}' ],
-        languageOptions: {
-          parser: require('@typescript-eslint/parser'),
-          parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
-        },
-        plugins: {
-          '@futdevpro/dynamo': {
-            rules: {
-              'import-order': require('../plugin/rules/import-order').default,
-              'naming-patterns': require('../plugin/rules/naming-patterns').default,
-            },
-          },
-        },
-        rules: {
-          '@futdevpro/dynamo/import-order': 'error',
-          '@futdevpro/dynamo/naming-patterns': 'warn',
-        },
-      },
-    ],
-    fix: true, // Enable auto-fixing
-  });
-
-  // Run ESLint on the file
-  const results = await eslint.lintFiles([ filePath ]);
-  const result = results[0];
-
-  // Write the fixed content back to the file if changes were made
-  if (result && result.output) {
-    writeFileSync(filePath, result.output);
-  }
-
-  // Return comprehensive fix statistics
-  return {
-    file: filePath,
-    fixed: result && result.output !== undefined,
-    errors: result.messages.filter(msg => msg.severity === 2).length,
-    warnings: result.messages.filter(msg => msg.severity === 1).length,
-    fixes: result.fixableErrorCount + result.fixableWarningCount,
-  };
-}
-
-/**
- * Main function that processes all TypeScript files in the project
- * 
- * Scans for all .ts and .tsx files, applies ESLint fixes, and provides
- * comprehensive reporting on the results.
- * 
- * @returns Promise that resolves when all files have been processed
- * 
- * @throws {Error} When file processing fails
- */
-async function main() {
-  // Find all TypeScript files, excluding common directories and test files
-  const files = await fg([ '**/*.{ts,tsx}' ], { 
-    ignore: [ '**/node_modules/**', '**/build/**', '**/dist/**', '**/*.spec.ts', '**/*.test.ts' ], 
-  });
-  
-  console.log(`[dynamo-fix] Fixing ${files.length} files...`);
-  
-  const results: FixResult[] = [];
-  let totalFixed = 0;
-  let totalErrors = 0;
-  let totalWarnings = 0;
-  let totalFixes = 0;
-
-  // Process each file individually
-  for (const file of files) {
-    try {
-      const result = await fixFile(file);
-
-      results.push(result);
-      
-      // Track successful fixes
-      if (result.fixed) {
-        totalFixed++;
-        console.log(`✅ Fixed: ${result.file}`);
-      }
-      
-      // Accumulate statistics
-      totalErrors += result.errors;
-      totalWarnings += result.warnings;
-      totalFixes += result.fixes;
-    } catch (error) {
-      console.error(`❌ Error processing ${file}:`, error);
-    }
-  }
-
-  // Generate comprehensive summary report
-  console.log(`\n📊 Fix Summary:`);
-  console.log(`   Files processed: ${files.length}`);
-  console.log(`   Files fixed: ${totalFixed}`);
-  console.log(`   Total errors: ${totalErrors}`);
-  console.log(`   Total warnings: ${totalWarnings}`);
-  console.log(`   Total fixes applied: ${totalFixes}`);
-
-  // Provide appropriate success/failure message
-  if (totalFixed === 0) {
-    console.log('✅ No files needed fixing!');
-  } else {
-    console.log(`\n🎉 Successfully fixed ${totalFixed} files!`);
-  }
-}
-
-// Execute the main function and handle any errors
-main().catch((err) => {
-  console.error('Fix failed:', err);
-  process.exit(1);
-});
+#!/usr/bin/env node
+/**
+ * @fileoverview Dynamo ESLint Auto-Fix Script
+ * 
+ * This script runs ESLint with auto-fix capabilities on TypeScript files across the project.
+ * It processes all .ts and .tsx files, applies Dynamo-specific rules, and automatically
+ * fixes issues where possible.
+ * 
+ * @usage
+ * ```bash
+ * dynamo-fix
+ * ```
+ * 
+ * @example
+ * ```bash
+ * # Fix all TypeScript files in the project
+ * npx dynamo-fix
+ * 
+ * # Or run via npm script
+ * npm run fix
+ * ```
+ * 
+ * @author Future Development Program Ltd.
+ * @version 1.14.3
+ */
+
+import fg from 'fast-glob';
+import { ESLint } from 'eslint';
+import { writeFileSync } from 'fs';
+
+/**
+ * Result of fixing a single file
+ */
+interface FixResult {
+  /** Path to the file that was processed */
+  file: string;
+  /** Whether the file was actually modified */
+  fixed: boolean;
+  /** Number of errors found in the file */
+  errors: number;
+  /** Number of warnings found in the file */
+  warnings: number;
+  /** Number of fixes applied to the file */
+  fixes: number;
+}
+
+/**
+ * Fixes a single TypeScript file using ESLint with auto-fix capabilities
+ * 
+ * @param filePath - Path to the TypeScript file to fix
+ * @returns Promise that resolves to a FixResult object containing fix statistics
+ * 
+ * @example
+ * ```typescript
+ * const result = await fixFile('./src/components/Button.tsx');
+ * console.log(`Fixed ${result.fixes} issues in ${result.file}`);
+ * ```
+ */
+async function fixFile(filePath: string): Promise<FixResult> {
+  // Configure ESLint with Dynamo-specific rules and auto-fix enabled
+  const eslint = new ESLint({
+    baseConfig: [
+      { ignores: [ 'build/**', 'dist/**', 'node_modules/**' ] },
+      {
+        files: [ '**/*.{ts,tsx}' ],
+        languageOptions: {
+          parser: require('@typescript-eslint/parser'),
+          parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
+        },
+        plugins: {
+          '@futdevpro/dynamo': {
+            rules: {
+              'import-order': require('../plugin/rules/import/import-order').default,
+              'naming-patterns': require('../plugin/rules/naming-patterns').default,
+            },
+          },
+        },
+        rules: {
+          '@futdevpro/dynamo/import-order': 'error',
+          '@futdevpro/dynamo/naming-patterns': 'warn',
+        },
+      },
+    ],
+    fix: true, // Enable auto-fixing
+  });
+
+  // Run ESLint on the file
+  const results = await eslint.lintFiles([ filePath ]);
+  const result = results[0];
+
+  // Write the fixed content back to the file if changes were made
+  if (result && result.output) {
+    writeFileSync(filePath, result.output);
+  }
+
+  // Return comprehensive fix statistics
+  return {
+    file: filePath,
+    fixed: result && result.output !== undefined,
+    errors: result.messages.filter(msg => msg.severity === 2).length,
+    warnings: result.messages.filter(msg => msg.severity === 1).length,
+    fixes: result.fixableErrorCount + result.fixableWarningCount,
+  };
+}
+
+/**
+ * Main function that processes all TypeScript files in the project
+ * 
+ * Scans for all .ts and .tsx files, applies ESLint fixes, and provides
+ * comprehensive reporting on the results.
+ * 
+ * @returns Promise that resolves when all files have been processed
+ * 
+ * @throws {Error} When file processing fails
+ */
+async function main() {
+  // Find all TypeScript files, excluding common directories and test files
+  const files = await fg([ '**/*.{ts,tsx}' ], { 
+    ignore: [ '**/node_modules/**', '**/build/**', '**/dist/**', '**/*.spec.ts', '**/*.test.ts' ], 
+  });
+  
+  console.log(`[dynamo-fix] Fixing ${files.length} files...`);
+  
+  const results: FixResult[] = [];
+  let totalFixed = 0;
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  let totalFixes = 0;
+
+  // Process each file individually
+  for (const file of files) {
+    try {
+      const result = await fixFile(file);
+
+      results.push(result);
+      
+      // Track successful fixes
+      if (result.fixed) {
+        totalFixed++;
+        console.log(`✅ Fixed: ${result.file}`);
+      }
+      
+      // Accumulate statistics
+      totalErrors += result.errors;
+      totalWarnings += result.warnings;
+      totalFixes += result.fixes;
+    } catch (error) {
+      console.error(`❌ Error processing ${file}:`, error);
+    }
+  }
+
+  // Generate comprehensive summary report
+  console.log(`\n📊 Fix Summary:`);
+  console.log(`   Files processed: ${files.length}`);
+  console.log(`   Files fixed: ${totalFixed}`);
+  console.log(`   Total errors: ${totalErrors}`);
+  console.log(`   Total warnings: ${totalWarnings}`);
+  console.log(`   Total fixes applied: ${totalFixes}`);
+
+  // Provide appropriate success/failure message
+  if (totalFixed === 0) {
+    console.log('✅ No files needed fixing!');
+  } else {
+    console.log(`\n🎉 Successfully fixed ${totalFixed} files!`);
+  }
+}
+
+// Execute the main function and handle any errors
+main().catch((err) => {
+  console.error('Fix failed:', err);
+  process.exit(1);
+});