 Courses from Rory Smith

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

In React Transition Group, enter and exit transitions occur by default. However, sometimes that may not be the required behaviour. In this lesson, let’s take a look at how to change this behaviour, using the `enter`, and `exit` props.

Disable RTG enter and/or exit Transitions using the `enter`, and `exit` Props

In React Transition Group, there are six ‘lifecycle’ props at our disposal: `onEnter`, `onEntering`, `onEntered`; `onExit`, `onExiting`, and `onExited`. In this lesson, let’s take a look at how we can fine-tune our transition’s behaviour by using these props, in situations where we may want certain events to occur during or after a transition.

Fine-tune Transitions with React Transition Group’s Lifecycle Props

In React Transition Group, it’s possible to use JSS to write transitions. In this lesson, we’re going to write a transition using JSS to find out how it differs from writing standard CSS or inline styles.

Write Transitions with React Transition Group using JSS

In React Transition Group, there are two components at our disposal for transitions of singular components; `<Transition>` and `<CSSTransition>`. In this lesson, we’re going to discuss the key feature that CSSTransition has over Transition, i.e. forcing reflows to make more complex transitions more predictable. We’ll also look at how to use the key props of any transition; `in`, `timeout`, and `children`. 

Transition a React Component using CSS with RTG’s `CSSTransition` component 

In React Transition Group, it can be a common situation for a transition to appear when the component renders, rather than wait for any state to change based on, for example, a button click. Should we want the component to show on mounting, instead of waiting for any state to change, we can make use of the `appear` prop, which adds two targetable classnames; `*-appear` and `*-appear-active`.

Show React Transition Group Elements with an Initial Transition with the `appear` Prop

In React Transition Group, There are two components available to use for transitioning single children; `<Transition>` and `<CSSTransition>`. However, what if we want to transition a list of elements? For that, we need to make use of the `<TransitionGroup>` component. In this lesson, we’re going to use this component to transition items in a list of elements in and out of the DOM. 

Transition Items within a List with React Transition Group

In React Transition Group, the `<TransitionGroup>` component uses a standard `<div>` as its container element. This can be changed to whichever HTML element you like. This can be very important for accessibility and maintaining DOM readability. We can also pass `null` as the `component`, which means no container element is used at all. This can be important for styling.

Render a Different HTML Element as the `<TransitionGroup>` Container Element

It’s possible to use React Transition Group for transitions between pages. This can be a clever and useful boost to overall user experience in your app. In this lesson, we’re going to transition between pages using React Transition Group and React Router 4. 

Transition between Pages with React Transition Group and React Router

It’s possible to use React Transition Group alongside Styled Components. This can be useful should you want to use `<CSSTransition>` but are also taking advantage of the Styled Components library. In this lesson, we are going to take a look at the `styled-transition-group` library in order to achieve this.

Use React Transition Group alongside the Styled Components library

In this course, we are going to learn about the fantastic React Transition Group library.

React Transition Group allows us to transition components in and out of the DOM in a declarative, neat, and efficient way.

I've personally used React Transition Group in my work as a front end developer, and usage of the library has allowed me to improve the user interface of several projects simply by applying subtle transitions with React Transition Group.

In this course we're going to concentrate on the `CSSTransition` and `TransitionGroup` components of React Transition Group. I'm going to be using a menu component to show you how React Transition Group works, hopeful that you can apply the same approaches to your own user interfaces with your own CSS transitions.

We're going to be looking at practical examples like using transitions with CSS-in-JS, and transitioning pages alongside react-router.

I hope you enjoy experimenting with React Transition Group alongside me. Animation brings user interface to life!

Course Overview: Create Smooth, Performant Transitions with React Transition Group v2

React Transition Group gives you the power to transition React components in and out of the DOM, depending on the state they’re tied to, with no weird hacks. Without React Transition Group, you may find yourself using a lot of `display: none` in your CSS, along with some pretty nasty `setTimeout` hacks. But with it, you can write your transition elements with a neat, declarative, all-new API — and no hacks in sight. 

You’ll get to explore v2 of the API in this course, as Rory Smith shows you how to use the React Transition Group library to write seamless, performant, beautiful transitions of elements in and out of the DOM. (i.e. no more jumping from state to state without warning.)

You’ll learn the features of React Transition Group in depth, so that you can turn features of your React app from dull and boring to slick and seamless.

Create Smooth, Performant Transitions with React Transition Group v2

Ultra high-performance, professional-grade HTML5 animation for the modern web

greensock

In this lesson, we will look at Greensock's Draggable API. We will implement a scrollable `<div>` container and explore some options available.

Create scrollable DOM elements with Greensock

Cascading Style Sheets bring order and beauty to our applications.

What happens if our grid items are in implicitly created tracks? Let’s learn how to handle the situation in which we may not have accounted for grid items to show.

Specify the sizes of implicitly created grid tracks

Using the `grid` shorthand property, we can set all of the explicit grid properties (`grid-template-rows`, `grid-template-columns`, and `grid-template-areas`), all the implicit grid properties (`grid-auto-rows`, `grid-auto-columns`, and `grid-auto-flow`), and the gutter properties (`grid-column-gap` and `grid-row-gap`) in a single declaration.

Specify many grid properties at once with the grid shorthand

As with flex items, we can set an `order` value on grid items. Let’s see how this affects the DOM and the appearance of our grid.

Re-order the appearance of grid items using the order property

We can specify grid columns, rows, and areas in one property using the `grid-template` shorthand.

Specify grid columns, rows, and areas at once with the grid-template shorthand

It’s possible to position a grid item anywhere on a grid track. To do this, let’s specify some `grid-template-columns` and `grid-template-rows`, and to the grid items, we’ll pass `grid-column` and `grid-row` some numeric values.

Place grid items on a grid using grid-column and grid-row

It’s beautifully straightforward to add a gutter to our grid layout. Let’s apply one with `grid-gap`.

Specify a grid gutter size with grid-gap

We can change the automatic behaviour of what order our grid items appear. We can even re-order the items in our grid to fill available space using the `dense` keyword. How do we approach this using `grid-auto-flow`?

Change the auto-placement behaviour of grid items with grid-auto-flow

A grid item can also be a grid container! Let’s see how to specify a grid within a grid.

Nest a grid within a grid

There’s an unfamiliar `fr` unit pertinent to CSS Grid, which allows us to specify a fractional unit of space. Let’s see how to apply it.

Refer to fractions of available space with the fr unit

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.

Rory Smith

Search Results