In this exercise, we're going to bring together several of the TypeScript concepts that we've seen so far.

Here we've got a `buttonPropsMap` object, which contains various button variants organized into three categories: `reset`, `submit`, and `next`:

```typescript
const buttonPropsMap = {
  reset: {
    className: "bg-blue-500 text-white",
    type: "reset",
    // @ts-expect-error
    illegalProperty: "whatever",
  },
  submit: {
    className: "bg-gray-200 text-black",
    type: "submit",
    // @ts-expect-error
    illegalProperty: "whatever",
  },
  next: {
    className: "bg-green-500 text-white",
    type: "button",
    // @ts-expect-error
    illegalProperty: "whatever",
  },
};
```

These variants are then incorporated into a `ButtonProps` type by using `keyof typeof`:

```typescript
type ButtonProps = {
  variant: keyof typeof buttonPropsMap;
};
```

However, we have an error on `button` where the types don't seem to be correctly assigned:

```typescript
const Button = (props: ButtonProps) => {
  return <button {...buttonPropsMap[props.variant]}>Click me</button>;
};
```

The error message is really long, but it's going to be helpful for us to understand what's going on:

```typescript
Type '{ 
  children: string; 
  className: string; 
  type: string; 
  illegalProperty: string; 
} | { 
  children: string; 
  className: string; 
  type: string; 
  illegalProperty: string; 
} | { 
  children: string; 
  className: string; 
  type: string; 
  illegalProperty: string; 
}' is not assignable to type 'DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>'.

Type '{ 
  children: string; 
  className: string; 
  type: string; 
  illegalProperty: string; 
}' is not assignable to type 'DetailedHTMLProps<ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>'.

Type '{ 
  children: string; 
  className: string; 
  type: string; 
  illegalProperty: string; 
}' is not assignable to type 'ButtonHTMLAttributes<HTMLButtonElement>'.

Types of property 'type' are incompatible. 

Type 'string' is not assignable to type '"button" | "submit" | "reset" | undefined'. ts(2322)
```

## Challenge

Your task is to identify and resolve this error by using `ComponentProps` and other techniques we've seen so far.

The categorization of `next`, `reset`, and `submit` buttons should be maintained, and any illegal properties need to show errors. You should also be able to autocomplete properties as expected.


First things first, we need to discern a type for our `buttonPropsMap`.

## Typing the `buttonPropsMap`

We'll define a type called `Map` which will be a `Record` with a `string` key and a value of `ComponentProps<"button">`.

```typescript
type Map = Record<string, ComponentProps<"button">>;
```

This `Map` type is essentially an index signature on an object, which is a string. Then the `React.DetailHTMLProps` represents the `button` props. 

Now we can apply the `Map` type to our `buttonPropsMap`:

```typescript
const buttonPropsMap: Map = {
   ...
```
With this change, we're now getting autocomplete inside the `buttonPropsMap` and all of the illegal properties have disappeared.

However, there's a snag.

## Fixing the `variant` Error

Our `variant` has stopped working. It's being inferred as a string, instead of `reset`, `submit` or `next`:

```typescript
// inside the Parent component's return:

{/* @ts-expect-error */} // not erroring like it should!
<Button variant="something"></Button>
```

The key inside of the `Record` is actually crucial to understanding this issue.

Here's what we currently have:

```typescript
type Map = Record<string, ComponentProps<"button">>;
```

Manually specifying the keys for the variants would fix the issue:

```typescript
type Map = Record<"reset" | "submit" | "next", ComponentProps<"button">>;
```

However, this isn't a great solution because it the variants aren't actually being inferred, and they are specified in two different places since `buttonPropsMap` is being specified as the `Map` type while also containing the variants.

As we've seen before, the way to get around this is to use `satisfies`.

## Using `satisfies` to Ensure Correct Inference

We'll remove the annotation on `buttonPropsMap` and use `satisfies` instead. We also can remove the `Map` type and specify the `Record` directly:

