instantsearch.js 4.56.5 → 4.56.7

package/dist/instantsearch.development.js

@@ -1,4 +1,4 @@
-/*! InstantSearch.js 4.56.5 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch.js */
+/*! InstantSearch.js 4.56.7 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch.js */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   typeof define === 'function' && define.amd ? define(factory) :
@@ -5590,12 +5590,14 @@
       return target;
     }
 
+    // eslint-disable-next-line no-restricted-syntax
     for (var key in source) {
       if (
         !Object.prototype.hasOwnProperty.call(source, key) ||
         key === '__proto__' ||
         key === 'constructor'
       ) {
+        // eslint-disable-next-line no-continue
         continue;
       }
 
@@ -5603,6 +5605,7 @@
       var targetVal = target[key];
 
       if (typeof targetVal !== 'undefined' && typeof sourceVal === 'undefined') {
+        // eslint-disable-next-line no-continue
         continue;
       }
 
@@ -5629,11 +5632,10 @@
    * - treats sparse arrays as sparse
    * - does not convert Array-like objects (Arguments, NodeLists, etc.) to arrays
    *
-   * @param {Object} object The destination object.
+   * @param {Object} target The destination object.
    * @param {...Object} [sources] The source objects.
    * @returns {Object} Returns `object`.
    */
-
   function merge(target) {
     if (!isObjectOrArrayOrFunction(target)) {
       target = {};
@@ -5656,8 +5658,8 @@
   var defaultsPure = function defaultsPure() {
     var sources = Array.prototype.slice.call(arguments);
 
-    return sources.reduceRight(function(acc, source) {
-      Object.keys(Object(source)).forEach(function(key) {
+    return sources.reduceRight(function (acc, source) {
+      Object.keys(Object(source)).forEach(function (key) {
         if (source[key] === undefined) {
           return;
         }
@@ -5672,7 +5674,7 @@
   };
 
   function intersection(arr1, arr2) {
-    return arr1.filter(function(value, index) {
+    return arr1.filter(function (value, index) {
       return (
         arr2.indexOf(value) > -1 &&
         arr1.indexOf(value) === index /* skips duplicates */
@@ -5693,6 +5695,8 @@
         return array[i];
       }
     }
+
+    return undefined;
   };
 
   function valToNumber(v) {
@@ -5704,7 +5708,9 @@
       return v.map(valToNumber);
     }
 
-    throw new Error('The value should be a number, a parsable string or an array of those.');
+    throw new Error(
+      'The value should be a number, a parsable string or an array of those.'
+    );
   }
 
   var valToNumber_1 = valToNumber;
@@ -5718,6 +5724,7 @@
     var i;
     for (i = 0; i < sourceKeys.length; i++) {
       key = sourceKeys[i];
+      // eslint-disable-next-line no-continue
       if (excluded.indexOf(key) >= 0) continue;
       target[key] = source[key];
     }
@@ -5770,9 +5777,9 @@
 
       var valueAsString = '' + value;
 
-      var facetRefinement = !refinementList[attribute] ?
-        [valueAsString] :
-        refinementList[attribute].concat(valueAsString);
+      var facetRefinement = !refinementList[attribute]
+        ? [valueAsString]
+        : refinementList[attribute].concat(valueAsString);
 
       var mod = {};
 
@@ -5789,18 +5796,22 @@
      * @param {string} [value] the value of the refinement
      * @return {RefinementList} a new and updated refinement lst
      */
-    removeRefinement: function removeRefinement(refinementList, attribute, value) {
+    removeRefinement: function removeRefinement(
+      refinementList,
+      attribute,
+      value
+    ) {
       if (value === undefined) {
         // we use the "filter" form of clearRefinement, since it leaves empty values as-is
         // the form with a string will remove the attribute completely
-        return lib.clearRefinement(refinementList, function(v, f) {
+        return lib.clearRefinement(refinementList, function (v, f) {
           return attribute === f;
         });
       }
 
       var valueAsString = '' + value;
 
-      return lib.clearRefinement(refinementList, function(v, f) {
+      return lib.clearRefinement(refinementList, function (v, f) {
         return attribute === f && valueAsString === v;
       });
     },
@@ -5811,8 +5822,13 @@
      * @param {string} value the value of the refinement
      * @return {RefinementList} a new and updated list
      */
-    toggleRefinement: function toggleRefinement(refinementList, attribute, value) {
-      if (value === undefined) throw new Error('toggleRefinement should be used with a value');
+    toggleRefinement: function toggleRefinement(
+      refinementList,
+      attribute,
+      value
+    ) {
+      if (value === undefined)
+        throw new Error('toggleRefinement should be used with a value');
 
       if (lib.isRefined(refinementList, attribute, value)) {
         return lib.removeRefinement(refinementList, attribute, value);
@@ -5831,8 +5847,14 @@
      * @param {string} [refinementType] optional parameter to give more context to the attribute function
      * @return {RefinementList} a new and updated refinement list
      */
-    clearRefinement: function clearRefinement(refinementList, attribute, refinementType) {
+    clearRefinement: function clearRefinement(
+      refinementList,
+      attribute,
+      refinementType
+    ) {
       if (attribute === undefined) {
+        // return the same object if the list is already empty
+        // this is mainly for tests, as it doesn't have much impact on performance
         if (!objectHasKeys_1(refinementList)) {
           return refinementList;
         }
@@ -5842,23 +5864,32 @@
       } else if (typeof attribute === 'function') {
         var hasChanged = false;
 
-        var newRefinementList = Object.keys(refinementList).reduce(function(memo, key) {
+        var newRefinementList = Object.keys(refinementList).reduce(function (
+          memo,
+          key
+        ) {
           var values = refinementList[key] || [];
-          var facetList = values.filter(function(value) {
+          var facetList = values.filter(function (value) {
             return !attribute(value, key, refinementType);
           });
 
           if (facetList.length !== values.length) {
             hasChanged = true;
           }
+
           memo[key] = facetList;
 
           return memo;
-        }, {});
+        },
+        {});
 
         if (hasChanged) return newRefinementList;
         return refinementList;
       }
+
+      // We return nothing if the attribute is not undefined, a string or a function,
+      // as it is not a valid value for a refinement
+      return undefined;
     },
     /**
      * Test if the refinement value is used for the attribute. If no refinement value
@@ -5867,10 +5898,11 @@
      * @param {RefinementList} refinementList the list of refinement
      * @param {string} attribute name of the attribute
      * @param {string} [refinementValue] value of the filter/refinement
-     * @return {boolean}
+     * @return {boolean} true if the attribute is refined, false otherwise
      */
     isRefined: function isRefined(refinementList, attribute, refinementValue) {
-      var containsRefinements = !!refinementList[attribute] &&
+      var containsRefinements =
+        Boolean(refinementList[attribute]) &&
         refinementList[attribute].length > 0;
 
       if (refinementValue === undefined || !containsRefinements) {
@@ -5880,7 +5912,7 @@
       var refinementValueAsString = '' + refinementValue;
 
       return refinementList[attribute].indexOf(refinementValueAsString) !== -1;
-    }
+    },
   };
 
   var RefinementList = lib;
@@ -5891,12 +5923,15 @@
    * - [5]
    * - [[5]]
    * - [[5,5],[4]]
+   * @param {any} a numeric refinement value
+   * @param {any} b numeric refinement value
+   * @return {boolean} true if the values are equal
    */
   function isEqualNumericRefinement(a, b) {
     if (Array.isArray(a) && Array.isArray(b)) {
       return (
         a.length === b.length &&
-        a.every(function(el, i) {
+        a.every(function (el, i) {
           return isEqualNumericRefinement(b[i], el);
         })
       );
@@ -5913,7 +5948,7 @@
    * @return {any} the searched value or undefined
    */
   function findArray(array, searchedValue) {
-    return find$1(array, function(currentValue) {
+    return find$1(array, function (currentValue) {
       return isEqualNumericRefinement(currentValue, searchedValue);
     });
   }
@@ -5966,10 +6001,15 @@
   }
    */
   function SearchParameters(newParameters) {
-    var params = newParameters ? SearchParameters._parseNumbers(newParameters) : {};
+    var params = newParameters
+      ? SearchParameters._parseNumbers(newParameters)
+      : {};
 
     if (params.userToken !== undefined && !isValidUserToken(params.userToken)) {
-      console.warn('[algoliasearch-helper] The `userToken` parameter is invalid. This can lead to wrong analytics.\n  - Format: [a-zA-Z0-9_-]{1,64}');
+      // eslint-disable-next-line no-console
+      console.warn(
+        '[algoliasearch-helper] The `userToken` parameter is invalid. This can lead to wrong analytics.\n  - Format: [a-zA-Z0-9_-]{1,64}'
+      );
     }
     /**
      * This attribute contains the list of all the conjunctive facets
@@ -6069,10 +6109,12 @@
      * be translated into the `facetFilters` attribute.
      * @member {Object.<string, SearchParameters.FacetList>}
      */
-    this.hierarchicalFacetsRefinements = params.hierarchicalFacetsRefinements || {};
+    this.hierarchicalFacetsRefinements =
+      params.hierarchicalFacetsRefinements || {};
 
+    // eslint-disable-next-line consistent-this
     var self = this;
-    Object.keys(params).forEach(function(paramName) {
+    Object.keys(params).forEach(function (paramName) {
       var isKeyKnown = SearchParameters.PARAMETERS.indexOf(paramName) !== -1;
       var isValueDefined = params[paramName] !== undefined;
 
@@ -6094,8 +6136,8 @@
    * @param {object} partialState full or part of a state
    * @return {object} a new object with the number keys as number
    */
-  SearchParameters._parseNumbers = function(partialState) {
-    // Do not reparse numbers in SearchParameters, they ought to be parsed already
+  SearchParameters._parseNumbers = function (partialState) {
+    // Do not parse numbers again in SearchParameters, they ought to be parsed already
     if (partialState instanceof SearchParameters) return partialState;
 
     var numbers = {};
@@ -6111,10 +6153,10 @@
       'distinct',
       'minimumAroundRadius',
       'hitsPerPage',
-      'minProximity'
+      'minProximity',
     ];
 
-    numberKeys.forEach(function(k) {
+    numberKeys.forEach(function (k) {
       var value = partialState[k];
       if (typeof value === 'string') {
         var parsedValue = parseFloat(value);
@@ -6126,9 +6168,11 @@
     // there's two formats of insideBoundingBox, we need to parse
     // the one which is an array of float geo rectangles
     if (Array.isArray(partialState.insideBoundingBox)) {
-      numbers.insideBoundingBox = partialState.insideBoundingBox.map(function(geoRect) {
+      numbers.insideBoundingBox = partialState.insideBoundingBox.map(function (
+        geoRect
+      ) {
         if (Array.isArray(geoRect)) {
-          return geoRect.map(function(value) {
+          return geoRect.map(function (value) {
             return parseFloat(value);
           });
         }
@@ -6138,14 +6182,14 @@
 
     if (partialState.numericRefinements) {
       var numericRefinements = {};
-      Object.keys(partialState.numericRefinements).forEach(function(attribute) {
+      Object.keys(partialState.numericRefinements).forEach(function (attribute) {
         var operators = partialState.numericRefinements[attribute] || {};
         numericRefinements[attribute] = {};
-        Object.keys(operators).forEach(function(operator) {
+        Object.keys(operators).forEach(function (operator) {
           var values = operators[operator];
-          var parsedValues = values.map(function(v) {
+          var parsedValues = values.map(function (v) {
             if (Array.isArray(v)) {
-              return v.map(function(vPrime) {
+              return v.map(function (vPrime) {
                 if (typeof vPrime === 'string') {
                   return parseFloat(vPrime);
                 }
@@ -6175,18 +6219,24 @@
     var instance = new SearchParameters(newParameters);
 
     var hierarchicalFacets = newParameters.hierarchicalFacets || [];
-    hierarchicalFacets.forEach(function(facet) {
+    hierarchicalFacets.forEach(function (facet) {
       if (facet.rootPath) {
         var currentRefinement = instance.getHierarchicalRefinement(facet.name);
 
-        if (currentRefinement.length > 0 && currentRefinement[0].indexOf(facet.rootPath) !== 0) {
+        if (
+          currentRefinement.length > 0 &&
+          currentRefinement[0].indexOf(facet.rootPath) !== 0
+        ) {
           instance = instance.clearRefinements(facet.name);
         }
 
         // get it again in case it has been cleared
         currentRefinement = instance.getHierarchicalRefinement(facet.name);
         if (currentRefinement.length === 0) {
-          instance = instance.toggleHierarchicalFacetRefinement(facet.name, facet.rootPath);
+          instance = instance.toggleHierarchicalFacetRefinement(
+            facet.name,
+            facet.rootPath
+          );
         }
       }
     });
@@ -6200,19 +6250,25 @@
    * @param {object|SearchParameters} parameters the new parameters to set
    * @return {Error|null} Error if the modification is invalid, null otherwise
    */
-  SearchParameters.validate = function(currentState, parameters) {
+  SearchParameters.validate = function (currentState, parameters) {
     var params = parameters || {};
 
-    if (currentState.tagFilters && params.tagRefinements && params.tagRefinements.length > 0) {
+    if (
+      currentState.tagFilters &&
+      params.tagRefinements &&
+      params.tagRefinements.length > 0
+    ) {
       return new Error(
         '[Tags] Cannot switch from the managed tag API to the advanced API. It is probably ' +
-        'an error, if it is really what you want, you should first clear the tags with clearTags method.');
+          'an error, if it is really what you want, you should first clear the tags with clearTags method.'
+      );
     }
 
     if (currentState.tagRefinements.length > 0 && params.tagFilters) {
       return new Error(
         '[Tags] Cannot switch from the advanced tag API to the managed API. It is probably ' +
-        'an error, if it is not, you should first clear the tags with clearTags method.');
+          'an error, if it is not, you should first clear the tags with clearTags method.'
+      );
     }
 
     if (
@@ -6230,8 +6286,9 @@
     if (objectHasKeys_1(currentState.numericRefinements) && params.numericFilters) {
       return new Error(
         "[Numeric filters] Can't switch from the managed API to the advanced. It" +
-        ' is probably an error, if this is really what you want, you have to first' +
-        ' clear the numeric filters.');
+          ' is probably an error, if this is really what you want, you have to first' +
+          ' clear the numeric filters.'
+      );
     }
 
     return null;
@@ -6247,7 +6304,7 @@
      * - If not given, means to clear all the filters.
      * - If `string`, means to clear all refinements for the `attribute` named filter.
      * - If `function`, means to clear all the refinements that return truthy values.
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance with filters cleared
      */
     clearRefinements: function clearRefinements(attribute) {
       var patch = {
@@ -6271,13 +6328,14 @@
           this.hierarchicalFacetsRefinements,
           attribute,
           'hierarchicalFacet'
-        )
+        ),
       };
       if (
         patch.numericRefinements === this.numericRefinements &&
         patch.facetsRefinements === this.facetsRefinements &&
         patch.facetsExcludes === this.facetsExcludes &&
-        patch.disjunctiveFacetsRefinements === this.disjunctiveFacetsRefinements &&
+        patch.disjunctiveFacetsRefinements ===
+          this.disjunctiveFacetsRefinements &&
         patch.hierarchicalFacetsRefinements === this.hierarchicalFacetsRefinements
       ) {
         return this;
@@ -6287,53 +6345,54 @@
     /**
      * Remove all the refined tags from the SearchParameters
      * @method
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance with tags cleared
      */
     clearTags: function clearTags() {
-      if (this.tagFilters === undefined && this.tagRefinements.length === 0) return this;
+      if (this.tagFilters === undefined && this.tagRefinements.length === 0)
+        return this;
 
       return this.setQueryParameters({
         tagFilters: undefined,
-        tagRefinements: []
+        tagRefinements: [],
       });
     },
     /**
      * Set the index.
      * @method
      * @param {string} index the index name
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setIndex: function setIndex(index) {
       if (index === this.index) return this;
 
       return this.setQueryParameters({
-        index: index
+        index: index,
       });
     },
     /**
      * Query setter
      * @method
      * @param {string} newQuery value for the new query
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setQuery: function setQuery(newQuery) {
       if (newQuery === this.query) return this;
 
       return this.setQueryParameters({
-        query: newQuery
+        query: newQuery,
       });
     },
     /**
      * Page setter
      * @method
      * @param {number} newPage new page number
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setPage: function setPage(newPage) {
       if (newPage === this.page) return this;
 
       return this.setQueryParameters({
-        page: newPage
+        page: newPage,
       });
     },
     /**
@@ -6341,11 +6400,11 @@
      * The facets are the simple facets, used for conjunctive (and) faceting.
      * @method
      * @param {string[]} facets all the attributes of the algolia records used for conjunctive faceting
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setFacets: function setFacets(facets) {
       return this.setQueryParameters({
-        facets: facets
+        facets: facets,
       });
     },
     /**
@@ -6353,11 +6412,11 @@
      * Change the list of disjunctive (or) facets the helper chan handle.
      * @method
      * @param {string[]} facets all the attributes of the algolia records used for disjunctive faceting
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setDisjunctiveFacets: function setDisjunctiveFacets(facets) {
       return this.setQueryParameters({
-        disjunctiveFacets: facets
+        disjunctiveFacets: facets,
       });
     },
     /**
@@ -6365,13 +6424,13 @@
      * Hits per page represents the number of hits retrieved for this query
      * @method
      * @param {number} n number of hits retrieved per page of results
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setHitsPerPage: function setHitsPerPage(n) {
       if (this.hitsPerPage === n) return this;
 
       return this.setQueryParameters({
-        hitsPerPage: n
+        hitsPerPage: n,
       });
     },
     /**
@@ -6379,13 +6438,13 @@
      * Set the value of typoTolerance
      * @method
      * @param {string} typoTolerance new value of typoTolerance ("true", "false", "min" or "strict")
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     setTypoTolerance: function setTypoTolerance(typoTolerance) {
       if (this.typoTolerance === typoTolerance) return this;
 
       return this.setQueryParameters({
-        typoTolerance: typoTolerance
+        typoTolerance: typoTolerance,
       });
     },
     /**
@@ -6396,19 +6455,19 @@
      * @param {string} attribute attribute to set the filter on
      * @param {string} operator operator of the filter (possible values: =, >, >=, <, <=, !=)
      * @param {number | number[]} value value of the filter
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      * @example
      * // for price = 50 or 40
-     * searchparameter.addNumericRefinement('price', '=', [50, 40]);
+     * state.addNumericRefinement('price', '=', [50, 40]);
      * @example
      * // for size = 38 and 40
-     * searchparameter.addNumericRefinement('size', '=', 38);
-     * searchparameter.addNumericRefinement('size', '=', 40);
+     * state.addNumericRefinement('size', '=', 38);
+     * state.addNumericRefinement('size', '=', 40);
      */
-    addNumericRefinement: function(attribute, operator, v) {
-      var value = valToNumber_1(v);
+    addNumericRefinement: function (attribute, operator, value) {
+      var val = valToNumber_1(value);
 
-      if (this.isNumericRefined(attribute, operator, value)) return this;
+      if (this.isNumericRefined(attribute, operator, val)) return this;
 
       var mod = merge_1({}, this.numericRefinements);
 
@@ -6418,13 +6477,13 @@
         // Array copy
         mod[attribute][operator] = mod[attribute][operator].slice();
         // Add the element. Concat can't be used here because value can be an array.
-        mod[attribute][operator].push(value);
+        mod[attribute][operator].push(val);
       } else {
-        mod[attribute][operator] = [value];
+        mod[attribute][operator] = [val];
       }
 
       return this.setQueryParameters({
-        numericRefinements: mod
+        numericRefinements: mod,
       });
     },
     /**
@@ -6432,7 +6491,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getConjunctiveRefinements: function(facetName) {
+    getConjunctiveRefinements: function (facetName) {
       if (!this.isConjunctiveFacet(facetName)) {
         return [];
       }
@@ -6443,7 +6502,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getDisjunctiveRefinements: function(facetName) {
+    getDisjunctiveRefinements: function (facetName) {
       if (!this.isDisjunctiveFacet(facetName)) {
         return [];
       }
@@ -6454,7 +6513,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getHierarchicalRefinement: function(facetName) {
+    getHierarchicalRefinement: function (facetName) {
       // we send an array but we currently do not support multiple
       // hierarchicalRefinements for a hierarchicalFacet
       return this.hierarchicalFacetsRefinements[facetName] || [];
@@ -6464,7 +6523,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getExcludeRefinements: function(facetName) {
+    getExcludeRefinements: function (facetName) {
       if (!this.isConjunctiveFacet(facetName)) {
         return [];
       }
@@ -6477,36 +6536,43 @@
      * @param {string} attribute attribute to set the filter on
      * @param {string} [operator] operator of the filter (possible values: =, >, >=, <, <=, !=)
      * @param {number} [number] the value to be removed
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
-    removeNumericRefinement: function(attribute, operator, paramValue) {
+    removeNumericRefinement: function (attribute, operator, number) {
+      var paramValue = number;
       if (paramValue !== undefined) {
         if (!this.isNumericRefined(attribute, operator, paramValue)) {
           return this;
         }
         return this.setQueryParameters({
-          numericRefinements: this._clearNumericRefinements(function(value, key) {
+          numericRefinements: this._clearNumericRefinements(function (
+            value,
+            key
+          ) {
             return (
               key === attribute &&
               value.op === operator &&
               isEqualNumericRefinement(value.val, valToNumber_1(paramValue))
             );
-          })
+          }),
         });
       } else if (operator !== undefined) {
         if (!this.isNumericRefined(attribute, operator)) return this;
         return this.setQueryParameters({
-          numericRefinements: this._clearNumericRefinements(function(value, key) {
+          numericRefinements: this._clearNumericRefinements(function (
+            value,
+            key
+          ) {
             return key === attribute && value.op === operator;
-          })
+          }),
         });
       }
 
       if (!this.isNumericRefined(attribute)) return this;
       return this.setQueryParameters({
-        numericRefinements: this._clearNumericRefinements(function(value, key) {
+        numericRefinements: this._clearNumericRefinements(function (value, key) {
           return key === attribute;
-        })
+        }),
       });
     },
     /**
@@ -6514,7 +6580,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {SearchParameters.OperatorList} list of refinements
      */
-    getNumericRefinements: function(facetName) {
+    getNumericRefinements: function (facetName) {
       return this.numericRefinements[facetName] || {};
     },
     /**
@@ -6523,8 +6589,11 @@
      * @param {string} operator operator applied on the refined values
      * @return {Array.<number|number[]>} refined values
      */
-    getNumericRefinement: function(attribute, operator) {
-      return this.numericRefinements[attribute] && this.numericRefinements[attribute][operator];
+    getNumericRefinement: function (attribute, operator) {
+      return (
+        this.numericRefinements[attribute] &&
+        this.numericRefinements[attribute][operator]
+      );
     },
     /**
      * Clear numeric filters.
@@ -6534,7 +6603,7 @@
      * - If not given, means to clear all the filters.
      * - If `string`, means to clear all refinements for the `attribute` named filter.
      * - If `function`, means to clear all the refinements that return truthy values.
-     * @return {Object.<string, OperatorList>}
+     * @return {Object.<string, OperatorList>} new numeric refinements
      */
     _clearNumericRefinements: function _clearNumericRefinements(attribute) {
       if (attribute === undefined) {
@@ -6547,39 +6616,50 @@
       } else if (typeof attribute === 'function') {
         var hasChanged = false;
         var numericRefinements = this.numericRefinements;
-        var newNumericRefinements = Object.keys(numericRefinements).reduce(function(memo, key) {
-          var operators = numericRefinements[key];
-          var operatorList = {};
-
-          operators = operators || {};
-          Object.keys(operators).forEach(function(operator) {
-            var values = operators[operator] || [];
-            var outValues = [];
-            values.forEach(function(value) {
-              var predicateResult = attribute({val: value, op: operator}, key, 'numeric');
-              if (!predicateResult) outValues.push(value);
+        var newNumericRefinements = Object.keys(numericRefinements).reduce(
+          function (memo, key) {
+            var operators = numericRefinements[key];
+            var operatorList = {};
+
+            operators = operators || {};
+            Object.keys(operators).forEach(function (operator) {
+              var values = operators[operator] || [];
+              var outValues = [];
+              values.forEach(function (value) {
+                var predicateResult = attribute(
+                  { val: value, op: operator },
+                  key,
+                  'numeric'
+                );
+                if (!predicateResult) outValues.push(value);
+              });
+              if (outValues.length !== values.length) {
+                hasChanged = true;
+              }
+              operatorList[operator] = outValues;
             });
-            if (outValues.length !== values.length) {
-              hasChanged = true;
-            }
-            operatorList[operator] = outValues;
-          });
 
-          memo[key] = operatorList;
+            memo[key] = operatorList;
 
-          return memo;
-        }, {});
+            return memo;
+          },
+          {}
+        );
 
         if (hasChanged) return newNumericRefinements;
         return this.numericRefinements;
       }
+
+      // We return nothing if the attribute is not undefined, a string or a function,
+      // as it is not a valid value for a refinement
+      return undefined;
     },
     /**
      * Add a facet to the facets attribute of the helper configuration, if it
      * isn't already present.
      * @method
      * @param {string} facet facet name to add
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     addFacet: function addFacet(facet) {
       if (this.isConjunctiveFacet(facet)) {
@@ -6587,7 +6667,7 @@
       }
 
       return this.setQueryParameters({
-        facets: this.facets.concat([facet])
+        facets: this.facets.concat([facet]),
       });
     },
     /**
@@ -6595,7 +6675,7 @@
      * configuration, if it isn't already present.
      * @method
      * @param {string} facet disjunctive facet name to add
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     addDisjunctiveFacet: function addDisjunctiveFacet(facet) {
       if (this.isDisjunctiveFacet(facet)) {
@@ -6603,7 +6683,7 @@
       }
 
       return this.setQueryParameters({
-        disjunctiveFacets: this.disjunctiveFacets.concat([facet])
+        disjunctiveFacets: this.disjunctiveFacets.concat([facet]),
       });
     },
     /**
@@ -6611,17 +6691,20 @@
      * configuration.
      * @method
      * @param {object} hierarchicalFacet hierarchical facet to add
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      * @throws will throw an error if a hierarchical facet with the same name was already declared
      */
     addHierarchicalFacet: function addHierarchicalFacet(hierarchicalFacet) {
       if (this.isHierarchicalFacet(hierarchicalFacet.name)) {
         throw new Error(
-          'Cannot declare two hierarchical facets with the same name: `' + hierarchicalFacet.name + '`');
+          'Cannot declare two hierarchical facets with the same name: `' +
+            hierarchicalFacet.name +
+            '`'
+        );
       }
 
       return this.setQueryParameters({
-        hierarchicalFacets: this.hierarchicalFacets.concat([hierarchicalFacet])
+        hierarchicalFacets: this.hierarchicalFacets.concat([hierarchicalFacet]),
       });
     },
     /**
@@ -6629,16 +6712,24 @@
      * @method
      * @param {string} facet attribute to apply the faceting on
      * @param {string} value value of the attribute (will be converted to string)
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     addFacetRefinement: function addFacetRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
-      if (RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;
+      if (RefinementList.isRefined(this.facetsRefinements, facet, value))
+        return this;
 
       return this.setQueryParameters({
-        facetsRefinements: RefinementList.addRefinement(this.facetsRefinements, facet, value)
+        facetsRefinements: RefinementList.addRefinement(
+          this.facetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6646,16 +6737,24 @@
      * @method
      * @param {string} facet attribute to apply the exclusion on
      * @param {string} value value of the attribute (will be converted to string)
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     addExcludeRefinement: function addExcludeRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
-      if (RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;
+      if (RefinementList.isRefined(this.facetsExcludes, facet, value))
+        return this;
 
       return this.setQueryParameters({
-        facetsExcludes: RefinementList.addRefinement(this.facetsExcludes, facet, value)
+        facetsExcludes: RefinementList.addRefinement(
+          this.facetsExcludes,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6663,31 +6762,42 @@
      * @method
      * @param {string} facet attribute to apply the faceting on
      * @param {string} value value of the attribute (will be converted to string)
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
-    addDisjunctiveFacetRefinement: function addDisjunctiveFacetRefinement(facet, value) {
+    addDisjunctiveFacetRefinement: function addDisjunctiveFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isDisjunctiveFacet(facet)) {
         throw new Error(
-          facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
+          facet +
+            ' is not defined in the disjunctiveFacets attribute of the helper configuration'
+        );
       }
 
-      if (RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;
+      if (
+        RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)
+      )
+        return this;
 
       return this.setQueryParameters({
         disjunctiveFacetsRefinements: RefinementList.addRefinement(
-          this.disjunctiveFacetsRefinements, facet, value)
+          this.disjunctiveFacetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
      * addTagRefinement adds a tag to the list used to filter the results
      * @param {string} tag tag to be added
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     addTagRefinement: function addTagRefinement(tag) {
       if (this.isTagRefined(tag)) return this;
 
       var modification = {
-        tagRefinements: this.tagRefinements.concat(tag)
+        tagRefinements: this.tagRefinements.concat(tag),
       };
 
       return this.setQueryParameters(modification);
@@ -6697,7 +6807,7 @@
      * is present.
      * @method
      * @param {string} facet facet name to remove
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeFacet: function removeFacet(facet) {
       if (!this.isConjunctiveFacet(facet)) {
@@ -6705,9 +6815,9 @@
       }
 
       return this.clearRefinements(facet).setQueryParameters({
-        facets: this.facets.filter(function(f) {
+        facets: this.facets.filter(function (f) {
           return f !== facet;
-        })
+        }),
       });
     },
     /**
@@ -6715,7 +6825,7 @@
      * helper configuration, if it is present.
      * @method
      * @param {string} facet disjunctive facet name to remove
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeDisjunctiveFacet: function removeDisjunctiveFacet(facet) {
       if (!this.isDisjunctiveFacet(facet)) {
@@ -6723,9 +6833,9 @@
       }
 
       return this.clearRefinements(facet).setQueryParameters({
-        disjunctiveFacets: this.disjunctiveFacets.filter(function(f) {
+        disjunctiveFacets: this.disjunctiveFacets.filter(function (f) {
           return f !== facet;
-        })
+        }),
       });
     },
     /**
@@ -6733,7 +6843,7 @@
      * helper configuration, if it is present.
      * @method
      * @param {string} facet hierarchical facet name to remove
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeHierarchicalFacet: function removeHierarchicalFacet(facet) {
       if (!this.isHierarchicalFacet(facet)) {
@@ -6741,9 +6851,9 @@
       }
 
       return this.clearRefinements(facet).setQueryParameters({
-        hierarchicalFacets: this.hierarchicalFacets.filter(function(f) {
+        hierarchicalFacets: this.hierarchicalFacets.filter(function (f) {
           return f.name !== facet;
-        })
+        }),
       });
     },
     /**
@@ -6753,16 +6863,24 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {string} [value] value used to filter
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeFacetRefinement: function removeFacetRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
-      if (!RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;
+      if (!RefinementList.isRefined(this.facetsRefinements, facet, value))
+        return this;
 
       return this.setQueryParameters({
-        facetsRefinements: RefinementList.removeRefinement(this.facetsRefinements, facet, value)
+        facetsRefinements: RefinementList.removeRefinement(
+          this.facetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6770,16 +6888,24 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {string} value value used to filter
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeExcludeRefinement: function removeExcludeRefinement(facet, value) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
-      if (!RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;
+      if (!RefinementList.isRefined(this.facetsExcludes, facet, value))
+        return this;
 
       return this.setQueryParameters({
-        facetsExcludes: RefinementList.removeRefinement(this.facetsExcludes, facet, value)
+        facetsExcludes: RefinementList.removeRefinement(
+          this.facetsExcludes,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6787,33 +6913,44 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {string} value value used to filter
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
-    removeDisjunctiveFacetRefinement: function removeDisjunctiveFacetRefinement(facet, value) {
+    removeDisjunctiveFacetRefinement: function removeDisjunctiveFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isDisjunctiveFacet(facet)) {
         throw new Error(
-          facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
+          facet +
+            ' is not defined in the disjunctiveFacets attribute of the helper configuration'
+        );
       }
-      if (!RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;
+      if (
+        !RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)
+      )
+        return this;
 
       return this.setQueryParameters({
         disjunctiveFacetsRefinements: RefinementList.removeRefinement(
-          this.disjunctiveFacetsRefinements, facet, value)
+          this.disjunctiveFacetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
      * Remove a tag from the list of tag refinements
      * @method
      * @param {string} tag the tag to remove
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeTagRefinement: function removeTagRefinement(tag) {
       if (!this.isTagRefined(tag)) return this;
 
       var modification = {
-        tagRefinements: this.tagRefinements.filter(function(t) {
+        tagRefinements: this.tagRefinements.filter(function (t) {
           return t !== tag;
-        })
+        }),
       };
 
       return this.setQueryParameters(modification);
@@ -6823,7 +6960,7 @@
      * and hierarchical facets
      * @param  {string} facet the facet to refine
      * @param  {string} value the associated value
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      * @throws will throw an error if the facet is not declared in the settings of the helper
      * @deprecated since version 2.19.0, see {@link SearchParameters#toggleFacetRefinement}
      */
@@ -6835,7 +6972,7 @@
      * and hierarchical facets
      * @param  {string} facet the facet to refine
      * @param  {string} value the associated value
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      * @throws will throw an error if the facet is not declared in the settings of the helper
      */
     toggleFacetRefinement: function toggleFacetRefinement(facet, value) {
@@ -6847,23 +6984,36 @@
         return this.toggleDisjunctiveFacetRefinement(facet, value);
       }
 
-      throw new Error('Cannot refine the undeclared facet ' + facet +
-        '; it should be added to the helper options facets, disjunctiveFacets or hierarchicalFacets');
+      throw new Error(
+        'Cannot refine the undeclared facet ' +
+          facet +
+          '; it should be added to the helper options facets, disjunctiveFacets or hierarchicalFacets'
+      );
     },
     /**
      * Switch the refinement applied over a facet/value
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
-    toggleConjunctiveFacetRefinement: function toggleConjunctiveFacetRefinement(facet, value) {
+    toggleConjunctiveFacetRefinement: function toggleConjunctiveFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
 
       return this.setQueryParameters({
-        facetsRefinements: RefinementList.toggleRefinement(this.facetsRefinements, facet, value)
+        facetsRefinements: RefinementList.toggleRefinement(
+          this.facetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6871,15 +7021,25 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
-    toggleExcludeFacetRefinement: function toggleExcludeFacetRefinement(facet, value) {
+    toggleExcludeFacetRefinement: function toggleExcludeFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isConjunctiveFacet(facet)) {
-        throw new Error(facet + ' is not defined in the facets attribute of the helper configuration');
+        throw new Error(
+          facet +
+            ' is not defined in the facets attribute of the helper configuration'
+        );
       }
 
       return this.setQueryParameters({
-        facetsExcludes: RefinementList.toggleRefinement(this.facetsExcludes, facet, value)
+        facetsExcludes: RefinementList.toggleRefinement(
+          this.facetsExcludes,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6887,17 +7047,25 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
-    toggleDisjunctiveFacetRefinement: function toggleDisjunctiveFacetRefinement(facet, value) {
+    toggleDisjunctiveFacetRefinement: function toggleDisjunctiveFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isDisjunctiveFacet(facet)) {
         throw new Error(
-          facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
+          facet +
+            ' is not defined in the disjunctiveFacets attribute of the helper configuration'
+        );
       }
 
       return this.setQueryParameters({
         disjunctiveFacetsRefinements: RefinementList.toggleRefinement(
-          this.disjunctiveFacetsRefinements, facet, value)
+          this.disjunctiveFacetsRefinements,
+          facet,
+          value
+        ),
       });
     },
     /**
@@ -6905,29 +7073,38 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
-    toggleHierarchicalFacetRefinement: function toggleHierarchicalFacetRefinement(facet, value) {
+    toggleHierarchicalFacetRefinement: function toggleHierarchicalFacetRefinement(
+      facet,
+      value
+    ) {
       if (!this.isHierarchicalFacet(facet)) {
         throw new Error(
-          facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration');
+          facet +
+            ' is not defined in the hierarchicalFacets attribute of the helper configuration'
+        );
       }
 
-      var separator = this._getHierarchicalFacetSeparator(this.getHierarchicalFacetByName(facet));
+      var separator = this._getHierarchicalFacetSeparator(
+        this.getHierarchicalFacetByName(facet)
+      );
 
       var mod = {};
 
-      var upOneOrMultipleLevel = this.hierarchicalFacetsRefinements[facet] !== undefined &&
-        this.hierarchicalFacetsRefinements[facet].length > 0 && (
+      var upOneOrMultipleLevel =
+        this.hierarchicalFacetsRefinements[facet] !== undefined &&
+        this.hierarchicalFacetsRefinements[facet].length > 0 &&
         // remove current refinement:
         // refinement was 'beer > IPA', call is toggleRefine('beer > IPA'), refinement should be `beer`
-        this.hierarchicalFacetsRefinements[facet][0] === value ||
-        // remove a parent refinement of the current refinement:
-        //  - refinement was 'beer > IPA > Flying dog'
-        //  - call is toggleRefine('beer > IPA')
-        //  - refinement should be `beer`
-        this.hierarchicalFacetsRefinements[facet][0].indexOf(value + separator) === 0
-      );
+        (this.hierarchicalFacetsRefinements[facet][0] === value ||
+          // remove a parent refinement of the current refinement:
+          //  - refinement was 'beer > IPA > Flying dog'
+          //  - call is toggleRefine('beer > IPA')
+          //  - refinement should be `beer`
+          this.hierarchicalFacetsRefinements[facet][0].indexOf(
+            value + separator
+          ) === 0);
 
       if (upOneOrMultipleLevel) {
         if (value.indexOf(separator) === -1) {
@@ -6941,7 +7118,11 @@
       }
 
       return this.setQueryParameters({
-        hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)
+        hierarchicalFacetsRefinements: defaultsPure(
+          {},
+          mod,
+          this.hierarchicalFacetsRefinements
+        ),
       });
     },
 
@@ -6952,17 +7133,24 @@
      * @return {SearchParameter} the new state
      * @throws Error if the facet is not defined or if the facet is refined
      */
-    addHierarchicalFacetRefinement: function(facet, path) {
+    addHierarchicalFacetRefinement: function (facet, path) {
       if (this.isHierarchicalFacetRefined(facet)) {
         throw new Error(facet + ' is already refined.');
       }
       if (!this.isHierarchicalFacet(facet)) {
-        throw new Error(facet + ' is not defined in the hierarchicalFacets attribute of the helper configuration.');
+        throw new Error(
+          facet +
+            ' is not defined in the hierarchicalFacets attribute of the helper configuration.'
+        );
       }
       var mod = {};
       mod[facet] = [path];
       return this.setQueryParameters({
-        hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)
+        hierarchicalFacetsRefinements: defaultsPure(
+          {},
+          mod,
+          this.hierarchicalFacetsRefinements
+        ),
       });
     },
 
@@ -6972,21 +7160,25 @@
      * @return {SearchParameter} the new state
      * @throws Error if the facet is not defined or if the facet is not refined
      */
-    removeHierarchicalFacetRefinement: function(facet) {
+    removeHierarchicalFacetRefinement: function (facet) {
       if (!this.isHierarchicalFacetRefined(facet)) {
         return this;
       }
       var mod = {};
       mod[facet] = [];
       return this.setQueryParameters({
-        hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)
+        hierarchicalFacetsRefinements: defaultsPure(
+          {},
+          mod,
+          this.hierarchicalFacetsRefinements
+        ),
       });
     },
     /**
      * Switch the tag refinement
      * @method
      * @param {string} tag the tag to remove or add
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     toggleTagRefinement: function toggleTagRefinement(tag) {
       if (this.isTagRefined(tag)) {
@@ -6999,27 +7191,27 @@
      * Test if the facet name is from one of the disjunctive facets
      * @method
      * @param {string} facet facet name to test
-     * @return {boolean}
+     * @return {boolean} true if facet is a disjunctive facet
      */
-    isDisjunctiveFacet: function(facet) {
+    isDisjunctiveFacet: function (facet) {
       return this.disjunctiveFacets.indexOf(facet) > -1;
     },
     /**
      * Test if the facet name is from one of the hierarchical facets
      * @method
      * @param {string} facetName facet name to test
-     * @return {boolean}
+     * @return {boolean} true if facetName is a hierarchical facet
      */
-    isHierarchicalFacet: function(facetName) {
+    isHierarchicalFacet: function (facetName) {
       return this.getHierarchicalFacetByName(facetName) !== undefined;
     },
     /**
      * Test if the facet name is from one of the conjunctive/normal facets
      * @method
      * @param {string} facet facet name to test
-     * @return {boolean}
+     * @return {boolean} true if facet is a conjunctive facet
      */
-    isConjunctiveFacet: function(facet) {
+    isConjunctiveFacet: function (facet) {
       return this.facets.indexOf(facet) > -1;
     },
     /**
@@ -7060,13 +7252,17 @@
      * @param {string} facet name of the attribute for used for faceting
      * @param {string} value optional, will test if the value is used for refinement
      * if there is one, otherwise will test if the facet contains any refinement
-     * @return {boolean}
+     * @return {boolean} true if the facet is refined
      */
     isDisjunctiveFacetRefined: function isDisjunctiveFacetRefined(facet, value) {
       if (!this.isDisjunctiveFacet(facet)) {
         return false;
       }
-      return RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value);
+      return RefinementList.isRefined(
+        this.disjunctiveFacetsRefinements,
+        facet,
+        value
+      );
     },
     /**
      * Returns true if the facet contains a refinement, or if a value passed is a
@@ -7075,9 +7271,12 @@
      * @param {string} facet name of the attribute for used for faceting
      * @param {string} value optional, will test if the value is used for refinement
      * if there is one, otherwise will test if the facet contains any refinement
-     * @return {boolean}
+     * @return {boolean} true if the facet is refined
      */
-    isHierarchicalFacetRefined: function isHierarchicalFacetRefined(facet, value) {
+    isHierarchicalFacetRefined: function isHierarchicalFacetRefined(
+      facet,
+      value
+    ) {
       if (!this.isHierarchicalFacet(facet)) {
         return false;
       }
@@ -7102,7 +7301,7 @@
      */
     isNumericRefined: function isNumericRefined(attribute, operator, value) {
       if (value === undefined && operator === undefined) {
-        return !!this.numericRefinements[attribute];
+        return Boolean(this.numericRefinements[attribute]);
       }
 
       var isOperatorDefined =
@@ -7124,7 +7323,7 @@
      * Returns true if the tag refined, false otherwise
      * @method
      * @param {string} tag the tag to check
-     * @return {boolean}
+     * @return {boolean} true if tag is refined
      */
     isTagRefined: function isTagRefined(tag) {
       return this.tagRefinements.indexOf(tag) !== -1;
@@ -7134,22 +7333,24 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {string[]}
+     * @return {string[]} returns the list of refinements
      */
     getRefinedDisjunctiveFacets: function getRefinedDisjunctiveFacets() {
+      // eslint-disable-next-line consistent-this
       var self = this;
 
       // attributes used for numeric filter can also be disjunctive
       var disjunctiveNumericRefinedFacets = intersection_1(
-        Object.keys(this.numericRefinements).filter(function(facet) {
+        Object.keys(this.numericRefinements).filter(function (facet) {
           return Object.keys(self.numericRefinements[facet]).length > 0;
         }),
         this.disjunctiveFacets
       );
 
-      return Object.keys(this.disjunctiveFacetsRefinements).filter(function(facet) {
-        return self.disjunctiveFacetsRefinements[facet].length > 0;
-      })
+      return Object.keys(this.disjunctiveFacetsRefinements)
+        .filter(function (facet) {
+          return self.disjunctiveFacetsRefinements[facet].length > 0;
+        })
         .concat(disjunctiveNumericRefinedFacets)
         .concat(this.getRefinedHierarchicalFacets());
     },
@@ -7158,15 +7359,18 @@
      * @method
      * @param {string} facet name of the attribute used for faceting
      * @param {value} value value used for filtering
-     * @return {string[]}
+     * @return {string[]} returns the list of refinements
      */
     getRefinedHierarchicalFacets: function getRefinedHierarchicalFacets() {
+      // eslint-disable-next-line consistent-this
       var self = this;
       return intersection_1(
         // enforce the order between the two arrays,
         // so that refinement name index === hierarchical facet index
-        this.hierarchicalFacets.map(function(facet) { return facet.name; }),
-        Object.keys(this.hierarchicalFacetsRefinements).filter(function(facet) {
+        this.hierarchicalFacets.map(function (facet) {
+          return facet.name;
+        }),
+        Object.keys(this.hierarchicalFacetsRefinements).filter(function (facet) {
           return self.hierarchicalFacetsRefinements[facet].length > 0;
         })
       );
@@ -7174,12 +7378,12 @@
     /**
      * Returned the list of all disjunctive facets not refined
      * @method
-     * @return {string[]}
+     * @return {string[]} returns the list of facets that are not refined
      */
-    getUnrefinedDisjunctiveFacets: function() {
+    getUnrefinedDisjunctiveFacets: function () {
       var refinedFacets = this.getRefinedDisjunctiveFacets();
 
-      return this.disjunctiveFacets.filter(function(f) {
+      return this.disjunctiveFacets.filter(function (f) {
         return refinedFacets.indexOf(f) === -1;
       });
     },
@@ -7196,17 +7400,22 @@
       'disjunctiveFacetsRefinements',
       'numericRefinements',
       'tagRefinements',
-      'hierarchicalFacetsRefinements'
+      'hierarchicalFacetsRefinements',
     ],
+
     getQueryParams: function getQueryParams() {
       var managedParameters = this.managedParameters;
 
       var queryParams = {};
 
+      // eslint-disable-next-line consistent-this
       var self = this;
-      Object.keys(this).forEach(function(paramName) {
+      Object.keys(this).forEach(function (paramName) {
         var paramValue = self[paramName];
-        if (managedParameters.indexOf(paramName) === -1 && paramValue !== undefined) {
+        if (
+          managedParameters.indexOf(paramName) === -1 &&
+          paramValue !== undefined
+        ) {
           queryParams[paramName] = paramValue;
         }
       });
@@ -7247,30 +7456,32 @@
         throw error;
       }
 
+      // eslint-disable-next-line consistent-this
       var self = this;
       var nextWithNumbers = SearchParameters._parseNumbers(params);
-      var previousPlainObject = Object.keys(this).reduce(function(acc, key) {
+      var previousPlainObject = Object.keys(this).reduce(function (acc, key) {
         acc[key] = self[key];
         return acc;
       }, {});
 
-      var nextPlainObject = Object.keys(nextWithNumbers).reduce(
-        function(previous, key) {
-          var isPreviousValueDefined = previous[key] !== undefined;
-          var isNextValueDefined = nextWithNumbers[key] !== undefined;
+      var nextPlainObject = Object.keys(nextWithNumbers).reduce(function (
+        previous,
+        key
+      ) {
+        var isPreviousValueDefined = previous[key] !== undefined;
+        var isNextValueDefined = nextWithNumbers[key] !== undefined;
 
-          if (isPreviousValueDefined && !isNextValueDefined) {
-            return omit$1(previous, [key]);
-          }
+        if (isPreviousValueDefined && !isNextValueDefined) {
+          return omit$1(previous, [key]);
+        }
 
-          if (isNextValueDefined) {
-            previous[key] = nextWithNumbers[key];
-          }
+        if (isNextValueDefined) {
+          previous[key] = nextWithNumbers[key];
+        }
 
-          return previous;
-        },
-        previousPlainObject
-      );
+        return previous;
+      },
+      previousPlainObject);
 
       return new this.constructor(nextPlainObject);
     },
@@ -7281,7 +7492,7 @@
      * the page is set -> return a new instance with a page of 0
      * @return {SearchParameters} a new updated instance
      */
-    resetPage: function() {
+    resetPage: function () {
       if (this.page === undefined) {
         return this;
       }
@@ -7291,40 +7502,40 @@
 
     /**
      * Helper function to get the hierarchicalFacet separator or the default one (`>`)
-     * @param  {object} hierarchicalFacet
+     * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.separator or `>` as default
      */
-    _getHierarchicalFacetSortBy: function(hierarchicalFacet) {
+    _getHierarchicalFacetSortBy: function (hierarchicalFacet) {
       return hierarchicalFacet.sortBy || ['isRefined:desc', 'name:asc'];
     },
 
     /**
      * Helper function to get the hierarchicalFacet separator or the default one (`>`)
      * @private
-     * @param  {object} hierarchicalFacet
+     * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.separator or `>` as default
      */
-    _getHierarchicalFacetSeparator: function(hierarchicalFacet) {
+    _getHierarchicalFacetSeparator: function (hierarchicalFacet) {
       return hierarchicalFacet.separator || ' > ';
     },
 
     /**
      * Helper function to get the hierarchicalFacet prefix path or null
      * @private
-     * @param  {object} hierarchicalFacet
+     * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.rootPath or null as default
      */
-    _getHierarchicalRootPath: function(hierarchicalFacet) {
+    _getHierarchicalRootPath: function (hierarchicalFacet) {
       return hierarchicalFacet.rootPath || null;
     },
 
     /**
      * Helper function to check if we show the parent level of the hierarchicalFacet
      * @private
-     * @param  {object} hierarchicalFacet
+     * @param  {object} hierarchicalFacet the hierarchicalFacet object
      * @return {string} returns the hierarchicalFacet.showParentLevel or true as default
      */
-    _getHierarchicalShowParentLevel: function(hierarchicalFacet) {
+    _getHierarchicalShowParentLevel: function (hierarchicalFacet) {
       if (typeof hierarchicalFacet.showParentLevel === 'boolean') {
         return hierarchicalFacet.showParentLevel;
       }
@@ -7333,16 +7544,13 @@
 
     /**
      * Helper function to get the hierarchicalFacet by it's name
-     * @param  {string} hierarchicalFacetName
+     * @param  {string} hierarchicalFacetName the hierarchicalFacet name
      * @return {object} a hierarchicalFacet
      */
-    getHierarchicalFacetByName: function(hierarchicalFacetName) {
-      return find$1(
-        this.hierarchicalFacets,
-        function(f) {
-          return f.name === hierarchicalFacetName;
-        }
-      );
+    getHierarchicalFacetByName: function (hierarchicalFacetName) {
+      return find$1(this.hierarchicalFacets, function (f) {
+        return f.name === hierarchicalFacetName;
+      });
     },
 
     /**
@@ -7350,7 +7558,7 @@
      * @param  {string} facetName Hierarchical facet name
      * @return {array.<string>} the path as an array of string
      */
-    getHierarchicalFacetBreadcrumb: function(facetName) {
+    getHierarchicalFacetBreadcrumb: function (facetName) {
       if (!this.isHierarchicalFacet(facetName)) {
         return [];
       }
@@ -7362,14 +7570,14 @@
         this.getHierarchicalFacetByName(facetName)
       );
       var path = refinement.split(separator);
-      return path.map(function(part) {
+      return path.map(function (part) {
         return part.trim();
       });
     },
 
-    toString: function() {
+    toString: function () {
       return JSON.stringify(this, null, 2);
-    }
+    },
   };
 
   /**
@@ -7413,6 +7621,7 @@
    * @param {Array<object>} collection object with keys in attributes
    * @param {Array<string>} iteratees attributes
    * @param {Array<string>} orders asc | desc
+   * @return {Array<object>} sorted collection
    */
   function orderBy(collection, iteratees, orders) {
     if (!Array.isArray(collection)) {
@@ -7423,13 +7632,13 @@
       orders = [];
     }
 
-    var result = collection.map(function(value, index) {
+    var result = collection.map(function (value, index) {
       return {
-        criteria: iteratees.map(function(iteratee) {
+        criteria: iteratees.map(function (iteratee) {
           return value[iteratee];
         }),
         index: index,
-        value: value
+        value: value,
       };
     });
 
@@ -7454,7 +7663,7 @@
       return object.index - other.index;
     });
 
-    return result.map(function(res) {
+    return result.map(function (res) {
       return res.value;
     });
   }
@@ -7490,7 +7699,7 @@
    * @return {array.<string[]>} array containing 2 elements : attributes, orders
    */
   var formatSort = function formatSort(sortBy, defaults) {
-    var defaultInstructions = (defaults || []).map(function(sort) {
+    var defaultInstructions = (defaults || []).map(function (sort) {
       return sort.split(':');
     });
 
@@ -7498,11 +7707,12 @@
       function preparePredicate(out, sort) {
         var sortInstruction = sort.split(':');
 
-        var matchingDefault = find$1(defaultInstructions, function(
-          defaultInstruction
-        ) {
-          return defaultInstruction[0] === sortInstruction[0];
-        });
+        var matchingDefault = find$1(
+          defaultInstructions,
+          function (defaultInstruction) {
+            return defaultInstruction[0] === sortInstruction[0];
+          }
+        );
 
         if (sortInstruction.length > 1 || !matchingDefault) {
           out[0].push(sortInstruction[0]);
@@ -7522,7 +7732,7 @@
    * Replaces a leading - with \-
    * @private
    * @param {any} value the facet value to replace
-   * @returns any
+   * @returns {any} the escaped facet value or the value if it was not a string
    */
   function escapeFacetValue$1(value) {
     if (typeof value !== 'string') return value;
@@ -7534,7 +7744,7 @@
    * Replaces a leading \- with -
    * @private
    * @param {any} value the escaped facet value
-   * @returns any
+   * @returns {any} the unescaped facet value or the value if it was not a string
    */
   function unescapeFacetValue$1(value) {
     if (typeof value !== 'string') return value;
@@ -7544,7 +7754,7 @@
 
   var escapeFacetValue_1 = {
     escapeFacetValue: escapeFacetValue$1,
-    unescapeFacetValue: unescapeFacetValue$1
+    unescapeFacetValue: unescapeFacetValue$1,
   };
 
   var generateHierarchicalTree_1 = generateTrees;
@@ -7563,20 +7773,17 @@
         (state.hierarchicalFacetsRefinements[hierarchicalFacet.name] &&
           state.hierarchicalFacetsRefinements[hierarchicalFacet.name][0]) ||
         '';
-      var hierarchicalSeparator = state._getHierarchicalFacetSeparator(
-        hierarchicalFacet
-      );
-      var hierarchicalRootPath = state._getHierarchicalRootPath(
-        hierarchicalFacet
-      );
-      var hierarchicalShowParentLevel = state._getHierarchicalShowParentLevel(
-        hierarchicalFacet
-      );
+      var hierarchicalSeparator =
+        state._getHierarchicalFacetSeparator(hierarchicalFacet);
+      var hierarchicalRootPath =
+        state._getHierarchicalRootPath(hierarchicalFacet);
+      var hierarchicalShowParentLevel =
+        state._getHierarchicalShowParentLevel(hierarchicalFacet);
       var sortBy = formatSort(
         state._getHierarchicalFacetSortBy(hierarchicalFacet)
       );
 
-      var rootExhaustive = hierarchicalFacetResult.every(function(facetResult) {
+      var rootExhaustive = hierarchicalFacetResult.every(function (facetResult) {
         return facetResult.exhaustive;
       });
 
@@ -7603,7 +7810,7 @@
         path: null, // root level, no path
         escapedValue: null,
         exhaustive: rootExhaustive,
-        data: null
+        data: null,
       });
     };
   }
@@ -7632,7 +7839,7 @@
            * @type {object[]]} hierarchical data
            */
           var data = parent && Array.isArray(parent.data) ? parent.data : [];
-          parent = find$1(data, function(subtree) {
+          parent = find$1(data, function (subtree) {
             return subtree.isRefined;
           });
           level++;
@@ -7653,10 +7860,10 @@
         // showing up
 
         var picked = Object.keys(hierarchicalFacetResult.data)
-          .map(function(facetValue) {
+          .map(function (facetValue) {
             return [facetValue, hierarchicalFacetResult.data[facetValue]];
           })
-          .filter(function(tuple) {
+          .filter(function (tuple) {
             var facetValue = tuple[0];
             return onlyMatchingTree(
               facetValue,
@@ -7669,7 +7876,7 @@
           });
 
         parent.data = orderBy_1(
-          picked.map(function(tuple) {
+          picked.map(function (tuple) {
             var facetValue = tuple[0];
             var facetCount = tuple[1];
 
@@ -7690,6 +7897,7 @@
     };
   }
 
+  // eslint-disable-next-line max-params
   function onlyMatchingTree(
     facetValue,
     parentPath,
@@ -7746,7 +7954,7 @@
         currentRefinement === facetValue ||
         currentRefinement.indexOf(facetValue + hierarchicalSeparator) === 0,
       exhaustive: exhaustive,
-      data: null
+      data: null,
     };
   }
 
@@ -7797,12 +8005,14 @@
    */
 
   /**
-   * @param {string[]} attributes
+   * Turn an array of attributes in an object of attributes with their position in the array as value
+   * @param {string[]} attributes the list of attributes in the record
+   * @return {object} the list of attributes indexed by attribute name
    */
   function getIndices(attributes) {
     var indices = {};
 
-    attributes.forEach(function(val, idx) {
+    attributes.forEach(function (val, idx) {
       indices[val] = idx;
     });
 
@@ -7822,22 +8032,24 @@
    */
 
   /**
-   * @param {HierarchicalFacet[]} hierarchicalFacets
-   * @param {string} hierarchicalAttributeName
+   * @param {HierarchicalFacet[]} hierarchicalFacets All hierarchical facets
+   * @param {string} hierarchicalAttributeName The name of the hierarchical attribute
+   * @return {HierarchicalFacet} The hierarchical facet matching the attribute name
    */
   function findMatchingHierarchicalFacetFromAttributeName(
     hierarchicalFacets,
     hierarchicalAttributeName
   ) {
-    return find$1(hierarchicalFacets, function facetKeyMatchesAttribute(
-      hierarchicalFacet
-    ) {
-      var facetNames = hierarchicalFacet.attributes || [];
-      return facetNames.indexOf(hierarchicalAttributeName) > -1;
-    });
+    return find$1(
+      hierarchicalFacets,
+      function facetKeyMatchesAttribute(hierarchicalFacet) {
+        var facetNames = hierarchicalFacet.attributes || [];
+        return facetNames.indexOf(hierarchicalAttributeName) > -1;
+      }
+    );
   }
 
-  /*eslint-disable */
+  // eslint-disable-next-line valid-jsdoc
   /**
    * Constructor for SearchResults
    * @class
@@ -7968,21 +8180,21 @@
      "index": "bestbuy"
   }
    **/
-  /*eslint-enable */
   function SearchResults(state, results, options) {
     var mainSubResponse = results[0];
 
     this._rawResults = results;
 
+    // eslint-disable-next-line consistent-this
     var self = this;
 
     // https://www.algolia.com/doc/api-reference/api-methods/search/#response
-    Object.keys(mainSubResponse).forEach(function(key) {
+    Object.keys(mainSubResponse).forEach(function (key) {
       self[key] = mainSubResponse[key];
     });
 
     // Make every key of the result options reachable from the instance
-    Object.keys(options || {}).forEach(function(key) {
+    Object.keys(options || {}).forEach(function (key) {
       self[key] = options[key];
     });
 
@@ -8004,8 +8216,8 @@
      * all the records that match the search parameters. Each record is
      * augmented with a new attribute `_highlightResult`
      * which is an object keyed by attribute and with the following properties:
-     *  - `value` : the value of the facet highlighted (html)
-     *  - `matchLevel`: full, partial or none depending on how the query terms match
+     * - `value` : the value of the facet highlighted (html)
+     * - `matchLevel`: `full`, `partial` or `none`, depending on how the query terms match
      * @name hits
      * @member {object[]}
      * @memberof SearchResults
@@ -8126,7 +8338,7 @@
      * @memberof SearchResults
      * @instance
      */
-    this.processingTimeMS = results.reduce(function(sum, result) {
+    this.processingTimeMS = results.reduce(function (sum, result) {
       return result.processingTimeMS === undefined
         ? sum
         : sum + result.processingTimeMS;
@@ -8141,9 +8353,11 @@
      * disjunctive facets results
      * @member {SearchResults.HierarchicalFacet[]}
      */
-    this.hierarchicalFacets = state.hierarchicalFacets.map(function initFutureTree() {
-      return [];
-    });
+    this.hierarchicalFacets = state.hierarchicalFacets.map(
+      function initFutureTree() {
+        return [];
+      }
+    );
     /**
      * other facets results
      * @member {SearchResults.Facet[]}
@@ -8161,7 +8375,7 @@
 
     var mainFacets = mainSubResponse.facets || {};
 
-    Object.keys(mainFacets).forEach(function(facetKey) {
+    Object.keys(mainFacets).forEach(function (facetKey) {
       var facetValueObject = mainFacets[facetKey];
 
       var hierarchicalFacet = findMatchingHierarchicalFacetFromAttributeName(
@@ -8173,13 +8387,13 @@
         // Place the hierarchicalFacet data at the correct index depending on
         // the attributes order that was defined at the helper initialization
         var facetIndex = hierarchicalFacet.attributes.indexOf(facetKey);
-        var idxAttributeName = findIndex$1(state.hierarchicalFacets, function(f) {
+        var idxAttributeName = findIndex$1(state.hierarchicalFacets, function (f) {
           return f.name === hierarchicalFacet.name;
         });
         self.hierarchicalFacets[idxAttributeName][facetIndex] = {
           attribute: facetKey,
           data: facetValueObject,
-          exhaustive: mainSubResponse.exhaustiveFacetsCount
+          exhaustive: mainSubResponse.exhaustiveFacetsCount,
         };
       } else {
         var isFacetDisjunctive = state.disjunctiveFacets.indexOf(facetKey) !== -1;
@@ -8191,18 +8405,26 @@
           self.disjunctiveFacets[position] = {
             name: facetKey,
             data: facetValueObject,
-            exhaustive: mainSubResponse.exhaustiveFacetsCount
+            exhaustive: mainSubResponse.exhaustiveFacetsCount,
           };
-          assignFacetStats(self.disjunctiveFacets[position], mainSubResponse.facets_stats, facetKey);
+          assignFacetStats(
+            self.disjunctiveFacets[position],
+            mainSubResponse.facets_stats,
+            facetKey
+          );
         }
         if (isFacetConjunctive) {
           position = facetsIndices[facetKey];
           self.facets[position] = {
             name: facetKey,
             data: facetValueObject,
-            exhaustive: mainSubResponse.exhaustiveFacetsCount
+            exhaustive: mainSubResponse.exhaustiveFacetsCount,
           };
-          assignFacetStats(self.facets[position], mainSubResponse.facets_stats, facetKey);
+          assignFacetStats(
+            self.facets[position],
+            mainSubResponse.facets_stats,
+            facetKey
+          );
         }
       }
     });
@@ -8211,24 +8433,27 @@
     this.hierarchicalFacets = compact(this.hierarchicalFacets);
 
     // aggregate the refined disjunctive facets
-    disjunctiveFacets.forEach(function(disjunctiveFacet) {
+    disjunctiveFacets.forEach(function (disjunctiveFacet) {
       var result = results[nextDisjunctiveResult];
       var facets = result && result.facets ? result.facets : {};
       var hierarchicalFacet = state.getHierarchicalFacetByName(disjunctiveFacet);
 
       // There should be only item in facets.
-      Object.keys(facets).forEach(function(dfacet) {
+      Object.keys(facets).forEach(function (dfacet) {
         var facetResults = facets[dfacet];
 
         var position;
 
         if (hierarchicalFacet) {
-          position = findIndex$1(state.hierarchicalFacets, function(f) {
+          position = findIndex$1(state.hierarchicalFacets, function (f) {
             return f.name === hierarchicalFacet.name;
           });
-          var attributeIndex = findIndex$1(self.hierarchicalFacets[position], function(f) {
-            return f.attribute === dfacet;
-          });
+          var attributeIndex = findIndex$1(
+            self.hierarchicalFacets[position],
+            function (f) {
+              return f.attribute === dfacet;
+            }
+          );
 
           // previous refinements and no results so not able to find it
           if (attributeIndex === -1) {
@@ -8243,20 +8468,31 @@
         } else {
           position = disjunctiveFacetsIndices[dfacet];
 
-          var dataFromMainRequest = mainSubResponse.facets && mainSubResponse.facets[dfacet] || {};
+          var dataFromMainRequest =
+            (mainSubResponse.facets && mainSubResponse.facets[dfacet]) || {};
 
           self.disjunctiveFacets[position] = {
             name: dfacet,
             data: defaultsPure({}, facetResults, dataFromMainRequest),
-            exhaustive: result.exhaustiveFacetsCount
+            exhaustive: result.exhaustiveFacetsCount,
           };
-          assignFacetStats(self.disjunctiveFacets[position], result.facets_stats, dfacet);
+          assignFacetStats(
+            self.disjunctiveFacets[position],
+            result.facets_stats,
+            dfacet
+          );
 
           if (state.disjunctiveFacetsRefinements[dfacet]) {
-            state.disjunctiveFacetsRefinements[dfacet].forEach(function(refinementValue) {
+            state.disjunctiveFacetsRefinements[dfacet].forEach(function (
+              refinementValue
+            ) {
               // add the disjunctive refinements if it is no more retrieved
-              if (!self.disjunctiveFacets[position].data[refinementValue] &&
-                state.disjunctiveFacetsRefinements[dfacet].indexOf(unescapeFacetValue$3(refinementValue)) > -1) {
+              if (
+                !self.disjunctiveFacets[position].data[refinementValue] &&
+                state.disjunctiveFacetsRefinements[dfacet].indexOf(
+                  unescapeFacetValue$3(refinementValue)
+                ) > -1
+              ) {
                 self.disjunctiveFacets[position].data[refinementValue] = 0;
               }
             });
@@ -8267,30 +8503,34 @@
     });
 
     // if we have some parent level values for hierarchical facets, merge them
-    state.getRefinedHierarchicalFacets().forEach(function(refinedFacet) {
+    state.getRefinedHierarchicalFacets().forEach(function (refinedFacet) {
       var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);
       var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
 
       var currentRefinement = state.getHierarchicalRefinement(refinedFacet);
       // if we are already at a root refinement (or no refinement at all), there is no
       // root level values request
-      if (currentRefinement.length === 0 || currentRefinement[0].split(separator).length < 2) {
+      if (
+        currentRefinement.length === 0 ||
+        currentRefinement[0].split(separator).length < 2
+      ) {
         return;
       }
 
-      results.slice(nextDisjunctiveResult).forEach(function(result) {
-        var facets = result && result.facets
-          ? result.facets
-          : {};
+      results.slice(nextDisjunctiveResult).forEach(function (result) {
+        var facets = result && result.facets ? result.facets : {};
 
-        Object.keys(facets).forEach(function(dfacet) {
+        Object.keys(facets).forEach(function (dfacet) {
           var facetResults = facets[dfacet];
-          var position = findIndex$1(state.hierarchicalFacets, function(f) {
+          var position = findIndex$1(state.hierarchicalFacets, function (f) {
             return f.name === hierarchicalFacet.name;
           });
-          var attributeIndex = findIndex$1(self.hierarchicalFacets[position], function(f) {
-            return f.attribute === dfacet;
-          });
+          var attributeIndex = findIndex$1(
+            self.hierarchicalFacets[position],
+            function (f) {
+              return f.attribute === dfacet;
+            }
+          );
 
           // previous refinements and no results so not able to find it
           if (attributeIndex === -1) {
@@ -8309,7 +8549,8 @@
 
           if (currentRefinement.length > 0) {
             var root = currentRefinement[0].split(separator)[0];
-            defaultData[root] = self.hierarchicalFacets[position][attributeIndex].data[root];
+            defaultData[root] =
+              self.hierarchicalFacets[position][attributeIndex].data[root];
           }
 
           self.hierarchicalFacets[position][attributeIndex].data = defaultsPure(
@@ -8324,17 +8565,17 @@
     });
 
     // add the excludes
-    Object.keys(state.facetsExcludes).forEach(function(facetName) {
+    Object.keys(state.facetsExcludes).forEach(function (facetName) {
       var excludes = state.facetsExcludes[facetName];
       var position = facetsIndices[facetName];
 
       self.facets[position] = {
         name: facetName,
         data: mainFacets[facetName],
-        exhaustive: mainSubResponse.exhaustiveFacetsCount
+        exhaustive: mainSubResponse.exhaustiveFacetsCount,
       };
-      excludes.forEach(function(facetValue) {
-        self.facets[position] = self.facets[position] || {name: facetName};
+      excludes.forEach(function (facetValue) {
+        self.facets[position] = self.facets[position] || { name: facetName };
         self.facets[position].data = self.facets[position].data || {};
         self.facets[position].data[facetValue] = 0;
       });
@@ -8343,7 +8584,9 @@
     /**
      * @type {Array}
      */
-    this.hierarchicalFacets = this.hierarchicalFacets.map(generateHierarchicalTree_1(state));
+    this.hierarchicalFacets = this.hierarchicalFacets.map(
+      generateHierarchicalTree_1(state)
+    );
 
     /**
      * @type {Array}
@@ -8363,14 +8606,16 @@
    * @param {string} name name of the faceted attribute
    * @return {SearchResults.Facet} the facet object
    */
-  SearchResults.prototype.getFacetByName = function(name) {
+  SearchResults.prototype.getFacetByName = function (name) {
     function predicate(facet) {
       return facet.name === name;
     }
 
-    return find$1(this.facets, predicate) ||
+    return (
+      find$1(this.facets, predicate) ||
       find$1(this.disjunctiveFacets, predicate) ||
-      find$1(this.hierarchicalFacets, predicate);
+      find$1(this.hierarchicalFacets, predicate)
+    );
   };
 
   /**
@@ -8389,55 +8634,70 @@
       var facet = find$1(results.facets, predicate);
       if (!facet) return [];
 
-      return Object.keys(facet.data).map(function(name) {
+      return Object.keys(facet.data).map(function (name) {
         var value = escapeFacetValue$3(name);
         return {
           name: name,
           escapedValue: value,
           count: facet.data[name],
           isRefined: results._state.isFacetRefined(attribute, value),
-          isExcluded: results._state.isExcludeRefined(attribute, name)
+          isExcluded: results._state.isExcludeRefined(attribute, name),
         };
       });
     } else if (results._state.isDisjunctiveFacet(attribute)) {
       var disjunctiveFacet = find$1(results.disjunctiveFacets, predicate);
       if (!disjunctiveFacet) return [];
 
-      return Object.keys(disjunctiveFacet.data).map(function(name) {
+      return Object.keys(disjunctiveFacet.data).map(function (name) {
         var value = escapeFacetValue$3(name);
         return {
           name: name,
           escapedValue: value,
           count: disjunctiveFacet.data[name],
-          isRefined: results._state.isDisjunctiveFacetRefined(attribute, value)
+          isRefined: results._state.isDisjunctiveFacetRefined(attribute, value),
         };
       });
     } else if (results._state.isHierarchicalFacet(attribute)) {
       var hierarchicalFacetValues = find$1(results.hierarchicalFacets, predicate);
       if (!hierarchicalFacetValues) return hierarchicalFacetValues;
 
-      var hierarchicalFacet = results._state.getHierarchicalFacetByName(attribute);
-      var currentRefinementSplit = unescapeFacetValue$3(
+      var hierarchicalFacet =
+        results._state.getHierarchicalFacetByName(attribute);
+      var separator =
+        results._state._getHierarchicalFacetSeparator(hierarchicalFacet);
+      var currentRefinement = unescapeFacetValue$3(
         results._state.getHierarchicalRefinement(attribute)[0] || ''
-      ).split(results._state._getHierarchicalFacetSeparator(hierarchicalFacet));
+      );
+
+      if (currentRefinement.indexOf(hierarchicalFacet.rootPath) === 0) {
+        currentRefinement = currentRefinement.replace(
+          hierarchicalFacet.rootPath + separator,
+          ''
+        );
+      }
+
+      var currentRefinementSplit = currentRefinement.split(separator);
       currentRefinementSplit.unshift(attribute);
 
       setIsRefined(hierarchicalFacetValues, currentRefinementSplit, 0);
 
       return hierarchicalFacetValues;
     }
+
+    return undefined;
   }
 
   /**
    * Set the isRefined of a hierarchical facet result based on the current state.
    * @param {SearchResults.HierarchicalFacet} item Hierarchical facet to fix
-   * @param {string[]} currentRefinementSplit array of parts of the current hierarchical refinement
+   * @param {string[]} currentRefinement array of parts of the current hierarchical refinement
    * @param {number} depth recursion depth in the currentRefinement
+   * @return {undefined} function mutates the item
    */
   function setIsRefined(item, currentRefinement, depth) {
     item.isRefined = item.name === currentRefinement[depth];
     if (item.data) {
-      item.data.forEach(function(child) {
+      item.data.forEach(function (child) {
         setIsRefined(child, currentRefinement, depth + 1);
       });
     }
@@ -8446,10 +8706,11 @@
   /**
    * Sort nodes of a hierarchical or disjunctive facet results
    * @private
-   * @param {function} sortFn
+   * @param {function} sortFn sort function to apply
    * @param {HierarchicalFacet|Array} node node upon which we want to apply the sort
    * @param {string[]} names attribute names
    * @param {number} [level=0] current index in the names array
+   * @return {HierarchicalFacet|Array} sorted node
    */
   function recSort(sortFn, node, names, level) {
     level = level || 0;
@@ -8462,11 +8723,11 @@
       return node;
     }
 
-    var children = node.data.map(function(childNode) {
+    var children = node.data.map(function (childNode) {
       return recSort(sortFn, childNode, names, level + 1);
     });
     var sortedChildren = sortFn(children, names[level]);
-    var newNode = defaultsPure({data: sortedChildren}, node);
+    var newNode = defaultsPure({ data: sortedChildren }, node);
     return newNode;
   }
 
@@ -8487,7 +8748,7 @@
    * Sorts facet arrays via their facet ordering
    * @param {Array} facetValues the values
    * @param {FacetOrdering} facetOrdering the ordering
-   * @returns {Array}
+   * @returns {Array} the sorted facet values
    */
   function sortViaFacetOrdering(facetValues, facetOrdering) {
     var orderedFacets = [];
@@ -8498,12 +8759,12 @@
      * an object with the keys being the values in order, the values their index:
      * ['one', 'two'] -> { one: 0, two: 1 }
      */
-    var reverseOrder = order.reduce(function(acc, name, i) {
+    var reverseOrder = order.reduce(function (acc, name, i) {
       acc[name] = i;
       return acc;
     }, {});
 
-    facetValues.forEach(function(item) {
+    facetValues.forEach(function (item) {
       // hierarchical facets get sorted using their raw name
       var name = item.path || item.name;
       if (reverseOrder[name] !== undefined) {
@@ -8513,7 +8774,7 @@
       }
     });
 
-    orderedFacets = orderedFacets.filter(function(facet) {
+    orderedFacets = orderedFacets.filter(function (facet) {
       return facet;
     });
 
@@ -8522,7 +8783,10 @@
     if (sortRemainingBy === 'hidden') {
       return orderedFacets;
     } else if (sortRemainingBy === 'alpha') {
-      ordering = [['path', 'name'], ['asc', 'asc']];
+      ordering = [
+        ['path', 'name'],
+        ['asc', 'asc'],
+      ];
     } else {
       ordering = [['count'], ['desc']];
     }
@@ -8535,7 +8799,7 @@
   /**
    * @param {SearchResults} results the search results class
    * @param {string} attribute the attribute to retrieve ordering of
-   * @returns {FacetOrdering=}
+   * @returns {FacetOrdering | undefined} the facet ordering
    */
   function getFacetOrdering(results, attribute) {
     return (
@@ -8594,7 +8858,7 @@
    *   });
    * });
    */
-  SearchResults.prototype.getFacetValues = function(attribute, opts) {
+  SearchResults.prototype.getFacetValues = function (attribute, opts) {
     var facetValues = extractNormalizedFacetValues(this, attribute);
     if (!facetValues) {
       return undefined;
@@ -8604,9 +8868,10 @@
       sortBy: SearchResults.DEFAULT_SORT,
       // if no sortBy is given, attempt to sort based on facetOrdering
       // if it is given, we still allow to sort via facet ordering first
-      facetOrdering: !(opts && opts.sortBy)
+      facetOrdering: !(opts && opts.sortBy),
     });
 
+    // eslint-disable-next-line consistent-this
     var results = this;
     var attributes;
     if (Array.isArray(facetValues)) {
@@ -8616,25 +8881,29 @@
       attributes = config.attributes;
     }
 
-    return recSort(function(data, facetName) {
-      if (options.facetOrdering) {
-        var facetOrdering = getFacetOrdering(results, facetName);
-        if (Boolean(facetOrdering)) {
-          return sortViaFacetOrdering(data, facetOrdering);
+    return recSort(
+      function (data, facetName) {
+        if (options.facetOrdering) {
+          var facetOrdering = getFacetOrdering(results, facetName);
+          if (facetOrdering) {
+            return sortViaFacetOrdering(data, facetOrdering);
+          }
         }
-      }
 
-      if (Array.isArray(options.sortBy)) {
-        var order = formatSort(options.sortBy, SearchResults.DEFAULT_SORT);
-        return orderBy_1(data, order[0], order[1]);
-      } else if (typeof options.sortBy === 'function') {
-        return vanillaSortFn(options.sortBy, data);
-      }
-      throw new Error(
-        'options.sortBy is optional but if defined it must be ' +
-          'either an array of string (predicates) or a sorting function'
-      );
-    }, facetValues, attributes);
+        if (Array.isArray(options.sortBy)) {
+          var order = formatSort(options.sortBy, SearchResults.DEFAULT_SORT);
+          return orderBy_1(data, order[0], order[1]);
+        } else if (typeof options.sortBy === 'function') {
+          return vanillaSortFn(options.sortBy, data);
+        }
+        throw new Error(
+          'options.sortBy is optional but if defined it must be ' +
+            'either an array of string (predicates) or a sorting function'
+        );
+      },
+      facetValues,
+      attributes
+    );
   };
 
   /**
@@ -8643,7 +8912,7 @@
    * @param {string} attribute name of the faceted attribute
    * @return {object} The stats of the facet
    */
-  SearchResults.prototype.getFacetStats = function(attribute) {
+  SearchResults.prototype.getFacetStats = function (attribute) {
     if (this._state.isConjunctiveFacet(attribute)) {
       return getFacetStatsIfAvailable(this.facets, attribute);
     } else if (this._state.isDisjunctiveFacet(attribute)) {
@@ -8660,10 +8929,11 @@
 
   /**
    * @param {FacetListItem[]} facetList (has more items, but enough for here)
-   * @param {string} facetName
+   * @param {string} facetName The attribute to look for
+   * @return {object|undefined} The stats of the facet
    */
   function getFacetStatsIfAvailable(facetList, facetName) {
-    var data = find$1(facetList, function(facet) {
+    var data = find$1(facetList, function (facet) {
       return facet.name === facetName;
     });
     return data && data.stats;
@@ -8681,53 +8951,76 @@
    *
    * @return {Array.<Refinement>} all the refinements
    */
-  SearchResults.prototype.getRefinements = function() {
+  SearchResults.prototype.getRefinements = function () {
     var state = this._state;
+    // eslint-disable-next-line consistent-this
     var results = this;
     var res = [];
 
-    Object.keys(state.facetsRefinements).forEach(function(attributeName) {
-      state.facetsRefinements[attributeName].forEach(function(name) {
-        res.push(getRefinement$1(state, 'facet', attributeName, name, results.facets));
+    Object.keys(state.facetsRefinements).forEach(function (attributeName) {
+      state.facetsRefinements[attributeName].forEach(function (name) {
+        res.push(
+          getRefinement$1(state, 'facet', attributeName, name, results.facets)
+        );
       });
     });
 
-    Object.keys(state.facetsExcludes).forEach(function(attributeName) {
-      state.facetsExcludes[attributeName].forEach(function(name) {
-        res.push(getRefinement$1(state, 'exclude', attributeName, name, results.facets));
+    Object.keys(state.facetsExcludes).forEach(function (attributeName) {
+      state.facetsExcludes[attributeName].forEach(function (name) {
+        res.push(
+          getRefinement$1(state, 'exclude', attributeName, name, results.facets)
+        );
       });
     });
 
-    Object.keys(state.disjunctiveFacetsRefinements).forEach(function(attributeName) {
-      state.disjunctiveFacetsRefinements[attributeName].forEach(function(name) {
-        res.push(getRefinement$1(state, 'disjunctive', attributeName, name, results.disjunctiveFacets));
+    Object.keys(state.disjunctiveFacetsRefinements).forEach(function (
+      attributeName
+    ) {
+      state.disjunctiveFacetsRefinements[attributeName].forEach(function (name) {
+        res.push(
+          getRefinement$1(
+            state,
+            'disjunctive',
+            attributeName,
+            name,
+            results.disjunctiveFacets
+          )
+        );
       });
     });
 
-    Object.keys(state.hierarchicalFacetsRefinements).forEach(function(attributeName) {
-      state.hierarchicalFacetsRefinements[attributeName].forEach(function(name) {
-        res.push(getHierarchicalRefinement(state, attributeName, name, results.hierarchicalFacets));
+    Object.keys(state.hierarchicalFacetsRefinements).forEach(function (
+      attributeName
+    ) {
+      state.hierarchicalFacetsRefinements[attributeName].forEach(function (name) {
+        res.push(
+          getHierarchicalRefinement(
+            state,
+            attributeName,
+            name,
+            results.hierarchicalFacets
+          )
+        );
       });
     });
 
-
-    Object.keys(state.numericRefinements).forEach(function(attributeName) {
+    Object.keys(state.numericRefinements).forEach(function (attributeName) {
       var operators = state.numericRefinements[attributeName];
-      Object.keys(operators).forEach(function(operator) {
-        operators[operator].forEach(function(value) {
+      Object.keys(operators).forEach(function (operator) {
+        operators[operator].forEach(function (value) {
           res.push({
             type: 'numeric',
             attributeName: attributeName,
             name: value,
             numericValue: value,
-            operator: operator
+            operator: operator,
           });
         });
       });
     });
 
-    state.tagRefinements.forEach(function(name) {
-      res.push({type: 'tag', attributeName: '_tags', name: name});
+    state.tagRefinements.forEach(function (name) {
+      res.push({ type: 'tag', attributeName: '_tags', name: name });
     });
 
     return res;
@@ -8741,14 +9034,15 @@
    */
 
   /**
-   * @param {*} state
-   * @param {*} type
-   * @param {string} attributeName
-   * @param {*} name
-   * @param {Facet[]} resultsFacets
+   * @param {SearchParameters} state the current state
+   * @param {string} type the type of the refinement
+   * @param {string} attributeName The attribute of the facet
+   * @param {*} name The name of the facet
+   * @param {Facet[]} resultsFacets facets from the results
+   * @return {Refinement} the refinement
    */
   function getRefinement$1(state, type, attributeName, name, resultsFacets) {
-    var facet = find$1(resultsFacets, function(f) {
+    var facet = find$1(resultsFacets, function (f) {
       return f.name === attributeName;
     });
     var count = facet && facet.data && facet.data[name] ? facet.data[name] : 0;
@@ -8759,27 +9053,29 @@
       attributeName: attributeName,
       name: name,
       count: count,
-      exhaustive: exhaustive
+      exhaustive: exhaustive,
     };
   }
 
   /**
-   * @param {*} state
-   * @param {string} attributeName
-   * @param {*} name
-   * @param {Facet[]} resultsFacets
+   * @param {SearchParameters} state the current state
+   * @param {string} attributeName the attribute of the hierarchical facet
+   * @param {string} name the name of the facet
+   * @param {Facet[]} resultsFacets facets from the results
+   * @return {HierarchicalFacet} the hierarchical facet
    */
   function getHierarchicalRefinement(state, attributeName, name, resultsFacets) {
     var facetDeclaration = state.getHierarchicalFacetByName(attributeName);
     var separator = state._getHierarchicalFacetSeparator(facetDeclaration);
     var split = name.split(separator);
-    var rootFacet = find$1(resultsFacets, function(facet) {
+    var rootFacet = find$1(resultsFacets, function (facet) {
       return facet.name === attributeName;
     });
 
-    var facet = split.reduce(function(intermediateFacet, part) {
+    var facet = split.reduce(function (intermediateFacet, part) {
       var newFacet =
-        intermediateFacet && find$1(intermediateFacet.data, function(f) {
+        intermediateFacet &&
+        find$1(intermediateFacet.data, function (f) {
           return f.name === part;
         });
       return newFacet !== undefined ? newFacet : intermediateFacet;
@@ -8794,7 +9090,7 @@
       attributeName: attributeName,
       name: path,
       count: count,
-      exhaustive: exhaustive
+      exhaustive: exhaustive,
     };
   }
 
@@ -9109,8 +9405,8 @@
         value: ctor,
         enumerable: false,
         writable: true,
-        configurable: true
-      }
+        configurable: true,
+      },
     });
   }
 
@@ -9125,6 +9421,8 @@
    *  - result: when the response is retrieved from Algolia and is processed.
    *    This event contains a {@link SearchResults} object and the
    *    {@link SearchParameters} corresponding to this answer.
+   * @param {AlgoliaSearchHelper} mainHelper the main helper
+   * @param {function} fn the function to create the derived state
    */
   function DerivedHelper(mainHelper, fn) {
     this.main = mainHelper;
@@ -9139,12 +9437,12 @@
    * @return {undefined}
    * @throws Error if the derived helper is already detached
    */
-  DerivedHelper.prototype.detach = function() {
+  DerivedHelper.prototype.detach = function () {
     this.removeAllListeners();
     this.main.detachDerivedHelper(this);
   };
 
-  DerivedHelper.prototype.getModifiedState = function(parameters) {
+  DerivedHelper.prototype.getModifiedState = function (parameters) {
     return this.fn(parameters);
   };
 
@@ -9152,10 +9450,10 @@
 
   function sortObject(obj) {
     return Object.keys(obj)
-      .sort(function(a, b) {
+      .sort(function (a, b) {
         return a.localeCompare(b);
       })
-      .reduce(function(acc, curr) {
+      .reduce(function (acc, curr) {
         acc[curr] = obj[curr];
         return acc;
       }, {});
@@ -9166,6 +9464,8 @@
      * Get all the queries to send to the client, those queries can used directly
      * with the Algolia client.
      * @private
+     * @param  {string} index The name of the index
+     * @param  {SearchParameters} state The state from which to get the queries
      * @return {object[]} The queries
      */
     _getQueries: function getQueries(index, state) {
@@ -9174,39 +9474,47 @@
       // One query for the hits
       queries.push({
         indexName: index,
-        params: requestBuilder._getHitsSearchParams(state)
+        params: requestBuilder._getHitsSearchParams(state),
       });
 
       // One for each disjunctive facets
-      state.getRefinedDisjunctiveFacets().forEach(function(refinedFacet) {
+      state.getRefinedDisjunctiveFacets().forEach(function (refinedFacet) {
         queries.push({
           indexName: index,
-          params: requestBuilder._getDisjunctiveFacetSearchParams(state, refinedFacet)
+          params: requestBuilder._getDisjunctiveFacetSearchParams(
+            state,
+            refinedFacet
+          ),
         });
       });
 
       // More to get the parent levels of the hierarchical facets when refined
-      state.getRefinedHierarchicalFacets().forEach(function(refinedFacet) {
+      state.getRefinedHierarchicalFacets().forEach(function (refinedFacet) {
         var hierarchicalFacet = state.getHierarchicalFacetByName(refinedFacet);
         var currentRefinement = state.getHierarchicalRefinement(refinedFacet);
         var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
 
         // If we are deeper than level 0 (starting from `beer > IPA`)
         // we want to get all parent values
-        if (currentRefinement.length > 0 && currentRefinement[0].split(separator).length > 1) {
+        if (
+          currentRefinement.length > 0 &&
+          currentRefinement[0].split(separator).length > 1
+        ) {
           // We generate a map of the filters we will use for our facet values queries
-          var filtersMap = currentRefinement[0].split(separator).slice(0, -1).reduce(
-            function createFiltersMap(map, segment, level) {
+          var filtersMap = currentRefinement[0]
+            .split(separator)
+            .slice(0, -1)
+            .reduce(function createFiltersMap(map, segment, level) {
               return map.concat({
                 attribute: hierarchicalFacet.attributes[level],
-                value: level === 0
-                  ? segment
-                  : [map[map.length - 1].value, segment].join(separator)
+                value:
+                  level === 0
+                    ? segment
+                    : [map[map.length - 1].value, segment].join(separator),
               });
-            }
-          , []);
+            }, []);
 
-          filtersMap.forEach(function(filter, level) {
+          filtersMap.forEach(function (filter, level) {
             var params = requestBuilder._getDisjunctiveFacetSearchParams(
               state,
               filter.attribute,
@@ -9215,37 +9523,48 @@
 
             // Keep facet filters unrelated to current hierarchical attributes
             function hasHierarchicalFacetFilter(value) {
-              return hierarchicalFacet.attributes.some(function(attribute) {
+              return hierarchicalFacet.attributes.some(function (attribute) {
                 return attribute === value.split(':')[0];
               });
             }
 
-            var filteredFacetFilters = (params.facetFilters || []).reduce(function(acc, facetFilter) {
-              if (Array.isArray(facetFilter)) {
-                var filtered = facetFilter.filter(function(filterValue) {
-                  return !hasHierarchicalFacetFilter(filterValue);
-                });
+            var filteredFacetFilters = (params.facetFilters || []).reduce(
+              function (acc, facetFilter) {
+                if (Array.isArray(facetFilter)) {
+                  var filtered = facetFilter.filter(function (filterValue) {
+                    return !hasHierarchicalFacetFilter(filterValue);
+                  });
 
-                if (filtered.length > 0) {
-                  acc.push(filtered);
+                  if (filtered.length > 0) {
+                    acc.push(filtered);
+                  }
                 }
-              }
 
-              if (typeof facetFilter === 'string' && !hasHierarchicalFacetFilter(facetFilter)) {
-                acc.push(facetFilter);
-              }
+                if (
+                  typeof facetFilter === 'string' &&
+                  !hasHierarchicalFacetFilter(facetFilter)
+                ) {
+                  acc.push(facetFilter);
+                }
 
-              return acc;
-            }, []);
+                return acc;
+              },
+              []
+            );
 
             var parent = filtersMap[level - 1];
             if (level > 0) {
-              params.facetFilters = filteredFacetFilters.concat(parent.attribute + ':' + parent.value);
+              params.facetFilters = filteredFacetFilters.concat(
+                parent.attribute + ':' + parent.value
+              );
             } else {
-              params.facetFilters = filteredFacetFilters.length > 0 ? filteredFacetFilters : undefined;
+              params.facetFilters =
+                filteredFacetFilters.length > 0
+                  ? filteredFacetFilters
+                  : undefined;
             }
 
-            queries.push({indexName: index, params: params});
+            queries.push({ indexName: index, params: params });
           });
         }
       });
@@ -9256,20 +9575,20 @@
     /**
      * Build search parameters used to fetch hits
      * @private
-     * @return {object.<string, any>}
+     * @param  {SearchParameters} state The state from which to get the queries
+     * @return {object.<string, any>} The search parameters for hits
      */
-    _getHitsSearchParams: function(state) {
+    _getHitsSearchParams: function (state) {
       var facets = state.facets
         .concat(state.disjunctiveFacets)
         .concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state));
 
-
       var facetFilters = requestBuilder._getFacetFilters(state);
       var numericFilters = requestBuilder._getNumericFilters(state);
       var tagFilters = requestBuilder._getTagFilters(state);
       var additionalParams = {
         facets: facets.indexOf('*') > -1 ? ['*'] : facets,
-        tagFilters: tagFilters
+        tagFilters: tagFilters,
       };
 
       if (facetFilters.length > 0) {
@@ -9286,19 +9605,28 @@
     /**
      * Build search parameters used to fetch a disjunctive facet
      * @private
+     * @param  {SearchParameters} state The state from which to get the queries
      * @param  {string} facet the associated facet name
      * @param  {boolean} hierarchicalRootLevel ?? FIXME
-     * @return {object}
+     * @return {object} The search parameters for a disjunctive facet
      */
-    _getDisjunctiveFacetSearchParams: function(state, facet, hierarchicalRootLevel) {
-      var facetFilters = requestBuilder._getFacetFilters(state, facet, hierarchicalRootLevel);
+    _getDisjunctiveFacetSearchParams: function (
+      state,
+      facet,
+      hierarchicalRootLevel
+    ) {
+      var facetFilters = requestBuilder._getFacetFilters(
+        state,
+        facet,
+        hierarchicalRootLevel
+      );
       var numericFilters = requestBuilder._getNumericFilters(state, facet);
       var tagFilters = requestBuilder._getTagFilters(state);
       var additionalParams = {
         hitsPerPage: 0,
         page: 0,
         analytics: false,
-        clickAnalytics: false
+        clickAnalytics: false,
       };
 
       if (tagFilters.length > 0) {
@@ -9308,11 +9636,12 @@
       var hierarchicalFacet = state.getHierarchicalFacetByName(facet);
 
       if (hierarchicalFacet) {
-        additionalParams.facets = requestBuilder._getDisjunctiveHierarchicalFacetAttribute(
-          state,
-          hierarchicalFacet,
-          hierarchicalRootLevel
-        );
+        additionalParams.facets =
+          requestBuilder._getDisjunctiveHierarchicalFacetAttribute(
+            state,
+            hierarchicalFacet,
+            hierarchicalRootLevel
+          );
       } else {
         additionalParams.facets = facet;
       }
@@ -9331,24 +9660,25 @@
     /**
      * Return the numeric filters in an algolia request fashion
      * @private
+     * @param {SearchParameters} state the state from which to get the filters
      * @param {string} [facetName] the name of the attribute for which the filters should be excluded
      * @return {string[]} the numeric filters in the algolia format
      */
-    _getNumericFilters: function(state, facetName) {
+    _getNumericFilters: function (state, facetName) {
       if (state.numericFilters) {
         return state.numericFilters;
       }
 
       var numericFilters = [];
 
-      Object.keys(state.numericRefinements).forEach(function(attribute) {
+      Object.keys(state.numericRefinements).forEach(function (attribute) {
         var operators = state.numericRefinements[attribute] || {};
-        Object.keys(operators).forEach(function(operator) {
+        Object.keys(operators).forEach(function (operator) {
           var values = operators[operator] || [];
           if (facetName !== attribute) {
-            values.forEach(function(value) {
+            values.forEach(function (value) {
               if (Array.isArray(value)) {
-                var vs = value.map(function(v) {
+                var vs = value.map(function (v) {
                   return attribute + operator + v;
                 });
                 numericFilters.push(vs);
@@ -9364,11 +9694,12 @@
     },
 
     /**
-     * Return the tags filters depending
+     * Return the tags filters depending on which format is used, either tagFilters or tagRefinements
      * @private
-     * @return {string}
+     * @param {SearchParameters} state the state from which to get the filters
+     * @return {string} Tag filters in a single string
      */
-    _getTagFilters: function(state) {
+    _getTagFilters: function (state) {
       if (state.tagFilters) {
         return state.tagFilters;
       }
@@ -9376,50 +9707,52 @@
       return state.tagRefinements.join(',');
     },
 
-
     /**
      * Build facetFilters parameter based on current refinements. The array returned
      * contains strings representing the facet filters in the algolia format.
      * @private
+     * @param  {SearchParameters} state The state from which to get the queries
      * @param  {string} [facet] if set, the current disjunctive facet
-     * @return {array.<string>}
+     * @param  {boolean} [hierarchicalRootLevel] ?? FIXME
+     * @return {array.<string>} The facet filters in the algolia format
      */
-    _getFacetFilters: function(state, facet, hierarchicalRootLevel) {
+    _getFacetFilters: function (state, facet, hierarchicalRootLevel) {
       var facetFilters = [];
 
       var facetsRefinements = state.facetsRefinements || {};
-      Object.keys(facetsRefinements).forEach(function(facetName) {
+      Object.keys(facetsRefinements).forEach(function (facetName) {
         var facetValues = facetsRefinements[facetName] || [];
-        facetValues.forEach(function(facetValue) {
+        facetValues.forEach(function (facetValue) {
           facetFilters.push(facetName + ':' + facetValue);
         });
       });
 
       var facetsExcludes = state.facetsExcludes || {};
-      Object.keys(facetsExcludes).forEach(function(facetName) {
+      Object.keys(facetsExcludes).forEach(function (facetName) {
         var facetValues = facetsExcludes[facetName] || [];
-        facetValues.forEach(function(facetValue) {
+        facetValues.forEach(function (facetValue) {
           facetFilters.push(facetName + ':-' + facetValue);
         });
       });
 
       var disjunctiveFacetsRefinements = state.disjunctiveFacetsRefinements || {};
-      Object.keys(disjunctiveFacetsRefinements).forEach(function(facetName) {
+      Object.keys(disjunctiveFacetsRefinements).forEach(function (facetName) {
         var facetValues = disjunctiveFacetsRefinements[facetName] || [];
         if (facetName === facet || !facetValues || facetValues.length === 0) {
           return;
         }
         var orFilters = [];
 
-        facetValues.forEach(function(facetValue) {
+        facetValues.forEach(function (facetValue) {
           orFilters.push(facetName + ':' + facetValue);
         });
 
         facetFilters.push(orFilters);
       });
 
-      var hierarchicalFacetsRefinements = state.hierarchicalFacetsRefinements || {};
-      Object.keys(hierarchicalFacetsRefinements).forEach(function(facetName) {
+      var hierarchicalFacetsRefinements =
+        state.hierarchicalFacetsRefinements || {};
+      Object.keys(hierarchicalFacetsRefinements).forEach(function (facetName) {
         var facetValues = hierarchicalFacetsRefinements[facetName] || [];
         var facetValue = facetValues[0];
 
@@ -9437,8 +9770,13 @@
         if (facet === facetName) {
           // if we are at the root level already, no need to ask for facet values, we get them from
           // the hits query
-          if (facetValue.indexOf(separator) === -1 || (!rootPath && hierarchicalRootLevel === true) ||
-            (rootPath && rootPath.split(separator).length === facetValue.split(separator).length)) {
+          if (
+            facetValue.indexOf(separator) === -1 ||
+            (!rootPath && hierarchicalRootLevel === true) ||
+            (rootPath &&
+              rootPath.split(separator).length ===
+                facetValue.split(separator).length)
+          ) {
             return;
           }
 
@@ -9465,13 +9803,18 @@
       return facetFilters;
     },
 
-    _getHitsHierarchicalFacetsAttributes: function(state) {
+    _getHitsHierarchicalFacetsAttributes: function (state) {
       var out = [];
 
       return state.hierarchicalFacets.reduce(
         // ask for as much levels as there's hierarchical refinements
-        function getHitsAttributesForHierarchicalFacet(allAttributes, hierarchicalFacet) {
-          var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0];
+        function getHitsAttributesForHierarchicalFacet(
+          allAttributes,
+          hierarchicalFacet
+        ) {
+          var hierarchicalRefinement = state.getHierarchicalRefinement(
+            hierarchicalFacet.name
+          )[0];
 
           // if no refinement, ask for root level
           if (!hierarchicalRefinement) {
@@ -9484,10 +9827,16 @@
           var newAttributes = hierarchicalFacet.attributes.slice(0, level + 1);
 
           return allAttributes.concat(newAttributes);
-        }, out);
+        },
+        out
+      );
     },
 
-    _getDisjunctiveHierarchicalFacetAttribute: function(state, hierarchicalFacet, rootLevel) {
+    _getDisjunctiveHierarchicalFacetAttribute: function (
+      state,
+      hierarchicalFacet,
+      rootLevel
+    ) {
       var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
       if (rootLevel === true) {
         var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);
@@ -9499,7 +9848,8 @@
         return [hierarchicalFacet.attributes[attributeIndex]];
       }
 
-      var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0] || '';
+      var hierarchicalRefinement =
+        state.getHierarchicalRefinement(hierarchicalFacet.name)[0] || '';
       // if refinement is 'beers > IPA > Flying dog',
       // then we want `facets: ['beers > IPA']` as disjunctive facet (parent level values)
 
@@ -9507,28 +9857,30 @@
       return hierarchicalFacet.attributes.slice(0, parentLevel + 1);
     },
 
-    getSearchForFacetQuery: function(facetName, query, maxFacetHits, state) {
-      var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName) ?
-        state.clearRefinements(facetName) :
-        state;
+    getSearchForFacetQuery: function (facetName, query, maxFacetHits, state) {
+      var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName)
+        ? state.clearRefinements(facetName)
+        : state;
       var searchForFacetSearchParameters = {
         facetQuery: query,
-        facetName: facetName
+        facetName: facetName,
       };
       if (typeof maxFacetHits === 'number') {
         searchForFacetSearchParameters.maxFacetHits = maxFacetHits;
       }
-      return sortObject(merge_1(
-        {},
-        requestBuilder._getHitsSearchParams(stateForSearchForFacetValues),
-        searchForFacetSearchParameters
-      ));
-    }
+      return sortObject(
+        merge_1(
+          {},
+          requestBuilder._getHitsSearchParams(stateForSearchForFacetValues),
+          searchForFacetSearchParameters
+        )
+      );
+    },
   };
 
   var requestBuilder_1 = requestBuilder;
 
-  var version = '3.13.2';
+  var version = '3.13.5';
 
   var escapeFacetValue$4 = escapeFacetValue_1.escapeFacetValue;
 
@@ -9658,19 +10010,19 @@
    * method is called, it triggers a `search` event. The results will
    * be available through the `result` event. If an error occurs, an
    * `error` will be fired instead.
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires search
    * @fires result
    * @fires error
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.search = function() {
-    this._search({onlyWithDerivedHelpers: false});
+  AlgoliaSearchHelper.prototype.search = function () {
+    this._search({ onlyWithDerivedHelpers: false });
     return this;
   };
 
-  AlgoliaSearchHelper.prototype.searchOnlyWithDerivedHelpers = function() {
-    this._search({onlyWithDerivedHelpers: true});
+  AlgoliaSearchHelper.prototype.searchOnlyWithDerivedHelpers = function () {
+    this._search({ onlyWithDerivedHelpers: true });
     return this;
   };
 
@@ -9679,7 +10031,7 @@
    * for the hits
    * @return {object} Query Parameters
    */
-  AlgoliaSearchHelper.prototype.getQuery = function() {
+  AlgoliaSearchHelper.prototype.getQuery = function () {
     var state = this.state;
     return requestBuilder_1._getHitsSearchParams(state);
   };
@@ -9691,7 +10043,7 @@
    * same as a search call before calling searchOnce.
    * @param {object} options can contain all the parameters that can be set to SearchParameters
    * plus the index
-   * @param {function} [callback] optional callback executed when the response from the
+   * @param {function} [cb] optional callback executed when the response from the
    * server is back.
    * @return {promise|undefined} if a callback is passed the method returns undefined
    * otherwise it returns a promise containing an object with two keys :
@@ -9720,21 +10072,24 @@
    *   // }
    * }
    */
-  AlgoliaSearchHelper.prototype.searchOnce = function(options, cb) {
-    var tempState = !options ? this.state : this.state.setQueryParameters(options);
+  AlgoliaSearchHelper.prototype.searchOnce = function (options, cb) {
+    var tempState = !options
+      ? this.state
+      : this.state.setQueryParameters(options);
     var queries = requestBuilder_1._getQueries(tempState.index, tempState);
+    // eslint-disable-next-line consistent-this
     var self = this;
 
     this._currentNbQueries++;
 
     this.emit('searchOnce', {
-      state: tempState
+      state: tempState,
     });
 
     if (cb) {
       this.client
         .search(queries)
-        .then(function(content) {
+        .then(function (content) {
           self._currentNbQueries--;
           if (self._currentNbQueries === 0) {
             self.emit('searchQueueEmpty');
@@ -9742,7 +10097,7 @@
 
           cb(null, new SearchResults_1(tempState, content.results), tempState);
         })
-        .catch(function(err) {
+        .catch(function (err) {
           self._currentNbQueries--;
           if (self._currentNbQueries === 0) {
             self.emit('searchQueueEmpty');
@@ -9754,22 +10109,25 @@
       return undefined;
     }
 
-    return this.client.search(queries).then(function(content) {
-      self._currentNbQueries--;
-      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
-      return {
-        content: new SearchResults_1(tempState, content.results),
-        state: tempState,
-        _originalResponse: content
-      };
-    }, function(e) {
-      self._currentNbQueries--;
-      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
-      throw e;
-    });
+    return this.client.search(queries).then(
+      function (content) {
+        self._currentNbQueries--;
+        if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
+        return {
+          content: new SearchResults_1(tempState, content.results),
+          state: tempState,
+          _originalResponse: content,
+        };
+      },
+      function (e) {
+        self._currentNbQueries--;
+        if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
+        throw e;
+      }
+    );
   };
 
-   /**
+  /**
    * Start the search for answers with the parameters set in the state.
    * This method returns a promise.
    * @param {Object} options - the options for answers API call
@@ -9780,7 +10138,8 @@
    * @return {promise} the answer results
    * @deprecated answers is deprecated and will be replaced with new initiatives
    */
-  AlgoliaSearchHelper.prototype.findAnswers = function(options) {
+  AlgoliaSearchHelper.prototype.findAnswers = function (options) {
+    // eslint-disable-next-line no-console
     console.warn('[algoliasearch-helper] answers is no longer supported');
     var state = this.state;
     var derivedHelper = this.derivedHelpers[0];
@@ -9791,19 +10150,20 @@
     var data = merge_1(
       {
         attributesForPrediction: options.attributesForPrediction,
-        nbHits: options.nbHits
+        nbHits: options.nbHits,
       },
       {
         params: omit$1(requestBuilder_1._getHitsSearchParams(derivedState), [
           'attributesToSnippet',
           'hitsPerPage',
           'restrictSearchableAttributes',
-          'snippetEllipsisText' // FIXME remove this line once the engine is fixed.
-        ])
+          'snippetEllipsisText',
+        ]),
       }
     );
 
-    var errorMessage = 'search for answers was called, but this client does not have a function client.initIndex(index).findAnswers';
+    var errorMessage =
+      'search for answers was called, but this client does not have a function client.initIndex(index).findAnswers';
     if (typeof this.client.initIndex !== 'function') {
       throw new Error(errorMessage);
     }
@@ -9848,7 +10208,12 @@
    * it in the generated query.
    * @return {promise.<FacetSearchResult>} the results of the search
    */
-  AlgoliaSearchHelper.prototype.searchForFacetValues = function(facet, query, maxFacetHits, userState) {
+  AlgoliaSearchHelper.prototype.searchForFacetValues = function (
+    facet,
+    query,
+    maxFacetHits,
+    userState
+  ) {
     var clientHasSFFV = typeof this.client.searchForFacetValues === 'function';
     var clientHasInitIndex = typeof this.client.initIndex === 'function';
     if (
@@ -9863,15 +10228,21 @@
 
     var state = this.state.setQueryParameters(userState || {});
     var isDisjunctive = state.isDisjunctiveFacet(facet);
-    var algoliaQuery = requestBuilder_1.getSearchForFacetQuery(facet, query, maxFacetHits, state);
+    var algoliaQuery = requestBuilder_1.getSearchForFacetQuery(
+      facet,
+      query,
+      maxFacetHits,
+      state
+    );
 
     this._currentNbQueries++;
+    // eslint-disable-next-line consistent-this
     var self = this;
     var searchForFacetValuesPromise;
     // newer algoliasearch ^3.27.1 - ~4.0.0
     if (clientHasSFFV) {
       searchForFacetValuesPromise = this.client.searchForFacetValues([
-        {indexName: state.index, params: algoliaQuery}
+        { indexName: state.index, params: algoliaQuery },
       ]);
       // algoliasearch < 3.27.1
     } else if (clientHasInitIndex) {
@@ -9888,8 +10259,8 @@
             type: 'facet',
             facet: facet,
             indexName: state.index,
-            params: algoliaQuery
-          }
+            params: algoliaQuery,
+          },
         ])
         .then(function processResponse(response) {
           return response.results[0];
@@ -9899,28 +10270,31 @@
     this.emit('searchForFacetValues', {
       state: state,
       facet: facet,
-      query: query
+      query: query,
     });
 
-    return searchForFacetValuesPromise.then(function addIsRefined(content) {
-      self._currentNbQueries--;
-      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
+    return searchForFacetValuesPromise.then(
+      function addIsRefined(content) {
+        self._currentNbQueries--;
+        if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
 
-      content = Array.isArray(content) ? content[0] : content;
+        content = Array.isArray(content) ? content[0] : content;
 
-      content.facetHits.forEach(function(f) {
-        f.escapedValue = escapeFacetValue$4(f.value);
-        f.isRefined = isDisjunctive
-          ? state.isDisjunctiveFacetRefined(facet, f.escapedValue)
-          : state.isFacetRefined(facet, f.escapedValue);
-      });
+        content.facetHits.forEach(function (f) {
+          f.escapedValue = escapeFacetValue$4(f.value);
+          f.isRefined = isDisjunctive
+            ? state.isDisjunctiveFacetRefined(facet, f.escapedValue)
+            : state.isFacetRefined(facet, f.escapedValue);
+        });
 
-      return content;
-    }, function(e) {
-      self._currentNbQueries--;
-      if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
-      throw e;
-    });
+        return content;
+      },
+      function (e) {
+        self._currentNbQueries--;
+        if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
+        throw e;
+      }
+    );
   };
 
   /**
@@ -9928,14 +10302,14 @@
    *
    * This method resets the current page to 0.
    * @param  {string} q the user query
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.setQuery = function(q) {
+  AlgoliaSearchHelper.prototype.setQuery = function (q) {
     this._change({
       state: this.state.resetPage().setQuery(q),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
@@ -9949,7 +10323,7 @@
    *
    * This method resets the current page to 0.
    * @param {string} [name] optional name of the facet / attribute on which we want to remove all refinements
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    * @example
@@ -9964,10 +10338,10 @@
    *   return type === 'exclude' && attribute === 'category';
    * }).search();
    */
-  AlgoliaSearchHelper.prototype.clearRefinements = function(name) {
+  AlgoliaSearchHelper.prototype.clearRefinements = function (name) {
     this._change({
       state: this.state.resetPage().clearRefinements(name),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
@@ -9977,14 +10351,14 @@
    * Remove all the tag filters.
    *
    * This method resets the current page to 0.
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.clearTags = function() {
+  AlgoliaSearchHelper.prototype.clearTags = function () {
     this._change({
       state: this.state.resetPage().clearTags(),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
@@ -9997,23 +10371,27 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value (will be converted to string)
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.addDisjunctiveFacetRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.addDisjunctiveFacetRefinement = function (
+    facet,
+    value
+  ) {
     this._change({
       state: this.state.resetPage().addDisjunctiveFacetRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addDisjunctiveFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.addDisjunctiveRefine = function() {
+  AlgoliaSearchHelper.prototype.addDisjunctiveRefine = function () {
     return this.addDisjunctiveFacetRefinement.apply(this, arguments);
   };
 
@@ -10025,15 +10403,18 @@
    * This method resets the current page to 0.
    * @param {string} facet the facet name
    * @param {string} path the hierarchical facet path
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @throws Error if the facet is not defined or if the facet is refined
    * @chainable
    * @fires change
    */
-  AlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.addHierarchicalFacetRefinement = function (
+    facet,
+    path
+  ) {
     this._change({
-      state: this.state.resetPage().addHierarchicalFacetRefinement(facet, value),
-      isPageReset: true
+      state: this.state.resetPage().addHierarchicalFacetRefinement(facet, path),
+      isPageReset: true,
     });
 
     return this;
@@ -10047,14 +10428,20 @@
    * @param  {string} attribute the attribute on which the numeric filter applies
    * @param  {string} operator the operator of the filter
    * @param  {number} value the value of the filter
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.addNumericRefinement = function(attribute, operator, value) {
+  AlgoliaSearchHelper.prototype.addNumericRefinement = function (
+    attribute,
+    operator,
+    value
+  ) {
     this._change({
-      state: this.state.resetPage().addNumericRefinement(attribute, operator, value),
-      isPageReset: true
+      state: this.state
+        .resetPage()
+        .addNumericRefinement(attribute, operator, value),
+      isPageReset: true,
     });
 
     return this;
@@ -10067,27 +10454,27 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value (will be converted to string)
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.addFacetRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.addFacetRefinement = function (facet, value) {
     this._change({
       state: this.state.resetPage().addFacetRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.addRefine = function() {
+  AlgoliaSearchHelper.prototype.addRefine = function () {
     return this.addFacetRefinement.apply(this, arguments);
   };
 
-
   /**
    * Adds a an exclusion filter to a faceted attribute with the `value` provided. If the
    * filter is already set, it doesn't change the filters.
@@ -10095,23 +10482,24 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value (will be converted to string)
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.addFacetExclusion = function(facet, value) {
+  AlgoliaSearchHelper.prototype.addFacetExclusion = function (facet, value) {
     this._change({
       state: this.state.resetPage().addExcludeRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#addFacetExclusion}
    */
-  AlgoliaSearchHelper.prototype.addExclude = function() {
+  AlgoliaSearchHelper.prototype.addExclude = function () {
     return this.addFacetExclusion.apply(this, arguments);
   };
 
@@ -10121,14 +10509,14 @@
    *
    * This method resets the current page to 0.
    * @param {string} tag the tag to add to the filter
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.addTag = function(tag) {
+  AlgoliaSearchHelper.prototype.addTag = function (tag) {
     this._change({
       state: this.state.resetPage().addTagRefinement(tag),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
@@ -10148,14 +10536,20 @@
    * @param  {string} attribute the attribute on which the numeric filter applies
    * @param  {string} [operator] the operator of the filter
    * @param  {number} [value] the value of the filter
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeNumericRefinement = function(attribute, operator, value) {
+  AlgoliaSearchHelper.prototype.removeNumericRefinement = function (
+    attribute,
+    operator,
+    value
+  ) {
     this._change({
-      state: this.state.resetPage().removeNumericRefinement(attribute, operator, value),
-      isPageReset: true
+      state: this.state
+        .resetPage()
+        .removeNumericRefinement(attribute, operator, value),
+      isPageReset: true,
     });
 
     return this;
@@ -10171,38 +10565,46 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} [value] the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeDisjunctiveFacetRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.removeDisjunctiveFacetRefinement = function (
+    facet,
+    value
+  ) {
     this._change({
-      state: this.state.resetPage().removeDisjunctiveFacetRefinement(facet, value),
-      isPageReset: true
+      state: this.state
+        .resetPage()
+        .removeDisjunctiveFacetRefinement(facet, value),
+      isPageReset: true,
     });
 
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeDisjunctiveFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.removeDisjunctiveRefine = function() {
+  AlgoliaSearchHelper.prototype.removeDisjunctiveRefine = function () {
     return this.removeDisjunctiveFacetRefinement.apply(this, arguments);
   };
 
   /**
    * Removes the refinement set on a hierarchical facet.
    * @param {string} facet the facet name
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @throws Error if the facet is not defined or if the facet is not refined
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function(facet) {
+  AlgoliaSearchHelper.prototype.removeHierarchicalFacetRefinement = function (
+    facet
+  ) {
     this._change({
       state: this.state.resetPage().removeHierarchicalFacetRefinement(facet),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
@@ -10218,23 +10620,24 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} [value] the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeFacetRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.removeFacetRefinement = function (facet, value) {
     this._change({
       state: this.state.resetPage().removeFacetRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.removeRefine = function() {
+  AlgoliaSearchHelper.prototype.removeRefine = function () {
     return this.removeFacetRefinement.apply(this, arguments);
   };
 
@@ -10248,23 +10651,24 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} [value] the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeFacetExclusion = function(facet, value) {
+  AlgoliaSearchHelper.prototype.removeFacetExclusion = function (facet, value) {
     this._change({
       state: this.state.resetPage().removeExcludeRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#removeFacetExclusion}
    */
-  AlgoliaSearchHelper.prototype.removeExclude = function() {
+  AlgoliaSearchHelper.prototype.removeExclude = function () {
     return this.removeFacetExclusion.apply(this, arguments);
   };
 
@@ -10274,14 +10678,14 @@
    *
    * This method resets the current page to 0.
    * @param {string} tag tag to remove from the filter
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.removeTag = function(tag) {
+  AlgoliaSearchHelper.prototype.removeTag = function (tag) {
     this._change({
       state: this.state.resetPage().removeTagRefinement(tag),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
@@ -10294,23 +10698,24 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.toggleFacetExclusion = function(facet, value) {
+  AlgoliaSearchHelper.prototype.toggleFacetExclusion = function (facet, value) {
     this._change({
       state: this.state.resetPage().toggleExcludeFacetRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetExclusion}
    */
-  AlgoliaSearchHelper.prototype.toggleExclude = function() {
+  AlgoliaSearchHelper.prototype.toggleExclude = function () {
     return this.toggleFacetExclusion.apply(this, arguments);
   };
 
@@ -10323,13 +10728,13 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @throws Error will throw an error if the facet is not declared in the settings of the helper
    * @fires change
    * @chainable
    * @deprecated since version 2.19.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.toggleRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.toggleRefinement = function (facet, value) {
     return this.toggleFacetRefinement(facet, value);
   };
 
@@ -10342,24 +10747,25 @@
    * This method resets the current page to 0.
    * @param  {string} facet the facet to refine
    * @param  {string} value the associated value
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @throws Error will throw an error if the facet is not declared in the settings of the helper
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.toggleFacetRefinement = function(facet, value) {
+  AlgoliaSearchHelper.prototype.toggleFacetRefinement = function (facet, value) {
     this._change({
       state: this.state.resetPage().toggleFacetRefinement(facet, value),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since version 2.4.0, see {@link AlgoliaSearchHelper#toggleFacetRefinement}
    */
-  AlgoliaSearchHelper.prototype.toggleRefine = function() {
+  AlgoliaSearchHelper.prototype.toggleRefine = function () {
     return this.toggleFacetRefinement.apply(this, arguments);
   };
 
@@ -10369,14 +10775,14 @@
    *
    * This method resets the current page to 0.
    * @param {string} tag tag to remove or add
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.toggleTag = function(tag) {
+  AlgoliaSearchHelper.prototype.toggleTag = function (tag) {
     this._change({
       state: this.state.resetPage().toggleTagRefinement(tag),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
@@ -10384,14 +10790,14 @@
 
   /**
    * Increments the page number by one.
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    * @example
    * helper.setPage(0).nextPage().getPage();
    * // returns 1
    */
-  AlgoliaSearchHelper.prototype.nextPage = function() {
+  AlgoliaSearchHelper.prototype.nextPage = function () {
     var page = this.state.page || 0;
     return this.setPage(page + 1);
   };
@@ -10399,26 +10805,30 @@
   /**
    * Decrements the page number by one.
    * @fires change
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @chainable
    * @example
    * helper.setPage(1).previousPage().getPage();
    * // returns 0
    */
-  AlgoliaSearchHelper.prototype.previousPage = function() {
+  AlgoliaSearchHelper.prototype.previousPage = function () {
     var page = this.state.page || 0;
     return this.setPage(page - 1);
   };
 
   /**
    * @private
+   * @param {number} page The page number
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @chainable
+   * @fires change
    */
   function setCurrentPage(page) {
     if (page < 0) throw new Error('Page requested below 0.');
 
     this._change({
       state: this.state.setPage(page),
-      isPageReset: false
+      isPageReset: false,
     });
 
     return this;
@@ -10428,7 +10838,7 @@
    * Change the current page
    * @deprecated
    * @param  {number} page The page number
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
@@ -10438,7 +10848,7 @@
    * Updates the current page.
    * @function
    * @param  {number} page The page number
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
@@ -10449,14 +10859,14 @@
    *
    * This method resets the current page to 0.
    * @param {string} name the index name
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.setIndex = function(name) {
+  AlgoliaSearchHelper.prototype.setIndex = function (name) {
     this._change({
       state: this.state.resetPage().setIndex(name),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
@@ -10473,16 +10883,16 @@
    * This method resets the current page to 0.
    * @param {string} parameter name of the parameter to update
    * @param {any} value new value of the parameter
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    * @example
    * helper.setQueryParameter('hitsPerPage', 20).search();
    */
-  AlgoliaSearchHelper.prototype.setQueryParameter = function(parameter, value) {
+  AlgoliaSearchHelper.prototype.setQueryParameter = function (parameter, value) {
     this._change({
       state: this.state.resetPage().setQueryParameter(parameter, value),
-      isPageReset: true
+      isPageReset: true,
     });
 
     return this;
@@ -10491,14 +10901,14 @@
   /**
    * Set the whole state (warning: will erase previous state)
    * @param {SearchParameters} newState the whole new state
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @fires change
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.setState = function(newState) {
+  AlgoliaSearchHelper.prototype.setState = function (newState) {
     this._change({
       state: SearchParameters_1.make(newState),
-      isPageReset: false
+      isPageReset: false,
     });
 
     return this;
@@ -10509,7 +10919,7 @@
    * Do not use this method unless you know what you are doing. (see the example
    * for a legit use case)
    * @param {SearchParameters} newState the whole new state
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    * @example
    *  helper.on('change', function(state){
    *    // In this function you might want to find a way to store the state in the url/history
@@ -10521,10 +10931,11 @@
    *  }
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent = function(newState) {
-    this.state = new SearchParameters_1(newState);
-    return this;
-  };
+  AlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent =
+    function (newState) {
+      this.state = new SearchParameters_1(newState);
+      return this;
+    };
 
   /**
    * Check if an attribute has any numeric, conjunctive, disjunctive or hierarchical filters.
@@ -10549,7 +10960,7 @@
    * helper.hasRefinements('categories'); // true
    *
    */
-  AlgoliaSearchHelper.prototype.hasRefinements = function(attribute) {
+  AlgoliaSearchHelper.prototype.hasRefinements = function (attribute) {
     if (objectHasKeys_1(this.state.getNumericRefinements(attribute))) {
       return true;
     } else if (this.state.isConjunctiveFacet(attribute)) {
@@ -10574,7 +10985,7 @@
    *
    * @param  {string}  facet name of the attribute for used for faceting
    * @param  {string}  [value] optional value. If passed will test that this value
-     * is filtering the given facet.
+   * is filtering the given facet.
    * @return {boolean} true if refined
    * @example
    * helper.isExcludeRefined('color'); // false
@@ -10587,42 +10998,43 @@
    * helper.isExcludeRefined('color', 'blue') // false
    * helper.isExcludeRefined('color', 'red') // true
    */
-  AlgoliaSearchHelper.prototype.isExcluded = function(facet, value) {
+  AlgoliaSearchHelper.prototype.isExcluded = function (facet, value) {
     return this.state.isExcludeRefined(facet, value);
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasRefinements}
    */
-  AlgoliaSearchHelper.prototype.isDisjunctiveRefined = function(facet, value) {
+  AlgoliaSearchHelper.prototype.isDisjunctiveRefined = function (facet, value) {
     return this.state.isDisjunctiveFacetRefined(facet, value);
   };
 
   /**
    * Check if the string is a currently filtering tag.
    * @param {string} tag tag to check
-   * @return {boolean}
+   * @return {boolean} true if the tag is currently refined
    */
-  AlgoliaSearchHelper.prototype.hasTag = function(tag) {
+  AlgoliaSearchHelper.prototype.hasTag = function (tag) {
     return this.state.isTagRefined(tag);
   };
 
+  // eslint-disable-next-line valid-jsdoc
   /**
    * @deprecated since 2.4.0, see {@link AlgoliaSearchHelper#hasTag}
    */
-  AlgoliaSearchHelper.prototype.isTagRefined = function() {
+  AlgoliaSearchHelper.prototype.isTagRefined = function () {
     return this.hasTagRefinements.apply(this, arguments);
   };
 
-
   /**
    * Get the name of the currently used index.
-   * @return {string}
+   * @return {string} name of the index
    * @example
    * helper.setIndex('highestPrice_products').getIndex();
    * // returns 'highestPrice_products'
    */
-  AlgoliaSearchHelper.prototype.getIndex = function() {
+  AlgoliaSearchHelper.prototype.getIndex = function () {
     return this.state.index;
   };
 
@@ -10648,7 +11060,7 @@
    *
    * @return {string[]} The list of tags currently set.
    */
-  AlgoliaSearchHelper.prototype.getTags = function() {
+  AlgoliaSearchHelper.prototype.getTags = function () {
     return this.state.tagRefinements;
   };
 
@@ -10696,47 +11108,48 @@
    * //   }
    * // ]
    */
-  AlgoliaSearchHelper.prototype.getRefinements = function(facetName) {
+  AlgoliaSearchHelper.prototype.getRefinements = function (facetName) {
     var refinements = [];
 
     if (this.state.isConjunctiveFacet(facetName)) {
       var conjRefinements = this.state.getConjunctiveRefinements(facetName);
 
-      conjRefinements.forEach(function(r) {
+      conjRefinements.forEach(function (r) {
         refinements.push({
           value: r,
-          type: 'conjunctive'
+          type: 'conjunctive',
         });
       });
 
       var excludeRefinements = this.state.getExcludeRefinements(facetName);
 
-      excludeRefinements.forEach(function(r) {
+      excludeRefinements.forEach(function (r) {
         refinements.push({
           value: r,
-          type: 'exclude'
+          type: 'exclude',
         });
       });
     } else if (this.state.isDisjunctiveFacet(facetName)) {
-      var disjRefinements = this.state.getDisjunctiveRefinements(facetName);
+      var disjunctiveRefinements =
+        this.state.getDisjunctiveRefinements(facetName);
 
-      disjRefinements.forEach(function(r) {
+      disjunctiveRefinements.forEach(function (r) {
         refinements.push({
           value: r,
-          type: 'disjunctive'
+          type: 'disjunctive',
         });
       });
     }
 
     var numericRefinements = this.state.getNumericRefinements(facetName);
 
-    Object.keys(numericRefinements).forEach(function(operator) {
+    Object.keys(numericRefinements).forEach(function (operator) {
       var value = numericRefinements[operator];
 
       refinements.push({
         value: value,
         operator: operator,
-        type: 'numeric'
+        type: 'numeric',
       });
     });
 
@@ -10749,7 +11162,10 @@
    * @param {string} operator operator applied on the refined values
    * @return {Array.<number|number[]>} refined values
    */
-  AlgoliaSearchHelper.prototype.getNumericRefinement = function(attribute, operator) {
+  AlgoliaSearchHelper.prototype.getNumericRefinement = function (
+    attribute,
+    operator
+  ) {
     return this.state.getNumericRefinement(attribute, operator);
   };
 
@@ -10758,7 +11174,9 @@
    * @param  {string} facetName Hierarchical facet name
    * @return {array.<string>} the path as an array of string
    */
-  AlgoliaSearchHelper.prototype.getHierarchicalFacetBreadcrumb = function(facetName) {
+  AlgoliaSearchHelper.prototype.getHierarchicalFacetBreadcrumb = function (
+    facetName
+  ) {
     return this.state.getHierarchicalFacetBreadcrumb(facetName);
   };
 
@@ -10767,12 +11185,14 @@
   /**
    * Perform the underlying queries
    * @private
-   * @return {undefined}
+   * @param {object} options options for the query
+   * @param {boolean} [options.onlyWithDerivedHelpers=false] if true, only the derived helpers will be queried
+   * @return {undefined} does not return anything
    * @fires search
    * @fires result
    * @fires error
    */
-  AlgoliaSearchHelper.prototype._search = function(options) {
+  AlgoliaSearchHelper.prototype._search = function (options) {
     var state = this.state;
     var states = [];
     var mainQueries = [];
@@ -10783,16 +11203,16 @@
       states.push({
         state: state,
         queriesCount: mainQueries.length,
-        helper: this
+        helper: this,
       });
 
       this.emit('search', {
         state: state,
-        results: this.lastResults
+        results: this.lastResults,
       });
     }
 
-    var derivedQueries = this.derivedHelpers.map(function(derivedHelper) {
+    var derivedQueries = this.derivedHelpers.map(function (derivedHelper) {
       var derivedState = derivedHelper.getModifiedState(state);
       var derivedStateQueries = derivedState.index
         ? requestBuilder_1._getQueries(derivedState.index, derivedState)
@@ -10801,12 +11221,12 @@
       states.push({
         state: derivedState,
         queriesCount: derivedStateQueries.length,
-        helper: derivedHelper
+        helper: derivedHelper,
       });
 
       derivedHelper.emit('search', {
         state: derivedState,
-        results: derivedHelper.lastResults
+        results: derivedHelper.lastResults,
       });
 
       return derivedStateQueries;
@@ -10818,21 +11238,24 @@
     this._currentNbQueries++;
 
     if (!queries.length) {
-      return Promise.resolve({results: []}).then(
+      return Promise.resolve({ results: [] }).then(
         this._dispatchAlgoliaResponse.bind(this, states, queryId)
       );
     }
 
     try {
-      this.client.search(queries)
+      this.client
+        .search(queries)
         .then(this._dispatchAlgoliaResponse.bind(this, states, queryId))
         .catch(this._dispatchAlgoliaError.bind(this, queryId));
     } catch (error) {
       // If we reach this part, we're in an internal error state
       this.emit('error', {
-        error: error
+        error: error,
       });
     }
+
+    return undefined;
   };
 
   /**
@@ -10840,28 +11263,31 @@
    * usable object that merge the results of all the batch requests. It will dispatch
    * over the different helper + derived helpers (when there are some).
    * @private
-   * @param {array.<{SearchParameters, AlgoliaQueries, AlgoliaSearchHelper}>}
-   *  state state used for to generate the request
+   * @param {array.<{SearchParameters, AlgoliaQueries, AlgoliaSearchHelper}>} states state used to generate the request
    * @param {number} queryId id of the current request
    * @param {object} content content of the response
    * @return {undefined}
    */
-  AlgoliaSearchHelper.prototype._dispatchAlgoliaResponse = function(states, queryId, content) {
-    // FIXME remove the number of outdated queries discarded instead of just one
+  AlgoliaSearchHelper.prototype._dispatchAlgoliaResponse = function (
+    states,
+    queryId,
+    content
+  ) {
+    // @TODO remove the number of outdated queries discarded instead of just one
 
     if (queryId < this._lastQueryIdReceived) {
       // Outdated answer
       return;
     }
 
-    this._currentNbQueries -= (queryId - this._lastQueryIdReceived);
+    this._currentNbQueries -= queryId - this._lastQueryIdReceived;
     this._lastQueryIdReceived = queryId;
 
     if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');
 
     var results = content.results.slice();
 
-    states.forEach(function(s) {
+    states.forEach(function (s) {
       var state = s.state;
       var queriesCount = s.queriesCount;
       var helper = s.helper;
@@ -10870,21 +11296,24 @@
       if (!state.index) {
         helper.emit('result', {
           results: null,
-          state: state
+          state: state,
         });
         return;
       }
 
-      var formattedResponse = helper.lastResults = new SearchResults_1(state, specificResults);
+      helper.lastResults = new SearchResults_1(state, specificResults);
 
       helper.emit('result', {
-        results: formattedResponse,
-        state: state
+        results: helper.lastResults,
+        state: state,
       });
     });
   };
 
-  AlgoliaSearchHelper.prototype._dispatchAlgoliaError = function(queryId, error) {
+  AlgoliaSearchHelper.prototype._dispatchAlgoliaError = function (
+    queryId,
+    error
+  ) {
     if (queryId < this._lastQueryIdReceived) {
       // Outdated answer
       return;
@@ -10894,31 +11323,40 @@
     this._lastQueryIdReceived = queryId;
 
     this.emit('error', {
-      error: error
+      error: error,
     });
 
     if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');
   };
 
-  AlgoliaSearchHelper.prototype.containsRefinement = function(query, facetFilters, numericFilters, tagFilters) {
-    return query ||
+  AlgoliaSearchHelper.prototype.containsRefinement = function (
+    query,
+    facetFilters,
+    numericFilters,
+    tagFilters
+  ) {
+    return (
+      query ||
       facetFilters.length !== 0 ||
       numericFilters.length !== 0 ||
-      tagFilters.length !== 0;
+      tagFilters.length !== 0
+    );
   };
 
   /**
    * Test if there are some disjunctive refinements on the facet
    * @private
    * @param {string} facet the attribute to test
-   * @return {boolean}
+   * @return {boolean} true if there are refinements on this attribute
    */
-  AlgoliaSearchHelper.prototype._hasDisjunctiveRefinements = function(facet) {
-    return this.state.disjunctiveRefinements[facet] &&
-      this.state.disjunctiveRefinements[facet].length > 0;
+  AlgoliaSearchHelper.prototype._hasDisjunctiveRefinements = function (facet) {
+    return (
+      this.state.disjunctiveRefinements[facet] &&
+      this.state.disjunctiveRefinements[facet].length > 0
+    );
   };
 
-  AlgoliaSearchHelper.prototype._change = function(event) {
+  AlgoliaSearchHelper.prototype._change = function (event) {
     var state = event.state;
     var isPageReset = event.isPageReset;
 
@@ -10928,17 +11366,17 @@
       this.emit('change', {
         state: this.state,
         results: this.lastResults,
-        isPageReset: isPageReset
+        isPageReset: isPageReset,
       });
     }
   };
 
   /**
    * Clears the cache of the underlying Algolia client.
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    */
-  AlgoliaSearchHelper.prototype.clearCache = function() {
-    this.client.clearCache && this.client.clearCache();
+  AlgoliaSearchHelper.prototype.clearCache = function () {
+    if (this.client.clearCache) this.client.clearCache();
     return this;
   };
 
@@ -10946,9 +11384,9 @@
    * Updates the internal client instance. If the reference of the clients
    * are equal then no update is actually done.
    * @param  {AlgoliaSearch} newClient an AlgoliaSearch client
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
    */
-  AlgoliaSearchHelper.prototype.setClient = function(newClient) {
+  AlgoliaSearchHelper.prototype.setClient = function (newClient) {
     if (this.client === newClient) return this;
 
     if (typeof newClient.addAlgoliaAgent === 'function') {
@@ -10961,9 +11399,9 @@
 
   /**
    * Gets the instance of the currently used client.
-   * @return {AlgoliaSearch}
+   * @return {AlgoliaSearch} the currently used client
    */
-  AlgoliaSearchHelper.prototype.getClient = function() {
+  AlgoliaSearchHelper.prototype.getClient = function () {
     return this.client;
   };
 
@@ -10984,9 +11422,9 @@
    * and the SearchParameters that is returned by the call of the
    * parameter function.
    * @param {function} fn SearchParameters -> SearchParameters
-   * @return {DerivedHelper}
+   * @return {DerivedHelper} a new DerivedHelper
    */
-  AlgoliaSearchHelper.prototype.derive = function(fn) {
+  AlgoliaSearchHelper.prototype.derive = function (fn) {
     var derivedHelper = new DerivedHelper_1(this, fn);
     this.derivedHelpers.push(derivedHelper);
     return derivedHelper;
@@ -10996,10 +11434,11 @@
    * This method detaches a derived Helper from the main one. Prefer using the one from the
    * derived helper itself, to remove the event listeners too.
    * @private
-   * @return {undefined}
+   * @param  {DerivedHelper} derivedHelper the derived helper to detach
+   * @return {undefined} nothing is returned
    * @throws Error
    */
-  AlgoliaSearchHelper.prototype.detachDerivedHelper = function(derivedHelper) {
+  AlgoliaSearchHelper.prototype.detachDerivedHelper = function (derivedHelper) {
     var pos = this.derivedHelpers.indexOf(derivedHelper);
     if (pos === -1) throw new Error('Derived helper already detached');
     this.derivedHelpers.splice(pos, 1);
@@ -11009,7 +11448,7 @@
    * This method returns true if there is currently at least one on-going search.
    * @return {boolean} true if there is a search pending
    */
-  AlgoliaSearchHelper.prototype.hasPendingRequests = function() {
+  AlgoliaSearchHelper.prototype.hasPendingRequests = function () {
     return this._currentNbQueries > 0;
   };
 
@@ -11060,7 +11499,7 @@
    * @param  {AlgoliaSearch} client an AlgoliaSearch client
    * @param  {string} index the name of the index to query
    * @param  {SearchParameters|object} opts an object defining the initial config of the search. It doesn't have to be a {SearchParameters}, just an object containing the properties you need from it.
-   * @return {AlgoliaSearchHelper}
+   * @return {AlgoliaSearchHelper} The helper instance
    */
   function algoliasearchHelper(client, index, opts) {
     return new algoliasearch_helper(client, index, opts);
@@ -14143,7 +14582,7 @@
     };
   }
 
-  var version$1 = '4.56.5';
+  var version$1 = '4.56.7';
 
   var withUsage$r = createDocumentationMessageGenerator({
     name: 'instantsearch'