ts-perf

Analyze TypeScript performance and provide optimization recommendations:

1. Performance Measurement

   Type-Checking Performance:

   # Measure baseline
   time npx tsc --noEmit
   
   # Extended diagnostics
   npx tsc --extendedDiagnostics
   
   # Generate trace for analysis
   npx tsc --generateTrace trace-$(date +%s)
   

   Capture metrics:

   • Total type-checking time
   • Files processed count
   • Types instantiated count
   • I/O time vs computation time
   • Memory usage

2. Analyze Trace File

   • Generate trace: npx tsc --generateTrace trace
   • Parse trace/*.json files
   • Identify slowest operations:
     • Slow type checks (which types are expensive)
     • Slow files (which files take longest)
     • Type instantiations (which types are instantiated most)
     • Type checking hotspots

   Provide instructions:

   Upload trace to https://ui.perfetto.dev/ for visual analysis
   Look for:
   - Red bars (expensive operations)
   - Long chains (deep type recursion)
   - Repeated patterns (type caching opportunities)
   

3. Configuration Analysis

   Review tsconfig.json for Performance:

   Check and suggest optimizations:

   {
     "compilerOptions": {
       // ✅ Enable for faster builds
       "skipLibCheck": true,          // Skip .d.ts files
       "incremental": true,           // Cache previous builds
       "composite": true,             // For project references
   
       // ⚠️ Disable if not needed
       "declaration": false,          // Only for libraries
       "declarationMap": false,       // Only if debugging types
       "sourceMap": false,            // Only for debugging
   
       // ✅ Optimize module resolution
       "moduleResolution": "bundler", // Faster than "node"
   
       // ✅ Exclude unnecessary files
       "exclude": [
         "node_modules",
         "dist",
         "**/*.test.ts"
       ]
     }
   }
   

4. Identify Performance Bottlenecks

   Overly Complex Types:

   // 🔴 Slow: Deep recursion
   type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends object
       ? DeepPartial<T[P]>
       : T[P];
   };
   
   // 🟢 Faster: Limit recursion depth
   type DeepPartial<T, Depth extends number = 3> = Depth extends 0
     ? T
     : {
         [P in keyof T]?: T[P] extends object
           ? DeepPartial<T[P], Prev<Depth>>
           : T[P];
       };
   

   Expensive Template Literals:

   // 🔴 Slow: Generates huge unions
   type AllPaths = `${string}/${string}/${string}`;
   
   // 🟢 Faster: Specific patterns
   type SpecificPaths =
     | `/users/${number}`
     | `/posts/${number}/comments`;
   

   Large Union Types:

   // 🔴 Slow: 1000+ member union
   type AllNumbers = 0 | 1 | 2 | ... | 999;
   
   // 🟢 Faster: Use branded type
   type NumberInRange = number & { __brand: 'InRange' };
   

5. Build Tool Performance

   Compare Build Tools:

   • Measure current build time
   • Compare with faster alternatives:
     • tsc: Baseline, slow but complete type checking
     • esbuild: 10-100x faster, no type checking
     • swc: 20-70x faster, limited type support
     • Vite: Fast dev server, esbuild-based

   Recommendation Matrix:

   Library project → tsup (esbuild + type gen)
   Web app → Vite (HMR + fast builds)
   Node service → esbuild + tsc --noEmit
   Monorepo → Project references + Turborepo
   

6. Monorepo Optimization

   Enable Project References:

   // Root tsconfig.json
   {
     "files": [],
     "references": [
       { "path": "./packages/core" },
       { "path": "./packages/ui" }
     ]
   }
   
   // Package tsconfig.json
   {
     "compilerOptions": {
       "composite": true,
       "incremental": true
     }
   }
   

   Benefits:

   • Parallel type checking
   • Incremental builds
   • Better caching
   • Faster watch mode

7. File-Level Analysis

   Identify slow files:

   • Files with most type errors
   • Files with complex types
   • Large files (>1000 lines)
   • Files importing many dependencies