Gain insights into integrating TypeScript with React to improve productivity. Learn about strongly-typed props, state, and events, and set up projects using Create React App, Webpack, and Babel.

If you are a React developer and want to build your React apps faster and more robustly, this course is for you. Learn to integrate TypeScript with React, boost your productivity, and create apps that are easier to maintain.

In this course, you will learn how to utilize TypeScript’s sophisticated type system to make React development faster and your code more readable. You will learn how to create component props, state, and events that are strongly-typed, allowing you to quickly understand what you can pass and helping you avoid mistakes.

Lastly, you will set up React projects with TypeScript. First, you will learn how to do this with the Create React App tool, then how to create a React and TypeScript project with Webpack and Babel.

Using TypeScript with React

# Adding React

We can install React into our project by running the following command in the terminal:

```shell
npm install react react-dom
```

This installs the core React library as well the React library for interacting with the browser.

# Adding TypeScript

TypeScript can be installed in our project as a development dependency by running the following command in the terminal:

```shell
npm install --save-dev typescript 
```

Why do you think we have installed TypeScript as a development dependency rather than a full dependency that is available at runtime?

TypeScript isn't used by the app at runtime. TypeScript is used to do type checking at development type. TypeScript code is transpiled to JavaScript during the build process. 

TypeScript is configured with a file called `tsconfig.json`. Let's create this file in the root of our project with the following content:

```json
{
  "compilerOptions": {
    "lib": [
      "dom",
      "dom.iterable",
      "esnext"
    ],
    "allowJs": true,
    "allowSyntheticDefaultImports": true,
    "skipLibCheck": true,
    "esModuleInterop": true,
    "strict": true,
    "forceConsistentCasingInFileNames": true,
    "moduleResolution": "node",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "noEmit": true,
    "jsx": "react"
  },
  "include": [
    "src"
  ]
}
```

We are only going to use TypeScript in our project for type checking. We are going to use a tool called [Babel](https://babeljs.io/) later in this lesson to do the code transpilation. So, the compiler options in our `tsconfig.json` are focused on type checking, not code transpilation.

Here's an explanation of the settings we have used:

* `lib`: The standard typing to be included in the type checking process. In our case, we have chosen to use the types for the browsers DOM as well as the latest version of ECMAScript.
* `allowJs`: Whether to allow JavaScript files to be compiled.
* `allowSyntheticDefaultImports`: This allows default imports from modules with no default export in the type checking process.
* `skipLibCheck`: Whether to skip type checking of all the type declaration files (`*.d.ts`).
* `esModuleInterop`: This enables compatibility with Babel.
* `strict`: This sets the level of type checking to very high. When this is true, the project is said to be running in *strict mode*.
* `forceConsistentCasingInFileNames`: Ensures that the casing of referenced file names is consistent during the type checking process.
* `moduleResolution`: How module dependencies get resolved which is `node` for our project.
* `resolveJsonModule`: This allows modules to be in `.json` files which are useful for configuration files.
* `noEmit`: Whether to suppress TypeScript generating code during the compilation process. This is `true` in our project because Babel will be generating the JavaScript code.
* `jsx`: Whether to support JSX in `.tsx` files.
* `include`: These are the files and folders for TypeScript to check. In our project, we have specified all the files in the `src` folder. 

More information on all the compiler options can be found [here](https://www.typescriptlang.org/docs/handbook/compiler-options.html).

Continuing from the last lesson, we are going to add both React and TypeScript to our project in this lesson. We'll also create the root React component as well.

Why TypeScript?

Using basic types

Creating types

Working with generic types

Creating strongly-typed function component props

Creating strongly-typed function component state

Creating strongly-typed class components

Creating strongly-typed component events and event handlers

Creating strongly-typed context

Creating strongly-typed refs

Creating React projects with TypeScript using Create React App

Creating a React and TypeScript project manually

Putting everything together

Adding React and TypeScript

Adding React #

Adding TypeScript #