@futdevpro/dynamo-eslint 1.15.25 → 1.15.28

package/build/scripts/fix-return-types.js

@@ -1,227 +1,227 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * @fileoverview TypeScript Type Annotation Fix Script
- *
- * This script uses TypeScript's AST (Abstract Syntax Tree) to automatically add
- * type annotations to functions and arrow functions. It analyzes TypeScript files,
- * infers return types using the TypeScript compiler, and adds explicit type
- * annotations where missing.
- *
- * @usage
- * ```bash
- * dynamo-fix-return-types
- * ```
- *
- * @example
- * ```bash
- * # Fix type annotations in all TypeScript files
- * npx dynamo-fix-return-types
- *
- * # Or run via npm script
- * npm run fix:types
- * ```
- *
- * @author Future Development Program Ltd.
- * @version 1.14.3
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildTypeNodeFromString = buildTypeNodeFromString;
-exports.addTypesToFile = addTypesToFile;
-const tslib_1 = require("tslib");
-const ts = tslib_1.__importStar(require("typescript"));
-const fs = tslib_1.__importStar(require("fs"));
-const fast_glob_1 = tslib_1.__importDefault(require("fast-glob"));
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-/**
- * Egy `checker.typeToString(...)`-bol jovo TIPUS-STRING-et valodi `ts.TypeNode`-da
- * alakit ugy, hogy egy eldobhato `type __T = <typeString>;` forrast parse-ol es
- * kiszedi belole a TypeNode-ot.
- *
- * MIERT: a regi megoldas `ts.factory.createTypeReferenceNode(typeString)`-et hivott,
- * ami CSAK bare identifier-t (entity-name-et) fogad el. Egy generic/union/stb.
- * tipus-string (pl. `Record<string, unknown>`) eseten ez tort node-ot epitett, amit
- * a printer csonka `Record`-kent (type-argumentumok nelkul) emittalt — ami EGYSZERRE
- * tsc-hiba ES uj lint-hiba, igy egyetlen fix-futas 0 → 1+ lint-szamot regresszalt.
- * A `typeToString` mindig syntactically valid TS tipus-syntaxot ad vissza, ezert a
- * `type __T = …;` parse-olas minden esetre korrekt TypeNode-ot allit elo.
- *
- * BAIL-OUT: ha a tipus nem alakithato biztonsagos node-da — pl. inline
- * `import("/abs/path").Foo` format tartalmaz, ami abszolut path-t szivarogtatna a
- * fajlba —, `undefined`-et adunk vissza. A hivo ilyenkor KIHAGYJA az annotaciot:
- * jobb annotalatlanul hagyni (marad a figyelmeztetes), mint tort kodot irni.
- */
-function buildTypeNodeFromString(typeString) {
-    // Inline `import(...)` tipus → projekt-specifikus abszolut/relativ path-t vinne a
-    // fajlba; sosem biztonsagos textualisan beilleszteni, ezert bail.
-    if (typeString.includes('import(')) {
-        return undefined;
-    }
-    const probe = ts.createSourceFile('__dynamo_type_probe__.ts', `type __T = ${typeString};`, ts.ScriptTarget.Latest, 
-    /* setParentNodes */ false);
-    const statement = probe.statements[0];
-    if (!statement || !ts.isTypeAliasDeclaration(statement) || !statement.type) {
-        return undefined;
-    }
-    return statement.type;
-}
-/**
- * Adds type annotations to functions and arrow functions in a TypeScript file
- *
- * Uses TypeScript's compiler API to analyze the file, infer return types,
- * and automatically add explicit type annotations where missing.
- *
- * @param filePath - Path to the TypeScript file to process
- * @returns FixResult object containing statistics about the changes made
- *
- * @example
- * ```typescript
- * const result = addTypesToFile('./src/utils.ts');
- * console.log(`Added ${result.changes} type annotations to ${result.file}`);
- * ```
- */
-function addTypesToFile(filePath) {
-    // Read and parse the source file
-    const sourceCode = fs.readFileSync(filePath, 'utf8');
-    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
-    // Create TypeScript program for type checking
-    const program = ts.createProgram([filePath], {
-        target: ts.ScriptTarget.Latest,
-        module: ts.ModuleKind.ESNext,
-        strict: true,
-        skipLibCheck: true,
-    });
-    const checker = program.getTypeChecker();
-    let changes = 0;
-    let hasChanges = false;
-    /**
-     * Recursively visits AST nodes and adds type annotations where needed
-     *
-     * @param node - The current AST node being visited
-     * @returns The potentially modified AST node
-     */
-    function visit(node) {
-        // Handle function declarations without return types
-        if (ts.isFunctionDeclaration(node) && !node.type) {
-            const signature = checker.getSignatureFromDeclaration(node);
-            if (signature) {
-                const returnType = checker.getReturnTypeOfSignature(signature);
-                const typeString = checker.typeToString(returnType);
-                // Add type annotation if it's not void or any
-                if (typeString !== 'void' && typeString !== 'any') {
-                    const newType = buildTypeNodeFromString(typeString);
-                    // newType === undefined → a tipus nem serializalhato biztonsagosan,
-                    // kihagyjuk az annotaciot ahelyett hogy tort kodot irnank (B2 bail-out).
-                    if (newType) {
-                        const updatedNode = ts.factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, newType, node.body);
-                        changes++;
-                        hasChanges = true;
-                        return ts.visitEachChild(updatedNode, visit, {});
-                    }
-                }
-            }
-        }
-        // Handle arrow functions without return types
-        if (ts.isArrowFunction(node) && !node.type) {
-            const signature = checker.getSignatureFromDeclaration(node);
-            if (signature) {
-                const returnType = checker.getReturnTypeOfSignature(signature);
-                const typeString = checker.typeToString(returnType);
-                // Add type annotation if it's not void or any
-                if (typeString !== 'void' && typeString !== 'any') {
-                    const newType = buildTypeNodeFromString(typeString);
-                    // newType === undefined → a tipus nem serializalhato biztonsagosan,
-                    // kihagyjuk az annotaciot ahelyett hogy tort kodot irnank (B2 bail-out).
-                    if (newType) {
-                        const updatedNode = ts.factory.updateArrowFunction(node, node.modifiers, node.typeParameters, node.parameters, newType, node.equalsGreaterThanToken, node.body);
-                        changes++;
-                        hasChanges = true;
-                        return ts.visitEachChild(updatedNode, visit, {});
-                    }
-                }
-            }
-        }
-        // Note: Variable declarations, parameters, and class properties
-        // are handled by the existing @typescript-eslint/typedef rule
-        // and can be auto-fixed with eslint --fix
-        return ts.visitEachChild(node, visit, {});
-    }
-    // Transform the AST and apply changes
-    const result = ts.visitEachChild(sourceFile, visit, {});
-    // Write the modified code back to the file if changes were made
-    if (hasChanges) {
-        const printer = ts.createPrinter();
-        const newSourceCode = printer.printFile(result);
-        fs.writeFileSync(filePath, newSourceCode);
-    }
-    return {
-        file: filePath,
-        fixed: hasChanges,
-        changes,
-    };
-}
-/**
- * Main function that processes all TypeScript files and adds type annotations
- *
- * Scans for all .ts and .tsx files in the project, processes each file to add
- * missing type annotations, 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 (0, fast_glob_1.default)(['**/*.{ts,tsx}'], {
-        ignore: [
-            '**/node_modules/**',
-            '**/build/**',
-            '**/dist/**',
-            '**/*.spec.ts',
-            '**/*.test.ts',
-        ],
-    });
-    fsm_dynamo_1.DyFM_Log.log(`[fix-types] Processing ${files.length} files...`);
-    const results = [];
-    let totalFixed = 0;
-    let totalChanges = 0;
-    // Process each file individually
-    for (const file of files) {
-        try {
-            const result = addTypesToFile(file);
-            results.push(result);
-            // Track successful fixes
-            if (result.fixed) {
-                totalFixed++;
-                totalChanges += result.changes;
-                fsm_dynamo_1.DyFM_Log.log(`✅ Fixed ${result.changes} type annotations in ${file}`);
-            }
-        }
-        catch (error) {
-            fsm_dynamo_1.DyFM_Log.error(`❌ Error processing ${file}:`, error);
-        }
-    }
-    // Generate comprehensive summary report
-    fsm_dynamo_1.DyFM_Log.log(`\n📊 Fix Summary:`);
-    fsm_dynamo_1.DyFM_Log.log(`   Files processed: ${files.length}`);
-    fsm_dynamo_1.DyFM_Log.log(`   Files fixed: ${totalFixed}`);
-    fsm_dynamo_1.DyFM_Log.log(`   Total type annotations added: ${totalChanges}`);
-    // Provide appropriate success/failure message
-    if (totalFixed > 0) {
-        fsm_dynamo_1.DyFM_Log.log(`🎉 Successfully added type annotations to ${totalFixed} files!`);
-    }
-    else {
-        fsm_dynamo_1.DyFM_Log.log('✅ No files needed type annotation fixes!');
-    }
-}
-// Csak akkor futtatjuk a teljes fajl-scan-t, ha a scriptet KOZVETLENUL hivjak
-// (CLI bin / `npm run fix:return-types`). Import eseten (pl. spec a helper-ekhez)
-// NEM indul el a main(), igy a tiszta segedfuggvenyek unit-tesztelhetok.
-if (require.main === module) {
-    // Execute the main function and handle any errors
-    main().catch((err) => {
-        fsm_dynamo_1.DyFM_Log.error('Fix script failed:', err);
-        process.exit(1);
-    });
-}
+#!/usr/bin/env node
+"use strict";
+/**
+ * @fileoverview TypeScript Type Annotation Fix Script
+ *
+ * This script uses TypeScript's AST (Abstract Syntax Tree) to automatically add
+ * type annotations to functions and arrow functions. It analyzes TypeScript files,
+ * infers return types using the TypeScript compiler, and adds explicit type
+ * annotations where missing.
+ *
+ * @usage
+ * ```bash
+ * dynamo-fix-return-types
+ * ```
+ *
+ * @example
+ * ```bash
+ * # Fix type annotations in all TypeScript files
+ * npx dynamo-fix-return-types
+ *
+ * # Or run via npm script
+ * npm run fix:types
+ * ```
+ *
+ * @author Future Development Program Ltd.
+ * @version 1.14.3
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTypeNodeFromString = buildTypeNodeFromString;
+exports.addTypesToFile = addTypesToFile;
+const tslib_1 = require("tslib");
+const ts = tslib_1.__importStar(require("typescript"));
+const fs = tslib_1.__importStar(require("fs"));
+const fast_glob_1 = tslib_1.__importDefault(require("fast-glob"));
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+/**
+ * Egy `checker.typeToString(...)`-bol jovo TIPUS-STRING-et valodi `ts.TypeNode`-da
+ * alakit ugy, hogy egy eldobhato `type __T = <typeString>;` forrast parse-ol es
+ * kiszedi belole a TypeNode-ot.
+ *
+ * MIERT: a regi megoldas `ts.factory.createTypeReferenceNode(typeString)`-et hivott,
+ * ami CSAK bare identifier-t (entity-name-et) fogad el. Egy generic/union/stb.
+ * tipus-string (pl. `Record<string, unknown>`) eseten ez tort node-ot epitett, amit
+ * a printer csonka `Record`-kent (type-argumentumok nelkul) emittalt — ami EGYSZERRE
+ * tsc-hiba ES uj lint-hiba, igy egyetlen fix-futas 0 → 1+ lint-szamot regresszalt.
+ * A `typeToString` mindig syntactically valid TS tipus-syntaxot ad vissza, ezert a
+ * `type __T = …;` parse-olas minden esetre korrekt TypeNode-ot allit elo.
+ *
+ * BAIL-OUT: ha a tipus nem alakithato biztonsagos node-da — pl. inline
+ * `import("/abs/path").Foo` format tartalmaz, ami abszolut path-t szivarogtatna a
+ * fajlba —, `undefined`-et adunk vissza. A hivo ilyenkor KIHAGYJA az annotaciot:
+ * jobb annotalatlanul hagyni (marad a figyelmeztetes), mint tort kodot irni.
+ */
+function buildTypeNodeFromString(typeString) {
+    // Inline `import(...)` tipus → projekt-specifikus abszolut/relativ path-t vinne a
+    // fajlba; sosem biztonsagos textualisan beilleszteni, ezert bail.
+    if (typeString.includes('import(')) {
+        return undefined;
+    }
+    const probe = ts.createSourceFile('__dynamo_type_probe__.ts', `type __T = ${typeString};`, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ false);
+    const statement = probe.statements[0];
+    if (!statement || !ts.isTypeAliasDeclaration(statement) || !statement.type) {
+        return undefined;
+    }
+    return statement.type;
+}
+/**
+ * Adds type annotations to functions and arrow functions in a TypeScript file
+ *
+ * Uses TypeScript's compiler API to analyze the file, infer return types,
+ * and automatically add explicit type annotations where missing.
+ *
+ * @param filePath - Path to the TypeScript file to process
+ * @returns FixResult object containing statistics about the changes made
+ *
+ * @example
+ * ```typescript
+ * const result = addTypesToFile('./src/utils.ts');
+ * console.log(`Added ${result.changes} type annotations to ${result.file}`);
+ * ```
+ */
+function addTypesToFile(filePath) {
+    // Read and parse the source file
+    const sourceCode = fs.readFileSync(filePath, 'utf8');
+    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
+    // Create TypeScript program for type checking
+    const program = ts.createProgram([filePath], {
+        target: ts.ScriptTarget.Latest,
+        module: ts.ModuleKind.ESNext,
+        strict: true,
+        skipLibCheck: true,
+    });
+    const checker = program.getTypeChecker();
+    let changes = 0;
+    let hasChanges = false;
+    /**
+     * Recursively visits AST nodes and adds type annotations where needed
+     *
+     * @param node - The current AST node being visited
+     * @returns The potentially modified AST node
+     */
+    function visit(node) {
+        // Handle function declarations without return types
+        if (ts.isFunctionDeclaration(node) && !node.type) {
+            const signature = checker.getSignatureFromDeclaration(node);
+            if (signature) {
+                const returnType = checker.getReturnTypeOfSignature(signature);
+                const typeString = checker.typeToString(returnType);
+                // Add type annotation if it's not void or any
+                if (typeString !== 'void' && typeString !== 'any') {
+                    const newType = buildTypeNodeFromString(typeString);
+                    // newType === undefined → a tipus nem serializalhato biztonsagosan,
+                    // kihagyjuk az annotaciot ahelyett hogy tort kodot irnank (B2 bail-out).
+                    if (newType) {
+                        const updatedNode = ts.factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, newType, node.body);
+                        changes++;
+                        hasChanges = true;
+                        return ts.visitEachChild(updatedNode, visit, {});
+                    }
+                }
+            }
+        }
+        // Handle arrow functions without return types
+        if (ts.isArrowFunction(node) && !node.type) {
+            const signature = checker.getSignatureFromDeclaration(node);
+            if (signature) {
+                const returnType = checker.getReturnTypeOfSignature(signature);
+                const typeString = checker.typeToString(returnType);
+                // Add type annotation if it's not void or any
+                if (typeString !== 'void' && typeString !== 'any') {
+                    const newType = buildTypeNodeFromString(typeString);
+                    // newType === undefined → a tipus nem serializalhato biztonsagosan,
+                    // kihagyjuk az annotaciot ahelyett hogy tort kodot irnank (B2 bail-out).
+                    if (newType) {
+                        const updatedNode = ts.factory.updateArrowFunction(node, node.modifiers, node.typeParameters, node.parameters, newType, node.equalsGreaterThanToken, node.body);
+                        changes++;
+                        hasChanges = true;
+                        return ts.visitEachChild(updatedNode, visit, {});
+                    }
+                }
+            }
+        }
+        // Note: Variable declarations, parameters, and class properties
+        // are handled by the existing @typescript-eslint/typedef rule
+        // and can be auto-fixed with eslint --fix
+        return ts.visitEachChild(node, visit, {});
+    }
+    // Transform the AST and apply changes
+    const result = ts.visitEachChild(sourceFile, visit, {});
+    // Write the modified code back to the file if changes were made
+    if (hasChanges) {
+        const printer = ts.createPrinter();
+        const newSourceCode = printer.printFile(result);
+        fs.writeFileSync(filePath, newSourceCode);
+    }
+    return {
+        file: filePath,
+        fixed: hasChanges,
+        changes,
+    };
+}
+/**
+ * Main function that processes all TypeScript files and adds type annotations
+ *
+ * Scans for all .ts and .tsx files in the project, processes each file to add
+ * missing type annotations, 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 (0, fast_glob_1.default)(['**/*.{ts,tsx}'], {
+        ignore: [
+            '**/node_modules/**',
+            '**/build/**',
+            '**/dist/**',
+            '**/*.spec.ts',
+            '**/*.test.ts',
+        ],
+    });
+    fsm_dynamo_1.DyFM_Log.log(`[fix-types] Processing ${files.length} files...`);
+    const results = [];
+    let totalFixed = 0;
+    let totalChanges = 0;
+    // Process each file individually
+    for (const file of files) {
+        try {
+            const result = addTypesToFile(file);
+            results.push(result);
+            // Track successful fixes
+            if (result.fixed) {
+                totalFixed++;
+                totalChanges += result.changes;
+                fsm_dynamo_1.DyFM_Log.log(`✅ Fixed ${result.changes} type annotations in ${file}`);
+            }
+        }
+        catch (error) {
+            fsm_dynamo_1.DyFM_Log.error(`❌ Error processing ${file}:`, error);
+        }
+    }
+    // Generate comprehensive summary report
+    fsm_dynamo_1.DyFM_Log.log(`\n📊 Fix Summary:`);
+    fsm_dynamo_1.DyFM_Log.log(`   Files processed: ${files.length}`);
+    fsm_dynamo_1.DyFM_Log.log(`   Files fixed: ${totalFixed}`);
+    fsm_dynamo_1.DyFM_Log.log(`   Total type annotations added: ${totalChanges}`);
+    // Provide appropriate success/failure message
+    if (totalFixed > 0) {
+        fsm_dynamo_1.DyFM_Log.log(`🎉 Successfully added type annotations to ${totalFixed} files!`);
+    }
+    else {
+        fsm_dynamo_1.DyFM_Log.log('✅ No files needed type annotation fixes!');
+    }
+}
+// Csak akkor futtatjuk a teljes fajl-scan-t, ha a scriptet KOZVETLENUL hivjak
+// (CLI bin / `npm run fix:return-types`). Import eseten (pl. spec a helper-ekhez)
+// NEM indul el a main(), igy a tiszta segedfuggvenyek unit-tesztelhetok.
+if (require.main === module) {
+    // Execute the main function and handle any errors
+    main().catch((err) => {
+        fsm_dynamo_1.DyFM_Log.error('Fix script failed:', err);
+        process.exit(1);
+    });
+}
 //# sourceMappingURL=fix-return-types.js.map

