TypeScript

1---
2description: TypeScript coding standards and best practices for modern web development
3globs: **/*.ts, **/*.tsx, **/*.d.ts
4---
5 
6# TypeScript Best Practices
7 
8## Type System
9- Prefer interfaces over types for object definitions
10- Use type for unions, intersections, and mapped types
11- Avoid using `any`, prefer `unknown` for unknown types
12- Use strict TypeScript configuration
13- Leverage TypeScript's built-in utility types
14- Use generics for reusable type patterns
15 
16## Naming Conventions
17- Use PascalCase for type names and interfaces
18- Use camelCase for variables and functions
19- Use UPPER_CASE for constants
20- Use descriptive names with auxiliary verbs (e.g., isLoading, hasError)
21- Prefix interfaces for React props with 'Props' (e.g., ButtonProps)
22 
23## Code Organization
24- Keep type definitions close to where they're used
25- Export types and interfaces from dedicated type files when shared
26- Use barrel exports (index.ts) for organizing exports
27- Place shared types in a `types` directory
28- Co-locate component props with their components
29 
30## Functions
31- Use explicit return types for public functions
32- Use arrow functions for callbacks and methods
33- Implement proper error handling with custom error types
34- Use function overloads for complex type scenarios
35- Prefer async/await over Promises
36 
37## Best Practices
38- Enable strict mode in tsconfig.json
39- Use readonly for immutable properties
40- Leverage discriminated unions for type safety
41- Use type guards for runtime type checking
42- Implement proper null checking
43- Avoid type assertions unless necessary
44 
45## Error Handling
46- Create custom error types for domain-specific errors
47- Use Result types for operations that can fail
48- Implement proper error boundaries
49- Use try-catch blocks with typed catch clauses
50- Handle Promise rejections properly
51 
52## Patterns
53- Use the Builder pattern for complex object creation
54- Implement the Repository pattern for data access
55- Use the Factory pattern for object creation
56- Leverage dependency injection
57- Use the Module pattern for encapsulation