jotai is a primitive and flexible state management solution for React. 

jotai gives you a minimalistic API that you can use that separates your state management from your UI. You get the benefits of well manages state AND you don't have to set up any boilerplate like defining actions, reducers, dispatchers, or stores. 

You create an atom and you're off to the races managing your application state.

In this course, you'll build an SVG drawing application. You'll see how you can represent the canvas as state through atoms and add svg path, change the path colors, delete, and even undo actions. You'll sum up your learning by learning how jotai can isolate state in your applications by using and composing Providers.

You'll be able to use the concepts you learn here to manage any state in your own application.

Jotai is a state management library for React. You will learn how it can be used instead of useState for shared state.

We'll start with two `Counter` components that each have their own React `useState` instance which isolates the state to that component. To share state, we'll create an `atom` from jotai and replace the `useState` calls to `useAtom`, and that's it, you have shared state.


Share State Between React Components with Jotai useAtom

Derived atoms can be created from other atoms. To do so, you pass a read function as the first argument which is traditionally called `get`. this will allow you to retrieve any other atom and transform the data received. 

The derived atom can be used just like a normal atom but this way lets you easily separate logic outside of a component.

Derive State from a Jotai Atom in React

We have a naive SVG app that can draw dots onto a canvas as the mouse scrolls over. You’ll notice as you drag the mouse around the canvas that the commit count in the top left corner increases. This is because the SVG component rerenders on every dot that’s drawn.

The rerenders are due to the fact that we are using the `dotsAtom` directly in the component. This is where write-only atoms come in handy. They can receive a write function that will handle the updates to your atom state which will fix the rerender issue.

We will also cover how to compose write-only atoms to add functionality.

Prevent Rerenders and Add Functionality with Jotai Write-only Atoms

Right now, the app that we have built draws dots on SVG on canvas. As you start applications you'll often find working in one file works the best to build something quickly. There comes a point when you need to move code out of the single file and structure it.

First, we'll see how the app has been refactored into 3 files. We are able to export the atoms and components that are needed throughout our app while keeping internal logic isolated in the file meaning not all atoms are exported.

Next, we'll create a new atom that takes a set of points and generates a path. You'll see how to create new functionality through an atom and import it into another component that's using Jotai atoms.

Structure Jotai Atoms and Add Functionality to a React App

In the previous lessons, we’ve been able to create and render shapes by storing the data needed into a Jotai atom. You’ll notice that each time you draw a path that the previous path is cleared. This is because we are setting the new path in the old path’s place, it's gone forever.

We can preserve state by aggregating atoms into another single atom by pushing them into an array. Once we have this array, we can map over the array in a new component to draw as many paths as you would like

Preserve State by Combining Multiple Jotai Atoms into One Atom

Atoms can take just about anything as input, this includes other Atoms as well! You will see how we can take an atom, `ShapeAtom`, as input so that we can highlight the shape that we select.

To do this, we will need to export two functions for you to consume elsewhere. One that sets the the input (an atom) as the atom contained within our newly created atom. The other function will determine if a current shape is selected or not. This will be done by deriving the selected atom from our newly created atom and returning a boolean if it matches the original shape.

With these two functions we can apply additional styles to shapes that are selected.

Add Additional Functionality by Creating Jotai Atoms that Hold Atoms

We added the ability to select an SVG by creating a new atom that holds an atom that you select. With this we can build additional functionality like setting the color of the SVG path.

In this lesson, we will update ShapeAtom to have an optional `color` property and create a new atom to set that property. You'll see how we can create a `Controls` Component that will interact with an SVG Path component through the `setColorAtom` atom. We can get the currently selected path with `selectedShapeAtomAtom` and control the properties of the atom within.

Compose Jotai Atoms to Update Atom Values From Different React Components

We will look at how to delete a shape that we have stored in an array. You'll see how we can continue building functionality by composing atoms together to achieve what we want. 

For this feature, we will need to create a few atoms to add the functionality needed. We will start by creating `selectedAtom` and `unselectAtom`. `selectedAtom` is a getter for the selected Shape and `unselectAtom` will be used to clear the selection when an atom is deleted.

When these two functions are set, we can create a `deleteSelectedShapeAtom` which will filter out the selected atom that is held in `shapeAtomsAtom`.  And finally, we'll wire this up to a button to actually use!  

Delete Data in a Jotai Atom by Composing and Filtering Atoms

Often times you'll want the user of your application to be able to undo an action that they've taken. Adding this feature requires you to keep track of the actions that have occurred and what state the application was in at each action. 

To solve this, you'll need to store the history in some way. With Jotai, because the atoms that you are using are immutable you can save a snapshot of an atom when an action is taken and store that for use later on.

We will replace the previous `shapesAtomsAtom` that stored the array of our svg shapes with a `historyAtom` that will add each snapshot of the canvas to an array. We can then export a new `shapesAtomsAtom` that will behave exactly like the previous one as well as a `saveHistoryAtom` that we can use when we update our state. This will allow implementing an `undoHistory` atom that will remove any shapes or colors that we don't want to use on our canvas.

Undo Actions on State by Implementing an undoHistory Feature with Jotai Atoms

Now that we have a lot of functionality finished for this example, we'd like to create multiple components (or multiple canvases) that you can draw on.

You'll notice that if you do that right now, drawing on one will draw on the other because state is global to the entire application.

Jotai exposes a `Provider` component that allows you to wrap any part of your application that you want to isolate state to.


Manage Application State with Jotai Atoms

Instructor

Course Content