package/build/scripts/validate-imports.d.ts

@@ -1,27 +1,27 @@
-#!/usr/bin/env node
-/**
- * @fileoverview Import Validation Script
- *
- * This script validates import ordering across all TypeScript files in the project
- * using the Dynamo import-order ESLint rule. It scans files, runs ESLint validation,
- * and reports any import ordering violations.
- *
- * @usage
- * ```bash
- * dynamo-validate-imports
- * ```
- *
- * @example
- * ```bash
- * # Validate import ordering in all TypeScript files
- * npx dynamo-validate-imports
- *
- * # Or run via npm script
- * npm run validate:imports
- * ```
- *
- * @author Future Development Program Ltd.
- * @version 1.14.3
- */
-export {};
+#!/usr/bin/env node
+/**
+ * @fileoverview Import Validation Script
+ *
+ * This script validates import ordering across all TypeScript files in the project
+ * using the Dynamo import-order ESLint rule. It scans files, runs ESLint validation,
+ * and reports any import ordering violations.
+ *
+ * @usage
+ * ```bash
+ * dynamo-validate-imports
+ * ```
+ *
+ * @example
+ * ```bash
+ * # Validate import ordering in all TypeScript files
+ * npx dynamo-validate-imports
+ *
+ * # Or run via npm script
+ * npm run validate:imports
+ * ```
+ *
+ * @author Future Development Program Ltd.
+ * @version 1.14.3
+ */
+export {};
 //# sourceMappingURL=validate-imports.d.ts.map