Typescript Course Built for AI-Assisted Learning

This chapter focuses on What TypeScript adds to JavaScript, Static typing against runtime behaviour, Installing the compiler and running tsc and the practice needed to use these concepts confidently in real projects.

• What TypeScript adds to JavaScript
• Static typing against runtime behaviour
• Installing the compiler and running tsc
• Your first typed file
• How type erasure works at build time
• The relationship between .ts and .js output
• Editor integration and inline diagnostics
• The TypeScript playground for experiments
• Type annotations and where they go
• Type inference and letting the compiler work
• const versus let and literal widening
• any and why it defeats the purpose
• unknown as the safe alternative to any
• never and unreachable code
• void and functions that return nothing
• Reading a TypeScript error message
• Common beginner errors and their fixes
• Compiling a small project end to end
• Watch mode and incremental builds
• Running TypeScript with Node
• Adding TypeScript to an existing project
• Migration strategy: file by file

This chapter focuses on string, number and boolean annotations, Arrays and readonly arrays, Tuples and named tuple elements and the practice needed to use these concepts confidently in real projects.

• string, number and boolean annotations
• Arrays and readonly arrays
• Tuples and named tuple elements
• Enums, const enums and string enums
• Why union of literals often beats an enum
• Object type literals
• Optional properties
• readonly properties
• Index signatures
• Interfaces and their declaration
• Type aliases and when to prefer them
• Interface merging and declaration merging
• Extending interfaces
• Intersection types
• Union types and their meaning
• Literal types and const assertions
• Structural typing explained
• Excess property checks on object literals
• Assignability rules
• Nested object typing
• Typing configuration objects
• Modelling a domain with types first

This chapter focuses on Typing parameters and return values, Optional and default parameters, Rest parameters with tuples and the practice needed to use these concepts confidently in real projects.

• Typing parameters and return values
• Optional and default parameters
• Rest parameters with tuples
• Function type expressions
• Call signatures on interfaces
• Construct signatures
• Function overloads and their order
• this typing in functions
• Typing callbacks and handlers
• Higher-order function types
• Narrowing with typeof
• Narrowing with instanceof
• Narrowing with the in operator
• Truthiness narrowing and its traps
• Equality narrowing
• Discriminated unions
• Exhaustiveness checking with never
• User-defined type guards
• Assertion functions
• Type predicates in array filters
• Control flow analysis in practice
• Refactoring conditionals into unions

This chapter focuses on Why generics exist, Generic functions and inference, Explicit type arguments and the practice needed to use these concepts confidently in real projects.

• Why generics exist
• Generic functions and inference
• Explicit type arguments
• Generic constraints with extends
• Multiple type parameters
• Default type parameters
• Generic interfaces
• Generic classes
• Generic type aliases
• keyof and key lookup types
• Indexed access types
• Typed property getters
• Generic factory functions
• Constraining to object shapes
• Generic React-style component props
• Generic API client patterns
• Variance in practice
• Inference from arguments and return position
• When a generic is over-engineering
• Reading generic-heavy library types
• Naming type parameters clearly
• Debugging inference failures

This chapter focuses on Conditional types and the extends check, infer and extracting inner types, Distributive conditional types and the practice needed to use these concepts confidently in real projects.

• Conditional types and the extends check
• infer and extracting inner types
• Distributive conditional types
• Mapped types over keys
• Key remapping with as clauses
• Modifiers: adding and removing optional and readonly
• Template literal types
• Building string unions programmatically
• Partial, Required and Readonly
• Pick, Omit and Record
• Exclude, Extract and NonNullable
• ReturnType, Parameters and Awaited
• Building your own utility types
• Recursive types and depth limits
• Branded and nominal-style types
• Opaque identifiers for safety
• Deep partial and deep readonly
• satisfies and its use cases
• const type parameters
• Type-level tests for your utilities
• Balancing cleverness and readability
• Performance of complex types on large projects

This chapter focuses on Class declarations and typed fields, Constructors and parameter properties, public, private and protected and the practice needed to use these concepts confidently in real projects.

