react-select-async-paginate

What is react-select-async-paginate?

The react-select-async-paginate package is a React component that extends the functionality of react-select to support asynchronous loading and pagination of options. This is particularly useful for large datasets where loading all options at once would be inefficient.

What are react-select-async-paginate's main functionalities?

Asynchronous Loading

This feature allows you to load options asynchronously from an API endpoint. The `loadOptions` function fetches data from the server based on the search query and the current page, enabling efficient data loading.

```jsx
import React from 'react';
import AsyncPaginate from 'react-select-async-paginate';

const loadOptions = async (searchQuery, loadedOptions, { page }) => {
  const response = await fetch(`https://api.example.com/data?page=${page}&query=${searchQuery}`);
  const responseJSON = await response.json();

  return {
    options: responseJSON.data,
    hasMore: responseJSON.hasMore,
    additional: {
      page: page + 1,
    },
  };
};

const MyComponent = () => (
  <AsyncPaginate
    loadOptions={loadOptions}
    additional={{ page: 1 }}
  />
);

export default MyComponent;
```

Pagination

Pagination is built into the asynchronous loading feature. The `loadOptions` function handles pagination by keeping track of the current page and fetching the next set of options when needed.

```jsx
import React from 'react';
import AsyncPaginate from 'react-select-async-paginate';

const loadOptions = async (searchQuery, loadedOptions, { page }) => {
  const response = await fetch(`https://api.example.com/data?page=${page}&query=${searchQuery}`);
  const responseJSON = await response.json();

  return {
    options: responseJSON.data,
    hasMore: responseJSON.hasMore,
    additional: {
      page: page + 1,
    },
  };
};

const MyComponent = () => (
  <AsyncPaginate
    loadOptions={loadOptions}
    additional={{ page: 1 }}
  />
);

export default MyComponent;
```

Custom Option Rendering

This feature allows you to customize how options are rendered in the dropdown. The `components` prop can be used to pass a custom option component, enabling you to display additional information or custom styles.

```jsx
import React from 'react';
import AsyncPaginate from 'react-select-async-paginate';

const loadOptions = async (searchQuery, loadedOptions, { page }) => {
  const response = await fetch(`https://api.example.com/data?page=${page}&query=${searchQuery}`);
  const responseJSON = await response.json();

  return {
    options: responseJSON.data,
    hasMore: responseJSON.hasMore,
    additional: {
      page: page + 1,
    },
  };
};

const customOption = (props) => (
  <div>
    <img src={props.data.image} alt={props.data.label} />
    <span>{props.data.label}</span>
  </div>
);

const MyComponent = () => (
  <AsyncPaginate
    loadOptions={loadOptions}
    additional={{ page: 1 }}
    components={{ Option: customOption }}
  />
);

export default MyComponent;
```

Other packages similar to react-select-async-paginate

react-select

react-select is a flexible and beautiful Select Input control for ReactJS with multiselect, autocomplete, async and creatable support. While it supports asynchronous loading, it does not have built-in pagination support like react-select-async-paginate.

react-virtualized-select

react-virtualized-select combines react-select and react-virtualized to handle large lists efficiently by rendering only the visible items. It does not support asynchronous loading out of the box but is optimized for performance with large datasets.

react-windowed-select

react-windowed-select is a fork of react-select that uses react-window for windowing large lists. It is similar to react-virtualized-select but uses a different underlying library for virtualization. It does not support asynchronous loading natively.

README

react-select-async-paginate

Wrapper above react-select that supports pagination on menu scroll.

Installation

npm install react-select react-select-async-paginate

or

yarn add react-select react-select-async-paginate

Usage

AsyncPaginate is an alternative of Select.Async but supports loading page by page. It is wrapper above default react-select thus it accepts all props of default Select except options and isLoading. And there are some new props:

• loadOptions

Required. Async function that take two arguments:

1. Current value of search input.
2. Loaded options for current search.

It should return next object:

{
  options: [{ label: 'label', value: 'value' }, ...],
  hasMore: true/false,
}

It similar to loadOptions from Select.Async but there is some differences:

1. Loaded options as 2nd argument.
2. Not supports callback.
3. Should return hasMore for detect end of options list for current search.

• cacheUniq

Not required. Can take any value. When this prop changed, AsyncPaginate cleans all cached options.

• selectRef

Ref for take react-select instance.

Example

import 'react-select/dist/react-select.css';
import AsyncPaginate from 'react-select-async-paginate';

...

/*
 * assuming the API returns something like this:
 *   const json = {
 *     results: [
 *       {
 *         value: 1,
 *         label: 'Audi',
 *       },
 *       {
 *         value: 2,
 *         label: 'Mercedes',
 *       },
 *       {
 *         value: 3,
 *         label: 'BMW',
 *       },
 *     ],
 *     has_more: true,
 *   };
 */

async function loadOptions(search, loadedOptions) {
  const response = await fetch(`/awesome-api-url/?search=${search}&offset=${loadedOptions.length}`);
  const responseJSON = await response.json();

  return {
    options: responseJSON.results,
    hasMore: responseJSON.has_more,
  };
}

<AsyncPaginate
  value={value}
  loadOptions={loadOptions}
  onChange={setValue}
/>