```typescript
// before:
const buttonPropsMap: Map = {
   ...
}

// after:
const buttonPropsMap = {
   ...
} satisfies Record<string, ComponentProps<"button">>;
```

Using `satisfies` ensures that our `button` variant satisfies the `Record` without overriding the type. 

This gives us the `reset`, `submit`, and `next` variants, and can be used in the component along with autocomplete:

```typescript
// hovering over buttonPropsMap

const buttonPropsMap: {
   reset: {
      className: string;
      type: "reset";
      illegalProperty: string;
   }
   ...
```

Using `satisfies` lets us avoid duplication by inferring everything from a single source of truth.

Discover the power of keyof and satisfies to ensure type safety while maintaining a single source of truth for your type.

Understanding and Implementing Dynamic Props Mapping in React

[00:00] Okay, let's see if we can solve this. This button props map here, we need to first of all just figure out a type that would even represent what this is trying to do here. It's kind of like a record or a map where the keys are component props button. So let's try and figure that out first.

[00:18] Let's say type map for instance, equals a record and let's say string and now component props button here. So we've got this map and this looks good. I mean, this is a pretty horrible readout, but this is essentially what it's doing. It's an index signature on this object, which is a string.

[00:36] And this huge React detail HTML props is just essentially an interface here that represents the button props. So we've got our map. Let's now take that map and use it on our button props map. So we've got map down here and this is really great. We're now getting auto-complete inside here.

[00:55] The illegal properties have disappeared and it all seems well. Now inside our button here, we've got button props map props.variant and this all seems good too. But there's something wrong here. There's a single error. And this single error is the key to understanding this exercise

[01:13] because now our variant has stopped working. This variant here, key of type of button props map is being inferred as a string, not as reset, submit or next. So this string here, the key inside of record is actually kind of key to understanding this. So we've got this record.

[01:32] Now record here, we could actually manually type this. We could say reset or we could say submit or we could say button down the bottom. And okay, this now works here. Or does it work? No, because I put next or put button instead of next. This works.

[01:53] And it means now that the variants down the bottom are all working. We've got next, reset and submit. Yay! Except this variant is now kind of lame because or rather this setup is really lame because we now have reset, submit and next, but they're not being inferred.

[02:12] We now have this duplicated in two places. Wouldn't it be great if we could infer one from the other? Well, there seems to be no way around this because it's kind of circular, right? This is being typed as map and this is being sort of typed before we even get to map. Well, there is a way around it. Let's put string back in here and we're going to take this

[02:32] and we're going to actually just delete this annotation. And just like in another exercise in this section, we're going to use satisfies here. And satisfies, what it's going to do is it's actually going to make sure that it satisfies that record string component props while not overriding the type. Yes!

[02:50] So now we get reset, submit and next. And we've got these two types inside here, which means that we can then use them later to figure out this variant down there, which is just perfect. So we've still got the autocompletes here. And it means now that if we add a new one to this,

[03:08] then we're still going to get autocomplete in here too and it's still going to be inferred down. So this means satisfies is a really, really nice way when you combine it with key of type of to actually still retain the responsibility principle for your types, a single source of truth, while still making sure that you can get autocomplete

[03:27] on that source of truth.

Inference from a Single Source of Truth

[00:00] In this exercise, we're combining a few things that we've learned together. We have this button props map kind of object here, which has a bunch of different variants of buttons. So we have our reset button, our submit button and our next button, like in a multi-step form. And in our button props, we're taking that variance and we're putting them in here.

[00:19] But there's an error kind of below here where we're not getting the right types in, it seems. So your job is to figure out what this error is. We also want to make sure we retain this kind of next reset and submit thing. And we want to make sure that these illegal properties start erroring.

[00:38] So you're going to need to find a type, again, possibly using component props and using some other stuff that we've seen before, to type button props map correctly so that we get rid of these errors, get rid of this error, and we still get the nice autocomplete below.

React is the framework for professional web development.

