Course overview

How to work with course materials

Introduction

Setting up Developer Environment

Setting up Initial Project

How to Use ESLint and Prettier Together in a React Project

How to Configure React to Use TypeScript

How to Add Jest to a React Project for Automated Testing

Setting up developer environment

Building React Hooks: API Considerations and Best Practices

How to Implement a Custom useBoolean React Hook

Testing a Custom useBoolean Hook With React Testing Library

How to Implement a Custom useMap Hook With Tests

How to Quickly Import Custom React Hooks With an Index File

Implement an Object Returning API With a react-hanger Clone

Development of custom hooks

CommonJS vs ES6: An Intro to JavaScript Module Systems

What is Transpilation? An Intro to Transpilers vs Compilers

An Intro to Transpilers: ESBuild, Babel, and SWC Compared

What are Babel Transforms and Plugins?

A Beginner's Guide to JavaScript Bundlers

How to Simplify Bundling React Code With Microbundle

How to Add TypeScript Build Steps to React

How to Implement Babel Build Steps in a React App

Conclusion

Preparing code for publishing

Add Continuous Integration to a React Build With GitHub Actions

How to Automatically Generate a React App Changelog

How to Publish a React Library to NPM With GitHub Actions

Publishing the Code

In this course we’ll build a set of custom reusable hooks, a mini react-hanger clone, essentially going from nothing to a fully-automated publishing pipeline that follows the best practices.  We will cover common Hooks APIs every React developer should know, then dive straight into implementing Custom React Hooks, similar to what you will find in leading React libraries in the open source React ecosystem.

## Why this course
React Hooks promise to eliminate the difficulties of sharing state without writing class-based components. The challenge is that Hooks do away with the lifecycle methods and class-based semantics of state management that many React developers were familiar with.  Learning React Hooks on your own can be time consuming, confusing and frustrating.  With that in mind, The newline Guide to Creating a React Hooks Library, was created to provide a complete tutorial that fully covers React Hooks.  Within a few hours you'll have a strong grasp on React Hooks and how to implement them.

## Course Topics
This course packs practical hands-on-instruction using and building React Hooks, along with the best practices you need to build wider React Hooks libraries others across your organization can use.
The first module provides an overview of the React Hooks library project we’ll build, and we'll set up a complete environment with tools for library development.
The subsequent modules then take you through building with React Hooks and creating your React Hooks library, including:
- Hooks API fundamentals
- Developing custom React Hooks
- How to write reusable React Hooks
- Common React Hooks mistakes to avoid in your code
- Transpilers and bundlers for JavaScript libraries
- Using GitHub Actions to test, build, and lint your library
- Publish your React Hooks library to NPM

We’ll use tools including React, TypeScript, Babel, as well as GitHub Actions to build, test, and package a React Hooks library available for others to download from NPM.  Ultimately, build your own React Hooks library and learn the best practices that will make your code reusable. With these skills, you can contribute more confidently to any React codebase using React Hooks, and make your team more productive.

This course is a complete step-by-step guide to coding custom React Hooks and building a Hooks library from scratch.  Confidently master React Hooks, a transformative update added since React version 16.8, that makes it much easier to reuse code as your React codebase grows.

The newline Guide to Creating a React Hooks Library

Common React Hooks mistakes to avoid in your code

Transpilers and bundlers for JavaScript libraries

Using GitHub Actions to test, build, and lint your library

First of all, we need to install all the required dependencies in 

 to test our hooks, and delete the useless 

 set of libraries, they are basically a set of wrappers around DOM selectors and other custom selectors that make testing more user-behavior-centric.

By "user-behavior-centric" I mean its API is designed in such a way that components are selected by user-centric terms like 

 or plain old CSS selector. Tests will look like a high-level user interaction scenario. These scenarios are way more important to the user, and hence the developer, than any of the implementation details, which they wouldn't be losing any sleep over.

It's about letting your tests give you the confidence that they are intended to. Since implementation details are not under test, we can easily refactor our components or even change an underlying framework without changing any of the test cases and assertions, changing only the preparation phase of the tests.

These libraries are absolute gold, and if you're still using 

 for unit testing your React components, you would do well to change to 

If we're testing functions (meaning unit tests rather than integration tests) we need to go down to the raw variables, reference comparisons etc. In the case of hooks testing, to avoid rendering some dummy components, we're going to use 

 package, which is essentially a set of helpers to test hooks in isolation. The authors of the library recommend, and I concur, that you should only use that for highly reusable hooks or hooks libraries such as we're writing now. In other scenarios you should test the whole component instead, using just 

