react-infi-scroller
TypeScript icon, indicating that this package has built-in type declarations

2.0.1 • Public • Published

React Infi Scroller

npm npm

React-based infinite scroll component that just works. It supports window and scrollable nodes, without inline style for height.

Installation

To install the component, run:

npm install react-infi-scroller

How to use

To import the component in your project:

import InfiScroller from 'react-infi-scroller';

Use InfiScroller on the window object:

import React, { useState } from 'react';
import InfiScroller from 'react-infi-scroller';
 
const MyComponent = () => {
  const generateItems = (items = [], length = 30) => {
    const nextItems = [...items];
    for (let i = 0; i < length; i += 1) {
      nextItems.push(items.length + i);
    }
    return nextItems;
  };
  const [items, setItems] = useState(generateItems());
  const [hasMore, setHasMore] = useState(true);
 
  return (
    <InfiScroller
      hasMore={hasMore}
      onLoadMore={() => {
        const nextItems = generateItems(items);
        setItems(nextItems);
        setHasMore(nextItems.length < 300);
      }}
    >
      <ul>
        {items.map((item) => (
          <li
            key={item}
            style={{ height: 100 }}
          >
            {`Item ${item}`}
          </li>
        ))}
      </ul>
    </InfiScroller>
  );
};

Use InfiScroller on a custom scroll target (like a modal):

import React, { useState, useRef } from 'react';
import InfiScroller from 'react-infi-scroller';
 
const MyComponent = () => {
  const generateItems = (items = [], length = 30) => {
    const nextItems = [...items];
    for (let i = 0; i < length; i += 1) {
      nextItems.push(items.length + i);
    }
    return nextItems;
  };
  const [items, setItems] = useState(generateItems());
  const [hasMore, setHasMore] = useState(true);
  const refComponent = useRef(null);
 
  return (
    <div ref={refComponent}>
      <InfiScroller
        scrollTarget={refComponent.current}
        hasMore={hasMore}
        onLoadMore={() => {
          const nextItems = generateItems(items);
          setItems(nextItems);
          setHasMore(nextItems.length < 300);
        }}
      >
        <ul>
          {items.map((item) => (
            <li
              key={item}
              style={{ height: 100 }}
            >
              {`Item ${item}`}
            </li>
          ))}
        </ul>
      </InfiScroller>
    </div>
  );
};

Use multiple InfiScroller components with custom scroll targets:

import React, { useState, useRef } from 'react';
import InfiScroller from 'react-infi-scroller';
 
const MyComponent = () => {
  const generateItems = (items = [], length = 30) => {
    const nextItems = [...items];
    for (let i = 0; i < length; i += 1) {
      nextItems.push(items.length + i);
    }
    return nextItems;
  };
  const [items, setItems] = useState(generateItems());
  const [hasMore, setHasMore] = useState(true);
  const [otherItems, setOtherItems] = useState(generateItems());
  const [hasMoreOther, setHasMoreOther] = useState(true);
  const refItemsWrapper = useRef(null);
  const refOtherItemsWrapper = useRef(null);
  
  /* Styles for the scroll targets used below
  <style>
    .items-scroller {
      height: 300px;
      overflow: auto;
      background-color: white;
    }
 
    .other-items-scroller {
      height: 500px;
      margin-top: 40px;
      overflow: auto;
      background-color: white;
    }
  </style>
  */
 
  return (
    <div>
      <div
        ref={refItemsWrapper}
        className="items-scroller"
      >
          <InfiScroller
            scrollTarget={refItemsWrapper.current}
            hasMore={hasMore}
            onLoadMore={() => {
              const nextItems = generateItems(items);
              setItems(nextItems);
              setHasMore(nextItems.length < 300);
            }}
          >
            <ul>
              {items.map((item) => (
                <li
                  key={item}
                  style={{ height: 100 }}
                >
                  {`Item ${item}`}
                </li>
              ))}
            </ul>
          </InfiScroller>
      </div>
 
      <div
        ref={refOtherItemsWrapper}
        className="other-items-scroller"
      >
          <InfiScroller
            scrollTarget={refOtherItemsWrapper.current}
            hasMore={hasMoreOther}
            onLoadMore={() => {
              const nextOtherItems = generateItems(otherItems);
              setOtherItems(nextOtherItems);
              setHasMoreOther(nextOtherItems.length < 120);
            }}
          >
            <ul>
              {otherItems.map((otherItem) => (
                <li
                  key={otherItem}
                  style={{ height: 100 }}
                >
                  {`Other Item ${otherItem}`}
                </li>
              ))}
            </ul>
          </InfiScroller>
      </div>
    </div>
  );
};