The scale and complexity of web applications is always expanding. This has led to missed deadlines, higher costs, and deep frustration on developers like you and your team.

TypeScript is the language of choice for professional web developers. TypeScript lets teams build faster, more robust applications.

TypeScript solves a lot of problems, but it's not a silver bullet. It’s a complex language with a lot of features, and is challenging to use effectively– particularly when it comes to React. 

TypeScript with React is a high-wire act. 

You have to keep your components flexible, type-safe, and structured so you can take advantage of inference and not sacrifice maintainability down the line.

As soon as you start throwing `any`s around or duplicating code you know should be reusable, you’ve lost the plot.

Advanced React with TypeScript by Matt Pocock is your secret weapon.

You’ve found the magic wand you need to stop fighting TypeScript and make it do YOUR bidding like a true wizard.

In this Advanced React with TypeScript workshop, you’ll learn how to combine the most important concepts and patterns of React with TypeScript. 

This combination is a superpower that will change the way you and your team build web applications.

You’ll write custom hooks that use generics, share some (but not all) props between components, and remove guesswork by diving into the types behind the scenes of React and other popular libraries.

This workshop has been vetted and tested with professional senior+ React developers and teams like yours.

Advanced TypeScript with React includes over 50 exercises spanning six in-depth sections: 

## Advanced Props with TypeScript
**Handle props and custom components**

Learn how to shape props to support multiple variants, share selected props between different components, use union types for conditional rendering, and other best practices for your components.

## TypeScript Generics in React
**Leverage generics for your components and custom hooks**

TypeScript generics are a key tool in creating flexible, reusable components and hooks in React.

Generics can be used to define how components should be rendered based on the data and structures passed in. You'll work with custom hooks that support async operations and proper error handling, as well as combine generics with useState and useReducer for complex state management. The exercises in this section will fundamentally change the way you build components.

## Advanced React Hooks with TypeScript
**Harness types to create safer hooks**

Using TypeScript with React Hooks provides serious benefits. You will practice with advanced concepts like returning read-only tuples from custom hooks and implementing function overloads for built-in hooks like useState. You'll implement loading and error states for an async hook, while provided a cancellation mechanism to avoid memory leaks. By the end of this section, you'll have the tools to create well-typed hooks that elevate your component development workflow.

## Types Deep Dive
**Read behind the scenes to build your understanding**

The TypeScript type system forms the backbone of React and other libraries you use on a regular basis. But the errors it gives you can be confusing in the extreme.

Examine the various members of the React namespace, and how to use them to build better prop types. From understanding JSX.IntrinsicElements to augmenting React’s types themselves, you’ll learn everything you need to remove the guesswork when solving React’s nastiest TypeScript errors.

## Advanced Patterns in React with TypeScript
**Recognize and follow industry-standard patterns**

Combining community-adopted React patterns with TypeScript features can significantly optimize your applications and the way you write code. You will work with classic component patterns like Render Props and Higher Order Components, solve the forwardRef problem, and master the ‘as’ prop– all with the added benefits of type safety.

The patterns you learn here will give you ideas for refactoring your existing React codebase - and build powerful design systems

## Leveraging External Libraries
**Safely integrate external libraries into your React components**

Libraries supercharge your React development productivity. But they can be a double-edged sword. With TypeScript, you’re not just adding runtime code– you’re adding types to your project.

You'll create type-safe form components with `react-hook-form`, and learn how to master third-party generics with `react-select`. You will look behind the type definitions behind React Query, and apply what you learn to defining a custom hook to encapsulate its functionality. The lessons you learn from diving deep into types in node modules will be applicable to any third-party library you choose to use.

## Prerequisites

You'll need a working knowledge of React, as well as foundational TypeScript knowledge. Working through the [React with TypeScript Tutorial](https://www.totaltypescript.com/tutorials/react-with-typescript) is recommended.





Expert-level knowledge for typing your React apps with TypeScript.

React TypeScript

