 Courses from Chance Strickland

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

For older applications, it's likely that you have some Class components. TypeScript works a little differently with these. The React.Component class is a generic class and it takes the props type as its first type argument. We will write out an alias for our props that I'll pass in the type argument space for the class. Child classes can also implement their own various methods for overriding parent methods, we'll also want to explicitly type the props in our constructor. 

With that, you've finished my course! Congratulations and thank you for taking it!

Use TypeScript to Type a React Class Component

Our `Radio`component file contains several compound components to create a related group of radio inputs. The `RadioGroupContext` is receiving a type of `any` currently.

This is a great example to peer into how Strict mode works. To see the difference between the strict mode's true and false setting, we will set `strict` to `true`. This will change our `RadioGroupContext` to be of type `null` which will raise some issues later down the line where trying to destructure an object that might be null. 

This also gives us the opportunity to better our application with error handling. I will write out a couple of custom hooks to help out with that.

Type a Radio Button Component in React using TypeScript

We get the state of our board from a `reduce` function. It currently has no error but also has no type safety since everything is inferred to be of type `any`. `useReducer` is generic and accepts type arguments, describing the state as well as the events it can expect to receive. 

The simplest way to add types to a `useReducer` is to add them directly to the `reducer` function itself. We will do this by using an alias for our types.

Use TypeScript to Type React useReducer

Previously, I added some type information for the utility function we are going to look at. By clicking on the function, a lightbulb appears. We can click that and select `Annotate everything with types from JSDoc`. Thanks to our plugin, it will type our function for us. It's not always perfect so double check to make sure it's exactly as you would like. 

Along with the utility function, we are going to look at how to type a `useMemo` hook, a `useCallback` hook, a `useRef` hook, a `useState` hook, and a custom hook.

Type React Hooks using TypeScript

We are going to start refactoring our `CountDisplay` component. It is a small stateless component but it has a few props that can benefit from type safety. 

There are three ways to type a component, inline, alias, and as a function expression. The inline typing adds a bit of noise to our code and can make it difficult to parse right out of the gate. To fix this, we use a type alias that reads a little bit nicer. To add in a function expression, which we get from the React Types that we downloaded, we can declare this variable to have a type of `React.FunctionComponent` which takes as a type argument, our props.

Refactor a React Component using TypeScript

There are a bunch of different ways that you can compile TypeScript and how you go about doing it will depend largely on what build tooling that you use. Since I'm using `rollup` and `babel` already to transpile my TypeScript code, I think it makes sense to utilize babel's typescript preset to handle all of our TypeScript compilation as well. So we will install it with `npm i -D @babel/preset-typescript` and configure it in our `rollup.config.js`.

Configure Build Tools to Work with TypeScript

First things first, let's install TypeScript in our project locally using `npm i -D typescript`. Next, I need to install our type dependencies. We could write our own types, but using type dependencies will speed this up and ease our process. So we will install those types using `npm i -D @types/react @types/react-dom`. 

To have TypeScript in our project, we need to create and configure a `tsconfig.json` file. In this lesson, we will quickly configure the basics.

Install and Configure TypeScript and Dependencies

The pluggable linting utility for JavaScript and JSX.

eslint

One of the other tools I use is Emmet. It's used for writing HTML much more quickly by using shorthand. It can also be used for JSX. VSCode also supports ESLint which we will use and configure in our VSCode `settings.json`. I will also set up Prettier as my default formatter for TypeScript and TypeScript React files. 

Configure Emmet, ESlint, and Prettier Extensions

TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.

typescript

To enhance our experience for coding, we are going to install a couple of extensions for VSCode, the TypeScript Importer and JavaScript and TypeScript Nightly. 

The TypeScript Importer helps you search your project's TypeScript paths as you type to look for models that it can auto-import. 

The JavaScript and TypeScript Nightly tells VSCode to use the very latest version of TypeScript available as its built-in TypeScript version. Only use this when you don't have a local version of TypeScript installed in your project.

Download TypeScript Importer and Javascript and TypeScript Nightly for VSCode