• Class declarations and typed fields
• Constructors and parameter properties
• public, private and protected
• The private hash field against the private keyword
• readonly members
• Static members and static blocks
• Getters and setters with types
• Abstract classes and members
• Implementing interfaces
• Inheritance and super calls
• Method overriding and the override keyword
• Polymorphism in typed code
• Generic classes revisited
• Mixins and composition
• Decorators and metadata
• Dependency injection patterns
• Class-based domain models
• When to use plain objects instead
• Serialising and deserialising classes
• Testing class behaviour
• Common inheritance mistakes
• Refactoring inheritance to composition

This chapter focuses on ES modules in TypeScript, Import and export type syntax, isolatedModules and its implications and the practice needed to use these concepts confidently in real projects.

• ES modules in TypeScript
• Import and export type syntax
• isolatedModules and its implications
• Module resolution strategies
• Path aliases and baseUrl
• tsconfig.json anatomy
• The strict family of flags
• noUncheckedIndexedAccess
• exactOptionalPropertyTypes
• noImplicitOverride and noImplicitReturns
• target, lib and downlevel output
• Source maps and declaration maps
• Declaration output for libraries
• Project references for monorepos
• Incremental builds and build info
• Type-only packages and DefinitelyTyped
• Writing your own .d.ts file
• Ambient declarations and global types
• Module augmentation
• Typing environment variables
• Type checking in CI
• Keeping the compiler fast

This chapter focuses on Why compile-time types are not runtime guarantees, Typing fetch responses honestly, Runtime validation libraries and the practice needed to use these concepts confidently in real projects.

• Why compile-time types are not runtime guarantees
• Typing fetch responses honestly
• Runtime validation libraries
• Schema-first types
• Parsing rather than casting
• Type assertions and their danger
• Non-null assertions and when they are justified
• Handling null and undefined deliberately
• Optional chaining and nullish coalescing under strict mode
• Typing errors in catch blocks
• Custom error hierarchies
• Result types and error-as-value patterns
• Typing form input and user data
• Typing localStorage and JSON round trips
• Date and time typing pitfalls
• Third-party libraries with weak types
• Wrapping untyped libraries safely
• Typing configuration and feature flags
• API contract sharing between client and server
• Generating types from an OpenAPI schema
• Keeping generated types in sync
• Breaking changes and contract versioning

This chapter focuses on ESLint with the TypeScript parser, Type-aware lint rules, Rules worth enabling and rules worth disabling and the practice needed to use these concepts confidently in real projects.

• ESLint with the TypeScript parser
• Type-aware lint rules
• Rules worth enabling and rules worth disabling
• Prettier alongside the type checker
• Testing typed code
• Typing mocks and test doubles
• Typed test fixtures and factories
• Testing generic utilities
• Compile-time assertions in tests
• Coverage in a typed codebase
• Debugging with source maps
• Build pipelines: tsc, bundlers and transpilers
• Type checking separate from bundling
• Speeding up large-project builds
• Editor performance on big codebases
• Reviewing types in pull requests
• Documenting types with TSDoc
• Deprecating and evolving public types
• Handling any in legacy code
• Tracking type debt
• Team conventions for types
• A checklist for production readiness

This chapter focuses on Designing the domain model in types, Modelling states so invalid states cannot exist, Typing the data access layer and the practice needed to use these concepts confidently in real projects.

• Designing the domain model in types
• Modelling states so invalid states cannot exist
• Typing the data access layer
• Typing the service layer
• Typing the presentation layer
• Shared types across modules
• Building a typed API client
• Typed error handling end to end
• Typed configuration loading
• Adding a typed caching layer
• Typed event handling and pub/sub
• Typed state machine for a workflow
• Refactoring safely with the compiler
• Renaming across the project
• Extracting a shared library
• Publishing types for consumers
• Writing tests for the finished modules
• Reviewing the type surface for leaks
• Removing remaining any usages
• Measuring build and check times
• Documenting the project for a new joiner
• Final review and walkthrough