Okay. I think we've cleared everything up here, so let's start writing tests!

 block, and all cases need to be checked using 

---
title: Testing a Custom useBoolean Hook With React Testing Library
isPublicLesson: false
privateVideoUrl: https://fullstack.wistia.com/medias/9sdstee4u3
---

First of all, we need to install all the required dependencies in `package.json` to test our hooks, and delete the useless `index.test.ts` from the root.

```json
{
  "devDependencies": {
    "@testing-library/react-hooks": "3.3.0",
    "react-dom": "^16.8.0",
    "react-testing-library": "^16.8.0"
  }
}
```

If you're not familiar with the `@testing-library` set of libraries, they are basically a set of wrappers around DOM selectors and other custom selectors that make testing more user-behavior-centric.

By "user-behavior-centric" I mean its API is designed in such a way that components are selected by user-centric terms like `findByLabel` or `findByText` rather than `React.displayName` or plain old CSS selector. Tests will look like a high-level user interaction scenario. These scenarios are way more important to the user, and hence the developer, than any of the implementation details, which they wouldn't be losing any sleep over.

It's about letting your tests give you the confidence that they are intended to. Since implementation details are not under test, we can easily refactor our components or even change an underlying framework without changing any of the test cases and assertions, changing only the preparation phase of the tests.

These libraries are absolute gold, and if you're still using `enzyme` for unit testing your React components, you would do well to change to `@testing-library/react` as soon as possible.

If we're testing functions (meaning unit tests rather than integration tests) we need to go down to the raw variables, reference comparisons etc. In the case of hooks testing, to avoid rendering some dummy components, we're going to use `@testing-library/react-hooks` package, which is essentially a set of helpers to test hooks in isolation. The authors of the library recommend, and I concur, that you should only use that for highly reusable hooks or hooks libraries such as we're writing now. In other scenarios you should test the whole component instead, using just `@testing-library/react`.

Okay. I think we've cleared everything up here, so let's start writing tests!

We're going to create `useBoolean.test.ts` file in `__tests__` folder, alongside our `useBoolean.ts` file.

We should add a `describe` block, and all cases need to be checked using `it` blocks.

```ts
describe("useBoolean array", () => {});
```

Now let's write the first case inside the `describe` block: that our hook should set true when we call `setTrue` action. This is how it will look:

```ts
import { renderHook, act } from "@testing-library/react-hooks";
import { useBoolean } from "./useBoolean";

describe("useBoolean array", () => {
  it("should set true", () => {
    const { result } = renderHook(() => useBoolean(false));
    const [, actions] = result.current;

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

The newline Guide to Creating a React Hooks Library

WELCOMEIntroduction

Introduction:

Start Here

Module 1: Introduction

Introduction:

Course overview

Lesson 1: (0:38)

How to work with course materials

Module 2: Setting up developer environment

Lesson 1: (3:39)

Setting up Developer Environment

Lesson 2:

Setting up Initial Project

Lesson 3: (11:40)

How to Use ESLint and Prettier Together in a React Project

Lesson 4: (5:04)

How to Configure React to Use TypeScript

Lesson 5: (4:38)

How to Add Jest to a React Project for Automated Testing

Module 3: Development of custom hooks

Lesson 1: (6:27)

Building React Hooks: API Considerations and Best Practices

Lesson 2:

How to Implement a Custom useBoolean React Hook

Lesson 3: (15:41)

Testing a Custom useBoolean Hook With React Testing Library

Lesson 4:

How to Implement a Custom useMap Hook With Tests

Lesson 5: (6:25)

How to Quickly Import Custom React Hooks With an Index File

Lesson 6:

Implement an Object Returning API With a react-hanger Clone

Module 4: Preparing code for publishing

Lesson 1:

CommonJS vs ES6: An Intro to JavaScript Module Systems

Lesson 2:

What is Transpilation? An Intro to Transpilers vs Compilers

Lesson 3:

An Intro to Transpilers: ESBuild, Babel, and SWC Compared

Lesson 4:

What are Babel Transforms and Plugins?

Lesson 5:

A Beginner's Guide to JavaScript Bundlers

Lesson 6:

How to Simplify Bundling React Code With Microbundle

Lesson 7:

How to Add TypeScript Build Steps to React

Lesson 8:

How to Implement Babel Build Steps in a React App

Lesson 9:

Conclusion

Module 5: Publishing the Code

Lesson 1:

Add Continuous Integration to a React Build With GitHub Actions

Lesson 2:

How to Automatically Generate a React App Changelog

Lesson 3:

How to Publish a React Library to NPM With GitHub Actions

Testing a Custom useBoolean Hook With React Testing Library