 Courses from Daishi Kato

Jotai's state management is primitive and flexible. This gives you room to build, compose, and share state throughout your application exactly how you need it.

This flexibility can become hard to manage when you have complex requirements that span across a number of states your application can be in.

Jotai lets you leverage other state management solutions through integrations so that you can solve the problem you're facing exactly how you need to.

One of those integrations is XState. XState gives you a safe abstraction to enumerate and handle the complex states your application can be in.

With Jotai + XState, you get the flexibility and ease of use of Jotai with the power of XState.

XState is a sophisticated library to provide a better and safer abstraction for state management. 

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

Complex State Management in React with Jotai and XState

Statecharts are a formalism for modeling stateful, reactive systems. This is useful for declaratively describing the behavior of your application, from the individual components to the overall application logic.

xstate

Sometimes adding initial values through the jotai Provider is not what you want. Provider will create a whole new store with atom values

One way to initialize a state machine inside Jotai is to turn our initial `lightAtom` into a function `createLightAtom`. This function will take an `initial` property that we can pass to `createLightMachine` when we declare the function. We will then useEffect to initialize our lightMachine.

There is a small limitation with this pattern, the machine is initialized with it's default value and then over ridden with the value we pass in the effect. The initial render will use that default value while the second render will have the value we passed in.


Initialize a Xstate Machine with Jotai Atom in Atom Pattern

We currently have a machine that displays a circle of green. When you click it, it will cycle through green, yellow, and Red.

What if you wanted to pass XState initial values from Jotai, you'll need to use the `initialValues` prop on Jotai Provider and pass a list of pair (atom and value) to it.

To do this we'll refactor the creation of the lightMachine to be a function that accepts an atom as an initial value.

One note to be aware of is that this initial value will only be set when the XState machines instantiate.


Provide XState with Initial Values through Jotai Provider

When you reuse a component, there are times when you’d like that state to share the same values as other instances of that state. In other cases, you want to isolate your state.
With Jotai, you only need to wrap your components that you want to share state in Jotai’s `<Provider>` component the subsequent atom (and XState machine) state is shared for those components.

Share and Isolate XState State using Jotai Provider

Sometimes you need to display values in specific ways throughout your application based on the state that you are managing. The way to do this is to derive your state so you don't have to track multiple stateful items.

In Jotai, this is accomplished by creating an atom, getting the value from another atom that you are managing (in this case from Xstate), and using that value how you need it in your derived atom. This atom will be re-evaluated every time the managed state changes.

This pattern is great to use if you have complex state managed in something like Xstate but need a derived state value that is not strongly tied to that managed state. The pattern works the same for async and synchronous function calls as well as pulling in multiple atoms and libraries to use in your derived state.


Derive Jotai Atom State from Complex State Managed in Xstate 

Jotai has a primitive and flexible API, because of this it's up to you on how you manage your state within an atom. 

Sometimes your state is complex enough to warrant a sophisticated library for safer abstraction. This is where you can install xstate to your application and Jotai will work seamlessly with the state machines that you define using `atomWithMachine`.

This allows you to consume the machine like any other atom in your components with `useAtom`. 

As an added bonus, I'll show you how to use xstate's visualizer to develop and interact with your state machine in dev tools. 


Handle Complex State in Jotai with XState using atomWithMachine

[Screen tearing](https://github.com/reactwg/react-18/discussions/69) is an issue that can crop up when you introduce concurrent rendering into your application. With React 18 coming out, you'll want to know how to handle this issue.

The React team has given us a solution for tearing with `useSyncExternalStore`. When we import his, we just need to pass our store's subscribe and selector functions to solve this issue. The added benefit here is that we can remove our uses of `useCallback` throughout our application.


Prevent Screen Tearing for React 18 in a Zustand-like App with useSyncExternalStore

At this point in our code, we have working module state that is similar to Zustand. If you look closely at the code you’ll notice that we are defining actions in our components. This works for some but you might want to define those actions when you create a store.

We will modify `createStore` to accept a `createState` function and use that function to initialize and update our state. This allows us to define actions while creating a store. We can use those defined actions in our components without having to implement any logic inline.

Define Actions in a Zustand-like Store to Modify React State

We have to functions right now. `createStore` that creates module state and `useStore` that consumes the module state that we created.

The logic is working as expected. State is being properly shared to the components that need it while still isolated from the rest of the app. The issue now is that we have extra re-renders in our application. Each component will rerender when any state changes

To fix this, we'll implement a selector function that will peek the value that you need out of state. This way only the components that depend on the value that is changed will re-render.


Implement Zustand State Selectors in React to Prevent Unneeded Rerenders

We have two components that use the same store. They display the data and update the store when a button is clicked. The logic in each component is the same and can be extracted into a custom hook

In this lesson, we'll extract the store logic into a `useStore` hook and use that custom hook like you would any other React hook. Then we'll extend the behavior of the hook to accept a function to update the previous state value.


Extract Module Logic (like Zustand) into a Custom React Hook

There are many cases where you want to share state between components in React. A lot of popular state management libraries implement this ‘module state’ for you such as Zustand.

We will implement a naive version of a `createStore` function that allows you to share your state between components in React.

`createStore` has a few functions that we return from it: `getState`, `setState`, and `subscribe`. Just like with React Hooks, we can get and set state within components. Because this is shared state, we need to give components a mechanism for updating when state changes in a separate component, that is where `subscribe` comes in. With the combination of these 3 functions, we can display and update a shared value between multiple components in React.

Share Module State Between Components in React Similar to Zustand

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.

Manage Application State 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.


Isolate State in an Application with Jotai Provider

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

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

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

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

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

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 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

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

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.

Daishi Kato

Search Results