@webpieces/code-rules 0.0.1 → 0.2.113

package/src/{validate-no-inline-types.ts → validate-no-inline-types.js}

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Validate No Inline Types Executor
  *
@@ -78,40 +79,22 @@
  * - Third-party library APIs that expect inline types
  * - Legacy code being incrementally migrated
  */
-
-import { execSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as ts from 'typescript';
-
-export type NoInlineTypesMode = 'OFF' | 'NEW_METHODS' | 'NEW_AND_MODIFIED_METHODS' | 'MODIFIED_FILES';
-
-export interface ValidateNoInlineTypesOptions {
-    mode?: NoInlineTypesMode;
-    disableAllowed?: boolean;
-    ignoreModifiedUntilEpoch?: number;
-}
-
-export interface ExecutorResult {
-    success: boolean;
-}
-
-interface InlineTypeViolation {
-    file: string;
-    line: number;
-    column: number;
-    context: string;
-}
-
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = runValidator;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const ts = tslib_1.__importStar(require("typescript"));
 /**
  * Get changed TypeScript files between base and head (or working tree if head not specified).
  */
 // webpieces-disable max-lines-new-methods -- Git command handling with untracked files requires multiple code paths
-function getChangedTypeScriptFiles(workspaceRoot: string, base: string, head?: string): string[] {
+function getChangedTypeScriptFiles(workspaceRoot, base, head) {
     // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
     try {
         const diffTarget = head ? `${base} ${head}` : base;
-        const output = execSync(`git diff --name-only ${diffTarget} -- '*.ts' '*.tsx'`, {
+        const output = (0, child_process_1.execSync)(`git diff --name-only ${diffTarget} -- '*.ts' '*.tsx'`, {
             cwd: workspaceRoot,
             encoding: 'utf-8',
         });
@@ -119,11 +102,10 @@ function getChangedTypeScriptFiles(workspaceRoot: string, base: string, head?: s
             .trim()
             .split('\n')
             .filter((f) => f && !f.includes('.spec.ts') && !f.includes('.test.ts'));
-
         if (!head) {
             // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
             try {
-                const untrackedOutput = execSync(`git ls-files --others --exclude-standard '*.ts' '*.tsx'`, {
+                const untrackedOutput = (0, child_process_1.execSync)(`git ls-files --others --exclude-standard '*.ts' '*.tsx'`, {
                     cwd: workspaceRoot,
                     encoding: 'utf-8',
                 });
@@ -133,39 +115,37 @@ function getChangedTypeScriptFiles(workspaceRoot: string, base: string, head?: s
                     .filter((f) => f && !f.includes('.spec.ts') && !f.includes('.test.ts'));
                 const allFiles = new Set([...changedFiles, ...untrackedFiles]);
                 return Array.from(allFiles);
-            } catch (err: unknown) {
+            }
+            catch (err) {
                 //const error = toError(err);
                 return changedFiles;
             }
         }
-
         return changedFiles;
-    } catch (err: unknown) {
+    }
+    catch (err) {
         //const error = toError(err);
         return [];
     }
 }
-
 /**
  * Get the diff content for a specific file.
  */
-function getFileDiff(workspaceRoot: string, file: string, base: string, head?: string): string {
+function getFileDiff(workspaceRoot, file, base, head) {
     // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
     try {
         const diffTarget = head ? `${base} ${head}` : base;
-        const diff = execSync(`git diff ${diffTarget} -- "${file}"`, {
+        const diff = (0, child_process_1.execSync)(`git diff ${diffTarget} -- "${file}"`, {
             cwd: workspaceRoot,
             encoding: 'utf-8',
         });
-
         if (!diff && !head) {
             const fullPath = path.join(workspaceRoot, file);
             if (fs.existsSync(fullPath)) {
-                const isUntracked = execSync(`git ls-files --others --exclude-standard "${file}"`, {
+                const isUntracked = (0, child_process_1.execSync)(`git ls-files --others --exclude-standard "${file}"`, {
                     cwd: workspaceRoot,
                     encoding: 'utf-8',
                 }).trim();
-
                 if (isUntracked) {
                     const content = fs.readFileSync(fullPath, 'utf-8');
                     const lines = content.split('\n');
@@ -173,46 +153,43 @@ function getFileDiff(workspaceRoot: string, file: string, base: string, head?: s
                 }
             }
         }
-
         return diff;
-    } catch (err: unknown) {
+    }
+    catch (err) {
         //const error = toError(err);
         return '';
     }
 }
-
 /**
  * Parse diff to extract changed line numbers (both additions and modifications).
  */
-function getChangedLineNumbers(diffContent: string): Set<number> {
-    const changedLines = new Set<number>();
+function getChangedLineNumbers(diffContent) {
+    const changedLines = new Set();
     const lines = diffContent.split('\n');
     let currentLine = 0;
-
     for (const line of lines) {
         const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
         if (hunkMatch) {
             currentLine = parseInt(hunkMatch[1], 10);
             continue;
         }
-
         if (line.startsWith('+') && !line.startsWith('+++')) {
             changedLines.add(currentLine);
             currentLine++;
-        } else if (line.startsWith('-') && !line.startsWith('---')) {
+        }
+        else if (line.startsWith('-') && !line.startsWith('---')) {
             // Deletions don't increment line number
-        } else {
+        }
+        else {
             currentLine++;
         }
     }
-
     return changedLines;
 }
-
 /**
  * Check if a line contains a webpieces-disable comment for no-inline-types.
  */
-function hasDisableComment(lines: string[], lineNumber: number): boolean {
+function hasDisableComment(lines, lineNumber) {
     const startCheck = Math.max(0, lineNumber - 5);
     for (let i = lineNumber - 2; i >= startCheck; i--) {
         const line = lines[i]?.trim() ?? '';
@@ -225,7 +202,6 @@ function hasDisableComment(lines: string[], lineNumber: number): boolean {
     }
     return false;
 }
-
 /**
  * Check if a TypeLiteral or TupleType node is in an allowed context.
  * Only allowed if the DIRECT parent is a TypeAliasDeclaration.
@@ -244,17 +220,16 @@ function hasDisableComment(lines: string[], lineNumber: number): boolean {
  *   // webpieces-disable no-inline-types -- Prisma API requires inline type argument
  *   type T = Prisma.GetPayload<{ include: {...} }>;
  */
-function isInAllowedContext(node: ts.TypeLiteralNode | ts.TupleTypeNode): boolean {
+function isInAllowedContext(node) {
     const parent = node.parent;
-    if (!parent) return false;
-
+    if (!parent)
+        return false;
     // Only allowed if it's the DIRECT body of a type alias
     if (ts.isTypeAliasDeclaration(parent)) {
         return true;
     }
     return false;
 }
-
 /**
  * Get a description of the context where the inline type or tuple appears.
  *
@@ -264,13 +239,12 @@ function isInAllowedContext(node: ts.TypeLiteralNode | ts.TupleTypeNode): boolea
  *   - "inline type in generic argument"
  */
 // webpieces-disable max-lines-new-methods -- Context detection requires checking many AST node types
-function getViolationContext(node: ts.TypeLiteralNode | ts.TupleTypeNode, sourceFile: ts.SourceFile): string {
+function getViolationContext(node, sourceFile) {
     // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
     try {
         const isTuple = ts.isTupleTypeNode(node);
         const prefix = isTuple ? 'tuple' : 'inline';
-
-        let current: ts.Node = node;
+        let current = node;
         while (current.parent) {
             const parent = current.parent;
             if (ts.isParameter(parent)) {
@@ -289,7 +263,7 @@ function getViolationContext(node: ts.TypeLiteralNode | ts.TupleTypeNode, source
                     return `${prefix} property type`;
                 }
                 // Check if it's nested inside another type literal
-                let ancestor: ts.Node | undefined = parent.parent;
+                let ancestor = parent.parent;
                 while (ancestor) {
                     if (ts.isTypeLiteralNode(ancestor)) {
                         return `nested ${prefix} type`;
@@ -320,51 +294,44 @@ function getViolationContext(node: ts.TypeLiteralNode | ts.TupleTypeNode, source
             current = parent;
         }
         return isTuple ? 'tuple type' : 'inline type literal';
-    } catch (err: unknown) {
+    }
+    catch (err) {
         //const error = toError(err);
         // Defensive: return generic context if AST traversal fails
         return ts.isTupleTypeNode(node) ? 'tuple type' : 'inline type literal';
     }
 }
-
-interface MethodInfo {
-    name: string;
-    startLine: number;
-    endLine: number;
-}
-
 /**
  * Find all methods/functions in a file with their line ranges.
  */
 // webpieces-disable max-lines-new-methods -- AST traversal requires inline visitor function
-function findMethodsInFile(filePath: string, workspaceRoot: string): MethodInfo[] {
+function findMethodsInFile(filePath, workspaceRoot) {
     const fullPath = path.join(workspaceRoot, filePath);
-    if (!fs.existsSync(fullPath)) return [];
-
+    if (!fs.existsSync(fullPath))
+        return [];
     const content = fs.readFileSync(fullPath, 'utf-8');
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-
-    const methods: MethodInfo[] = [];
-
+    const methods = [];
     // webpieces-disable max-lines-new-methods -- AST visitor pattern requires handling multiple node types
-    function visit(node: ts.Node): void {
-        let methodName: string | undefined;
-        let startLine: number | undefined;
-        let endLine: number | undefined;
-
+    function visit(node) {
+        let methodName;
+        let startLine;
+        let endLine;
         if (ts.isMethodDeclaration(node) && node.name) {
             methodName = node.name.getText(sourceFile);
             const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
             const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
             startLine = start.line + 1;
             endLine = end.line + 1;
-        } else if (ts.isFunctionDeclaration(node) && node.name) {
+        }
+        else if (ts.isFunctionDeclaration(node) && node.name) {
             methodName = node.name.getText(sourceFile);
             const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
             const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
             startLine = start.line + 1;
             endLine = end.line + 1;
-        } else if (ts.isArrowFunction(node)) {
+        }
+        else if (ts.isArrowFunction(node)) {
             if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
                 methodName = node.parent.name.getText(sourceFile);
                 const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
@@ -373,27 +340,18 @@ function findMethodsInFile(filePath: string, workspaceRoot: string): MethodInfo[
                 endLine = end.line + 1;
             }
         }
-
         if (methodName && startLine !== undefined && endLine !== undefined) {
             methods.push({ name: methodName, startLine, endLine });
         }
-
         ts.forEachChild(node, visit);
     }
-
     visit(sourceFile);
     return methods;
 }
-
 /**
  * Check if a line is within any method's range and if that method has changes.
  */
-function isLineInChangedMethod(
-    line: number,
-    methods: MethodInfo[],
-    changedLines: Set<number>,
-    newMethodNames: Set<string>
-): boolean {
+function isLineInChangedMethod(line, methods, changedLines, newMethodNames) {
     for (const method of methods) {
         if (line >= method.startLine && line <= method.endLine) {
             // Check if this method is new or has changes
@@ -410,11 +368,10 @@ function isLineInChangedMethod(
     }
     return false;
 }
-
 /**
  * Check if a line is within a new method.
  */
-function isLineInNewMethod(line: number, methods: MethodInfo[], newMethodNames: Set<string>): boolean {
+function isLineInNewMethod(line, methods, newMethodNames) {
     for (const method of methods) {
         if (line >= method.startLine && line <= method.endLine && newMethodNames.has(method.name)) {
             return true;
@@ -422,21 +379,18 @@ function isLineInNewMethod(line: number, methods: MethodInfo[], newMethodNames:
     }
     return false;
 }
-
 /**
  * Parse diff to find newly added method signatures.
  */
-function findNewMethodSignaturesInDiff(diffContent: string): Set<string> {
-    const newMethods = new Set<string>();
+function findNewMethodSignaturesInDiff(diffContent) {
+    const newMethods = new Set();
     const lines = diffContent.split('\n');
-
     const patterns = [
         /^\+\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/,
         /^\+\s*(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(/,
         /^\+\s*(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s+)?function/,
         /^\+\s*(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:async\s+)?(\w+)\s*\(/,
     ];
-
     for (const line of lines) {
         if (line.startsWith('+') && !line.startsWith('+++')) {
             for (const pattern of patterns) {
@@ -451,17 +405,8 @@ function findNewMethodSignaturesInDiff(diffContent: string): Set<string> {
             }
         }
     }
-
     return newMethods;
 }
-
-interface InlineTypeInfo {
-    line: number;
-    column: number;
-    context: string;
-    hasDisableComment: boolean;
-}
-
 /**
  * Find all inline type literals AND tuple types in a file.
  *
@@ -472,17 +417,15 @@ interface InlineTypeInfo {
  * Both are flagged unless they are the DIRECT body of a type alias.
  */
 // webpieces-disable max-lines-new-methods -- AST traversal with visitor pattern
-function findInlineTypesInFile(filePath: string, workspaceRoot: string): InlineTypeInfo[] {
+function findInlineTypesInFile(filePath, workspaceRoot) {
     const fullPath = path.join(workspaceRoot, filePath);
-    if (!fs.existsSync(fullPath)) return [];
-
+    if (!fs.existsSync(fullPath))
+        return [];
     const content = fs.readFileSync(fullPath, 'utf-8');
     const fileLines = content.split('\n');
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-
-    const inlineTypes: InlineTypeInfo[] = [];
-
-    function visit(node: ts.Node): void {
+    const inlineTypes = [];
+    function visit(node) {
         // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
         try {
             // Check for inline type literals: { x: number }
@@ -495,7 +438,6 @@ function findInlineTypesInFile(filePath: string, workspaceRoot: string): InlineT
                         const column = pos.character + 1;
                         const context = getViolationContext(node, sourceFile);
                         const disabled = hasDisableComment(fileLines, line);
-
                         inlineTypes.push({
                             line,
                             column,
@@ -505,7 +447,6 @@ function findInlineTypesInFile(filePath: string, workspaceRoot: string): InlineT
                     }
                 }
             }
-
             // Check for tuple types: [A, B]
             if (ts.isTupleTypeNode(node)) {
                 if (!isInAllowedContext(node)) {
@@ -516,7 +457,6 @@ function findInlineTypesInFile(filePath: string, workspaceRoot: string): InlineT
                         const column = pos.character + 1;
                         const context = getViolationContext(node, sourceFile);
                         const disabled = hasDisableComment(fileLines, line);
-
                         inlineTypes.push({
                             line,
                             column,
@@ -526,44 +466,34 @@ function findInlineTypesInFile(filePath: string, workspaceRoot: string): InlineT
                     }
                 }
             }
-        } catch (err: unknown) {
+        }
+        catch (err) {
             //const error = toError(err);
             // Skip nodes that cause errors during analysis
         }
-
         ts.forEachChild(node, visit);
     }
-
     visit(sourceFile);
     return inlineTypes;
 }
-
 /**
  * Find violations in new methods only (NEW_METHODS mode).
  */
 // webpieces-disable max-lines-new-methods -- File iteration with diff parsing and method matching
-function findViolationsForNewMethods(
-    workspaceRoot: string,
-    changedFiles: string[],
-    base: string,
-    head: string | undefined,
-    disableAllowed: boolean
-): InlineTypeViolation[] {
-    const violations: InlineTypeViolation[] = [];
-
+function findViolationsForNewMethods(workspaceRoot, changedFiles, base, head, disableAllowed) {
+    const violations = [];
     for (const file of changedFiles) {
         const diff = getFileDiff(workspaceRoot, file, base, head);
         const newMethodNames = findNewMethodSignaturesInDiff(diff);
-
-        if (newMethodNames.size === 0) continue;
-
+        if (newMethodNames.size === 0)
+            continue;
         const methods = findMethodsInFile(file, workspaceRoot);
         const inlineTypes = findInlineTypesInFile(file, workspaceRoot);
-
         for (const inlineType of inlineTypes) {
-            if (disableAllowed && inlineType.hasDisableComment) continue;
-            if (!isLineInNewMethod(inlineType.line, methods, newMethodNames)) continue;
-
+            if (disableAllowed && inlineType.hasDisableComment)
+                continue;
+            if (!isLineInNewMethod(inlineType.line, methods, newMethodNames))
+                continue;
             violations.push({
                 file,
                 line: inlineType.line,
@@ -572,35 +502,25 @@ function findViolationsForNewMethods(
             });
         }
     }
-
     return violations;
 }
-
 /**
  * Find violations in new and modified methods (NEW_AND_MODIFIED_METHODS mode).
  */
 // webpieces-disable max-lines-new-methods -- Combines new method detection with change detection
-function findViolationsForModifiedAndNewMethods(
-    workspaceRoot: string,
-    changedFiles: string[],
-    base: string,
-    head: string | undefined,
-    disableAllowed: boolean
-): InlineTypeViolation[] {
-    const violations: InlineTypeViolation[] = [];
-
+function findViolationsForModifiedAndNewMethods(workspaceRoot, changedFiles, base, head, disableAllowed) {
+    const violations = [];
     for (const file of changedFiles) {
         const diff = getFileDiff(workspaceRoot, file, base, head);
         const newMethodNames = findNewMethodSignaturesInDiff(diff);
         const changedLines = getChangedLineNumbers(diff);
-
         const methods = findMethodsInFile(file, workspaceRoot);
         const inlineTypes = findInlineTypesInFile(file, workspaceRoot);
-
         for (const inlineType of inlineTypes) {
-            if (disableAllowed && inlineType.hasDisableComment) continue;
-            if (!isLineInChangedMethod(inlineType.line, methods, changedLines, newMethodNames)) continue;
-
+            if (disableAllowed && inlineType.hasDisableComment)
+                continue;
+            if (!isLineInChangedMethod(inlineType.line, methods, changedLines, newMethodNames))
+                continue;
             violations.push({
                 file,
                 line: inlineType.line,
@@ -609,22 +529,18 @@ function findViolationsForModifiedAndNewMethods(
             });
         }
     }
-
     return violations;
 }
-
 /**
  * Find all violations in modified files (MODIFIED_FILES mode).
  */
-function findViolationsForModifiedFiles(workspaceRoot: string, changedFiles: string[], disableAllowed: boolean): InlineTypeViolation[] {
-    const violations: InlineTypeViolation[] = [];
-
+function findViolationsForModifiedFiles(workspaceRoot, changedFiles, disableAllowed) {
+    const violations = [];
     for (const file of changedFiles) {
         const inlineTypes = findInlineTypesInFile(file, workspaceRoot);
-
         for (const inlineType of inlineTypes) {
-            if (disableAllowed && inlineType.hasDisableComment) continue;
-
+            if (disableAllowed && inlineType.hasDisableComment)
+                continue;
             violations.push({
                 file,
                 line: inlineType.line,
@@ -633,50 +549,47 @@ function findViolationsForModifiedFiles(workspaceRoot: string, changedFiles: str
             });
         }
     }
-
     return violations;
 }
-
 /**
  * Auto-detect the base branch by finding the merge-base with origin/main.
  */
-function detectBase(workspaceRoot: string): string | null {
+function detectBase(workspaceRoot) {
     // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
     try {
-        const mergeBase = execSync('git merge-base HEAD origin/main', {
+        const mergeBase = (0, child_process_1.execSync)('git merge-base HEAD origin/main', {
             cwd: workspaceRoot,
             encoding: 'utf-8',
             stdio: ['pipe', 'pipe', 'pipe'],
         }).trim();
-
         if (mergeBase) {
             return mergeBase;
         }
-    } catch (err: unknown) {
+    }
+    catch (err) {
         //const error = toError(err);
         // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
         try {
-            const mergeBase = execSync('git merge-base HEAD main', {
+            const mergeBase = (0, child_process_1.execSync)('git merge-base HEAD main', {
                 cwd: workspaceRoot,
                 encoding: 'utf-8',
                 stdio: ['pipe', 'pipe', 'pipe'],
             }).trim();
-
             if (mergeBase) {
                 return mergeBase;
             }
-        } catch (err2: unknown) {
+        }
+        catch (err2) {
             //const error2 = toError(err2);
             // Ignore
         }
     }
     return null;
 }
-
 /**
  * Report violations to console.
  */
-function reportViolations(violations: InlineTypeViolation[], mode: NoInlineTypesMode): void {
+function reportViolations(violations, mode) {
     console.error('');
     console.error('❌ Inline type literals found! Use named types instead.');
     console.error('');
@@ -690,13 +603,11 @@ function reportViolations(violations: InlineTypeViolation[], mode: NoInlineTypes
     console.error('   GOOD: type MyData = { x: number };');
     console.error('         type Nullable = MyData | null;');
     console.error('');
-
     for (const v of violations) {
         console.error(`  ❌ ${v.file}:${v.line}:${v.column}`);
         console.error(`     ${v.context}`);
     }
     console.error('');
-
     console.error('   To fix: Extract inline types to named type aliases or interfaces');
     console.error('');
     console.error('   Escape hatch (use sparingly):');
@@ -705,12 +616,11 @@ function reportViolations(violations: InlineTypeViolation[], mode: NoInlineTypes
     console.error(`   Current mode: ${mode}`);
     console.error('');
 }
-
 /**
  * Resolve mode considering ignoreModifiedUntilEpoch override.
  * When active, downgrades to OFF. When expired, logs a warning.
  */
-function resolveMode(normalMode: NoInlineTypesMode, epoch: number | undefined): NoInlineTypesMode {
+function resolveMode(normalMode, epoch) {
     if (epoch === undefined || normalMode === 'OFF') {
         return normalMode;
     }
@@ -723,65 +633,50 @@ function resolveMode(normalMode: NoInlineTypesMode, epoch: number | undefined):
     }
     return normalMode;
 }
-
-export default async function runValidator(
-    options: ValidateNoInlineTypesOptions,
-    workspaceRoot: string
-): Promise<ExecutorResult> {
-    const mode: NoInlineTypesMode = resolveMode(options.mode ?? 'OFF', options.ignoreModifiedUntilEpoch);
+async function runValidator(options, workspaceRoot) {
+    const mode = resolveMode(options.mode ?? 'OFF', options.ignoreModifiedUntilEpoch);
     const disableAllowed = options.disableAllowed ?? true;
-
     if (mode === 'OFF') {
         console.log('\n⏭️  Skipping no-inline-types validation (mode: OFF)');
         console.log('');
         return { success: true };
     }
-
     console.log('\n📏 Validating No Inline Types\n');
     console.log(`   Mode: ${mode}`);
-
     let base = process.env['NX_BASE'];
     const head = process.env['NX_HEAD'];
-
     if (!base) {
         base = detectBase(workspaceRoot) ?? undefined;
-
         if (!base) {
             console.log('\n⏭️  Skipping no-inline-types validation (could not detect base branch)');
             console.log('');
             return { success: true };
         }
     }
-
     console.log(`   Base: ${base}`);
     console.log(`   Head: ${head ?? 'working tree (includes uncommitted changes)'}`);
     console.log('');
-
     const changedFiles = getChangedTypeScriptFiles(workspaceRoot, base, head);
-
     if (changedFiles.length === 0) {
         console.log('✅ No TypeScript files changed');
         return { success: true };
     }
-
     console.log(`📂 Checking ${changedFiles.length} changed file(s)...`);
-
-    let violations: InlineTypeViolation[] = [];
-
+    let violations = [];
     if (mode === 'NEW_METHODS') {
         violations = findViolationsForNewMethods(workspaceRoot, changedFiles, base, head, disableAllowed);
-    } else if (mode === 'NEW_AND_MODIFIED_METHODS') {
+    }
+    else if (mode === 'NEW_AND_MODIFIED_METHODS') {
         violations = findViolationsForModifiedAndNewMethods(workspaceRoot, changedFiles, base, head, disableAllowed);
-    } else if (mode === 'MODIFIED_FILES') {
+    }
+    else if (mode === 'MODIFIED_FILES') {
         violations = findViolationsForModifiedFiles(workspaceRoot, changedFiles, disableAllowed);
     }
-
     if (violations.length === 0) {
         console.log('✅ No inline type literals found');
         return { success: true };
     }
-
     reportViolations(violations, mode);
-
     return { success: false };
 }
+//# sourceMappingURL=validate-no-inline-types.js.map