@futdevpro/dynamo-eslint 1.20.2 → 1.20.5

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

@@ -1,64 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-#!/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);
-});

package/src/scripts/eslintrc-audit.ts

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-/**
- * @fileoverview ESLint Configuration Audit Script
- * 
- * This script analyzes ESLint configuration files (.eslintrc.json) across the project
- * to provide statistics on rule usage. It helps identify commonly used rules and
- * potential configuration inconsistencies.
- * 
- * @usage
- * ```bash
- * dynamo-eslintrc-audit
- * ```
- * 
- * @example
- * ```bash
- * # Audit all ESLint configurations in the project
- * npx dynamo-eslintrc-audit
- * 
- * # Or run via npm script
- * npm run audit:eslintrc
- * ```
- * 
- * @author Future Development Program Ltd.
- * @version 1.14.3
- */
-
-import fg from 'fast-glob';
-import { readFileSync } from 'fs';
-/** Type alias for any JSON value */
-type AnyJson = any;
-
-/**
- * Safely parses a JSON file and returns the parsed object or null if parsing fails
- * 
- * @param jsonPath - Path to the JSON file to parse
- * @returns Parsed JSON object or null if parsing fails
- * 
- * @example
- * ```typescript
- * const config = safeParse('./.eslintrc.json');
- * if (config) {
- *   console.log('Rules:', Object.keys(config.rules || {}));
- * }
- * ```
- */
-function safeParse(jsonPath: string): AnyJson | null {
-  try {
-    const content = readFileSync(jsonPath, 'utf8');
-
-    return JSON.parse(content);
-  } catch {
-    // Return null for any parsing errors (malformed JSON, file not found, etc.)
-    return null;
-  }
-}
-
-/**
- * Main function that analyzes ESLint configuration files and generates rule usage statistics
- * 
- * Scans for all .eslintrc.json files in the project, extracts rule configurations,
- * and provides a sorted table of the most commonly used rules.
- * 
- * @returns Promise that resolves when analysis is complete
- * 
- * @example
- * ```typescript
- * // The function will output a table like:
- * // ┌─────────┬─────────────────────────┬───────┐
- * // │ (index) │          rule           │ count │
- * // ├─────────┼─────────────────────────┼───────┤
- * // │    0    │    'no-unused-vars'     │   5   │
- * // │    1    │    'semi'               │   4   │
- * // └─────────┴─────────────────────────┴───────┘
- * ```
- */
-async function main(): Promise<void> {
-  // Find all ESLint configuration files, excluding node_modules
-  const files: string[] = await fg([ '**/.eslintrc.json' ], { ignore: [ '**/node_modules/**' ] });
-  const ruleCounts: Record<string, number> = {};
-  const total: number = files.length;
-
-  // Process each configuration file
-  for (const p of files) {
-    const cfg = safeParse(p);
-
-    // Skip files without rules configuration
-    if (!cfg?.rules) continue;
-
-    // Count each rule occurrence
-    for (const key of Object.keys(cfg.rules)) {
-      ruleCounts[key] = (ruleCounts[key] ?? 0) + 1;
-    }
-  }
-
-  // Sort rules by usage count (most used first)
-  const entries = Object.entries(ruleCounts).sort(
-    (a: [ string, number ], b: [ string, number ]): number => b[1] - a[1]
-  );
-
-  // Display results
-  console.log(`[dynamo-eslintrc-audit] analyzed ${total} files`);
-  console.table(entries.slice(0, 50).map(([ rule, count ]) => ({ rule, count })));
-}
-
-// Execute the main function and handle any errors
-main().catch((err: Error): void => {
-  console.error(err);
-  process.exit(1);
-});
-
-
-
-
-
-
-

package/src/scripts/fix-return-types.spec.ts

@@ -1,65 +0,0 @@
-import * as ts from 'typescript';
-
-import { buildTypeNodeFromString } from './fix-return-types';
-
-/**
- * A `buildTypeNodeFromString` helper-t fedi le — ez a B2 regresszio magja: a regi
- * `ts.factory.createTypeReferenceNode(typeString)` csonka `Record`-ot emittalt a
- * generic tipusoknal. A helper most a teljes tipus-stringet valodi TypeNode-da
- * parse-olja, vagy bail-el (undefined), ha nem biztonsagos.
- */
-describe('| fix-return-types buildTypeNodeFromString', () => {
-  const printer: ts.Printer = ts.createPrinter();
-  const dummySource: ts.SourceFile = ts.createSourceFile('__dummy__.ts', '', ts.ScriptTarget.Latest, false);
-
-  /** Egy TypeNode-ot vissza-printel forras-szovegge az assert-hez. */
-  function printType(node: ts.TypeNode): string {
-    return printer.printNode(ts.EmitHint.Unspecified, node, dummySource);
-  }
-
-  it('| should keep the type arguments of a generic Record (no truncation)', () => {
-    const node: ts.TypeNode | undefined = buildTypeNodeFromString('Record<string, unknown>');
-
-    expect(node).toBeDefined();
-
-    const printed: string = printType(node as ts.TypeNode);
-
-    // A regi bug itt csonka "Record"-ot adott — most a teljes generic megmarad.
-    expect(printed).toContain('Record');
-    expect(printed).toContain('<');
-    expect(printed).toContain('string');
-    expect(printed).toContain('unknown');
-    expect(printed).not.toMatch(/^Record;?$/);
-  });
-
-  it('| should preserve a union type', () => {
-    const node: ts.TypeNode | undefined = buildTypeNodeFromString('string | null');
-
-    expect(node).toBeDefined();
-    expect(printType(node as ts.TypeNode)).toContain('|');
-  });
-
-  it('| should preserve a nested generic (Promise of array)', () => {
-    const node: ts.TypeNode | undefined = buildTypeNodeFromString('Promise<number[]>');
-
-    expect(node).toBeDefined();
-
-    const printed: string = printType(node as ts.TypeNode);
-    expect(printed).toContain('Promise');
-    expect(printed).toContain('number');
-    expect(printed).toContain('[]');
-  });
-
-  it('| should bail (undefined) on an inline import() type to avoid leaking a path', () => {
-    const node: ts.TypeNode | undefined = buildTypeNodeFromString('import("/abs/path/to/mod").Foo');
-
-    expect(node).toBeUndefined();
-  });
-
-  it('| should still handle a plain identifier type', () => {
-    const node: ts.TypeNode | undefined = buildTypeNodeFromString('MyType');
-
-    expect(node).toBeDefined();
-    expect(printType(node as ts.TypeNode)).toBe('MyType');
-  });
-});