TypeScript Roadmap

Open a topic for notes and resources. Mark it done when you are ready to move on.

26 stages · 103 topics 0% done
TypeScript
✓ Generic Constraints & extends
✓ Generic Inference & Contextual Typing
✓ Foundations
✓ Generic Classes & Factories
✓ Higher-Order Generic Functions
✓ Core Concepts
✓ Generic Type Guards & Assertions
✓ Distributive Conditional Types
✓ Mapping with key remapping (TS 4.1+)
✓ Conditional Type Basics
✓ Intermediate Skills
✓ Infer Keyword
✓ Recursive Conditional Types
✓ Advanced Topics
✓ Template Literal Types & Pattern Inference
✓ Mapped Types with as Clauses
✓ Satisfies Operator (TS 4.9+)
✓ Recursive Type Instantiation Limits
✓ Expert Level
✓ Contextual Typing Patterns
✓ Best Common Type
✓ Mastery
✓ Literal Inference (const assertions)
✓ Control Flow Narrowing
✓ Discriminated Unions
✓ Assert Functions (TS 3.7+)
✓ Ecosystem
✓ Type Predicate Functions
✓ Mapped Type Basics (in keyof)
✓ Architecture
✓ Mapping Modifiers (readonly, ?)
✓ Template Literal Types
✓ Key Remapping via as
✓ Intrinsic String Types (Uppercase, Lowercase)
✓ Optimization
✓ Recursive Conditional & Mapped Types
✓ Deep Mapped Type Patterns
✓ Deployment
✓ Class Decorators
✓ Method & Property Decorators
✓ Parameter & Accessor Decorators
✓ Decorator Factory & Metadata
✓ Phase 11
✓ Decorator Order & Composition
✓ Reflect Metadata (reflect-metadata)
✓ Phase 12
✓ emcascript Decorators (Stage 3)
✓ TypeScript Compiler Architecture
✓ SourceFile & AST Nodes
✓ TypeChecker API
✓ Phase 13
✓ Custom Transforms (before/after)
✓ LanguageService & Plugins
✓ Phase 14
✓ Program & Builder
✓ Performance Optimization for Type Checking
✓ Partial, Required, Readonly
✓ Pick, Omit, Extract, Exclude
✓ Phase 15
✓ Record & NonNullable
✓ Parameters, ReturnType, ConstructorParameters
✓ Phase 16
✓ ThisParameterType & OmitThisParameter
✓ Awaited (TS 4.5+)
✓ Custom Utility Type Implementation
✓ Extends Constraint vs Satisfies
✓ Phase 17
✓ Branded/Nominal Types
✓ Type Guards via Branding
✓ Phase 18
✓ Phantom Generics
✓ Exact Type Emulation
✓ Readonly Deep Constraint
✓ Type-Level Arithmetic & Recursion
✓ Phase 19
✓ Structural vs Nominal Typing
✓ Brand Type Pattern
✓ Phase 20
✓ Opaque Types with _brand
✓ Intersection Brand Types
✓ Flavoring (type-level branding)
✓ Brands with Symbols
✓ Phase 21
✓ Real-World: Fluent Validation IDs
✓ Type Instantiation Complexity
✓ Phase 22
✓ Excess Property Checking
✓ Emit vs No-Emit Performance
✓ Project References
✓ Incremental Builds (--incremental)
✓ Phase 23
✓ Isolated Declarations (TS 5.5+)
✓ Type Tracing & Debugging
✓ Phase 24
✓ Type Assertion Testing
✓ Expect-Type Utility
✓ ts-expect-error Directive
✓ Vitest for Type Tests
✓ Phase 25
✓ Compiler API Test Patterns
✓ Type Regression Testing
✓ Phase 26
✓ Testing Distributive Types
Text version of this roadmap

1. Foundations

  • Generic Constraints & extends
  • Generic Inference & Contextual Typing
  • Generic Classes & Factories

2. Core Concepts

  • Higher-Order Generic Functions
  • Generic Type Guards & Assertions
  • Distributive Conditional Types

