Imagine that `NavBar` is a component that comes from an external library:

```typescript
// Imagine NavBar is an external library!

export const NavBar = (props: {
  title: string;
  links: string[];
  children: React.ReactNode;
}) => {
  return <div>Some content</div>;
};
```

For whatever reason, they authors haven't pulled out the props into something that they've exported. We are not able to just import them as a reusable type, as seen by the errors in our test:

```typescript
// Your app:

import { Equal, Expect } from "../helpers/type-utils";

type NavBarProps = unknown;

type test = Expect<
  Equal<
    NavBarProps,
    {
      title: string;
      links: string[];
      children: React.ReactNode;
    }
  >
>;
```

## Challenge

Your challenge is to find some way to take the props of the `NavBar` and pull them into a type.

```typescript
type NavBarProps = unknown 
```

**Hint:** Try to find a <a href="https://react-typescript-cheatsheet.netlify.app/docs/advanced/patterns_by_usecase/#componentprops" target="_blank" rel="noopener">type helper</a> from React that will help you to grab props!

The solution actually uses something that we've used before.

First, let's import `ComponentProps` from React:

```typescript
import { ComponentProps } from "react"; 
```

There are two ways to use `ComponentProps`. You can pass it an actual HTML DOM element, or you can pass it an existing component.

If we pass `typeof NavBar`, then `ComponentProps` will extract out all of the props from the `NavBar` itself.

```typescript
type NavBarProps = ComponentProps<typeof NavBar>; 
```

Navigate into the type definitions of `ComponentProps` by `CMD + Clicking` on it.

The type definition is complicated, but notice that `ComponentProps` has either `JSX.IntrinsicElements` (the `a`, `div`, `span`, etc.) or `JSXElementConstructor`, which is a function or class that returns JSX.

Because `ComponentProps` was passed in `typeof NavBar`, it now is typed as `title`, `links`, and `children` as we wanted it to!

Use a Type Helper to Extract Component Props

[0:00] The solution here is actually using something that we've used before. I'm going to grab ComponentProps again from React. Let me just pull this so it's in with all my other imports nice and neat.  
  
[0:12] ComponentProps actually has two modes. You can either pass it like one of these things here, big. Big? I've not actually heard of that one before. Animate, animateMotion, all of these actual HTML DOM elements. Or what you can do is you can pass it an existing component. I can say ComponentProps typeof NavBar, and that will extract out all of the props from this NavBar itself.  
  
[0:41] If I command-click on it, I can actually go in. This is a complicated type definition, so bear with me. We have either key of JSX.IntrinsicElements, which is a div, span, all that stuff, or a JSXElementConstructor. A JSXElementConstructor is going to be a function that returns some JSX or a class that returns some JSX.  
  
[1:05] This is super cool. It means that NavBarProps is now typed as title, links, children. Beautiful.

Extracting Props from Custom Components

[0:00] Let's say that we have a component that comes in from an external library, this NavBar up here. It's in an external library. For whatever reason, they haven't pulled out these props into something that they've exported. These props aren't something that you can just import into your application and reuse as a reusable type.  
  
[0:19] We need to find some way where we can take the props of NavBar and pull them into a type. Let's say we want to use it in some other component's type. This is a really, really common situation. Some libraries just don't export the props that come with their components. So annoying. We needed to find a way around this.  
  
[0:39] There is a way you can do this where you would take in NavBar. Imagine we're just importing the components of NavBar. We need to do something to it, perhaps using a reusable type helper from React, and then grab the props from it. That's your job, is to try and find out all of the little pieces that we'll need to solve this puzzle. Good luck.

TypeScript's features and developer experience make a great combination with React, but it can be confusing to get started.

What’s the best way to type component props? What are these weird `useRef` errors?

That's where this React with TypeScript tutorial comes in!

Starting from the very beginning of bringing TS support to a React project, you'll soon find yourself properly typing hooks and mastering components. You’ll learn everything you need to know to get productive with React and TypeScript.

Tutorial topics include:

* Reading React's type definitions to debug errors and ensure correct usage
* Defining props for custom and `React.FC` function components.
* Putting TypeScript's inference to work for you
* Supporting component children
* Typing and overriding event handlers
* Utilizing `ComponentProps` to extract properties from imported components or HTML DOM elements
* Understanding the APIs and typing for `useState`, `useCallback`, `useEffect`, and other React Hooks. By the end of this workshop, you'll be confident when using React with TypeScript in your own projects!

