TypeScript

Advanced type inference combined generics allows us to build complex types on top of other ones.

Generics allows us to write a typesafe code that will work with a wide range of primitives and objects.

The TypeScript 'never' keyword is a bit of a mystery to many developers. What does it do, and when should you use it?

In this post, we will cover how TypeScript infers variable's type. Knowing this is important to build a solid understanding of the language.

Schema validation will help you ensure that your data is valid during runtime and Zod is the one of the best TypeScript libraries for it.

We will cover what ambient modules are, how to use them, and some caveats and tips when working with them.

When you get stuck, use module augmentation to tweak the modules that you can't access otherwise.

This post explores some of the common best practices, why they don't always work, and what's a better approach.

Polymorphic components is a powerful React pattern for controlling how your components render in DOM.

Let's cover the right approach of implementing React higher-order components in TypeScript using generics and utility types.

Let's cover some of the new TypeScript features that will help write precise and clean code.

Let's explore TypeScript utility types for React. Utility types are a powerful feature for constructing new types.

I'll cover each of the types used for children prop and discuss the trade-offs so you can pick the right one for your use case.