Learn Auth0, Vue and Xstate

Vue (pronounced /vjuː/, like view) is a progressive framework for building user interfaces. Unlike other monolithic frameworks, Vue is designed from the ground up to be incrementally adoptable. The core library is focused on the view layer only, and is very easy to pick up and integrate with other libraries or existing projects. On the other hand, Vue is also perfectly capable of powering sophisticated Single-Page Applications when used in combination with modern tooling and supporting libraries.

There are several components from the `@tresjs/cientos` that you can use to enhance your **TresJS 3D scenes**.

- `ContactShadows` for performant fake shadows
- Wrap models with `Levioso` for subtle floating animations
- Add real HTML markup to your animations with `HTML`

Using these abstractions from `@tresjs/cientos`, you can create polished **3D experiences**.

Enhance Your TresJS Scenes with the @tresjs/cientos Package

In this **TresJS** lesson you will see how to connect a 3D model to your application state. You'll learn to:

- Access your model's material colors using the `materials` property from `useGLTF`
- Use Vue's `watch` function to update the model's colors when the user changes the selection in the UI

This allows you to create an interactive 3D experience that responds to user input.

Connect a TresJS Model with Vue State

In this lesson, you'll learn how to create a reactive color selector in Vue using the `useState` composable function. We'll cover:

- Creating a shared state that contains base colors and a selected base color
- Using the `toRefs` utility to convert reactive properties to refs
- Importing and using the `useState` composable in components
- Iterating through colors to create buttons
- Assigning click event handlers to update the selected color reactively

Create a Reactive Color Selector in Vue with useState

In this **TresJS** tutorial, we'll explore how to find and use free 3D models in GLTF format from sites like:

