npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

react-intersection-observer-ng

v8.22.10

Published

Monitor if a component is inside the viewport, using IntersectionObserver API

Downloads

80

Readme

react-intersection-observer

Version Badge GZipped size Build Status Coverage Statu dependency status dev dependency status License Downloads Greenkeeper badge styled with prettier

React implementation of the Intersection Observer API to tell you when an element enters or leaves the viewport. Contains both a Hooks, render props and plain children implementation.

Storybook Demo: https://thebuilder.github.io/react-intersection-observer/

Features

  • 🎣 Hooks or Component API - With useInView it's easier than ever to monitor elements
  • ⚡️ Optimized performance - Auto reuses Intersection Observer instances where possible
  • ⚙️ Matches native API - Intuitive to use
  • 🌳 Tree-shakeable - Only include the parts you use
  • 💥 Tiny bundle ~1.9 kB gzipped

Installation

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.

Usage

Hooks 🎣

useInView

const [ref, inView, entry] = useInView(options)

The new React Hooks, makes it easier then ever to monitor the inView state of your components. Call the useInView hook, with the (optional) options you need. It will return an array containing a ref, the inView status and the current IntersectionObserverEntry. Assign the ref to the DOM element you want to monitor, and the hook will report the status.

import React, { useRef } from 'react'
import { useInView } from 'react-intersection-observer'

const Component = () => {
  const [ref, inView] = useInView({
    /* Optional options */
    threshold: 0,
  })

  return (
    <div ref={ref}>
      <h2>{`Header inside viewport ${inView}.`}</h2>
    </div>
  )
}

Render props

To use the <InView> component , you pass it a function. It will be called whenever the state changes, with the new value of inView. In addition to the inView prop, children also receives a ref that should be set on the containing DOM element. This is the element that the IntersectionObserver will monitor.

import { InView } from 'react-intersection-observer'

const Component = () => (
  <InView>
    {({ inView, ref }) => (
      <div ref={ref}>
        <h2>{`Header inside viewport ${inView}.`}</h2>
      </div>
    )}
  </InView>
)

export default Component

Plain children

You can pass any element to the <InView />, and it will handle creating the wrapping DOM element. Add a handler to the onChange method, and control the state in your own component. It will pass any extra props to the HTML element, allowing you set the className, style, etc.

import { InView } from 'react-intersection-observer'

const Component = () => (
  <InView as="div" onChange={inView => console.log('Inview:', inView)}>
    <h2>Plain children are always rendered. Use onChange to monitor state.</h2>
  </InView>
)

export default Component

⚠️ When rendering a plain child, make sure you keep your HTML output semantic. Change the as to match the context, and add a className to style the <InView />.

API

Options

Provide these as props on the <InView /> component and as the options argument for the hooks.

| Name | Type | Default | Required | Description | | --------------- | ------------------ | ------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | root | Element | window | false | The Element that is used as the viewport for checking visibility of the target. Defaults to the browser viewport (window) if not specified or if null. | | 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). | | threshold | number | number[] | 0 | false | Number between 0 and 1 indicating the percentage that should be visible before triggering. Can also be an array of numbers, to create multiple trigger points. | | triggerOnce | boolean | false | false | Only trigger this method once |

InView Props

The <InView /> component also accepts the following props:

| Name | Type | Default | Required | Description | | ------------ | ------------------------- | ------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | as | string | 'div' | false | Render the wrapping element as this element. Defaults to div. | | children | Function, ReactNode | | true | Children expects a function that receives an object contain an inView boolean and ref that should be assigned to the element root. Alternately pass a plain child, to have the <Observer /> deal with the wrapping element. You will also get the IntersectionObserverEntry as entry, giving you more details. | | **onChange** | (inView, entry) => void` | | false | Call this function whenever the in view state changes |

Testing

In order to write meaningful tests, the IntersectionObserver needs to be mocked. If you are writing your tests in Jest, you can use the included test-utils.js. It mocks the IntersectionObserver, and includes a few methods to assist with faking the inView state.

test-utils.js

Import the methods from react-intersection-observer/test-utils.

mockAllIsIntersecting(isIntersecting:boolean)
Set the isIntersecting on all current IntersectionObserver instances.

mockIsIntersecting(element:Element, isIntersecting:boolean)
Set the isIntersecting for the IntersectionObserver of a specific element.

intersectionMockInstance(element:Element): IntersectionObserver
Call the intersectionMockInstance method with an element, to get the (mocked) IntersectionObserver instance. You can use this to spy on the observe and unobserve methods.

Test Example

import React from 'react'
import { render } from 'react-testing-library'
import { useInView } from 'react-intersection-observer'
import { mockAllIsIntersecting } from 'react-intersection-observer/test-utils'

const HookComponent = ({ options }) => {
  const [ref, inView] = useInView(options)
  return <div ref={ref}>{inView.toString()}</div>
}

test('should create a hook inView', () => {
  const { getByText } = render(<HookComponent />)

  // This causes all (existing) IntersectionObservers to be set as intersecting
  mockAllIsIntersecting(true)
  getByText('true')
})

Built using react-intersection-observer

Sticks 'n' Sushi

The new brand site for Sticks 'n' Sushi is filled with scroll based animations. All of these are triggered by react-intersection-observer, with react-scroll-percentage controlling the animations.

Intersection Observer

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.

Polyfill

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:

/**
 * Do feature detection, to figure out which polyfills needs to be imported.
 **/
async function loadPolyfills() {
  if (typeof window.IntersectionObserver === 'undefined') {
    await import('intersection-observer')
  }
}