Total TypeScript Core Volume is a set of four full TypeScript workshops for the intermediate to expert professional TypeScript programmer that wants to take their skills to the next level. This bundle also includes the Advanced React with TypeScript workshop that will give you expert-level knowledge for typing your React apps.

Type Transformations

TypeScript Generics

Advanced TypeScript Patterns

Advanced React with TypeScript

TypeScript Expert Interviews

Core Volume

Enhance the type safety of React props by leveraging discriminated unions to restrict possible variations.

Using Discriminated Unions to Create Flexible Component Props in React

Type-Checking React Props With Discriminated Unions

Figure out how to fix a common type error that occurs when destructuring props with discriminated unions in React components.

Manage TypeScript's control flow limitations in discriminated unions with destructuring: balance prop access and discriminator narrowing.

Destructuring vs Accessing Discriminated Union Props

Destructuring Discriminated Unions in React Props

Learn how to add a required React property to different variants of a discriminated union in TypeScript

A guide on how to properly use intersection to resolve union types in TypeScript and ensure code readability.

Resolving Discriminated Union Types with an Intersection

Adding a Prop Required Across Discriminated Union Variants

Handle a situation where a Boolean is used as a discriminator in a discriminated union, and learn how to use a default value to avoid passing unnecessary props.

Learn how to use discriminated unions to handle conditional props in TypeScript.

Discriminated Unions for Conditional Props in TypeScript

Differentiating Props With a Boolean Discriminator

In this exercise, you will learn how to use the Record type to represent an empty object by passing in a string and never type.

Using the Record Type to Represent an Empty Object

In this exercise, we'll be using a discriminated union to handle different behaviors based on a prop value due.

Make props optional in components by typing them as undefined in discriminated union branches.

Allow Optional Props Using A Discriminated Union Branch With Undefined Types

Conditionally Require Props With Discriminated Unions

Explore how to find a better type definition for a mapped React component.

Learn what makes these two React types different and how to use them effectively to ensure type safety in your code.

What's The Difference Between React.ReactNode and React.FC?

Finding a Better Type Definition For A Mapped Component

TypeScript infers data structures, allowing a type to serve as the source of truth, with props inferred from runtime behavior.

The `keyof typeof` pattern in TypeScript to derive types from variables and create dynamic maps for runtime behavior.

The `keyof typeof` Pattern

Syncing Types without Manual Updates

There is a quirk in TypeScript where autocompletion for types with predefined values and strings doesn't work quite as you might expect.

Wrap the string in parentheses and intersect with an empty object to resolve the partial autocompletion quirk in TypeScript.

Solving Partial Autocompletion

The Partial Autocompletion Quirk

Using `as const` and indexed access types helps you extract keys and values from a type.

The combination of `as const` and indexed access types allows you to extract keys and values from a type.

Using `as const` and Indexed Access Types to Extract Keys and Values from a Type

Extracting Keys and Values from a Type

TypeScript has a few different ways to ensure correct inference depending on how restrictive or permissive your checking needs to be.

Differentiate between annotation operators, "as const", and "satisfies" in TypeScript for optimal type inference and validation based on specific use cases.

Comparing `as const`, `as`, and `satisfies`

Ensuring Correct Inference for Prop Types

Advanced Props

Generics and type helpers combine to create reusable code that's easy to understand and maintain.

A generic type helper makes our code more reusable and easier to understand.

Implement a Generic Type Helper

DRY out Code with Generic Type Helpers

Refactor complex type logic into a type helper.

An "All or Nothing" type helper simplifies complex logic while allowing for flexible object shapes.

Creating an "All or Nothing" Type Helper for React props

Refactoring to a Type Helper

Generic type parameters can be constrained to accept only specific values, improving the reliability and predictability of your type helpers.

Enforcing constraints helps you prevent errors from occurring, and ensures your type helpers are being used in the correct way.

Add Generic Constraints to Type Helpers

Constraining a Type Helper to Accept Specific Values