- [poly.pizza](https://poly.pizza/)
- [Sketchfab](https://sketchfab.com/)
- [pmndrs Market](https://market.pmnd.rs/)

We'll then cover using the `useGLTF` composable from `drei-sfc` to load models asynchronously, handling it gracefully with Vue's `<Suspense>` component. 

Once loaded, you will see how to explore the object and get the model node you're looking for. Then, you'll pass that node to the Vue `primitive` component's `:object` prop to render the model. 

By the end of the lesson, you'll be ready to start adding awesome 3D models to your own TresJS projects!

Load Models with useGLTF and the TresJS primitive Component

This is an overview of the [TresJS project template](https://github.com/alvarosabu/egghead-tres-3D-product-configurator/tree/main/lessons/starter).

The template is styled with the atomic CSS framework, [UnoCSS](https://unocss.dev), and comes with a default TresJS scene setup, including:

- a perspective camera
- ambient light
- directional light

There is also a color selector initially implemented using an array of colors and a `ref` variable for the selected color. Each color is rendered as a circle. 

Project Overview of the TresJS Product Template

In this **TresJS** lesson you will learn how to use `OrbitControls` from the [@tresjs/cientos](https://cientos.tresjs.org/) package to add interactivity to your scenes by:

- Importing `OrbitControls`
- Adding it below your `TresPerspectiveCamera` component

The `@tresjs/cientos` package is part of the TresJS ecosystem and provides useful abstractions and composables to extend the core framework. 


Use OrbitControls to Interact with your TresJS Scene

In this **TresJS** lesson, we explore how to animate 3D objects in a scene using the render loop. 

We'll cover:

- Using the `useRenderLoop` composable and `onLoop` callback to run code every frame
- Creating refs with `useRef` to reference and modify 3D object properties like position and rotation
- Handling varying device frame rates with `delta` or `elapsed` time for consistent animation speed

By the end of the video, you'll be ready to create smooth animations in your own TresJS scenes.

Animate TresJS Objects with the useRenderLoop Composable

In this **TresJS** lesson, you'll learn how to **enable shadows** in your 3D scenes. 

We'll cover: 
- the `shadows` prop to turn on shadows
- the `cast-shadow` property for lights
- and the `cast-shadow` and `receive-shadow` properties for meshes. 

You will see how to adjust light intensity, position, and object placement to **control the appearance of shadows**. By the end, you'll understand the key aspects of configuring shadows in TresJS scenes.

Enable Shadows in Your TresJS Scene

This TresJS lesson teaches you the basics of lighting 3D scenes. 

You'll learn how to:

- add ambient lights for overall lighting `<TresAmbientLight />`
- add directional lights for light from a specific direction `<TresDirectionalLight />`
- change light color and intensity using theprops. 

You will also see how materials, such as the `<TresMeshStandardMaterial>`, work with the lights in your scene.

Add Ambient and Directional Lighting to Your TresJS Scene

This TresJS lesson shows you how to transform 3D objects in your scene. You'll learn how to:

*   Adjust an object's position with `TresMesh`'s `position`, `scale`, and `rotation` props   
*   Use the `TresAxesHelper` component to guide object transformations in 3D space
    

Transform TresJS Objects Using Props

Learn how to add a 3D cube to your TresJS scene using the `TresMeshComponent`, `TresBoxGeometry`, and `TresMeshNormalMaterial` components. 

This lesson shows TresJS's declarative approach that makes 3D rendering simpler than using plain Three.js.

Add a Cube to Your TresJS 3D Scene

[TresCanvas](https://docs.tresjs.org/api/tres-canvas) is a Vue.js component that wraps the Three.js renderer. 

It can be imported, added to templates, and customized with props like background color and window size.

Add a TresCanvas to Your Vue App

[Link to the course repo](https://github.com/alvarosabu/egghead-tres-3D-product-configurator)

Our goal is to create an application that allows the user to customize a 3D product with different color materials visually. The first step is setting up the starter to follow up during the course

In this first lesson, we will download the course repo ‣. The repo is a monorepo containing all the lessons available for this course. When you clone it you are going to find

Getting Started with the TresJS Product Course Repo

Create Interactive 3D Experiences with TresJS

An easy to implement, adaptable authentication and authorization platform which basically makes your login box awesome.



auth0

After a user successfully logs in, Auth0 sends an ID token to your React application. Auth0, uses ID Tokens to cache user profile information and give it to a client application. The caching of ID tokens can improve the performance and responsiveness of your React application.

You can use the data from the ID token to personalize the user interface of your application. The Auth0 React SDK decodes the ID token and stores its data in the user object from the `useAuth0()` React hook. 

Customize UI With ID Token Data From The useAuth0 Hook's User Object

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

You can log out users from your React application by logging them out of their Auth0 sessions using the `logout()` method from the Auth0 React SDK.

Create a `logout-button.js` file in the src/components/buttons folder

Create a logout button component with the following code

```js
import { useAuth0 } from "@auth0/auth0-react";
import React from "react";

export const LogoutButton = () => {
  const { logout } = useAuth0();

  const handleLogout = () => {
    logout({
      logoutParams: {
        returnTo: window.location.origin,
      },
    });
  };

  return (
    <button className="button__logout" onClick={handleLogout}>
      Log Out
    </button>
  );
};
```

The `logout() method from Auth0 React SDK clears the application session and redirects to the Auth0 /v2/logout endpoint to clear the Auth0 session.

You can pass an object argument to `logout()` to customize the logout behavior of the React application. You can define a `logoutParams` property on that object to define parameters for the /v2/logout call. This process is invisible to the user. 

Pass the `logoutParams.returnTo` option to specify the URL where Auth0 should redirect your users after they log out. 

Setting `logoutParams.returnTo` to `window.location.origin` will ensure that Auth0 redirects your users to your production URL that you add to the "Allowed Logout URLs" list.




End Auth0 User Session with the logout Method from useAuth0 Hook

In this lesson, we create an AuthenticationGuard file that uses the Auth0React SDK to protect React routes by requiring login. 

You need to create the AuthenticationGuard component, pass in a component prop, and use it to protect any React route. 

```js
import { withAuthenticationRequired } from "@auth0/auth0-react";
import React from "react";
import { PageLoader } from "./page-loader";

export const AuthenticationGuard = ({ component }) => {
  const Component = withAuthenticationRequired(component);

  return <Component />;
};
```

Will also demonstrates how to use the AuthenticationGuard component to protect the profile, and admin routes in the application. 

```js
import { useAuth0 } from "@auth0/auth0-react";
import React from "react";
import { Route, Routes } from "react-router-dom";
import { PageLoader } from "./components/page-loader";
import { AuthenticationGuard } from "./components/authentication-guard";
import { AdminPage } from "./pages/admin-page";
import { CallbackPage } from "./pages/callback-page";
import { HomePage } from "./pages/home-page";
import { NotFoundPage } from "./pages/not-found-page";
import { ProfilePage } from "./pages/profile-page";
import { ProtectedPage } from "./pages/protected-page";
import { PublicPage } from "./pages/public-page";

export const App = () => {

  return (
    <Routes>
      <Route path="/" element={<HomePage />} />
      <Route
        path="/profile"
        element={<AuthenticationGuard component={ProfilePage} />}
      />
      <Route path="/public" element={<PublicPage />} />
      <Route
        path="/protected"
        element={<AuthenticationGuard component={ProtectedPage} />}
      />
      <Route
        path="/admin"
        element={<AuthenticationGuard component={AdminPage} />}
      />
      <Route path="/callback" element={<CallbackPage />} />
      <Route path="*" element={<NotFoundPage />} />
    </Routes>
  );
};

```

Use Auth0 component withAuthenticationRequired To Protect React Router 6 Routes

The `isAuthenticated` value represents the authentication state of your users it's tracked by the Auth0 React SDK. This value returns `true` when the user has been authenticated and `false` they're when not. Use `isAuthenticated` to render UI elements conditionally depending on the authentication state of your users.

```js
import { useAuth0 } from "@auth0/auth0-react";
import React from "react";
import { LoginButton } from "../../buttons/login-button";
import { LogoutButton } from "../../buttons/logout-button";
import { SignupButton } from "../../buttons/signup-button";

export const NavBarButtons = () => {
  const { isAuthenticated } = useAuth0();

  return (
    <div className="nav-bar__buttons">
      {!isAuthenticated && (
        <>
          <SignupButton />
          <LoginButton />
        </>
      )}
      {isAuthenticated && (
        <>
          <LogoutButton />
        </>
      )}
    </div>
  );
};
```
Authentication process doesn’t happen in your React application when using Auth0. Your React application will redirect your users to the Auth0 Universal Login page. Auth0 asks for credentials and redirects the user back to your application with the result of the authentication.


Use the Value of isAuthenticated to Render Components Conditionality

Create a `signup-button.js` file under the src/components/buttons folder

Add the following code:

```js
import { useAuth0 } from "@auth0/auth0-react";
import React from "react";

export const SignupButton = () => {
  const { loginWithRedirect } = useAuth0();

  const handleSignUp = async () => {
    await loginWithRedirect({
      appState: {
        returnTo: "/profile",
      },
      authorizationParams: {
        screen_hint: "signup",
      },
    });
  };

  return (
    <button className="button__sign-up" onClick={handleSignUp}>
      Sign Up
    </button>
  );
};
```
Adding `authorizationParams` to the `loginWithRedirect()` configuration object with the `screen_hint ` property and a value of `signup` will take users from your React application to the sign-up page.

Pass authorizationParams to loginWithRedirect to Direct Users to Auth0 Sign Up

Create a buttons folder the src/components folder

Create a `login-button.js` file and add the following code:

```js
import { useAuth0 } from "@auth0/auth0-react";
import React from "react";

export const LoginButton = () => {
  const { loginWithRedirect } = useAuth0();

  const handleLogin = async () => {
    await loginWithRedirect({
      appState: {
        returnTo: "/profile",
      },
    });
  };

  return (
    <button className="button__login" onClick={handleLogin}>
      Log In
    </button>
  );
};
```

`loginWithRedirect()` redirects to the Auth0 /authorize endpoint to start the authentication process. You can pass a configuration object to this method to customize the login experience.

Setting up the value of `appState.returnTo` to "/profile", you are telling the Auth0 React SDK to: When my users log in with Auth0 and return to my React application, take them to the "Profile" page.

If you don't set up this `appState.returnTo` option, your users will be redirected by default to the / path after they log in.

Apply useAuth0 hook and loginWithReditect to Add User Login to React Application

Install the Auth React SDK on the terminal 

```bash
npm install @auth0/auth0-react
```

Create an `auth0-provider-with-navigate.js` file in the src folder.

Add the following code.

```js
import { Auth0Provider } from "@auth0/auth0-react";
import React from "react";
import { useNavigate } from "react-router-dom";

export const Auth0ProviderWithNavigate = ({ children }) => {
  const navigate = useNavigate();

  const domain = process.env.REACT_APP_AUTH0_DOMAIN;
  const clientId = process.env.REACT_APP_AUTH0_CLIENT_ID;
  const redirectUri = process.env.REACT_APP_AUTH0_CALLBACK_URL;

  const onRedirectCallback = (appState) => {
    navigate(appState?.returnTo || window.location.pathname);
  };

  if (!(domain && clientId && redirectUri)) {
    return null;
  }

  return (
    <Auth0Provider
      domain={domain}
      clientId={clientId}
      authorizationParams={{
        redirect_uri: redirectUri,
      }}
      onRedirectCallback={onRedirectCallback}
    >
      {children}
    </Auth0Provider>
  );
};
```

Wrap the `Auth0ProviderWithNavigate` component around the `App` component inside of `index.js` to give it access to the `Auth0Context`.

`Auth0ProviderWithNavigate` needs the `BrowserRouter` component from React Router to be its parent, grandparent, or great-great-great-grandparent.


Install Auth0 React SDK and Create Auth0Provider with Access to Session History

I've been using Cursor for a very long time and their "Agent" feature in Composer is fairly new, so I'm still getting used to it. But since Windsurf recently got onto the stage with their Cascade agent, they've slowly been gaining the mind share on the UX for coding agents. I decided to put them to the test by putting Windsurf and Cursor on the exact same screen side by side trying to accomplish the same task and to see which workflow I would prefer. I've been a diehard Cursor user for over a year now, so it's going to take a lot for me to switch to a different IDE. But I just have to say, even from this simple demo, Windsurf is looking pretty nice.

This lesson is just going to walk through creating a CLI using both tools to print out inspirational quotes and to explore how they approach the step-by-step of installing packages and running commands and setting up all the files we need to get this running.

Windsurf Cascade vs. Cursor Composer Agent Side-by-Side Comparison

This TypeScript tutorial explains how to use generics, allowing for different types to be passed as arguments. It discusses the use of shorthand syntax in generics and illustrates with examples. This method is useful for library creation, providing type safety and control to the user.

```typescript
interface PhotoMetadata<T> {
  title: string;
  takenAt: Date;
  customData: T;
}

// Function that processes a photo with custom metadata
function processPhoto<T>(photo: PhotoMetadata<T>): {
  processedTitle: string;
  daysSinceCapture: number;
  customDataSummary: T;
} {
  const today = new Date();
  const daysSinceCapture = Math.floor(
    (today.getTime() - photo.takenAt.getTime()) / (1000 * 60 * 60 * 24)
  );

  return {
    processedTitle: photo.title.toUpperCase(),
    daysSinceCapture,
    customDataSummary: photo.customData
  };
}

// Example usage with different custom data shapes
type CameraSettings = {
  iso: number;
  aperture: string;
  shutterSpeed: string;
}

type LocationData = {
  latitude: number;
  longitude: number;
  locationName: string;
}

// Using with camera settings
const photoWithCamera: PhotoMetadata<CameraSettings> = {
  title: "Sunset at beach",
  takenAt: new Date('2024-01-15'),
  customData: {
    iso: 100,
    aperture: "f/2.8",
    shutterSpeed: "1/1000"
  }
};

// Using with location data
const photoWithLocation: PhotoMetadata<LocationData> = {
  title: "Mountain vista",
  takenAt: new Date('2024-02-01'),
  customData: {
    latitude: 45.5231,
    longitude: -122.6765,
    locationName: "Mount Hood"
  }
};

const processedCameraPhoto = processPhoto(photoWithCamera);
const processedLocationPhoto = processPhoto(photoWithLocation);

processedCameraPhoto.customDataSummary.iso
processedLocationPhoto.customDataSummary.longitude

```

Basic Explanation of Typescript Generics

A very basic explanation of generic function arguments

I've been using Cursor as my primary editor for over a year now, but recently I've heard wonderful things about Windsurf AI Agent features. I decided to record myself building out something I've always wanted to make, but never made the time for.

In this lesson, I demonstrate how to leverage Windsurf's powerful agent process to create a fun word-guessing game inspired by Heads Up. Watch as I build an interactive application featuring category selection and word navigation, complete with data hosting on GitHub Gists and deployment to GitHub Pages - all in under 30 minutes (before editing the lesson down to 12 minutes)!

What makes this project particularly exciting is how Windsurf eliminates the typical friction points of development. While this game was always on my project wishlist, the overhead of setup, configuration, and deployment made it hard to justify the time investment. Windsurf's agent process handles all these pain points seamlessly, from managing URLs to orchestrating deployment.

This lesson perfectly showcases how AI agents can help developers bring their backlog of project ideas to life, transforming what would typically be time-consuming tasks into efficient, enjoyable development experiences.

Build a Word Game with Windsurf's Cascade AI Agent



Discover how to harness the power of Cursor IDE's Composer Agent feature to optimize your code. In this lesson, you'll witness an AI agent doing all the work to generate test suites, implement performance benchmarks, and create optimized function variations - all without writing a single line of code. You'll learn how to validate performance improvements through data-driven benchmarking, ensuring that optimizations are backed by concrete metrics rather than speculation. This hands-on demonstration showcases a groundbreaking approach to automated function development that combines the precision of test-driven development with the efficiency of AI-powered optimization.


Agent-Driven Development in Cursor: Testing, Benchmarking, and Optimizing Functions

This course is aimed for using `zod` effectively in projects based on TypeScript (both browser and node.js). The benefits you gain with this course is not just simply coding, but also understanding when/why/how should you perform runtime validation.

`zod` is the missing piece to TypeScript's capabilities, which can guarantee type-safety only in compile-time.

`zod` can be used whenever the compiler cannot guarantee what happens in runtime. And... it's a very frequent usecase, such as HTTP calls, websockets, etc.

In this course you get quickly up and running by:
1. using `zod` with primitives and objects
2. adapting `zod` quickly to existing projects thanks to automatic generators
3. changing the strategy frm type-first to schema-first
4. using error-throwing `parse` or non-error-throwing `safeParse` basing on your needs
5. applying `zod` to the most common usecase - validating API responses
6. handling errors the most convenient way (out of many!)

Take advantage of runtime validation with `zod`. Take advantage of the detailed lessons in this course 🔥

Effective Runtime Type Checks with Zod


Cursor can now automatically run commands in the terminal and walk step-by-step towards building out your entire project. You give it a goal, then it will suggest the commands you need to run and the files that you need to create and you can work with it to achieve what you're building. This lesson does a quick walkthough of using a Cursor Agent to build a project from scratch and guide it along the way. Cursor Agents definitely feel like a sneak peek at the future of programming!

Cursor Agents Initial Impressions - Allow an AI to Build Your Entire Project

Mock Service Worker is an API mocking library that allows you to write client-agnostic mocks and reuse them across any frameworks, tools, and environments.



Mocking WebSocket APIs with Mock Service Worker


While using anonymous functions might seem convenient, they can create difficulties when trying to identify performance bottlenecks during profiling. This lesson will demonstrate how named functions make it easier to pinpoint and address performance issues, ultimately leading to more efficient and debuggable code. Learning this practice will greatly improve your ability to locate and fix performance issues in complex projects.

Always Name Functions in JavaScript


When attempting to load the same module twice in JavaScript you'll hit a cache and code won't re-run. In scenarios where you actually do want to have state in your modules, you'll have to use a cache-busting technique by passing a query parameter to a dynamic import. This lesson walks through how to add a query parameter, how to add the appropriate types for loading dynamic modules in TypeScript, and when these techniques are valuable.

Import the Same JavaScript Module Multiple Times with Cache Busting



The include keyword in GitHub Actions empowers you to add custom variables to your matrix strategy, providing flexibility beyond standard configurations. In this video, we'll explore how include allows you to define specific combinations of variables, enhancing control over your workflow runs. You'll see how this feature enables you to tailor jobs for unique environments or scenarios not covered by the default matrix options. By leveraging include, you can efficiently manage complex build processes with greater precision. This technique helps you streamline your CI/CD pipeline, making it more adaptable to your project's evolving needs.

Search

Search Results