Security News
RubyGems.org Adds New Maintainer Role
RubyGems.org has added a new "maintainer" role that allows for publishing new versions of gems. This new permission type is aimed at improving security for gem owners and the service overall.
react-intersection-observer
Advanced tools
Monitor if a component is inside the viewport, using IntersectionObserver API
The react-intersection-observer package is a React implementation of the Intersection Observer API, making it easier to perform actions based on how an element intersects with the viewport. It's useful for lazy loading, infinite scroll, or triggering animations when the user scrolls.
Observing visibility of an element
This feature allows you to track the visibility of a component or element. The `useInView` hook returns a `ref` that you attach to the element you want to observe. It also returns a state `inView` that tells you whether the element is in the viewport or not.
import { useInView } from 'react-intersection-observer';
function Component() {
const { ref, inView } = useInView();
return (
<div ref={ref}>
{inView ? 'In view!' : 'Not in view!'}
</div>
);
}
Triggering animations when entering the viewport
This code sample demonstrates how to use the `useInView` hook to trigger animations or add classes to an element once it enters the viewport. The `threshold` option specifies how much of the element should be visible before `inView` becomes true.
import { useInView } from 'react-intersection-observer';
import { useEffect } from 'react';
function AnimatedComponent() {
const { ref, inView } = useInView({ threshold: 0.1 });
useEffect(() => {
if (inView) {
// Trigger animation or add class
}
}, [inView]);
return <div ref={ref}>Animate me!</div>;
}
This package is designed specifically for lazy loading images in React applications. It provides components like `LazyLoadImage` for easy integration. While it's focused on images, react-intersection-observer offers a more general approach for observing any element's visibility.
React Waypoint is another package for handling the visibility of elements during scroll. It triggers a function when you scroll to an element. Compared to react-intersection-observer, it's less flexible with the observer options but still a solid choice for simple use cases.
React component that triggers a function when the component enters or leaves the viewport. No complex configuration needed, just wrap your views and it handles the events.
Storybook demo: https://thebuilder.github.io/react-intersection-observer/
Install using Yarn:
yarn add react-intersection-observer
or NPM:
npm install react-intersection-observer --save
⚠️You also want to add the intersection-observer polyfill for full browser support. Check out adding the polyfill for details about how you can include it.
The easiest way to use the Observer
, is to pass a function as the child. It
will be called whenever the state changes, with the new value of inView
.
By default it will render inside a <div>
, but you can change the element by setting tag
to the HTMLElement you need.
import Observer from 'react-intersection-observer'
const Component = () => (
<Observer>
{inView => <h2>{`Header inside viewport ${inView}.`}</h2>}
</Observer>
)
export default Component
Using the render prop you can get full control over the output.
In addition to the inView
prop, the render also receives a ref
that should be set on the containing DOM element.
import Observer from 'react-intersection-observer'
const Component = () => (
<Observer
render={({ inView, ref }) => (
<div ref={ref}>
<h2>{`Header inside viewport ${inView}.`}</h2>
</div>
)}
/>
)
export default Component
You can monitor the onChange method, and control the state in your own component. This works with plain children, child as function or render props.
import Observer from 'react-intersection-observer'
const Component = () => (
<Observer onChange={inView => console.log('Inview:', inView)}>
<h2>Plain children are always rendered. Use onChange to monitor state.</h2>
</Observer>
)
export default Component
The <Observer />
accepts the following props:
Name | Type | Default | Required | Description |
---|---|---|---|---|
children | Func/Node | false | Children should be either a function or a node | |
render | ({inView, ref}) => Node | false | Render prop allowing you to control the view. | |
root | HTMLElement | false | The HTMLElement that is used as the viewport for checking visibility of the target. Defaults to the browser viewport if not specified or if null. | |
rootId | String | false | Unique identifier for the root element - This is used to identify the IntersectionObserver instance, so it can be reused. If you defined a root element, without adding an id, it will create a new instance for all components. | |
rootMargin | String | '0px' | false | Margin around the root. Can have values similar to the CSS margin property, e.g. "10px 20px 30px 40px" (top, right, bottom, left). |
tag | String | 'div' | false | Element tag to use for the wrapping element when rendering using 'children'. Defaults to 'div' |
threshold | Number | 0 | false | Number between 0 and 1 indicating the the percentage that should be visible before triggering. Can also be an array of numbers, to create multiple trigger points. |
triggerOnce | Bool | false | false | Only trigger this method once |
onChange | Func | false | Call this function whenever the in view state changes |
This module is used in
react-scroll-percentage
to monitor the scroll position of elements in view, useful for animating items as
they become visible. This module is also a great example of using react-intersection-observer
as the basis for more complex needs.
Intersection Observer is the API is used to determine if an element is inside the viewport or not. Browser support is pretty good, but Safari is still missing support.
You can import the polyfill directly or use a service like polyfill.io to add it when needed.
yarn add intersection-observer
Then import it in your app:
import 'intersection-observer'
If you are using Webpack (or similar) you could use dynamic imports, to load the Polyfill only if needed. A basic implementation could look something like this:
loadPolyfills()
.then(() => /* Render React application now that your Polyfills are ready */)
/**
* Do feature detection, to figure out which polyfills needs to be imported.
**/
function loadPolyfills() {
const polyfills = []
if (!supportsIntersectionObserver()) {
polyfills.push(import('intersection-observer'))
}
return Promise.all(polyfills)
}
function supportsIntersectionObserver() {
return (
'IntersectionObserver' in global &&
'IntersectionObserverEntry' in global &&
'intersectionRatio' in IntersectionObserverEntry.prototype
)
}
FAQs
Monitor if a component is inside the viewport, using IntersectionObserver API
The npm package react-intersection-observer receives a total of 1,090,662 weekly downloads. As such, react-intersection-observer popularity was classified as popular.
We found that react-intersection-observer demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
RubyGems.org has added a new "maintainer" role that allows for publishing new versions of gems. This new permission type is aimed at improving security for gem owners and the service overall.
Security News
Node.js will be enforcing stricter semver-major PR policies a month before major releases to enhance stability and ensure reliable release candidates.
Security News
Research
Socket's threat research team has detected five malicious npm packages targeting Roblox developers, deploying malware to steal credentials and personal data.