TypeScript · Intermediate
Mapped Types
Mapped types allow you to create new types based on the properties of an existing type. They are essential for transforming object structures dynamically.
Open snippet →Code library
Intermediate TypeScript exercises
Read these Intermediate TypeScript snippets line by line — each one comes with a written breakdown of what the code does and why.
TypeScript · Intermediate
Conditional Types
Conditional types select one of two possible types based on a condition expressed as a type relationship test.
Open snippet →TypeScript · Intermediate
Intersection Types
Intersection types combine multiple types into one, allowing you to merge existing types to create a type that has all the features you need.
Open snippet →TypeScript · Intermediate
Discriminated Unions
Discriminated unions use a common literal property (the discriminant) to allow TypeScript to narrow down members of a union safely.
Open snippet →TypeScript · Intermediate
Generics with keyof Constraints
Using 'keyof' with generics ensures that a function parameter is a valid key of a specific object, providing full type safety and IDE autocompletion.
Open snippet →TypeScript · Intermediate
Index Signatures for Dynamic Keys
Index signatures allow objects to have flexible keys that aren't known ahead of time. You define the type of the key (usually string or number) and the type of the value it returns.
Open snippet →TypeScript · Intermediate
Abstract Classes for Shared Logic
Abstract classes cannot be instantiated directly. They serve as templates, allowing you to define shared methods while forcing subclasses to implement specific 'abstract' logic.
Open snippet →TypeScript · Intermediate
User-Defined Type Guards
A type guard is a function that returns a type predicate ('pet is Fish'). It allows TypeScript to narrow down the type of an object within a specific code block after a runtime check.
Open snippet →TypeScript · Intermediate
Template Literal Types
Template literal types allow you to create new string types by combining existing union types. This is extremely useful for generating predictable string patterns like CSS classes or action names.
Open snippet →TypeScript · Intermediate
Extracting Types with ReturnType
The ReturnType utility type extracts the return type of a function. This ensures that if the function's implementation changes, the dependent types update automatically, maintaining a single source…
Open snippet →TypeScript · Intermediate
Handling Async Operations with Type-Safe Result Objects
Instead of relying on unhandled promise rejections, this pattern wraps asynchronous operation outcomes into typed success or failure result objects. It provides structured error handling using cust…
Open snippet →TypeScript · Intermediate
Immutable Array Pipeline Transformations using Readonly Types
Using readonly modifiers for array parameters prevents accidental mutation of input data during collection processing. Pipeline operations like filter and map produce new arrays, maintaining functi…
Open snippet →TypeScript · Intermediate
Type-Safe Input Sanitization via Branded Types
Branded types create nominal type distinctions over primitive types like strings. This forces developers to pass user input through an explicit sanitization function before it can be accepted by se…
Open snippet →TypeScript · Intermediate
Creating Type-Safe Test Doubles with Spy Interfaces
Creating test doubles by implementing domain interfaces allows unit testing without reliance on external mocking frameworks. The mock class records call parameters for assertions while satisfying s…
Open snippet →TypeScript · Intermediate
Streaming Data Streams with Typed Async Generators
Async generators typed with AsyncGenerator<T, ReturnType, NextType> allow processing asynchronous sequences lazily. Consuming batches sequentially with for await...of keeps memory consumption low d…
Open snippet →TypeScript · Intermediate
Building a Lightweight Dependency Injection Container
Dependency injection (DI) is a core architectural pattern used in modern application frameworks. Using TypeScript's generics and Symbols, you can build a light, type-safe DI container that maps uni…
Open snippet →TypeScript · Intermediate
Developing a Type-Safe Event Bus Architecture
An Event Bus decouples publishers from subscribers across modular application layers. Leveraging mapped types and indexed accesses (`Events[K]`), TypeScript enforces exact payload contracts for eve…
Open snippet →TypeScript · Intermediate
Designing a Minimal Middleware Pipeline for Task Handlers
Middleware pipelines process requests or background tasks sequentially. By parameterizing middleware functions with generic context boundaries, you achieve extensible request processing while retai…
Open snippet →TypeScript · Intermediate
Constructing a Type-Safe Micro State Store with Subscriptions
Centralized state management frameworks rely on predictable state mutations and reactive subscriptions. Combining `Readonly<T>`, `Partial<T>`, and `Object.freeze`, this micro store ensures state im…
Open snippet →TypeScript · Intermediate
Implementing a Declarative Schema Validation Utility
Validation engines form the backbone of web frameworks by converting raw external inputs into safe internal types. Using generic inference (`infer`), TypeScript dynamically maps object schemas to i…
Open snippet →TypeScript · Intermediate
Exhaustive Pattern Matching with Discriminated Unions and Never
Discriminated unions combine a literal tag property ('kind') with TypeScript's type narrowing. By passing the default switch branch to a function accepting only the 'never' type, the compiler guara…
Open snippet →TypeScript · Intermediate
Streaming Data Batches with Async Generators and Async Iterators
Async generator functions combine the yield keyword with asynchronous operations. Returning an AsyncGenerator interface allows consumers to process paginated data sequentially item-by-item using 'f…
Open snippet →TypeScript · Intermediate
Extracting Function Return Types Using Conditional Types and Infer
Conditional types allow type transformations based on shape checks (T extends U ? X : Y). The 'infer' keyword introduces a type variable inside the conditional check to capture inner types, such as…
Open snippet →TypeScript · Intermediate
Transforming Property Names with Mapped Types and Key Remapping
Mapped types can iterate over object keys and use template literal types combined with the 'as' keyword to dynamically rename property keys at compile time. This snippet turns object keys like 'the…
Open snippet →TypeScript · Intermediate
Type-Safe Functional Error Handling using Result Wrappers
Instead of relying on unhandled exception throwing, explicit Result types model outcomes using a success boolean flag. This forces callers to check the result state before accessing the success val…
Open snippet →TypeScript · Intermediate
Narrowing Unknown Data Payload with Type Predicates
Type predicates allow functions to act as custom type guards. By specifying `data is UserProfile` as the return type, TypeScript automatically narrows the type of `payload` inside conditional block…
Open snippet →TypeScript · Intermediate
Deep Readonly Immutability with Const Assertions
Const assertions (`as const`) convert object literals and arrays into read-only literal types recursively, preventing modifications to properties and enforcing strict literal values instead of wide…
Open snippet →TypeScript · Intermediate
Constructing Event Names using Template Literal Types
Template literal types generate string unions by combining string templates with intrinsics like `Capitalize`. This allows creating type-safe dynamic property names such as event listeners automati…
Open snippet →TypeScript · Intermediate
Dictionary Schema Validation with Satisfies and Record Types
The `satisfies` operator validates that an object matches a type like `Record<K, V>` without widening or erasing specific key inference, allowing type safety alongside exact property autocompletion.
Open snippet →TypeScript · Intermediate
Self-Referencing Generic Interfaces for Recursive Tree Structures
TypeScript interfaces can recursively reference themselves to model hierarchical data structures like trees or graph nodes while maintaining static type parameters throughout all child levels.
Open snippet →