Let's run through the file structure so that you understand what is going on in our application. We will quickly view the src directory which houses our `lib`, `styles`, and `UI`. This course will focus on the components in the `UI` folder. 

Generally, I would start off an application using `create-react-app` which will build out all of the file structure for us for TypeScript but this course will teach you how to implement TypeScript in an already built application.

Walkthrough of the Refactoring Project

This course is split up into two main parts. The first half is the TypeScript compiler and how it fits into your existing build infrastructure and local dev environment. The second half is about refactoring your JavaScript code to TypeScript. 

This course is not an intro to React or TypeScript. If you are struggling to follow along because of this, try checking out one of the intros to React or TypeScript courses here on egghead.

Refactor a React Application to TypeScript

## Intro

TypeScript has been growing in popularity among companies who build their products with React, and for good reason!

Types play nicely when working with components, and lead to a super smooth developer experience.

But what if your application is already being shipped and continuously deployed? It doesn't mean you can't take advantage of everything TypeScript has to offer.

Refactoring an application to TypeScript doesn't have to be daunting. Follow Chance's lead, and you'll be well on your way!

The course starts with an overview of some of Chance's favorite tools and their TypeScript-specific settings. These tools will help you search your project's TypeScript paths for auto-importing, a shorthand tool for writing JSX and TypeScript to speed up your writing, and a tool for helping you to maintain your code to a high quality.

The tools are Emmet, ESLint, Prettier, and a variety of VSCode extensions. There's even some rollup and Babel thrown in for transpiling and compiling our TypeScript to make configuration and build setup a breeze.

## The Project

