<h2>Website animations</h2>
In this day and age websites seem to require animations. I would say, depending on what type of website you are going for, animations may be appropriate. In this article let's go over how to trigger animations using React Hooks. We want to be able to control when the user sees the animation. When the user scrolls to a certain section of the website we will slide the element in using CSS.
<h2>Setup</h2>
For this article I will be using React and Tailwind CSS, however you can use whatever CSS you want to use. I will be using a component for Tailwind CSS called @headlessui/react. So let's begin by installing this package.
<pre><code class="hljs language-bash">npm i @headlessui/react</code></pre>
<h2>Slide Component</h2>
So now we have that installed, let's make a component to use Tailwind CSS classes that will animate the element so it will slide into the screen.
<pre><code class="hljs language-javascript">import { Transition } from '@headlessui/react';

interface Props {
 show?: boolean;
 children: React.ReactNode;
}

export default function SlideUp(props: Props) {
 const { show, children } = props;
 return (
 &#x3C;Transition
 show={show}
 enter="transform transition ease-out duration-500"
 enterFrom="opacity-0 translate-y-full"
 enterTo="opacity-100 translate-y-0"
 leave="transform transition ease-out duration-500"
 leaveFrom="opacity-100 translate-y-0"
 leaveTo="opacity-0 translate-y-full"
 >
 {children}
 &#x3C;/Transition>
 );
}</code></pre>
With this component you can define what CSS runs when the boolean show is set to true. Then when it gets set to false it will undo or hide the element.
So when it wants to show it will run this from and to animations class
from
<pre><code class="hljs language-bash">opacity-0 translate-y-full</code></pre>
to
<pre><code class="hljs language-bash">opacity-100 translate-y-0</code></pre>
which will start with a opacity of 0 and slide the element into the view port animating the opacity to 100.
Now let's create a container component to control the show boolean.
<pre><code class="hljs language-javascript">import { useState, useRef } from 'react';
import useTriggerOnScroll from '../../../hooks/useTriggerOnScroll';
import Slide from '../SlideUp';

interface Props {
 className?: string;
 children: React.ReactNode;
}

export default function ScrollSlideUp(props: Props) {
 const { className = '', children } = props;
 const el = useRef();
 const [show, setShow] = useState&#x3C;boolean>(false);
 useTriggerOnScroll(el, (triggered) => {
 setShow(triggered);
 });
 return (
 &#x3C;div className={className} ref={el}>
 &#x3C;Slide show={show}>{children}&#x3C;/Slide>
 &#x3C;/div>
 );
}</code></pre>
This component will wrap around our Transition component. You can setup your own CSS classes, you don't need to use Tailwind for this. This container component will setup a react reference to control the element and use our custom hook to calculate whether or not the element has been scrolled to. If it has then it will call the callback with a triggered boolean. Then with that triggered boolean we can set our Transition component to animate.
<h2>useTriggerOnScroll</h2>
Now let's create our custom hook.
<pre><code class="hljs language-javascript">import { useEffect, useState } from 'react';

function getOffset(el) {
 var _x = 0;
 var _y = 0;
 while (el &#x26;&#x26; !isNaN(el.offsetLeft) &#x26;&#x26; !isNaN(el.offsetTop)) {
 _x += el.offsetLeft - el.scrollLeft;
 _y += el.offsetTop - el.scrollTop;
 el = el.offsetParent;
 }
 return { top: _y, left: _x };
}

function hasScrolledTo(el) {
 if (!el) return false;
 const top = getOffset(el).top;
 const offset = window.innerHeight / 2;
 return top - offset &#x3C;= window.pageYOffset;
}

export default function useTriggerOnScroll(ref, onTrigger) {
 const [triggered, setTriggered] = useState&#x3C;boolean>(false);
 useEffect(() => {
 function onScroll() {
 const viewed = hasScrolledTo(ref.current);
 if (viewed &#x26;&#x26; !triggered) {
 window.removeEventListener('scroll', onScroll);
 setTriggered(true);
 onTrigger(true);
 } else if (!viewed &#x26;&#x26; triggered) {
 window.removeEventListener('scroll', onScroll);
 setTriggered(false);
 onTrigger(false);
 }
 }
 setTimeout(() => {
 window.addEventListener('scroll', onScroll);
 }, 1000);
 return () => {
 window.removeEventListener('scroll', onScroll);
 };
 }, [ref, onTrigger, triggered]);
}</code></pre>
This will setup some helper functions to calculate whether or not the element has been scrolled to. Then we setup a useEffect which creates the window scroll event listener. Anytime the webpage is scrolled it will call our event handler and check if the element has been scrolled to. If it has we set our state to true and call the onTrigger call back, which will then call our container component and animate the element. When the user scrolls back up if will set the show boolean to false and re hide the element.
<h2>Conclusion</h2>
There are many CSS animation libraries and packages out there. This is creating a custom hook to animate anything you want if you need any custom code written. If you have any comments or advice on how you run animations, please feel free to leave a comment.

This article will cover how to setup a React hook to trigger sliding animations.

How to trigger animations using React Hooks

This course requires a subscription to view