Type arguments allow us to pass in a type to a hook, which can be used to provide more accurate return values.

By default, type arguments are inferred as `unknown`. When using this type of API in your code, it is crucial to have it well-documented.

Adding Type Arguments to a Function

Adding Type Arguments to a Hook

Learn how TypeScript behaves when wrapping one generic function inside of another generic function.

TypeScript uses type inference to infer the type of generic functions, making them easier to use.

Type Inference with Generic Functions in TypeScript

Wrapping a Generic Function Inside of Another

Generics are useful for components, especially in situations where different props depend on each other.

By adding a generic type argument to a props interface, we can infer prop types.

Add a Generic Type Argument to a Props Interface

Applying Generics to Components

There are still class components in legacy codebases, so it's important to understand how to make them generic.

Props work the same whether we're using functional components or class components. It's just the generic syntax that's different.

Converting a Class Component to be Generic

Generics in Class Components

Discover how to use type enforcement in React components to address data inconsistencies in a user table, preserving data integrity.

In order to get proper inference, the type arguments need to be passed appropriately to the type helpers.

Use the Angle Brackets Syntax to Pass a type to a Component

Passing Type Arguments To Components

Generics enable the useful pattern of inferring type arguments through multiple different type helpers.

Adding Generic Type Arguments to Type Helpers

Generic Inference through Multiple Type Helpers

Discover how to optimize your code by making use of generic hooks and type constraints in useMutation. 

Comparing function arguments rather than the functions themselves should be considered a best practice when dealing with function assignability in TypeScript. 

Refactoring a Generic Hook for Best Inference

Build a useMutation hook

Generics aren't always the best solution for every problem. Sometimes, a different approach is better suited for the task at hand.

Replacing generics with a discriminated union can make your code cleaner and easier to understand while still maintaining the same inference.

Refactoring from Generics to a Discriminated Union

Generics vs Discriminated Unions

Using Generics with Components

Learn how to get better inference from a custom hook without changing its runtime behavior.

Learn how to identify and resolve type inference problems when using useState in React, ensuring accurate type information for returned values.

Use 'as const' to Infer a Tuple return type

Fixing Type Inference in a Custom React Hook

Learn how to create a strongly typed context in React using the createRequiredContext function, and fix type errors that can occur

Avoid the common issue of creating a context and not knowing what to pass into it.

Using Type Arguments to Create A Strongly Typed Context

Strongly Typing React Context

Learn a pattern for managing complex state that helps you track every possible state your application can be in.

Learn how to properly type complex React state that represents different possibilities using TypeScript.

Handling Complex State Management with TypeScript Unions

Using TypeScript to Manage Complex State

Clever usage of TypeScript types provides a great alternative to useReducer for tracking multiple properties in state.

Learn how to use discriminated unions with useState to effectively manage different states and properties in your React applications.

Handling Different State Values with Discriminated Unions

Using Discriminated Unions in useState

Learn how a different type signature can lead to better inference when working with different statuses in React state.

Discover how using discriminated tuples in TypeScript gives better inference as demonstrated through an example involving loading, success, and error states.

Improved Type Safety with Discriminated Tuples in TypeScript

Discriminated Tuples in Custom Hooks

Function overloads resolve type inference issues when a function can return different types of values.

Overloading Functions in TypeScript

Use Function Overloads for Better Type Inference

By mimicking the function overloads on `useState`, you can make your custom hooks behave in the same way.

Be careful when using function overloads, because it's easy to end up in an impossible position and TypeScript won't warn you about it!

Wrapping useState Functionality with Function Overloads

Mimicking useState Behavior with Function Overloads

This pattern of creating an outer hook and returning a hook from inside it is sometimes referred to as "currying hooks".

Generics need to be captured at the point where they're used as well as where they're being inferred from.

Inferring Type Arguments in Curried Hooks

Currying Hooks

Advanced Hooks

React provides a namespace that contains types, functions, and values. Type definitions can help you understand why and how React works the way it does.

