Infinite Scroll

Overview

The infinite list is a very common pattern to display a list of results. Most of the times this pattern comes with two variants:

• with a button to click on at the end of the list of results
• with a listener on the scroll event that is called when the list of results reaches the end

We can cover those two different implementations with React InstantSearch. The former is covered by the built-in InfiniteHits widget and the latter is covered by the InfiniteHits connector. In this guide we will focus on the second implementation using the Intersection Observer API. We choose to use a browser API in the example but the concepts can be applied to any kind of infinite scroll library. You can find the complete example on GitHub.

Note that the Intersection Observer API isn’t yet widely supported. You may want to consider using a polyfill. Here the compatibility table to find more information about its support.

Display a list of hits

The first step to create our infinite scroll component is to render the results with the InfiniteHits connector. We have an external Hit component but it’s not the point of this guide, the intent is to keep the code simple. You can find more information about the connectors API in the dedicated guide about widget customisation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import React, { Component } from 'react';
import { connectInfiniteHits } from 'react-instantsearch-dom';
import Hit from './Hit';

class InfiniteHits extends Component {
  render() {
    const { hits } = this.props;

    return (
      <div className="ais-InfiniteHits">
        <ul className="ais-InfiniteHits-list">
          {hits.map(hit => (
            <li key={hit.objectID} className="ais-InfiniteHits-item">
              <Hit hit={hit} />
            </li>
          ))}
        </ul>
      </div>
    );
  }
}

export default connectInfiniteHits(InfiniteHits);

Track the scroll position

Once we have our list of results the next step is to track the scroll position to determine when the rest of the content needs to be loaded. For this purpose, we use the Intersection Observer API. To track when the bottom of the list enters inside the viewport we observe a “sentinel” element. We use this trick to avoid observing all the items of our results. We can reuse the same element across the different renders. You can find more information about this pattern on the Web Fundamentals website.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class InfiniteHits extends Component {
  sentinel = null;

  render() {
    const { hits } = this.props;

    return (
      <div className="ais-InfiniteHits">
        <ul className="ais-InfiniteHits-list">
          {hits.map(hit => (
            <li key={hit.objectID} className="ais-InfiniteHits-item">
              <Hit hit={hit} />
            </li>
          ))}
          <li
            className="ais-InfiniteHits-sentinel"
            ref={c => (this.sentinel = c)}
          />
        </ul>
      </div>
    );
  }
}

Once we have the ref of our “sentinel” element we can create the Intersection Observer instance to observe when the element enter or not inside the page. You can provide options to the Intersection Observer API don’t hesitate to adjust the example to your needs.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class InfiniteHits extends Component {
  onSentinelIntersection = entries => {
    entries.forEach(entry => {
      if (entry.isIntersecting) {
        // In that case we can refine
      }
    });
  };

  componentDidMount() {
    this.observer = new IntersectionObserver(this.onSentinelIntersection);

    this.observer.observe(this.sentinel);
  }

  render() {
    const { hits } = this.props;

    return (
      <div className="ais-InfiniteHits">
        <ul className="ais-InfiniteHits-list">
          {hits.map(hit => (
            <li key={hit.objectID} className="ais-InfiniteHits-item">
              <Hit hit={hit} />
            </li>
          ))}
          <li
            className="ais-InfiniteHits-sentinel"
            ref={c => (this.sentinel = c)}
          />
        </ul>
      </div>
    );
  }
}

Last but not least don’t forget to clear the observer once the component is unmounted.

1
2
3
4
5
6
7
8
9
class InfiniteHits extends Component {
  componentWillUnmount() {
    this.observer.disconnect();
  }

  render() {
    // ...
  }
}

Retrieve more results

Now that we are able to track when we reach the end of our results we can hook the refineNext function inside the callback function onSentinelIntersection. But we should only trigger the function when we still have results to retrieve. For this use case the connector provide a prop hasMore that indicates if we still have results or not.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class InfiniteHits extends Component {
  onSentinelIntersection = entries => {
    const { hasMore, refineNext } = this.props;

    entries.forEach(entry => {
      if (entry.isIntersecting && hasMore) {
        refineNext();
      }
    });
  };

  render() {
    // ...
  }
}

Go further than 1000 hits

By default Algolia limits the number of hits you can retrieve for a query to 1000; when doing an infinite scroll, you usually don’t want to go over this limit.

1
2
3
$index->setSettings([
  'paginationLimitedTo' => 1000
]);

1
2
3
index.set_settings({
  paginationLimitedTo: 1000
})

1
2
3
4
5
index.setSettings({
  paginationLimitedTo: 1000
}).then(() => {
  // done
});

1
2
3
index.set_settings({
    'paginationLimitedTo': 1000
})

1
2
3
4
5
6
7
8
let settings = Settings()
  .set(\.paginationLimitedTo, to: 1000)

index.setSettings(settings) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
index.setSettings(
  new JSONObject().put("paginationLimitedTo", 1000)
);

1
2
3
4
IndexSettings settings = new IndexSettings();
settings.PaginationLimitedTo = 1000;

index.SetSettings(settings);

1
2
3
index.setSettings(
  new IndexSettings().setPaginationLimitedTo(1000)
);

1
2
3
res, err := index.SetSettings(search.Settings{
  opt.PaginationLimitedTo(1000),
})

1
2
3
4
5
client.execute {
  changeSettings of "myIndex" `with` IndexSettings(
    paginationLimitedTo = Some(1000)
  )
}

1
2
3
4
5
val settings = settings {
    paginationLimitedTo = 1000
}

index.setSettings(settings)

Disabling the limit does not mean that we will be able to go until the end of the hits, but just that Algolia will go as far as possible in the index to retrieve results in a reasonable time.

That’s it! Now you should have a complete infinite scroll experience! Don’t forget that the complete source code of the example is available on GitHub.