InstantSearch.js FAQ

The ratingMenu doesn’t support float values. You can store an integer representation of this value in your records (for example, 0.5 * 10 = 5) and display the original value in your UI.

To search only when the query is longer than a certain length, you can implement a proxy search client. Then, you can add a condition, for example, query.length > 3.

The uiState only works when the widgets responsible for each UI state attribute are mounted. For example, a searchBox widget is necessary to provide a query.

The uiState passed to initialUiState or via routing needs to be nested per index. For example, if you only have a root index called “instant_search”, you should use a value like { instant_search: { query: 'query' } }.

If you want to change, for example, “query into “q” in routing, you need to use the stateMapping functions to:

• first, in stateToRoute, return an object containing “q” for the query,
• then, in routeToState, replace that “q” again with “query”.

If you want to group, for example, “turquoise”, “ocean” and “sky” under “blue”, the recommended solution is to group them at indexing time. You can either add the group name as a separate attribute to globally filter on, or add both values in an array to make both the group and the individual value show up in the list.

For example, with the following dataset:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
[
  {
    "objectID": "1",
    "color": "turquoise"
  },
  {
    "objectID": "2",
    "color": "ocean"
  },
  {
    "objectID": "3",
    "color": "sky"
  }
]

You could create an additional attribute and use it for faceting:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[
  {
    "objectID": "1",
    "color": "turquoise",
    "colorGroup": "blue"
  },
  {
    "objectID": "2",
    "color": "ocean",
    "colorGroup": "blue"
  },
  {
    "objectID": "3",
    "color": "sky",
    "colorGroup": "blue"
  }
]

Or you could list the individual colors and their groups so you can use them both for faceting:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[
  {
    "objectID": "1",
    "color": [
      "turquoise",
      "blue"
    ]
  },
  {
    "objectID": "2",
    "color": [
      "ocean",
      "blue"
    ]
  },
  {
    "objectID": "3",
    "color": [
      "sky",
      "blue"
    ]
  }
]

When the search result is the same, some components (templates) may skip re-render.

You can use a panel widget to access the results, and use the hidden function to hide a refinement based on how many facet values it has:

1
2
3
4
5
6
7
8
9
instantsearch.widgets.panel({
  hidden(options) {
    const facetValues = options.results.getFacetValues('brand');
    return Array.isArray(facetValues) ? facetValues.length <= 1 : false;
  },
})(instantsearch.widgets.refinementList)({
  container: '#brand-list',
  attribute: 'brand',
})

To search only when the query is longer than a certain length, you can use the searchFunction to add a condition in which you don’t call helper.search().

When the dynamicWidgets receives results, it mounts the chosen widgets for that result. An initial search does two network requests. This is because adding a new widget requires a new network request, to know what the refinements are for a facet.

You can avoid this by forcing all facets to be returned by Algolia, or all facets that you maximally want to display the results of. This can be done by adding facets: ['*'] and maxValuesPerFacet using a configure widget:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
search.addWidgets([
  instantsearch.widgets.configure({
    facets: ['*'],
    // the highest value you could mount in "limit"
    maxValuesPerFacet: 10,
  }),
  instantsearch.widgets.dynamicWidgets({
    container: '#dynamic-widgets',
    fallbackWidget: ({ container, attribute }) =>
      instantsearch.widgets.menu({ container, attribute, limit: 10 }),
    widgets: [
      container =>
        instantsearch.widgets.hierarchicalMenu({
          limit: 10,
          attributes: [
            'hierarchicalCategories.lvl0',
            'hierarchicalCategories.lvl1',
          ],
        }),
    ],
  }),
]);

When the dynamicWidgets receives results, it mounts the chosen widgets for that result. To avoid doing an extra network request, facets is set to ['*'] by default.

If you prefer to do two network requests with only the relevant facets returned, you can set facets to [] like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
search.addWidgets([
  instantsearch.widgets.dynamicWidgets({
    container: '#dynamic-widgets',
    facets: [],
    fallbackWidget: ({ container, attribute }) =>
      instantsearch.widgets.menu({ container, attribute, limit: 10 }),
    widgets: [
      container =>
        instantsearch.widgets.hierarchicalMenu({
          limit: 10,
          attributes: [
            'hierarchicalCategories.lvl0',
            'hierarchicalCategories.lvl1',
          ],
        }),
    ],
  }),
]);

More detail on these approaches can be found in the facet display guide.