![https://res.cloudinary.com/dg3gyk0gu/video/upload/e_loop/q_100/v1639426695/course-resources/refactor-react-components-to-typescript-c70bffa0/landing-page-gif.gif](https://res.cloudinary.com/dg3gyk0gu/video/upload/e_loop/q_100/v1639426695/course-resources/refactor-react-components-to-typescript-c70bffa0/landing-page-gif.gif)

Once the tooling is in place, Chance works through converting a completely functional Windows 98-style Minesweeper game away from JS React into one that takes advantage of the power of TypeScript. It'll be clear how changing the JS to TS will not affect the functionality of the game at all but improves the safety of your app. 

Topics in the second half of the course include component refactoring as well as adding types to React Hooks, useReducer, and Context. You'll even see how to add types to a legacy Class component!

Chance has several years of experience working with component libraries and this is your opportunity to learn from his experience and apply his process to your own.

## Gain these Skills

Chance will give you the knowledge of how to incorporate TypeScript into any React application, whether it's shipped and continuously deployed or not. You'll take the practices and tools that you learn here to be much more productive in your TypeScript, wherever you use it. Lastly, He will give you the knowledge of when you see React Types vs your own custom types. 

## Prerequisites

This is not an introduction to React or TypeScript course. You will need to have a basic understanding of the two to be able to follow along. If you don't have that basic understanding, or just want a refresher on the subjects, [The Beginner's Guide to React](https://egghead.io/courses/the-beginner-s-guide-to-react) and [Up and Running with TypeScript](https://egghead.io/courses/up-and-running-with-typescript) are the best two places to start. 

## What's Next?

**[The Beginner's Guide to React](https://egghead.io/courses/the-beginner-s-guide-to-react)** is the best place to go if you are just starting out in React. This course by Kent C. Dodds covers all the basics to get you up and running with React. 

**[Advanced TypeScript Fundamentals](https://egghead.io/courses/advanced-typescript-fundamentals-579c174f)** by Marius Schulz will take you beyond the basics to teach you some new language features TypeScript has to offer courtesy of the wonderful team over ta TypeScript.

[TypeScript: Tips and Tricks](https://egghead.io/courses/typescript-tips-and-tricks-20c4) by Kamran Ahmed is where to go once you've started using TypeScript but looking for that little something to take it to the next level.

When comparing two visually similar websites, it can often be challenging to precisely identify the subtle differences between them. To facilitate a rapid analysis of these discrepancies, a practical technique involves leveraging Chrome's integrated developer tools to capture full-page screenshots of each site. Subsequently, these screenshots can be uploaded to a platform like AI Studio. There, the AI can analyze the images and generate a report detailing the variations. This entire process, leveraging a few quick shortcuts, can be completed in under a minute, delivering a comprehensive breakdown of the differences for efficient comparison and analysis.

Quickly Compare Two Sites Using AI Studio with Chrome Full Page Screenshots

It's fairly trivial to create a React project, but there's always a big hurdle between creating it locally and making it shareable so that someone else can run it. This lesson walks you through the process of automating creating a React project locally, creating the repository where it's going to be hosted, and creating shareable links where it can be run so that you can quickly and easily create single one-off demos and shoot them over to your friends and coworkers for sharing your code ideas in a working environment.


```bash
share-react-project() {
  if [[ -z "$1" ]]; then
    echo "Usage: share-react-project <project_name>"
    return 1
  fi

  local project_name="$1"
  local github_username=$(gh api /user --jq '.login')

  echo "Creating Vite project: $project_name"
  pnpm create vite "$project_name" --template react

  cd "$project_name"

  echo "Initializing Git repository"
  git init

  echo "Adding all files to Git"
  git add .

  echo "Creating initial commit"
  git commit -m "Initial commit"

  local codesandbox_link="https://codesandbox.io/p/github/${github_username}/${project_name}"

  echo "Adding CodeSandbox link to README.md"
  echo "" >> README.md
  echo "## CodeSandbox" >> README.md
  echo "[![Open in CodeSandbox](https://assets.codesandbox.io/github/button-edit-blue.svg)](${codesandbox_link})" >> README.md

  echo "Adding README.md to Git"
  git add README.md

  echo "Committing README.md changes"
  git commit -m "Add CodeSandbox link"

  echo "Creating GitHub repository: $github_username/$project_name"
  gh repo create "$github_username/$project_name" --public

  echo "Pushing to remote 'origin'"
  git push -u origin main

  echo "Project '$project_name' created successfully!"
  echo "GitHub repository: https://github.com/$github_username/$project_name"
  echo "CodeSandbox link: $codesandbox_link"
}
```

Automate Creating a Local React Project, GitHub Repository, and Live Hosted Demo in a Single Command

[Verdaccio](https://verdaccio.org/) is a fully featured NPM registry that you can run locally on your machine. It’s a great tool for testing your release process, running end-to-end tests, and simulating real-world scenarios like deploying packages, installing them, and verifying functionality as an end user would.

Nx includes a [generator](https://nx.dev/features/generate-code) that simplifies setting up Verdaccio. To configure it, run:

```shell
npx nx g @nx/js:setup-verdaccio   
```

This command installs the necessary NPM packages and creates a `project.json` file with a `local-registry` target. To start the local registry, open a new terminal window and run:

```shell
npx nx local-registry
```

This will:
- Launch the Verdaccio registry.
- Configure NPM to point to the local Verdaccio server at `http://localhost:4873`.

> **Note:** A `project.json` file provides an advanced way to define scripts, offering more flexibility than a traditional `package.json` for managing complex targets.

Setup local Verdaccio server to release NPM packages

Learn how to spin up a local NPM registry powered by Verdaccio to test deploy your NPM packages.

In TypeScript, developers often begin by defining the structure of their data using type definitions or interfaces, which is a powerful way to ensure type safety. However, as applications grow and become more complex, simply defining the shape of an object might not be enough to guarantee its consistent creation and behavior throughout the codebase. This often leads to situations where objects that are intended to be of a certain "type" might be missing crucial properties or have incorrect data, which can be difficult to track down and debug.

This lesson tackles the question of when and why to move beyond basic type definitions and embrace classes in TypeScript. It demonstrates how classes provide a more robust mechanism for defining object structure, enforcing type constraints, and ensuring consistent object creation. By establishing a clear blueprint for objects, classes not only improve compile-time type safety but also offer runtime benefits and better code organization, ultimately helping developers avoid common pitfalls associated with loosely structured objects in larger TypeScript projects.

Stop Avoiding Classes in TypeScript

Karabiner isn't only for your keyboard. It can also hijack your mouse buttons and enable them to be similar to layers on your keyboard, where holding down a mouse button can allow you to tap keys on your keyboard to trigger commands and macros that can completely revolutionize your workflows. For example, you can hold down the right mouse button and tap on R to go to references in VS Code. Or hold down the right mouse button and tap the left mouse button to chop up videos and Screenflow.

This completely unlocks a whole new world of possibilities and use cases for your mouse as you can hover your mouse over anywhere on the page. And just tapping keys on your keyboard allows you to trigger mouse actions, to trigger keyboard actions, or to trigger macros and applications and terminal commands. and anything that your imagination can come up with. 

Karabiner: Rethinking Right-Click as a Macro Command Center

Make an HTML table more readable on mobile devices by using the ::before pseudo-element. We add labels to each cell, so they appear like cards when the table is viewed on smaller screens. The ::before content is set using a data-label attribute for each cell to enhance mobile viewability without horizontal scrolling.



Create a mobile friendly table with the before pseudo-element

Learn to use CSS ::before pseudo-element for mobile-friendly HTML tables. Add labels to cells for enhanced readability on mobile, avoiding horizontal scroll.

Any app of a decent size has event flows and messages being passed around. At a certain point it becomes complicated to explain it through prose and you want to turn towards diagrams. Now setting aside the time to create diagrams that accurately describe what's happening in your codebase can be quite time consuming. Luckily, with today's AI tools, we can now just do basic walkthroughs with rough recordings over codebase dictating what's going on along the way and then upload that to tools like AI Studio and then ask it to generate diagrams in a text-based format such as Mermaid that will then generate the flowcharts and diagrams for us. So this video walks us through this process of recording a rough video, uploading it to AI Studio and then asking AI Studio to generate the proper Mermaid diagram syntax.

Generate Mermaid Flow Chart Diagrams with Gemini 2.0 from Rough Screen Recordings

I'm a diehard Karabiner user and anytime I start doing something repetitively I always move it into my Karabiner configuration. Sometimes I'll fall into scenarios where I want to trigger a command, but I also want to know if that command succeeded or failed. Since Karabiner can trigger any command, setting up the command is fairly straightforward, but knowing whether it succeeded or failed became much more difficult. Luckily for me there is a package called terminal-notifier that you can install from homebrew and you can pipe the output of your command to terminal-notifier. And have a seamless way of triggering your keyboard shortcut which runs a command and you can be notified of the results.

Use Karabiner to Trigger a Terminal Command and Get Notified of the Results

There are a lot of scenarios when inspecting a site in Chrome where you don't want any click events to fire and you don't want any scripts to run. Or maybe something is animating in and out of the page and you want to capture it at a certain moment. This is a great use case for pausing script execution, which is kind of using the debugger manually by going into the Chrome DevTools and the Sources tab and clicking the pause button to essentially pause the entire page. This will give you a chance to inspect any of the elements and styles you want to inspect. And you don't have to worry about fire and click events or anything that might interrupt your investigation into the elements and styles that you want to find.

Pause Script Execution in Chrome to Easily Inspect Elements

Gemini 2.0 has a context window of a million tokens, and this means that you can upload hundreds of files and allow it to inspect and analyze massive refactors across entire code bases. 

This lesson demonstrates concatenating an entire code base into a single file and then uploading it to AI Studio. Once within AI Studio, we ask it to find the types of tasks that it can evaluate for us. Then we select one of the tasks and ask it to generate instructions for that task. Once those instructions are complete, we then turn them over to Windsurf's Cascade agent, and we allow Windsurf's Cascade to do all of the work for us as we sit back, relax, and let the AI do our jobs.

Chance Strickland

Search Results

Use TypeScript to Type a React Class Component

Type a Radio Button Component in React using TypeScript

Use TypeScript to Type React useReducer

Type React Hooks using TypeScript

Refactor a React Component using TypeScript

Configure Build Tools to Work with TypeScript

Install and Configure TypeScript and Dependencies

Configure Emmet, ESlint, and Prettier Extensions

Download TypeScript Importer and Javascript and TypeScript Nightly for VSCode

Walkthrough of the Refactoring Project

Refactor a React Application to TypeScript

Refactor a React Application to TypeScript