<Testimonial author={{name: "Francisko de Moraes Rezende", image: "https://cdn.sanity.io/images/z9io1e0u/production/8e2b0b48599527885121568e19c761edd1c3e2ee-460x460.jpg"}}>Went through it and I think it's great! I wish this tutorial existed when I started my first gig 11 months ago. It teaches all the things I use on a daily basis and some that I didn't know; I was using the verbose way of getting HTML props in types until I went through the tutorial. This is my new go-to recommendation for people starting to work with TS+React. Thanks for creating this and making it free, Matt.</Testimonial>

## Instructions

This React with TypeScript tutorial is split into several exercises. Each features a problem that encourages you to take an active, exploratory approach to finding a solution.

You'll need to:

* Watch and read the problem introduction.
* Check out the TypeScript or React documentation or dive into type definitions to look for help
* Try a solution and check your work. There may be more than one way to solve the challenge! Whether you succeed or get stuck, watch and read the solution and check out the included code.

## Prerequisites

You'll need a working knowledge of React, as well as foundational TypeScript knowledge. Working through the <a href="https://www.totaltypescript.com/tutorials/beginners-typescript" target="_blank" rel="noopener">Beginner's TypeScript Tutorial</a> is recommended.

## Running the Exercises

Exercises can be worked on using the inline Stackblitz editor, or by <a href="https://gitpod.io/#https://github.com/total-typescript/react-typescript-tutorial" target="_blank" rel="noopener">opening the tutorial repo in Gitpod</a>. Online editors do not support the full feature set of a local VS Code installation (e.g. quickly jumping to type definitions).

To work locally, clone the <a href="https://github.com/total-typescript/react-typescript-tutorial" target="_blank" rel="noopener">React with TypeScript Tutorial repo</a>, and use a package manager to install dependencies. From there, check out the README for further instructions.

Get productive building applications with React and TypeScript with our interactive guide on React's types - from component props to useRef.

React TypeScript Tutorial 

There are a few steps to follow in order to add React to a TypeScript project.

Adding React to a TypeScript Project

Most frontend frameworks include optional TypeScript support, meaning you won't have to manually set it up.

TypeScript in React Frameworks

VS Code has a variety of features for working around your codebase when writing JSX.

Three Helpful Tools for Writing JSX

Navigating JSX Types

Introduction

It's important to understand how to type props since you'll work with them every day in React.

Four Approaches to Typing Props

Ensure Props are Present and Defined

React's Function Component React.FC has its own considerations for enabling proper type checking.

Specifying Props for React.FC 

Typing a Component as a Function

Many teams type React's children as any, but there is a better option.

Typing React's Children

Solving the any Problem with Children

Instead of guessing a handler's type, you should be specific.

Choose the Correct Event Handler Type

Typing Event Handlers

When building React components, there are a couple of options for proper typing based on the underlying HTML element.

Add HTML Props to React Components

Using HTML Props in React Components

Components can have a lot of built-in props for things like event handlers that you don't always want, but there are a few techniques for overriding them.

Techniques for Overriding Native Props

Overriding and Removing Component Props 

Components

It's common for the useState hook to be called with an empty array, which TypeScript has issues inferring. Follow this approach for proper typing.

Fix useState's never[] Error

Properly Typing useState

The useState hook uses function overloads to handle cases where you may or may not want to pass an intial value.

Specifying types for useState

Typing useState with undefined

There's a strange property of the useState API that TypeScript treats in a specific way.

Going from Function Comparisons to Object Comparisons

Calling useState with Excess Properties

The useEffect Hook isn't generic, so you need to follow its API to use it properly.

Properly use the useEffect API

Solving Errors with useEffect

By examining a function's type definitions, you can properly type React's useCallBack Hook

Have TypeScript Infer the Callback Function Type

Typing the useCallback Hook

Not all hooks use the same type signature. Dive in to fix errors and specify the return type of a memoized value.

Specify or Infer useMemo's Return Type

Typing the useMemo Hook

There are three type definitions for useRef. Let's start by looking at the most basic.

Typing the useRef Hook

Basic useRef Typing

There are a few different ways to use refs in React, along with some rules to follow.

Refs in React

Specify the Initial Value with useRef

useRef with HTML Elements

Targeting a useRef Overload

Making a Read-Only Ref Mutable

Leveraging one of TypeScript's built-in features allows you to specifically type the state and actions for a reducer function in React.

Transcript

Extracting Props from Custom Components

Transcript