3. Intermediate Skills

  • Mapping with key remapping (TS 4.1+)
  • Conditional Type Basics
  • Infer Keyword

4. Advanced Topics

  • Recursive Conditional Types
  • Template Literal Types & Pattern Inference
  • Mapped Types with as Clauses

5. Expert Level

  • Satisfies Operator (TS 4.9+)
  • Recursive Type Instantiation Limits
  • Contextual Typing Patterns: Various type inference patterns emerge when working with contextual typing patterns in Typescript. These patterns provide reusable solutions to common programming challenges.

6. Mastery

  • Best Common Type
  • Literal Inference (const assertions)
  • Control Flow Narrowing

7. Ecosystem

  • Discriminated Unions
  • Assert Functions (TS 3.7+)
  • Type Predicate Functions

8. Architecture

  • Mapped Type Basics (in keyof)
  • Mapping Modifiers (readonly, ?)
  • Template Literal Types

9. Optimization

  • Key Remapping via as
  • Intrinsic String Types (Uppercase, Lowercase)
  • Recursive Conditional & Mapped Types

10. Deployment

  • Deep Mapped Type Patterns: Various mapped & template literal patterns emerge when working with deep mapped type patterns in Typescript. These patterns provide reusable solutions to common programming challenges.
  • Class Decorators
  • Method & Property Decorators

11. Phase 11

  • Parameter & Accessor Decorators
  • Decorator Factory & Metadata
  • Decorator Order & Composition

12. Phase 12

  • Reflect Metadata (reflect-metadata)
  • emcascript Decorators (Stage 3)
  • TypeScript Compiler Architecture

13. Phase 13

  • SourceFile & AST Nodes
  • TypeChecker API
  • Custom Transforms (before/after)

14. Phase 14

  • LanguageService & Plugins
  • Program & Builder
  • Performance Optimization for Type Checking: Performance considerations for performance optimization for type checking in Typescript significantly impact application behavior. Understanding optimization strategies helps avoid common pitfalls and improve runtime characteristics.

15. Phase 15

  • Partial, Required, Readonly
  • Pick, Omit, Extract, Exclude
  • Record & NonNullable

16. Phase 16

  • Parameters, ReturnType, ConstructorParameters
  • ThisParameterType & OmitThisParameter
  • Awaited (TS 4.5+)

17. Phase 17

  • Custom Utility Type Implementation: The custom utility type implementation pattern in Typescript provides a structured approach to handling Utility Types. Understanding the implementation details helps write more robust and maintainable code.
  • Extends Constraint vs Satisfies
  • Branded/Nominal Types

18. Phase 18

  • Type Guards via Branding
  • Phantom Generics
  • Exact Type Emulation

19. Phase 19

  • Readonly Deep Constraint
  • Type-Level Arithmetic & Recursion
  • Structural vs Nominal Typing

20. Phase 20

  • Brand Type Pattern
  • Opaque Types with _brand
  • Intersection Brand Types

21. Phase 21

  • Flavoring (type-level branding)
  • Brands with Symbols
  • Real-World: Fluent Validation IDs

22. Phase 22

  • Type Instantiation Complexity
  • Excess Property Checking
  • Emit vs No-Emit Performance: Performance considerations for emit vs no-emit performance in Typescript significantly impact application behavior. Understanding optimization strategies helps avoid common pitfalls and improve runtime characteristics.

23. Phase 23

  • Project References
  • Incremental Builds (--incremental)
  • Isolated Declarations (TS 5.5+)

24. Phase 24

  • Type Tracing & Debugging
  • Type Assertion Testing
  • Expect-Type Utility

25. Phase 25

  • ts-expect-error Directive
  • Vitest for Type Tests
  • Compiler API Test Patterns: Various testing types patterns emerge when working with compiler api test patterns in Typescript. These patterns provide reusable solutions to common programming challenges.

26. Phase 26

  • Type Regression Testing
  • Testing Distributive Types