driftdetect-detectors 0.1.0

package/dist/types/utility-types.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Utility Types Detector - TypeScript utility type pattern detection
+ *
+ * Detects utility type patterns including:
+ * - Built-in utility types (Partial, Required, Pick, Omit, etc.)
+ * - Custom utility types
+ * - Mapped type utilities
+ * - Conditional type utilities
+ * - Template literal types
+ * - Recursive types
+ *
+ * @requirements 18.5 - Utility type patterns
+ */
+import type { Violation, QuickFix, PatternCategory, Language } from 'driftdetect-core';
+import { RegexDetector } from '../base/regex-detector.js';
+import type { DetectionContext, DetectionResult } from '../base/base-detector.js';
+export type UtilityTypePatternType = 'partial' | 'required' | 'readonly' | 'pick' | 'omit' | 'record' | 'exclude' | 'extract' | 'non-nullable' | 'return-type' | 'parameters' | 'instance-type' | 'awaited' | 'this-type' | 'custom-mapped' | 'custom-conditional' | 'template-literal' | 'recursive-type' | 'branded-type' | 'deep-partial' | 'deep-readonly';
+export type UtilityTypeViolationType = 'redundant-utility' | 'nested-utility' | 'missing-utility' | 'complex-utility-chain';
+export interface UtilityTypePatternInfo {
+    type: UtilityTypePatternType;
+    file: string;
+    line: number;
+    column: number;
+    matchedText: string;
+    utilityName?: string | undefined;
+    targetType?: string | undefined;
+    isBuiltIn: boolean;
+    context?: string | undefined;
+}
+export interface UtilityTypeViolationInfo {
+    type: UtilityTypeViolationType;
+    file: string;
+    line: number;
+    column: number;
+    matchedText: string;
+    issue: string;
+    suggestedFix?: string | undefined;
+    severity: 'high' | 'medium' | 'low';
+}
+export interface UtilityTypesAnalysis {
+    patterns: UtilityTypePatternInfo[];
+    violations: UtilityTypeViolationInfo[];
+    builtInCount: number;
+    customCount: number;
+    usesDeepUtilities: boolean;
+    usesBrandedTypes: boolean;
+    confidence: number;
+}
+export declare const PARTIAL_PATTERNS: readonly [RegExp, RegExp];
+export declare const REQUIRED_PATTERNS: readonly [RegExp, RegExp];
+export declare const READONLY_PATTERNS: readonly [RegExp, RegExp, RegExp];
+export declare const PICK_PATTERNS: readonly [RegExp, RegExp];
+export declare const OMIT_PATTERNS: readonly [RegExp, RegExp];
+export declare const RECORD_PATTERNS: readonly [RegExp, RegExp, RegExp];
+export declare const EXCLUDE_PATTERNS: readonly [RegExp, RegExp];
+export declare const EXTRACT_PATTERNS: readonly [RegExp];
+export declare const NON_NULLABLE_PATTERNS: readonly [RegExp];
+export declare const RETURN_TYPE_PATTERNS: readonly [RegExp, RegExp];
+export declare const PARAMETERS_PATTERNS: readonly [RegExp, RegExp];
+export declare const INSTANCE_TYPE_PATTERNS: readonly [RegExp, RegExp];
+export declare const AWAITED_PATTERNS: readonly [RegExp, RegExp, RegExp];
+export declare const THIS_TYPE_PATTERNS: readonly [RegExp, RegExp, RegExp];
+export declare const CUSTOM_MAPPED_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp];
+export declare const CUSTOM_CONDITIONAL_PATTERNS: readonly [RegExp, RegExp];
+export declare const TEMPLATE_LITERAL_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp, RegExp, RegExp];
+export declare const RECURSIVE_TYPE_PATTERNS: readonly [RegExp, RegExp];
+export declare const BRANDED_TYPE_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp];
+export declare const DEEP_PARTIAL_PATTERNS: readonly [RegExp, RegExp];
+export declare const DEEP_READONLY_PATTERNS: readonly [RegExp, RegExp];
+export declare const REDUNDANT_UTILITY_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp];
+export declare const NESTED_UTILITY_PATTERNS: readonly [RegExp, RegExp, RegExp, RegExp];
+export declare const COMPLEX_UTILITY_CHAIN_PATTERNS: readonly [RegExp];
+export declare function shouldExcludeFile(filePath: string): boolean;
+export declare function detectPartial(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectRequired(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectReadonly(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectPick(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectOmit(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectRecord(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectExclude(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectExtract(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectNonNullable(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectReturnType(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectParameters(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectInstanceType(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectAwaited(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectThisType(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectCustomMapped(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectCustomConditional(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectTemplateLiteral(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectRecursiveType(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectBrandedType(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectDeepPartial(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectDeepReadonly(content: string, filePath: string): UtilityTypePatternInfo[];
+export declare function detectRedundantUtilityViolations(content: string, filePath: string): UtilityTypeViolationInfo[];
+export declare function detectNestedUtilityViolations(content: string, filePath: string): UtilityTypeViolationInfo[];
+export declare function detectComplexUtilityChainViolations(content: string, filePath: string): UtilityTypeViolationInfo[];
+export declare function analyzeUtilityTypes(content: string, filePath: string): UtilityTypesAnalysis;
+export declare class UtilityTypesDetector extends RegexDetector {
+    readonly id = "types/utility-types";
+    readonly name = "Utility Types Detector";
+    readonly description = "Detects TypeScript utility type patterns including built-in and custom utilities";
+    readonly category: PatternCategory;
+    readonly subcategory = "utility-types";
+    readonly supportedLanguages: Language[];
+    detect(context: DetectionContext): Promise<DetectionResult>;
+    generateQuickFix(_violation: Violation): QuickFix | null;
+}
+export declare function createUtilityTypesDetector(): UtilityTypesDetector;
+//# sourceMappingURL=utility-types.d.ts.map

package/dist/types/utility-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility-types.d.ts","sourceRoot":"","sources":["../../src/types/utility-types.ts"],"names":[],"mappings":"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"}

package/dist/types/utility-types.js

@@ -0,0 +1,547 @@
+/**
+ * Utility Types Detector - TypeScript utility type pattern detection
+ *
+ * Detects utility type patterns including:
+ * - Built-in utility types (Partial, Required, Pick, Omit, etc.)
+ * - Custom utility types
+ * - Mapped type utilities
+ * - Conditional type utilities
+ * - Template literal types
+ * - Recursive types
+ *
+ * @requirements 18.5 - Utility type patterns
+ */
+import { RegexDetector } from '../base/regex-detector.js';
+// ============================================================================
+// Constants
+// ============================================================================
+export const PARTIAL_PATTERNS = [
+    /Partial<(\w+)>/g,
+    /Partial<typeof\s+\w+>/g,
+];
+export const REQUIRED_PATTERNS = [
+    /Required<(\w+)>/g,
+    /Required<typeof\s+\w+>/g,
+];
+export const READONLY_PATTERNS = [
+    /Readonly<(\w+)>/g,
+    /Readonly<typeof\s+\w+>/g,
+    /readonly\s+\w+\[\]/g,
+];
+export const PICK_PATTERNS = [
+    /Pick<(\w+),\s*['"`]?\w+['"`]?(?:\s*\|\s*['"`]?\w+['"`]?)*>/g,
+    /Pick<(\w+),\s*keyof\s+\w+>/g,
+];
+export const OMIT_PATTERNS = [
+    /Omit<(\w+),\s*['"`]?\w+['"`]?(?:\s*\|\s*['"`]?\w+['"`]?)*>/g,
+    /Omit<(\w+),\s*keyof\s+\w+>/g,
+];
+export const RECORD_PATTERNS = [
+    /Record<(\w+),\s*(\w+)>/g,
+    /Record<string,\s*(\w+)>/g,
+    /Record<number,\s*(\w+)>/g,
+];
+export const EXCLUDE_PATTERNS = [
+    /Exclude<(\w+),\s*(\w+)>/g,
+    /Exclude<(\w+),\s*null\s*\|\s*undefined>/g,
+];
+export const EXTRACT_PATTERNS = [
+    /Extract<(\w+),\s*(\w+)>/g,
+];
+export const NON_NULLABLE_PATTERNS = [
+    /NonNullable<(\w+)>/g,
+];
+export const RETURN_TYPE_PATTERNS = [
+    /ReturnType<typeof\s+(\w+)>/g,
+    /ReturnType<(\w+)>/g,
+];
+export const PARAMETERS_PATTERNS = [
+    /Parameters<typeof\s+(\w+)>/g,
+    /Parameters<(\w+)>/g,
+];
+export const INSTANCE_TYPE_PATTERNS = [
+    /InstanceType<typeof\s+(\w+)>/g,
+    /InstanceType<(\w+)>/g,
+];
+export const AWAITED_PATTERNS = [
+    /Awaited<(\w+)>/g,
+    /Awaited<Promise<(\w+)>>/g,
+    /Awaited<ReturnType<typeof\s+\w+>>/g,
+];
+export const THIS_TYPE_PATTERNS = [
+    /ThisType<(\w+)>/g,
+    /ThisParameterType<(\w+)>/g,
+    /OmitThisParameter<(\w+)>/g,
+];
+export const CUSTOM_MAPPED_PATTERNS = [
+    /type\s+(\w+)\s*<[^>]+>\s*=\s*\{\s*\[/g,
+    /type\s+(\w+)\s*=\s*\{\s*\[\s*\w+\s+in/g,
+    /\{\s*\[\s*\w+\s+in\s+keyof\s+\w+\s*\]\s*-?\s*\??\s*:/g,
+    /\{\s*-?\s*readonly\s*\[\s*\w+\s+in/g,
+];
+export const CUSTOM_CONDITIONAL_PATTERNS = [
+    /type\s+(\w+)\s*<[^>]+>\s*=\s*\w+\s+extends\s+\w+\s*\?/g,
+    /type\s+(\w+)\s*=\s*\w+\s+extends\s+infer\s+\w+\s*\?/g,
+];
+export const TEMPLATE_LITERAL_PATTERNS = [
+    /type\s+(\w+)\s*=\s*`\$\{[^}]+\}`/g,
+    /`\$\{[^}]+\}\$\{[^}]+\}`/g,
+    /Uppercase<(\w+)>/g,
+    /Lowercase<(\w+)>/g,
+    /Capitalize<(\w+)>/g,
+    /Uncapitalize<(\w+)>/g,
+];
+export const RECURSIVE_TYPE_PATTERNS = [
+    /type\s+(\w+)\s*=\s*[^;]*\1[^;]*;/g,
+    /type\s+(\w+)\s*<[^>]+>\s*=\s*[^;]*\1</g,
+];
+export const BRANDED_TYPE_PATTERNS = [
+    /type\s+(\w+)\s*=\s*\w+\s*&\s*\{\s*(?:readonly\s+)?__brand\s*:/g,
+    /type\s+(\w+)\s*=\s*\w+\s*&\s*\{\s*(?:readonly\s+)?_tag\s*:/g,
+    /type\s+(\w+)\s*=\s*\w+\s*&\s*\{\s*(?:readonly\s+)?__type\s*:/g,
+    /declare\s+const\s+\w+:\s*unique\s+symbol/g,
+];
+export const DEEP_PARTIAL_PATTERNS = [
+    /type\s+DeepPartial\s*</g,
+    /DeepPartial<(\w+)>/g,
+];
+export const DEEP_READONLY_PATTERNS = [
+    /type\s+DeepReadonly\s*</g,
+    /DeepReadonly<(\w+)>/g,
+];
+export const REDUNDANT_UTILITY_PATTERNS = [
+    /Partial<Partial<(\w+)>>/g,
+    /Required<Required<(\w+)>>/g,
+    /Readonly<Readonly<(\w+)>>/g,
+    /NonNullable<NonNullable<(\w+)>>/g,
+];
+export const NESTED_UTILITY_PATTERNS = [
+    /Partial<Required<(\w+)>>/g,
+    /Required<Partial<(\w+)>>/g,
+    /Pick<Omit<(\w+)/g,
+    /Omit<Pick<(\w+)/g,
+];
+export const COMPLEX_UTILITY_CHAIN_PATTERNS = [
+    /\w+<\w+<\w+<\w+<\w+/g, // 4+ levels of nesting
+];
+// ============================================================================
+// Analysis Functions
+// ============================================================================
+export function shouldExcludeFile(filePath) {
+    const excludePatterns = [
+        /\.test\.[jt]sx?$/,
+        /\.spec\.[jt]sx?$/,
+        /__tests__\//,
+        /node_modules\//,
+        /\.min\.[jt]s$/,
+    ];
+    return excludePatterns.some((p) => p.test(filePath));
+}
+function detectBuiltInUtility(content, filePath, patterns, type, utilityName) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of patterns) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type,
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    utilityName,
+                    targetType: match[1],
+                    isBuiltIn: true,
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectPartial(content, filePath) {
+    return detectBuiltInUtility(content, filePath, PARTIAL_PATTERNS, 'partial', 'Partial');
+}
+export function detectRequired(content, filePath) {
+    return detectBuiltInUtility(content, filePath, REQUIRED_PATTERNS, 'required', 'Required');
+}
+export function detectReadonly(content, filePath) {
+    return detectBuiltInUtility(content, filePath, READONLY_PATTERNS, 'readonly', 'Readonly');
+}
+export function detectPick(content, filePath) {
+    return detectBuiltInUtility(content, filePath, PICK_PATTERNS, 'pick', 'Pick');
+}
+export function detectOmit(content, filePath) {
+    return detectBuiltInUtility(content, filePath, OMIT_PATTERNS, 'omit', 'Omit');
+}
+export function detectRecord(content, filePath) {
+    return detectBuiltInUtility(content, filePath, RECORD_PATTERNS, 'record', 'Record');
+}
+export function detectExclude(content, filePath) {
+    return detectBuiltInUtility(content, filePath, EXCLUDE_PATTERNS, 'exclude', 'Exclude');
+}
+export function detectExtract(content, filePath) {
+    return detectBuiltInUtility(content, filePath, EXTRACT_PATTERNS, 'extract', 'Extract');
+}
+export function detectNonNullable(content, filePath) {
+    return detectBuiltInUtility(content, filePath, NON_NULLABLE_PATTERNS, 'non-nullable', 'NonNullable');
+}
+export function detectReturnType(content, filePath) {
+    return detectBuiltInUtility(content, filePath, RETURN_TYPE_PATTERNS, 'return-type', 'ReturnType');
+}
+export function detectParameters(content, filePath) {
+    return detectBuiltInUtility(content, filePath, PARAMETERS_PATTERNS, 'parameters', 'Parameters');
+}
+export function detectInstanceType(content, filePath) {
+    return detectBuiltInUtility(content, filePath, INSTANCE_TYPE_PATTERNS, 'instance-type', 'InstanceType');
+}
+export function detectAwaited(content, filePath) {
+    return detectBuiltInUtility(content, filePath, AWAITED_PATTERNS, 'awaited', 'Awaited');
+}
+export function detectThisType(content, filePath) {
+    return detectBuiltInUtility(content, filePath, THIS_TYPE_PATTERNS, 'this-type', 'ThisType');
+}
+export function detectCustomMapped(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of CUSTOM_MAPPED_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'custom-mapped',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    utilityName: match[1] || 'mapped-type',
+                    isBuiltIn: false,
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectCustomConditional(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of CUSTOM_CONDITIONAL_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'custom-conditional',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    utilityName: match[1],
+                    isBuiltIn: false,
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectTemplateLiteral(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of TEMPLATE_LITERAL_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'template-literal',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    utilityName: match[1] || 'template-literal',
+                    isBuiltIn: /^(Uppercase|Lowercase|Capitalize|Uncapitalize)/.test(match[0]),
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectRecursiveType(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of RECURSIVE_TYPE_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'recursive-type',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    utilityName: match[1],
+                    isBuiltIn: false,
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectBrandedType(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of BRANDED_TYPE_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'branded-type',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    utilityName: match[1] || 'branded-type',
+                    isBuiltIn: false,
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectDeepPartial(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of DEEP_PARTIAL_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'deep-partial',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    utilityName: 'DeepPartial',
+                    targetType: match[1],
+                    isBuiltIn: false,
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectDeepReadonly(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of DEEP_READONLY_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'deep-readonly',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    utilityName: 'DeepReadonly',
+                    targetType: match[1],
+                    isBuiltIn: false,
+                    context: line.trim(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectRedundantUtilityViolations(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of REDUNDANT_UTILITY_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'redundant-utility',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    issue: 'Redundant nested utility type',
+                    suggestedFix: 'Remove the outer utility type',
+                    severity: 'low',
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectNestedUtilityViolations(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of NESTED_UTILITY_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'nested-utility',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    issue: 'Potentially conflicting nested utility types',
+                    suggestedFix: 'Consider simplifying or using a custom type',
+                    severity: 'medium',
+                });
+            }
+        }
+    }
+    return results;
+}
+export function detectComplexUtilityChainViolations(content, filePath) {
+    const results = [];
+    const lines = content.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        for (const pattern of COMPLEX_UTILITY_CHAIN_PATTERNS) {
+            const regex = new RegExp(pattern.source, pattern.flags);
+            let match;
+            while ((match = regex.exec(line)) !== null) {
+                results.push({
+                    type: 'complex-utility-chain',
+                    file: filePath,
+                    line: i + 1,
+                    column: match.index + 1,
+                    matchedText: match[0],
+                    issue: 'Complex utility type chain (4+ levels)',
+                    suggestedFix: 'Break into intermediate types for readability',
+                    severity: 'medium',
+                });
+            }
+        }
+    }
+    return results;
+}
+export function analyzeUtilityTypes(content, filePath) {
+    if (shouldExcludeFile(filePath)) {
+        return {
+            patterns: [],
+            violations: [],
+            builtInCount: 0,
+            customCount: 0,
+            usesDeepUtilities: false,
+            usesBrandedTypes: false,
+            confidence: 1.0,
+        };
+    }
+    const patterns = [
+        ...detectPartial(content, filePath),
+        ...detectRequired(content, filePath),
+        ...detectReadonly(content, filePath),
+        ...detectPick(content, filePath),
+        ...detectOmit(content, filePath),
+        ...detectRecord(content, filePath),
+        ...detectExclude(content, filePath),
+        ...detectExtract(content, filePath),
+        ...detectNonNullable(content, filePath),
+        ...detectReturnType(content, filePath),
+        ...detectParameters(content, filePath),
+        ...detectInstanceType(content, filePath),
+        ...detectAwaited(content, filePath),
+        ...detectThisType(content, filePath),
+        ...detectCustomMapped(content, filePath),
+        ...detectCustomConditional(content, filePath),
+        ...detectTemplateLiteral(content, filePath),
+        ...detectRecursiveType(content, filePath),
+        ...detectBrandedType(content, filePath),
+        ...detectDeepPartial(content, filePath),
+        ...detectDeepReadonly(content, filePath),
+    ];
+    const violations = [
+        ...detectRedundantUtilityViolations(content, filePath),
+        ...detectNestedUtilityViolations(content, filePath),
+        ...detectComplexUtilityChainViolations(content, filePath),
+    ];
+    const builtInCount = patterns.filter((p) => p.isBuiltIn).length;
+    const customCount = patterns.filter((p) => !p.isBuiltIn).length;
+    const usesDeepUtilities = patterns.some((p) => p.type === 'deep-partial' || p.type === 'deep-readonly');
+    const usesBrandedTypes = patterns.some((p) => p.type === 'branded-type');
+    let confidence = 0.7;
+    if (patterns.length > 0)
+        confidence += 0.15;
+    if (builtInCount > 0)
+        confidence += 0.05;
+    if (violations.length === 0)
+        confidence += 0.05;
+    confidence = Math.min(confidence, 0.95);
+    return {
+        patterns,
+        violations,
+        builtInCount,
+        customCount,
+        usesDeepUtilities,
+        usesBrandedTypes,
+        confidence,
+    };
+}
+// ============================================================================
+// Detector Class
+// ============================================================================
+export class UtilityTypesDetector extends RegexDetector {
+    id = 'types/utility-types';
+    name = 'Utility Types Detector';
+    description = 'Detects TypeScript utility type patterns including built-in and custom utilities';
+    category = 'types';
+    subcategory = 'utility-types';
+    supportedLanguages = ['typescript'];
+    async detect(context) {
+        if (!this.supportsLanguage(context.language)) {
+            return this.createEmptyResult();
+        }
+        const analysis = analyzeUtilityTypes(context.content, context.file);
+        if (analysis.patterns.length === 0 && analysis.violations.length === 0) {
+            return this.createEmptyResult();
+        }
+        return this.createResult([], [], analysis.confidence, {
+            custom: {
+                patterns: analysis.patterns,
+                violations: analysis.violations,
+                builtInCount: analysis.builtInCount,
+                customCount: analysis.customCount,
+                usesDeepUtilities: analysis.usesDeepUtilities,
+                usesBrandedTypes: analysis.usesBrandedTypes,
+            },
+        });
+    }
+    generateQuickFix(_violation) {
+        return null;
+    }
+}
+export function createUtilityTypesDetector() {
+    return new UtilityTypesDetector();
+}
+//# sourceMappingURL=utility-types.js.map