Use InfiScroller with a spinner/loader:

import React, { useState } from 'react';
import InfiScroller from 'react-infi-scroller';
 
const MyComponent = () => {
  const generateItems = (items = [], length = 30) => {
    const nextItems = [...items];
    for (let i = 0; i < length; i += 1) {
      nextItems.push(items.length + i);
    }
    return nextItems;
  };
  const [items, setItems] = useState(generateItems());
  const [hasMore, setHasMore] = useState(true);
 
  return (
    <InfiScroller
      hasMore={hasMore}
      onLoadMore={() => {
        const nextItems = generateItems(items);
        setItems(nextItems);
        setHasMore(nextItems.length < 300);
      }}
    >
      <ul>
        {items.map((item) => (
          <li
            key={item}
            style={{ height: 100 }}
          >
            {`Item ${item}`}
          </li>
        ))}
      </ul>
 
      {hasMore && (
        <span>Loading...</span>
      )}
    </InfiScroller>
  );
};

Props

Name Type Default Description
children Node | NodeList The content in the infinite scroller. Contains the list of items you want to trigger infinite scrolling for.
scrollTarget Node null The scroll target. Can be set to a custom scrollable node or omitted/null. When omitted/null the window object is used as scroll target.
debounceDelay Number 300 Debounce delay (in milliseconds) to optimize high-frequency scroll events. A recommended delay of 300 milliseconds is set by default.
gutter Number 10 Additional space (in pixels) used in the default shouldLoadMore calculation. Increasing it will cause the onLoadMore callback to be called before the scrollbar has reached the bottom of the scrollTarget. The larger the number, the earlier the onLoadMore callback will be called. A recommended minimum gutter of 10 pixels is set by default.
immediate Boolean false Whether to trigger an initial check, before any scroll event, if onLoadMore callback should be called. Set it to truewhen you want onLoadMore to be called immediately after the scrollTarget is mounted. This can be useful in case the scrollbar has been preset to the bottom of the scrollTarget or the content of the scrollTarget is less than its height and no scroll exist for it yet.
active Boolean true Turn on/off the infinite scroller. Keeps the component's children visible. Attaches event listeners when set to true. Detaches event listeners when set to false. Useful when the infinite scroller is placed inside a modal and you want it disabled until the modal is activated.
hasMore Boolean false Whether there are more items to load. This flag is used to determine if onLoadMore should be called. The entire check looks like this hasMore && shouldLoadMore(...).
shouldLoadMore
(
 scrollTargetHeight: number,
 scrollYOffset: number,
 gutter: number,
 scrollHeight: number
) => boolean
(
 scrollTargetHeight,
 scrollYOffset,
 gutter,
 scrollHeight
) => (
  scrollTargetHeight
  + scrollYOffset
  + gutter
  >= scrollHeight
)
Determine if more items should be loaded. By default a scrollTargetHeight + scrollYOffset + gutter >= scrollHeight formula is used. Provide a different function to customize this behavior. Note that shouldLoadMore will be called only if hasMore is true.
onLoadMore () => void Called when hasMore && shouldLoadMore(...) is true. You should load and render more items in the infinite scroller when onLoadMore is called.

Package Sidebar

Install

npm i react-infi-scroller

Weekly Downloads

36

Version

2.0.1

License

MIT

Unpacked Size

22.6 kB

Total Files

7

Last publish

Collaborators

  • neven_dyulgerov