The DefinitelyTyped contributors have structured the React types so that they work in both the runtime and type worlds.

Understanding the React Namespace

Exploring the React Namespace

React gives us a few different types to use for our components. Understanding the differences between them can help you avoid errors and write better code.

Learn how JSX.Element, React.ReactElement, and React.ReactNode affect type inference and return values in React components.

Understanding React's JSX Types

JSX.Element, React.ReactElement, and React.ReactNode

A strongly requested feature for React & TypeScript is to strongly type the children. Is this even possible?

Manually call JSX to force the type of children passed to a component to be a specific type.

Strongly Typing Children in React Doesn't Work

Strongly Typing Children in React

JSX.IntrinsicElements is a global interface that contains HTML attributes as properties that you'll when using TypeScript in React.

JSX.IntrinsicElements is a global interface that contains HTML elements and attributes.

Understand the Structure of React's JSX.IntrinsicElements

Exploring JSX.IntrinsicElements

ElementType and ComponentType are two React type helpers which help describe the shapes of components.

Understanding React's ElementType and ComponentType

Learn how to add an interface to React's global namespace.

Adding interfaces into global namespaces can be useful in a variety of situations.

Merge Namespaces in TypeScript

Appending to React's Global Namespace

Declaration merging can be used to modify existing interfaces in the global namespace.

Learn how to merge interfaces in TypeScript to combine and extend their properties in the same global namespace.

Extend the Global React namespace with Declaration Merging in TypeScript

Modify Existing Interfaces in the Global React Namespace

By utilizing declaration merging, you can inform TypeScript of the types of custom elements from external libraries.

Type external JSX elements through declaration merging by extending JSX.IntrinsicElements.

Extend JSX.IntrinsicElements with Declaration Merging

Add a New Global Element in TypeScript

The types that React exposes for each element are extensive. Take a deep into these types to understand how they are defined and work.

Navigating HTMLAttribute types

Exploring HTML Attribute and Element Types

Having an optional test attributes available can be useful for testing elements.

Have a clear understanding of the namespace structure and hierarchy of interfaces in React, you'll be better equipped to handle any errors

Updating the Global Namespace for an Additional Attribute

Add Attributes to All Elements with Declaration Merging

Types Deep Dive

Lazy loading allows us to dynamically import and render components, but it can be tricky to type props correctly.

It's important to understand constraints when typing third-party libraries.

Strongly Typing Lazy Loaded Components with Generics

Strongly Typed Lazy Loading

While not as common as it used to be, the Render Props pattern is sometimes the best solution to a problem.

The Render Props pattern allows for flexibility that can't be achieved with hooks alone.

Typing the Children Prop for Render Props

Render Props

Using a Record and the satisfies operator saves you from manually specifying types when multiple components share the same props.

The pattern of using a record with satisfies is useful when you have multiple components that share the same props.

Infer Shared Props for Multiple Components

Records of Components with the Same Props

React's implementation of forwardRef has some properties that make it annoying when working with generic components, but it can be worked around.

The Problem With forwardRef

When overriding global behavior, it's best to do it locally to prevent conflicts in library development scenarios.

Override forwardRef's Behavior Locally

Fixing forwardRef Locally

Higher Order Components (HOCs) are great for creating reusable functionality in React, but typing a wrapped component has its challenges.

By making an HOC generic and properly handling the props it is passed, we can create a more flexible component.

Implementing a Generic Higher Order Component

Typing Higher Order Components

Our current Higher Order Component implementation doesn't work with generic components. Let's fix that.

By updating type signatures and changing how props are handled, we can make a Higher Order Component that works with generic components.

Add Generic Component Support to a Higher Order Component

Using Higher Order Components with Generic Components

The `as` prop is one of the most complex in TypeScript, and there are lots of different ways to approach it.

Explored here are two approaches to the `as` prop in React, with one much more efficient than the other.

Transcript

Inference from a Single Source of Truth

Transcript