react-instantsearch-core 6.40.0 → 6.40.2

package/dist/umd/ReactInstantSearchCore.js

@@ -873,7 +873,7 @@
     });
   }
 
-  var version = '6.40.0';
+  var version = '6.40.2';
 
   function translatable(defaultTranslations) {
     return function (Composed) {
@@ -1215,45 +1215,32 @@
   });
 
   function clone(value) {
-    if (typeof value === 'object' && value !== null) {
+    if (_typeof(value) === 'object' && value !== null) {
       return _merge(Array.isArray(value) ? [] : {}, value);
     }
     return value;
   }
-
   function isObjectOrArrayOrFunction(value) {
-    return (
-      typeof value === 'function' ||
-      Array.isArray(value) ||
-      Object.prototype.toString.call(value) === '[object Object]'
-    );
+    return typeof value === 'function' || Array.isArray(value) || Object.prototype.toString.call(value) === '[object Object]';
   }
-
   function _merge(target, source) {
     if (target === source) {
       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'
-      ) {
+      if (!Object.prototype.hasOwnProperty.call(source, key) || key === '__proto__' || key === 'constructor') {
+        // eslint-disable-next-line no-continue
         continue;
       }
-
       var sourceVal = source[key];
       var targetVal = target[key];
-
       if (typeof targetVal !== 'undefined' && typeof sourceVal === 'undefined') {
+        // eslint-disable-next-line no-continue
         continue;
       }
-
-      if (
-        isObjectOrArrayOrFunction(targetVal) &&
-        isObjectOrArrayOrFunction(sourceVal)
-      ) {
+      if (isObjectOrArrayOrFunction(targetVal) && isObjectOrArrayOrFunction(sourceVal)) {
         target[key] = _merge(targetVal, sourceVal);
       } else {
         target[key] = clone(sourceVal);
@@ -1273,35 +1260,34 @@
    * - 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 = {};
     }
-
     for (var i = 1, l = arguments.length; i < l; i++) {
       var source = arguments[i];
-
       if (isObjectOrArrayOrFunction(source)) {
         _merge(target, source);
       }
     }
     return target;
   }
+  module.exports = merge;
 
-  var merge_1 = merge;
+  var merge$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null
+  });
 
   // NOTE: this behaves like lodash/defaults, but doesn't mutate the target
   // it also preserve keys order
   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;
         }
@@ -1316,11 +1302,8 @@
   };
 
   function intersection(arr1, arr2) {
-    return arr1.filter(function(value, index) {
-      return (
-        arr2.indexOf(value) > -1 &&
-        arr1.indexOf(value) === index /* skips duplicates */
-      );
+    return arr1.filter(function (value, index) {
+      return arr2.indexOf(value) > -1 && arr1.indexOf(value) === index /* skips duplicates */;
     });
   }
 
@@ -1331,12 +1314,12 @@
     if (!Array.isArray(array)) {
       return undefined;
     }
-
     for (var i = 0; i < array.length; i++) {
       if (comparator(array[i])) {
         return array[i];
       }
     }
+    return undefined;
   };
 
   function valToNumber(v) {
@@ -1347,10 +1330,8 @@
     } else if (Array.isArray(v)) {
       return v.map(valToNumber);
     }
-
     throw new Error('The value should be a number, a parsable string or an array of those.');
   }
-
   var valToNumber_1 = valToNumber;
 
   // https://github.com/babel/babel/blob/3aaafae053fa75febb3aa45d45b6f00646e30ba4/packages/babel-helpers/src/helpers.js#L604-L620
@@ -1362,18 +1343,17 @@
     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];
     }
     return target;
   }
-
   var omit$1 = _objectWithoutPropertiesLoose$1;
 
   function objectHasKeys$1(obj) {
     return obj && Object.keys(obj).length > 0;
   }
-
   var objectHasKeys_1 = objectHasKeys$1;
 
   var isValidUserToken = function isValidUserToken(userToken) {
@@ -1397,8 +1377,6 @@
 
 
 
-
-
   var lib = {
     /**
      * Adds a refinement to a RefinementList
@@ -1411,17 +1389,10 @@
       if (lib.isRefined(refinementList, attribute, value)) {
         return refinementList;
       }
-
       var valueAsString = '' + value;
-
-      var facetRefinement = !refinementList[attribute] ?
-        [valueAsString] :
-        refinementList[attribute].concat(valueAsString);
-
+      var facetRefinement = !refinementList[attribute] ? [valueAsString] : refinementList[attribute].concat(valueAsString);
       var mod = {};
-
       mod[attribute] = facetRefinement;
-
       return defaultsPure({}, mod, refinementList);
     },
     /**
@@ -1437,14 +1408,12 @@
       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;
       });
     },
@@ -1457,11 +1426,9 @@
      */
     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);
       }
-
       return lib.addRefinement(refinementList, attribute, value);
     },
     /**
@@ -1477,6 +1444,8 @@
      */
     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;
         }
@@ -1485,24 +1454,24 @@
         return omit$1(refinementList, [attribute]);
       } 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
@@ -1511,22 +1480,17 @@
      * @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] &&
-        refinementList[attribute].length > 0;
-
+      var containsRefinements = Boolean(refinementList[attribute]) && refinementList[attribute].length > 0;
       if (refinementValue === undefined || !containsRefinements) {
         return containsRefinements;
       }
-
       var refinementValueAsString = '' + refinementValue;
-
       return refinementList[attribute].indexOf(refinementValueAsString) !== -1;
     }
   };
-
   var RefinementList = lib;
 
   /**
@@ -1535,15 +1499,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) {
-          return isEqualNumericRefinement(b[i], el);
-        })
-      );
+      return a.length === b.length && a.every(function (el, i) {
+        return isEqualNumericRefinement(b[i], el);
+      });
     }
     return a === b;
   }
@@ -1557,7 +1521,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);
     });
   }
@@ -1611,8 +1575,8 @@
    */
   function SearchParameters(newParameters) {
     var params = newParameters ? SearchParameters._parseNumbers(newParameters) : {};
-
     if (params.userToken !== undefined && !isValidUserToken(params.userToken)) {
+      // 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}');
     }
     /**
@@ -1715,11 +1679,11 @@
      */
     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;
-
       if (!isKeyKnown && isValueDefined) {
         self[paramName] = params[paramName];
       }
@@ -1738,27 +1702,12 @@
    * @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 = {};
-
-    var numberKeys = [
-      'aroundPrecision',
-      'aroundRadius',
-      'getRankingInfo',
-      'minWordSizefor2Typos',
-      'minWordSizefor1Typo',
-      'page',
-      'maxValuesPerFacet',
-      'distinct',
-      'minimumAroundRadius',
-      'hitsPerPage',
-      'minProximity'
-    ];
-
-    numberKeys.forEach(function(k) {
+    var numberKeys = ['aroundPrecision', 'aroundRadius', 'getRankingInfo', 'minWordSizefor2Typos', 'minWordSizefor1Typo', 'page', 'maxValuesPerFacet', 'distinct', 'minimumAroundRadius', 'hitsPerPage', 'minProximity'];
+    numberKeys.forEach(function (k) {
       var value = partialState[k];
       if (typeof value === 'string') {
         var parsedValue = parseFloat(value);
@@ -1770,26 +1719,25 @@
     // 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);
           });
         }
         return geoRect;
       });
     }
-
     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);
                 }
@@ -1805,8 +1753,7 @@
       });
       numbers.numericRefinements = numericRefinements;
     }
-
-    return merge_1({}, partialState, numbers);
+    return merge$1({}, partialState, numbers);
   };
 
   /**
@@ -1817,12 +1764,10 @@
    */
   SearchParameters.make = function makeSearchParameters(newParameters) {
     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) {
           instance = instance.clearRefinements(facet.name);
         }
@@ -1834,7 +1779,6 @@
         }
       }
     });
-
     return instance;
   };
 
@@ -1844,46 +1788,24 @@
    * @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) {
-      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.');
+      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.');
     }
-
     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.');
-    }
-
-    if (
-      currentState.numericFilters &&
-      params.numericRefinements &&
-      objectHasKeys_1(params.numericRefinements)
-    ) {
-      return new Error(
-        "[Numeric filters] Can't switch from the advanced to the managed API. It" +
-          ' is probably an error, if this is really what you want, you have to first' +
-          ' clear the numeric filters.'
-      );
+      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.');
+    }
+    if (currentState.numericFilters && params.numericRefinements && objectHasKeys_1(params.numericRefinements)) {
+      return new Error("[Numeric filters] Can't switch from the advanced to the managed API. It" + ' is probably an error, if this is really what you want, you have to first' + ' clear the numeric filters.');
     }
-
     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.');
+      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.');
     }
-
     return null;
   };
-
   SearchParameters.prototype = {
     constructor: SearchParameters,
-
     /**
      * Remove all refinements (disjunctive + conjunctive + excludes + numeric filters)
      * @method
@@ -1891,39 +1813,17 @@
      * - 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 = {
         numericRefinements: this._clearNumericRefinements(attribute),
-        facetsRefinements: RefinementList.clearRefinement(
-          this.facetsRefinements,
-          attribute,
-          'conjunctiveFacet'
-        ),
-        facetsExcludes: RefinementList.clearRefinement(
-          this.facetsExcludes,
-          attribute,
-          'exclude'
-        ),
-        disjunctiveFacetsRefinements: RefinementList.clearRefinement(
-          this.disjunctiveFacetsRefinements,
-          attribute,
-          'disjunctiveFacet'
-        ),
-        hierarchicalFacetsRefinements: RefinementList.clearRefinement(
-          this.hierarchicalFacetsRefinements,
-          attribute,
-          'hierarchicalFacet'
-        )
+        facetsRefinements: RefinementList.clearRefinement(this.facetsRefinements, attribute, 'conjunctiveFacet'),
+        facetsExcludes: RefinementList.clearRefinement(this.facetsExcludes, attribute, 'exclude'),
+        disjunctiveFacetsRefinements: RefinementList.clearRefinement(this.disjunctiveFacetsRefinements, attribute, 'disjunctiveFacet'),
+        hierarchicalFacetsRefinements: RefinementList.clearRefinement(this.hierarchicalFacetsRefinements, attribute, 'hierarchicalFacet')
       };
-      if (
-        patch.numericRefinements === this.numericRefinements &&
-        patch.facetsRefinements === this.facetsRefinements &&
-        patch.facetsExcludes === this.facetsExcludes &&
-        patch.disjunctiveFacetsRefinements === this.disjunctiveFacetsRefinements &&
-        patch.hierarchicalFacetsRefinements === this.hierarchicalFacetsRefinements
-      ) {
+      if (patch.numericRefinements === this.numericRefinements && patch.facetsRefinements === this.facetsRefinements && patch.facetsExcludes === this.facetsExcludes && patch.disjunctiveFacetsRefinements === this.disjunctiveFacetsRefinements && patch.hierarchicalFacetsRefinements === this.hierarchicalFacetsRefinements) {
         return this;
       }
       return this.setQueryParameters(patch);
@@ -1931,11 +1831,10 @@
     /**
      * 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;
-
       return this.setQueryParameters({
         tagFilters: undefined,
         tagRefinements: []
@@ -1945,11 +1844,10 @@
      * 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
       });
@@ -1958,11 +1856,10 @@
      * 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
       });
@@ -1971,11 +1868,10 @@
      * 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
       });
@@ -1985,7 +1881,7 @@
      * 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({
@@ -1997,7 +1893,7 @@
      * 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({
@@ -2009,11 +1905,10 @@
      * 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
       });
@@ -2023,11 +1918,10 @@
      * 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
       });
@@ -2040,33 +1934,28 @@
      * @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);
-
-      if (this.isNumericRefined(attribute, operator, value)) return this;
-
-      var mod = merge_1({}, this.numericRefinements);
-
-      mod[attribute] = merge_1({}, mod[attribute]);
-
+    addNumericRefinement: function addNumericRefinement(attribute, operator, value) {
+      var val = valToNumber_1(value);
+      if (this.isNumericRefined(attribute, operator, val)) return this;
+      var mod = merge$1({}, this.numericRefinements);
+      mod[attribute] = merge$1({}, mod[attribute]);
       if (mod[attribute][operator]) {
         // 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
       });
@@ -2076,7 +1965,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getConjunctiveRefinements: function(facetName) {
+    getConjunctiveRefinements: function getConjunctiveRefinements(facetName) {
       if (!this.isConjunctiveFacet(facetName)) {
         return [];
       }
@@ -2087,7 +1976,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getDisjunctiveRefinements: function(facetName) {
+    getDisjunctiveRefinements: function getDisjunctiveRefinements(facetName) {
       if (!this.isDisjunctiveFacet(facetName)) {
         return [];
       }
@@ -2098,7 +1987,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getHierarchicalRefinement: function(facetName) {
+    getHierarchicalRefinement: function getHierarchicalRefinement(facetName) {
       // we send an array but we currently do not support multiple
       // hierarchicalRefinements for a hierarchicalFacet
       return this.hierarchicalFacetsRefinements[facetName] || [];
@@ -2108,47 +1997,42 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {string[]} list of refinements
      */
-    getExcludeRefinements: function(facetName) {
+    getExcludeRefinements: function getExcludeRefinements(facetName) {
       if (!this.isConjunctiveFacet(facetName)) {
         return [];
       }
       return this.facetsExcludes[facetName] || [];
     },
-
     /**
      * Remove all the numeric filter for a given (attribute, operator)
      * @method
      * @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 removeNumericRefinement(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) {
-            return (
-              key === attribute &&
-              value.op === operator &&
-              isEqualNumericRefinement(value.val, valToNumber_1(paramValue))
-            );
+          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;
         })
       });
@@ -2158,7 +2042,7 @@
      * @param {string} facetName name of the attribute used for faceting
      * @return {SearchParameters.OperatorList} list of refinements
      */
-    getNumericRefinements: function(facetName) {
+    getNumericRefinements: function getNumericRefinements(facetName) {
       return this.numericRefinements[facetName] || {};
     },
     /**
@@ -2167,7 +2051,7 @@
      * @param {string} operator operator applied on the refined values
      * @return {Array.<number|number[]>} refined values
      */
-    getNumericRefinement: function(attribute, operator) {
+    getNumericRefinement: function getNumericRefinement(attribute, operator) {
       return this.numericRefinements[attribute] && this.numericRefinements[attribute][operator];
     },
     /**
@@ -2178,7 +2062,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) {
@@ -2191,16 +2075,18 @@
       } else if (typeof attribute === 'function') {
         var hasChanged = false;
         var numericRefinements = this.numericRefinements;
-        var newNumericRefinements = Object.keys(numericRefinements).reduce(function(memo, key) {
+        var newNumericRefinements = Object.keys(numericRefinements).reduce(function (memo, key) {
           var operators = numericRefinements[key];
           var operatorList = {};
-
           operators = operators || {};
-          Object.keys(operators).forEach(function(operator) {
+          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');
+            values.forEach(function (value) {
+              var predicateResult = attribute({
+                val: value,
+                op: operator
+              }, key, 'numeric');
               if (!predicateResult) outValues.push(value);
             });
             if (outValues.length !== values.length) {
@@ -2208,28 +2094,28 @@
             }
             operatorList[operator] = outValues;
           });
-
           memo[key] = operatorList;
-
           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)) {
         return this;
       }
-
       return this.setQueryParameters({
         facets: this.facets.concat([facet])
       });
@@ -2239,13 +2125,12 @@
      * 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)) {
         return this;
       }
-
       return this.setQueryParameters({
         disjunctiveFacets: this.disjunctiveFacets.concat([facet])
       });
@@ -2255,15 +2140,13 @@
      * 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 + '`');
+        throw new Error('Cannot declare two hierarchical facets with the same name: `' + hierarchicalFacet.name + '`');
       }
-
       return this.setQueryParameters({
         hierarchicalFacets: this.hierarchicalFacets.concat([hierarchicalFacet])
       });
@@ -2273,14 +2156,13 @@
      * @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');
       }
       if (RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;
-
       return this.setQueryParameters({
         facetsRefinements: RefinementList.addRefinement(this.facetsRefinements, facet, value)
       });
@@ -2290,14 +2172,13 @@
      * @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');
       }
       if (RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;
-
       return this.setQueryParameters({
         facetsExcludes: RefinementList.addRefinement(this.facetsExcludes, facet, value)
       });
@@ -2307,33 +2188,27 @@
      * @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) {
       if (!this.isDisjunctiveFacet(facet)) {
-        throw new Error(
-          facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
+        throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
       }
-
       if (RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;
-
       return this.setQueryParameters({
-        disjunctiveFacetsRefinements: RefinementList.addRefinement(
-          this.disjunctiveFacetsRefinements, facet, value)
+        disjunctiveFacetsRefinements: RefinementList.addRefinement(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)
       };
-
       return this.setQueryParameters(modification);
     },
     /**
@@ -2341,15 +2216,14 @@
      * is present.
      * @method
      * @param {string} facet facet name to remove
-     * @return {SearchParameters}
+     * @return {SearchParameters} new instance
      */
     removeFacet: function removeFacet(facet) {
       if (!this.isConjunctiveFacet(facet)) {
         return this;
       }
-
       return this.clearRefinements(facet).setQueryParameters({
-        facets: this.facets.filter(function(f) {
+        facets: this.facets.filter(function (f) {
           return f !== facet;
         })
       });
@@ -2359,15 +2233,14 @@
      * 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)) {
         return this;
       }
-
       return this.clearRefinements(facet).setQueryParameters({
-        disjunctiveFacets: this.disjunctiveFacets.filter(function(f) {
+        disjunctiveFacets: this.disjunctiveFacets.filter(function (f) {
           return f !== facet;
         })
       });
@@ -2377,15 +2250,14 @@
      * 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)) {
         return this;
       }
-
       return this.clearRefinements(facet).setQueryParameters({
-        hierarchicalFacets: this.hierarchicalFacets.filter(function(f) {
+        hierarchicalFacets: this.hierarchicalFacets.filter(function (f) {
           return f.name !== facet;
         })
       });
@@ -2397,14 +2269,13 @@
      * @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');
       }
       if (!RefinementList.isRefined(this.facetsRefinements, facet, value)) return this;
-
       return this.setQueryParameters({
         facetsRefinements: RefinementList.removeRefinement(this.facetsRefinements, facet, value)
       });
@@ -2414,14 +2285,13 @@
      * @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');
       }
       if (!RefinementList.isRefined(this.facetsExcludes, facet, value)) return this;
-
       return this.setQueryParameters({
         facetsExcludes: RefinementList.removeRefinement(this.facetsExcludes, facet, value)
       });
@@ -2431,35 +2301,30 @@
      * @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) {
       if (!this.isDisjunctiveFacet(facet)) {
-        throw new Error(
-          facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
+        throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
       }
       if (!RefinementList.isRefined(this.disjunctiveFacetsRefinements, facet, value)) return this;
-
       return this.setQueryParameters({
-        disjunctiveFacetsRefinements: RefinementList.removeRefinement(
-          this.disjunctiveFacetsRefinements, facet, value)
+        disjunctiveFacetsRefinements: RefinementList.removeRefinement(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);
     },
     /**
@@ -2467,7 +2332,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}
      */
@@ -2479,7 +2344,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) {
@@ -2490,22 +2355,19 @@
       } else if (this.isDisjunctiveFacet(facet)) {
         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) {
       if (!this.isConjunctiveFacet(facet)) {
         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)
       });
@@ -2515,13 +2377,12 @@
      * @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) {
       if (!this.isConjunctiveFacet(facet)) {
         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)
       });
@@ -2531,17 +2392,14 @@
      * @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) {
       if (!this.isDisjunctiveFacet(facet)) {
-        throw new Error(
-          facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
+        throw new Error(facet + ' is not defined in the disjunctiveFacets attribute of the helper configuration');
       }
-
       return this.setQueryParameters({
-        disjunctiveFacetsRefinements: RefinementList.toggleRefinement(
-          this.disjunctiveFacetsRefinements, facet, value)
+        disjunctiveFacetsRefinements: RefinementList.toggleRefinement(this.disjunctiveFacetsRefinements, facet, value)
       });
     },
     /**
@@ -2549,30 +2407,23 @@
      * @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) {
       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 separator = this._getHierarchicalFacetSeparator(this.getHierarchicalFacetByName(facet));
-
       var mod = {};
-
-      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
-      );
-
+      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);
       if (upOneOrMultipleLevel) {
         if (value.indexOf(separator) === -1) {
           // go back to root level
@@ -2583,12 +2434,10 @@
       } else {
         mod[facet] = [value];
       }
-
       return this.setQueryParameters({
         hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)
       });
     },
-
     /**
      * Adds a refinement on a hierarchical facet.
      * @param {string} facet the facet name
@@ -2596,7 +2445,7 @@
      * @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 addHierarchicalFacetRefinement(facet, path) {
       if (this.isHierarchicalFacetRefined(facet)) {
         throw new Error(facet + ' is already refined.');
       }
@@ -2609,14 +2458,13 @@
         hierarchicalFacetsRefinements: defaultsPure({}, mod, this.hierarchicalFacetsRefinements)
       });
     },
-
     /**
      * Removes the refinement set on a hierarchical facet.
      * @param {string} facet the facet name
      * @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 removeHierarchicalFacetRefinement(facet) {
       if (!this.isHierarchicalFacetRefined(facet)) {
         return this;
       }
@@ -2630,40 +2478,39 @@
      * 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)) {
         return this.removeTagRefinement(tag);
       }
-
       return this.addTagRefinement(tag);
     },
     /**
      * 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 isDisjunctiveFacet(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 isHierarchicalFacet(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 isConjunctiveFacet(facet) {
       return this.facets.indexOf(facet) > -1;
     },
     /**
@@ -2704,7 +2551,7 @@
      * @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)) {
@@ -2719,19 +2566,16 @@
      * @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) {
       if (!this.isHierarchicalFacet(facet)) {
         return false;
       }
-
       var refinements = this.getHierarchicalRefinement(facet);
-
       if (!value) {
         return refinements.length > 0;
       }
-
       return refinements.indexOf(value) !== -1;
     },
     /**
@@ -2746,29 +2590,21 @@
      */
     isNumericRefined: function isNumericRefined(attribute, operator, value) {
       if (value === undefined && operator === undefined) {
-        return !!this.numericRefinements[attribute];
+        return Boolean(this.numericRefinements[attribute]);
       }
-
-      var isOperatorDefined =
-        this.numericRefinements[attribute] &&
-        this.numericRefinements[attribute][operator] !== undefined;
-
+      var isOperatorDefined = this.numericRefinements[attribute] && this.numericRefinements[attribute][operator] !== undefined;
       if (value === undefined || !isOperatorDefined) {
         return isOperatorDefined;
       }
-
       var parsedValue = valToNumber_1(value);
-      var isAttributeValueDefined =
-        findArray(this.numericRefinements[attribute][operator], parsedValue) !==
-        undefined;
-
+      var isAttributeValueDefined = findArray(this.numericRefinements[attribute][operator], parsedValue) !== undefined;
       return isOperatorDefined && isAttributeValueDefined;
     },
     /**
      * 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;
@@ -2778,83 +2614,63 @@
      * @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) {
-          return Object.keys(self.numericRefinements[facet]).length > 0;
-        }),
-        this.disjunctiveFacets
-      );
-
-      return Object.keys(this.disjunctiveFacetsRefinements).filter(function(facet) {
+      var disjunctiveNumericRefinedFacets = intersection_1(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;
-      })
-        .concat(disjunctiveNumericRefinedFacets)
-        .concat(this.getRefinedHierarchicalFacets());
+      }).concat(disjunctiveNumericRefinedFacets).concat(this.getRefinedHierarchicalFacets());
     },
     /**
      * Returns the list of all disjunctive facets refined
      * @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) {
-          return self.hierarchicalFacetsRefinements[facet].length > 0;
-        })
-      );
+      // 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) {
+        return self.hierarchicalFacetsRefinements[facet].length > 0;
+      }));
     },
     /**
      * 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 getUnrefinedDisjunctiveFacets() {
       var refinedFacets = this.getRefinedDisjunctiveFacets();
-
-      return this.disjunctiveFacets.filter(function(f) {
+      return this.disjunctiveFacets.filter(function (f) {
         return refinedFacets.indexOf(f) === -1;
       });
     },
-
-    managedParameters: [
-      'index',
-
-      'facets',
-      'disjunctiveFacets',
-      'facetsRefinements',
-      'hierarchicalFacets',
-      'facetsExcludes',
-
-      'disjunctiveFacetsRefinements',
-      'numericRefinements',
-      'tagRefinements',
-      'hierarchicalFacetsRefinements'
-    ],
+    managedParameters: ['index', 'facets', 'disjunctiveFacets', 'facetsRefinements', 'hierarchicalFacets', 'facetsExcludes', 'disjunctiveFacetsRefinements', 'numericRefinements', 'tagRefinements', '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) {
           queryParams[paramName] = paramValue;
         }
       });
-
       return queryParams;
     },
     /**
@@ -2869,11 +2685,8 @@
      */
     setQueryParameter: function setParameter(parameter, value) {
       if (this[parameter] === value) return this;
-
       var modification = {};
-
       modification[parameter] = value;
-
       return this.setQueryParameters(modification);
     },
     /**
@@ -2884,134 +2697,109 @@
      */
     setQueryParameters: function setQueryParameters(params) {
       if (!params) return this;
-
       var error = SearchParameters.validate(this, params);
-
       if (error) {
         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;
-
-          if (isPreviousValueDefined && !isNextValueDefined) {
-            return omit$1(previous, [key]);
-          }
-
-          if (isNextValueDefined) {
-            previous[key] = nextWithNumbers[key];
-          }
-
-          return previous;
-        },
-        previousPlainObject
-      );
-
+      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 (isNextValueDefined) {
+          previous[key] = nextWithNumbers[key];
+        }
+        return previous;
+      }, previousPlainObject);
       return new this.constructor(nextPlainObject);
     },
-
     /**
      * Returns a new instance with the page reset. Two scenarios possible:
      * the page is omitted -> return the given instance
      * the page is set -> return a new instance with a page of 0
      * @return {SearchParameters} a new updated instance
      */
-    resetPage: function() {
+    resetPage: function resetPage() {
       if (this.page === undefined) {
         return this;
       }
-
       return this.setPage(0);
     },
-
     /**
      * 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 _getHierarchicalFacetSortBy(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 _getHierarchicalFacetSeparator(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 _getHierarchicalRootPath(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 _getHierarchicalShowParentLevel(hierarchicalFacet) {
       if (typeof hierarchicalFacet.showParentLevel === 'boolean') {
         return hierarchicalFacet.showParentLevel;
       }
       return true;
     },
-
     /**
      * 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 getHierarchicalFacetByName(hierarchicalFacetName) {
+      return find$1(this.hierarchicalFacets, function (f) {
+        return f.name === hierarchicalFacetName;
+      });
     },
-
     /**
      * Get the current breadcrumb for a hierarchical facet, as an array
      * @param  {string} facetName Hierarchical facet name
      * @return {array.<string>} the path as an array of string
      */
-    getHierarchicalFacetBreadcrumb: function(facetName) {
+    getHierarchicalFacetBreadcrumb: function getHierarchicalFacetBreadcrumb(facetName) {
       if (!this.isHierarchicalFacet(facetName)) {
         return [];
       }
-
       var refinement = this.getHierarchicalRefinement(facetName)[0];
       if (!refinement) return [];
-
-      var separator = this._getHierarchicalFacetSeparator(
-        this.getHierarchicalFacetByName(facetName)
-      );
+      var separator = this._getHierarchicalFacetSeparator(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 toString() {
       return JSON.stringify(this, null, 2);
     }
   };
@@ -3031,22 +2819,12 @@
     if (value !== other) {
       var valIsDefined = value !== undefined;
       var valIsNull = value === null;
-
       var othIsDefined = other !== undefined;
       var othIsNull = other === null;
-
-      if (
-        (!othIsNull && value > other) ||
-        (valIsNull && othIsDefined) ||
-        !valIsDefined
-      ) {
+      if (!othIsNull && value > other || valIsNull && othIsDefined || !valIsDefined) {
         return 1;
       }
-      if (
-        (!valIsNull && value < other) ||
-        (othIsNull && valIsDefined) ||
-        !othIsDefined
-      ) {
+      if (!valIsNull && value < other || othIsNull && valIsDefined || !othIsDefined) {
         return -1;
       }
     }
@@ -3057,29 +2835,26 @@
    * @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)) {
       return [];
     }
-
     if (!Array.isArray(orders)) {
       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
       };
     });
-
     result.sort(function comparer(object, other) {
       var index = -1;
-
       while (++index < object.criteria.length) {
         var res = compareAscending(object.criteria[index], other.criteria[index]);
         if (res) {
@@ -3097,19 +2872,16 @@
       // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.
       return object.index - other.index;
     });
-
-    return result.map(function(res) {
+    return result.map(function (res) {
       return res.value;
     });
   }
-
   var orderBy_1 = orderBy;
 
   var compact = function compact(array) {
     if (!Array.isArray(array)) {
       return [];
     }
-
     return array.filter(Boolean);
   };
 
@@ -3118,7 +2890,6 @@
     if (!Array.isArray(array)) {
       return -1;
     }
-
     for (var i = 0; i < array.length; i++) {
       if (comparator(array[i])) {
         return i;
@@ -3134,43 +2905,33 @@
    * @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(':');
     });
-
-    return sortBy.reduce(
-      function preparePredicate(out, sort) {
-        var sortInstruction = sort.split(':');
-
-        var matchingDefault = find$1(defaultInstructions, function(
-          defaultInstruction
-        ) {
-          return defaultInstruction[0] === sortInstruction[0];
-        });
-
-        if (sortInstruction.length > 1 || !matchingDefault) {
-          out[0].push(sortInstruction[0]);
-          out[1].push(sortInstruction[1]);
-          return out;
-        }
-
-        out[0].push(matchingDefault[0]);
-        out[1].push(matchingDefault[1]);
+    return sortBy.reduce(function preparePredicate(out, sort) {
+      var sortInstruction = sort.split(':');
+      var matchingDefault = find$1(defaultInstructions, function (defaultInstruction) {
+        return defaultInstruction[0] === sortInstruction[0];
+      });
+      if (sortInstruction.length > 1 || !matchingDefault) {
+        out[0].push(sortInstruction[0]);
+        out[1].push(sortInstruction[1]);
         return out;
-      },
-      [[], []]
-    );
+      }
+      out[0].push(matchingDefault[0]);
+      out[1].push(matchingDefault[1]);
+      return out;
+    }, [[], []]);
   };
 
   /**
    * 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(value) {
     if (typeof value !== 'string') return value;
-
     return String(value).replace(/^-/, '\\-');
   }
 
@@ -3178,14 +2939,12 @@
    * 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;
-
     return value.replace(/^\\-/, '-');
   }
-
   var escapeFacetValue_1 = {
     escapeFacetValue: escapeFacetValue,
     unescapeFacetValue: unescapeFacetValue$1
@@ -3196,87 +2955,50 @@
 
 
 
-
   var escapeFacetValue$1 = escapeFacetValue_1.escapeFacetValue;
   var unescapeFacetValue$2 = escapeFacetValue_1.unescapeFacetValue;
-
   function generateTrees(state) {
     return function generate(hierarchicalFacetResult, hierarchicalFacetIndex) {
       var hierarchicalFacet = state.hierarchicalFacets[hierarchicalFacetIndex];
-      var hierarchicalFacetRefinement =
-        (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 sortBy = formatSort(
-        state._getHierarchicalFacetSortBy(hierarchicalFacet)
-      );
-
-      var rootExhaustive = hierarchicalFacetResult.every(function(facetResult) {
+      var hierarchicalFacetRefinement = 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 sortBy = formatSort(state._getHierarchicalFacetSortBy(hierarchicalFacet));
+      var rootExhaustive = hierarchicalFacetResult.every(function (facetResult) {
         return facetResult.exhaustive;
       });
-
-      var generateTreeFn = generateHierarchicalTree(
-        sortBy,
-        hierarchicalSeparator,
-        hierarchicalRootPath,
-        hierarchicalShowParentLevel,
-        hierarchicalFacetRefinement
-      );
-
+      var generateTreeFn = generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel, hierarchicalFacetRefinement);
       var results = hierarchicalFacetResult;
-
       if (hierarchicalRootPath) {
-        results = hierarchicalFacetResult.slice(
-          hierarchicalRootPath.split(hierarchicalSeparator).length
-        );
+        results = hierarchicalFacetResult.slice(hierarchicalRootPath.split(hierarchicalSeparator).length);
       }
-
       return results.reduce(generateTreeFn, {
         name: state.hierarchicalFacets[hierarchicalFacetIndex].name,
-        count: null, // root level, no count
-        isRefined: true, // root level, always refined
-        path: null, // root level, no path
+        count: null,
+        // root level, no count
+        isRefined: true,
+        // root level, always refined
+        path: null,
+        // root level, no path
         escapedValue: null,
         exhaustive: rootExhaustive,
         data: null
       });
     };
   }
-
-  function generateHierarchicalTree(
-    sortBy,
-    hierarchicalSeparator,
-    hierarchicalRootPath,
-    hierarchicalShowParentLevel,
-    currentRefinement
-  ) {
-    return function generateTree(
-      hierarchicalTree,
-      hierarchicalFacetResult,
-      currentHierarchicalLevel
-    ) {
+  function generateHierarchicalTree(sortBy, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel, currentRefinement) {
+    return function generateTree(hierarchicalTree, hierarchicalFacetResult, currentHierarchicalLevel) {
       var parent = hierarchicalTree;
-
       if (currentHierarchicalLevel > 0) {
         var level = 0;
-
         parent = hierarchicalTree;
-
         while (level < currentHierarchicalLevel) {
           /**
            * @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++;
@@ -3296,99 +3018,49 @@
         // If parent refinement is `beers`, then we do not want to have `bières > Belges`
         // showing up
 
-        var picked = Object.keys(hierarchicalFacetResult.data)
-          .map(function(facetValue) {
-            return [facetValue, hierarchicalFacetResult.data[facetValue]];
-          })
-          .filter(function(tuple) {
-            var facetValue = tuple[0];
-            return onlyMatchingTree(
-              facetValue,
-              parent.path || hierarchicalRootPath,
-              currentRefinement,
-              hierarchicalSeparator,
-              hierarchicalRootPath,
-              hierarchicalShowParentLevel
-            );
-          });
-
-        parent.data = orderBy_1(
-          picked.map(function(tuple) {
-            var facetValue = tuple[0];
-            var facetCount = tuple[1];
-
-            return format(
-              facetCount,
-              facetValue,
-              hierarchicalSeparator,
-              unescapeFacetValue$2(currentRefinement),
-              hierarchicalFacetResult.exhaustive
-            );
-          }),
-          sortBy[0],
-          sortBy[1]
-        );
+        var picked = Object.keys(hierarchicalFacetResult.data).map(function (facetValue) {
+          return [facetValue, hierarchicalFacetResult.data[facetValue]];
+        }).filter(function (tuple) {
+          var facetValue = tuple[0];
+          return onlyMatchingTree(facetValue, parent.path || hierarchicalRootPath, currentRefinement, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel);
+        });
+        parent.data = orderBy_1(picked.map(function (tuple) {
+          var facetValue = tuple[0];
+          var facetCount = tuple[1];
+          return format(facetCount, facetValue, hierarchicalSeparator, unescapeFacetValue$2(currentRefinement), hierarchicalFacetResult.exhaustive);
+        }), sortBy[0], sortBy[1]);
       }
-
       return hierarchicalTree;
     };
   }
 
-  function onlyMatchingTree(
-    facetValue,
-    parentPath,
-    currentRefinement,
-    hierarchicalSeparator,
-    hierarchicalRootPath,
-    hierarchicalShowParentLevel
-  ) {
+  // eslint-disable-next-line max-params
+  function onlyMatchingTree(facetValue, parentPath, currentRefinement, hierarchicalSeparator, hierarchicalRootPath, hierarchicalShowParentLevel) {
     // we want the facetValue is a child of hierarchicalRootPath
-    if (
-      hierarchicalRootPath &&
-      (facetValue.indexOf(hierarchicalRootPath) !== 0 ||
-        hierarchicalRootPath === facetValue)
-    ) {
+    if (hierarchicalRootPath && (facetValue.indexOf(hierarchicalRootPath) !== 0 || hierarchicalRootPath === facetValue)) {
       return false;
     }
 
     // we always want root levels (only when there is no prefix path)
-    return (
-      (!hierarchicalRootPath &&
-        facetValue.indexOf(hierarchicalSeparator) === -1) ||
-      // if there is a rootPath, being root level mean 1 level under rootPath
-      (hierarchicalRootPath &&
-        facetValue.split(hierarchicalSeparator).length -
-          hierarchicalRootPath.split(hierarchicalSeparator).length ===
-          1) ||
-      // if current refinement is a root level and current facetValue is a root level,
-      // keep the facetValue
-      (facetValue.indexOf(hierarchicalSeparator) === -1 &&
-        currentRefinement.indexOf(hierarchicalSeparator) === -1) ||
-      // currentRefinement is a child of the facet value
-      currentRefinement.indexOf(facetValue) === 0 ||
-      // facetValue is a child of the current parent, add it
-      (facetValue.indexOf(parentPath + hierarchicalSeparator) === 0 &&
-        (hierarchicalShowParentLevel ||
-          facetValue.indexOf(currentRefinement) === 0))
-    );
-  }
-
-  function format(
-    facetCount,
-    facetValue,
-    hierarchicalSeparator,
-    currentRefinement,
-    exhaustive
-  ) {
+    return !hierarchicalRootPath && facetValue.indexOf(hierarchicalSeparator) === -1 ||
+    // if there is a rootPath, being root level mean 1 level under rootPath
+    hierarchicalRootPath && facetValue.split(hierarchicalSeparator).length - hierarchicalRootPath.split(hierarchicalSeparator).length === 1 ||
+    // if current refinement is a root level and current facetValue is a root level,
+    // keep the facetValue
+    facetValue.indexOf(hierarchicalSeparator) === -1 && currentRefinement.indexOf(hierarchicalSeparator) === -1 ||
+    // currentRefinement is a child of the facet value
+    currentRefinement.indexOf(facetValue) === 0 ||
+    // facetValue is a child of the current parent, add it
+    facetValue.indexOf(parentPath + hierarchicalSeparator) === 0 && (hierarchicalShowParentLevel || facetValue.indexOf(currentRefinement) === 0);
+  }
+  function format(facetCount, facetValue, hierarchicalSeparator, currentRefinement, exhaustive) {
     var parts = facetValue.split(hierarchicalSeparator);
     return {
       name: parts[parts.length - 1].trim(),
       path: facetValue,
       escapedValue: escapeFacetValue$1(facetValue),
       count: facetCount,
-      isRefined:
-        currentRefinement === facetValue ||
-        currentRefinement.indexOf(facetValue + hierarchicalSeparator) === 0,
+      isRefined: currentRefinement === facetValue || currentRefinement.indexOf(facetValue + hierarchicalSeparator) === 0,
       exhaustive: exhaustive,
       data: null
     };
@@ -3398,7 +3070,6 @@
   var unescapeFacetValue$3 = escapeFacetValue_1.unescapeFacetValue;
 
 
-
   /**
    * @typedef SearchResults.Facet
    * @type {object}
@@ -3441,18 +3112,17 @@
    */
 
   /**
-   * @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;
     });
-
     return indices;
   }
-
   function assignFacetStats(dest, facetStats, key) {
     if (facetStats && facetStats[key]) {
       dest.stats = facetStats[key];
@@ -3466,22 +3136,18 @@
    */
 
   /**
-   * @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
-    ) {
+  function findMatchingHierarchicalFacetFromAttributeName(hierarchicalFacets, hierarchicalAttributeName) {
+    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
@@ -3612,21 +3278,20 @@
      "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];
     });
 
@@ -3648,8 +3313,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
@@ -3765,12 +3430,13 @@
 
     /**
      * sum of the processing time of all the queries
+     * @name processingTimeMS
      * @member {number}
+     * @memberof SearchResults
+     * @instance
      */
-    this.processingTimeMS = results.reduce(function(sum, result) {
-      return result.processingTimeMS === undefined
-        ? sum
-        : sum + result.processingTimeMS;
+    this.processingTimeMS = results.reduce(function (sum, result) {
+      return result.processingTimeMS === undefined ? sum : sum + result.processingTimeMS;
     }, 0);
 
     /**
@@ -3790,9 +3456,7 @@
      * @member {SearchResults.Facet[]}
      */
     this.facets = [];
-
     var disjunctiveFacets = state.getRefinedDisjunctiveFacets();
-
     var facetsIndices = getIndices(state.facets);
     var disjunctiveFacetsIndices = getIndices(state.disjunctiveFacets);
     var nextDisjunctiveResult = 1;
@@ -3801,20 +3465,14 @@
     // we get the facets information from the first, general, response.
 
     var mainFacets = mainSubResponse.facets || {};
-
-    Object.keys(mainFacets).forEach(function(facetKey) {
+    Object.keys(mainFacets).forEach(function (facetKey) {
       var facetValueObject = mainFacets[facetKey];
-
-      var hierarchicalFacet = findMatchingHierarchicalFacetFromAttributeName(
-        state.hierarchicalFacets,
-        facetKey
-      );
-
+      var hierarchicalFacet = findMatchingHierarchicalFacetFromAttributeName(state.hierarchicalFacets, facetKey);
       if (hierarchicalFacet) {
         // 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(state.hierarchicalFacets, function(f) {
+        var idxAttributeName = findIndex(state.hierarchicalFacets, function (f) {
           return f.name === hierarchicalFacet.name;
         });
         self.hierarchicalFacets[idxAttributeName][facetIndex] = {
@@ -3826,7 +3484,6 @@
         var isFacetDisjunctive = state.disjunctiveFacets.indexOf(facetKey) !== -1;
         var isFacetConjunctive = state.facets.indexOf(facetKey) !== -1;
         var position;
-
         if (isFacetDisjunctive) {
           position = disjunctiveFacetsIndices[facetKey];
           self.disjunctiveFacets[position] = {
@@ -3852,22 +3509,20 @@
     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(state.hierarchicalFacets, function(f) {
+          position = findIndex(state.hierarchicalFacets, function (f) {
             return f.name === hierarchicalFacet.name;
           });
-          var attributeIndex = findIndex(self.hierarchicalFacets[position], function(f) {
+          var attributeIndex = findIndex(self.hierarchicalFacets[position], function (f) {
             return f.attribute === dfacet;
           });
 
@@ -3875,29 +3530,20 @@
           if (attributeIndex === -1) {
             return;
           }
-
-          self.hierarchicalFacets[position][attributeIndex].data = merge_1(
-            {},
-            self.hierarchicalFacets[position][attributeIndex].data,
-            facetResults
-          );
+          self.hierarchicalFacets[position][attributeIndex].data = merge$1({}, self.hierarchicalFacets[position][attributeIndex].data, facetResults);
         } else {
           position = disjunctiveFacetsIndices[dfacet];
-
           var dataFromMainRequest = mainSubResponse.facets && mainSubResponse.facets[dfacet] || {};
-
           self.disjunctiveFacets[position] = {
             name: dfacet,
             data: defaultsPure({}, facetResults, dataFromMainRequest),
             exhaustive: result.exhaustiveFacetsCount
           };
           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;
               }
             });
@@ -3908,28 +3554,23 @@
     });
 
     // 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) {
         return;
       }
-
-      results.slice(nextDisjunctiveResult).forEach(function(result) {
-        var facets = result && result.facets
-          ? result.facets
-          : {};
-
-        Object.keys(facets).forEach(function(dfacet) {
+      results.slice(nextDisjunctiveResult).forEach(function (result) {
+        var facets = result && result.facets ? result.facets : {};
+        Object.keys(facets).forEach(function (dfacet) {
           var facetResults = facets[dfacet];
-          var position = findIndex(state.hierarchicalFacets, function(f) {
+          var position = findIndex(state.hierarchicalFacets, function (f) {
             return f.name === hierarchicalFacet.name;
           });
-          var attributeIndex = findIndex(self.hierarchicalFacets[position], function(f) {
+          var attributeIndex = findIndex(self.hierarchicalFacets[position], function (f) {
             return f.attribute === dfacet;
           });
 
@@ -3947,35 +3588,29 @@
           //   | beers (5)
           //     > IPA (5)
           var defaultData = {};
-
           if (currentRefinement.length > 0) {
             var root = currentRefinement[0].split(separator)[0];
             defaultData[root] = self.hierarchicalFacets[position][attributeIndex].data[root];
           }
-
-          self.hierarchicalFacets[position][attributeIndex].data = defaultsPure(
-            defaultData,
-            facetResults,
-            self.hierarchicalFacets[position][attributeIndex].data
-          );
+          self.hierarchicalFacets[position][attributeIndex].data = defaultsPure(defaultData, facetResults, self.hierarchicalFacets[position][attributeIndex].data);
         });
-
         nextDisjunctiveResult++;
       });
     });
 
     // 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: mainSubResponse.facets[facetName],
+        data: mainFacets[facetName],
         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;
       });
@@ -3994,7 +3629,6 @@
      * @type {Array}
      */
     this.disjunctiveFacets = compact(this.disjunctiveFacets);
-
     this._state = state;
   }
 
@@ -4004,14 +3638,11 @@
    * @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) ||
-      find$1(this.disjunctiveFacets, predicate) ||
-      find$1(this.hierarchicalFacets, predicate);
+    return find$1(this.facets, predicate) || find$1(this.disjunctiveFacets, predicate) || find$1(this.hierarchicalFacets, predicate);
   };
 
   /**
@@ -4025,12 +3656,10 @@
     function predicate(facet) {
       return facet.name === attribute;
     }
-
     if (results._state.isConjunctiveFacet(attribute)) {
       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$2(name);
         return {
           name: name,
@@ -4043,8 +3672,7 @@
     } 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$2(name);
         return {
           name: name,
@@ -4056,29 +3684,31 @@
     } 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(
-        results._state.getHierarchicalRefinement(attribute)[0] || ''
-      ).split(results._state._getHierarchicalFacetSeparator(hierarchicalFacet));
+      var separator = results._state._getHierarchicalFacetSeparator(hierarchicalFacet);
+      var currentRefinement = unescapeFacetValue$3(results._state.getHierarchicalRefinement(attribute)[0] || '');
+      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);
       });
     }
@@ -4087,32 +3717,30 @@
   /**
    * 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;
-
     if (Array.isArray(node)) {
       return sortFn(node, names[level]);
     }
-
     if (!node.data || node.data.length === 0) {
       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;
   }
-
   SearchResults.DEFAULT_SORT = ['isRefined:desc', 'count:desc', 'name:asc'];
-
   function vanillaSortFn(order, data) {
     return data.sort(order);
   }
@@ -4128,23 +3756,21 @@
    * 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 = [];
     var remainingFacets = [];
-
     var order = facetOrdering.order || [];
     /**
      * 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) {
@@ -4153,11 +3779,9 @@
         remainingFacets.push(item);
       }
     });
-
-    orderedFacets = orderedFacets.filter(function(facet) {
+    orderedFacets = orderedFacets.filter(function (facet) {
       return facet;
     });
-
     var sortRemainingBy = facetOrdering.sortRemainingBy;
     var ordering;
     if (sortRemainingBy === 'hidden') {
@@ -4167,24 +3791,16 @@
     } else {
       ordering = [['count'], ['desc']];
     }
-
-    return orderedFacets.concat(
-      orderBy_1(remainingFacets, ordering[0], ordering[1])
-    );
+    return orderedFacets.concat(orderBy_1(remainingFacets, ordering[0], ordering[1]));
   }
 
   /**
    * @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 (
-      results.renderingContent &&
-      results.renderingContent.facetOrdering &&
-      results.renderingContent.facetOrdering.values &&
-      results.renderingContent.facetOrdering.values[attribute]
-    );
+    return results.renderingContent && results.renderingContent.facetOrdering && results.renderingContent.facetOrdering.values && results.renderingContent.facetOrdering.values[attribute];
   }
 
   /**
@@ -4235,12 +3851,11 @@
    *   });
    * });
    */
-  SearchResults.prototype.getFacetValues = function(attribute, opts) {
+  SearchResults.prototype.getFacetValues = function (attribute, opts) {
     var facetValues = extractNormalizedFacetValues(this, attribute);
     if (!facetValues) {
       return undefined;
     }
-
     var options = defaultsPure({}, opts, {
       sortBy: SearchResults.DEFAULT_SORT,
       // if no sortBy is given, attempt to sort based on facetOrdering
@@ -4248,6 +3863,7 @@
       facetOrdering: !(opts && opts.sortBy)
     });
 
+    // eslint-disable-next-line consistent-this
     var results = this;
     var attributes;
     if (Array.isArray(facetValues)) {
@@ -4256,25 +3872,20 @@
       var config = results._state.getHierarchicalFacetByName(facetValues.name);
       attributes = config.attributes;
     }
-
-    return recSort(function(data, facetName) {
+    return recSort(function (data, facetName) {
       if (options.facetOrdering) {
         var facetOrdering = getFacetOrdering(results, facetName);
-        if (Boolean(facetOrdering)) {
+        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'
-      );
+      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);
   };
 
@@ -4284,13 +3895,12 @@
    * @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)) {
       return getFacetStatsIfAvailable(this.disjunctiveFacets, attribute);
     }
-
     return undefined;
   };
 
@@ -4301,10 +3911,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;
@@ -4322,40 +3933,35 @@
    *
    * @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) {
+    Object.keys(state.facetsRefinements).forEach(function (attributeName) {
+      state.facetsRefinements[attributeName].forEach(function (name) {
         res.push(getRefinement(state, 'facet', attributeName, name, results.facets));
       });
     });
-
-    Object.keys(state.facetsExcludes).forEach(function(attributeName) {
-      state.facetsExcludes[attributeName].forEach(function(name) {
+    Object.keys(state.facetsExcludes).forEach(function (attributeName) {
+      state.facetsExcludes[attributeName].forEach(function (name) {
         res.push(getRefinement(state, 'exclude', attributeName, name, results.facets));
       });
     });
-
-    Object.keys(state.disjunctiveFacetsRefinements).forEach(function(attributeName) {
-      state.disjunctiveFacetsRefinements[attributeName].forEach(function(name) {
+    Object.keys(state.disjunctiveFacetsRefinements).forEach(function (attributeName) {
+      state.disjunctiveFacetsRefinements[attributeName].forEach(function (name) {
         res.push(getRefinement(state, 'disjunctive', attributeName, name, results.disjunctiveFacets));
       });
     });
-
-    Object.keys(state.hierarchicalFacetsRefinements).forEach(function(attributeName) {
-      state.hierarchicalFacetsRefinements[attributeName].forEach(function(name) {
+    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,
@@ -4366,11 +3972,13 @@
         });
       });
     });
-
-    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;
   };
 
@@ -4382,19 +3990,19 @@
    */
 
   /**
-   * @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(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;
-    var exhaustive = (facet && facet.exhaustive) || false;
-
+    var exhaustive = facet && facet.exhaustive || false;
     return {
       type: type,
       attributeName: attributeName,
@@ -4405,31 +4013,28 @@
   }
 
   /**
-   * @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 newFacet =
-        intermediateFacet && find$1(intermediateFacet.data, function(f) {
-          return f.name === part;
-        });
+    var facet = split.reduce(function (intermediateFacet, part) {
+      var newFacet = intermediateFacet && find$1(intermediateFacet.data, function (f) {
+        return f.name === part;
+      });
       return newFacet !== undefined ? newFacet : intermediateFacet;
     }, rootFacet);
-
-    var count = (facet && facet.count) || 0;
-    var exhaustive = (facet && facet.exhaustive) || false;
-    var path = (facet && facet.path) || '';
-
+    var count = facet && facet.count || 0;
+    var exhaustive = facet && facet.exhaustive || false;
+    var path = facet && facet.path || '';
     return {
       type: 'hierarchical',
       attributeName: attributeName,
@@ -4438,7 +4043,6 @@
       exhaustive: exhaustive
     };
   }
-
   var SearchResults_1 = SearchResults;
 
   // Copyright Joyent, Inc. and other Node contributors.
@@ -4754,7 +4358,6 @@
       }
     });
   }
-
   var inherits_1 = inherits;
 
   /**
@@ -4766,13 +4369,14 @@
    *  - 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;
     this.fn = fn;
     this.lastResults = null;
   }
-
   inherits_1(DerivedHelper, events);
 
   /**
@@ -4780,33 +4384,30 @@
    * @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);
   };
-
   var DerivedHelper_1 = DerivedHelper;
 
   function sortObject(obj) {
-    return Object.keys(obj)
-      .sort(function(a, b) {
-        return a.localeCompare(b);
-      })
-      .reduce(function(acc, curr) {
-        acc[curr] = obj[curr];
-        return acc;
-      }, {});
+    return Object.keys(obj).sort(function (a, b) {
+      return a.localeCompare(b);
+    }).reduce(function (acc, curr) {
+      acc[curr] = obj[curr];
+      return acc;
+    }, {});
   }
-
   var requestBuilder = {
     /**
      * 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) {
@@ -4819,7 +4420,7 @@
       });
 
       // One for each disjunctive facets
-      state.getRefinedDisjunctiveFacets().forEach(function(refinedFacet) {
+      state.getRefinedDisjunctiveFacets().forEach(function (refinedFacet) {
         queries.push({
           indexName: index,
           params: requestBuilder._getDisjunctiveFacetSearchParams(state, refinedFacet)
@@ -4827,7 +4428,7 @@
       });
 
       // 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);
@@ -4836,75 +4437,58 @@
         // we want to get all parent values
         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) {
-              return map.concat({
-                attribute: hierarchicalFacet.attributes[level],
-                value: level === 0
-                  ? segment
-                  : [map[map.length - 1].value, segment].join(separator)
-              });
-            }
-          , []);
-
-          filtersMap.forEach(function(filter, level) {
-            var params = requestBuilder._getDisjunctiveFacetSearchParams(
-              state,
-              filter.attribute,
-              level === 0
-            );
+          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)
+            });
+          }, []);
+          filtersMap.forEach(function (filter, level) {
+            var params = requestBuilder._getDisjunctiveFacetSearchParams(state, filter.attribute, level === 0);
 
             // 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) {
+            var filteredFacetFilters = (params.facetFilters || []).reduce(function (acc, facetFilter) {
               if (Array.isArray(facetFilter)) {
-                var filtered = facetFilter.filter(function(filterValue) {
+                var filtered = facetFilter.filter(function (filterValue) {
                   return !hasHierarchicalFacetFilter(filterValue);
                 });
-
                 if (filtered.length > 0) {
                   acc.push(filtered);
                 }
               }
-
               if (typeof facetFilter === 'string' && !hasHierarchicalFacetFilter(facetFilter)) {
                 acc.push(facetFilter);
               }
-
               return acc;
             }, []);
-
             var parent = filtersMap[level - 1];
             if (level > 0) {
               params.facetFilters = filteredFacetFilters.concat(parent.attribute + ':' + parent.value);
             } else {
               params.facetFilters = filteredFacetFilters.length > 0 ? filteredFacetFilters : undefined;
             }
-
-            queries.push({indexName: index, params: params});
+            queries.push({
+              indexName: index,
+              params: params
+            });
           });
         }
       });
-
       return queries;
     },
-
     /**
      * 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) {
-      var facets = state.facets
-        .concat(state.disjunctiveFacets)
-        .concat(requestBuilder._getHitsHierarchicalFacetsAttributes(state));
-
-
+    _getHitsSearchParams: function _getHitsSearchParams(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);
@@ -4912,26 +4496,23 @@
         facets: facets.indexOf('*') > -1 ? ['*'] : facets,
         tagFilters: tagFilters
       };
-
       if (facetFilters.length > 0) {
         additionalParams.facetFilters = facetFilters;
       }
-
       if (numericFilters.length > 0) {
         additionalParams.numericFilters = numericFilters;
       }
-
-      return sortObject(merge_1({}, state.getQueryParams(), additionalParams));
+      return sortObject(merge$1({}, state.getQueryParams(), additionalParams));
     },
-
     /**
      * 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) {
+    _getDisjunctiveFacetSearchParams: function _getDisjunctiveFacetSearchParams(state, facet, hierarchicalRootLevel) {
       var facetFilters = requestBuilder._getFacetFilters(state, facet, hierarchicalRootLevel);
       var numericFilters = requestBuilder._getNumericFilters(state, facet);
       var tagFilters = requestBuilder._getTagFilters(state);
@@ -4941,55 +4522,43 @@
         analytics: false,
         clickAnalytics: false
       };
-
       if (tagFilters.length > 0) {
         additionalParams.tagFilters = tagFilters;
       }
-
       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;
       }
-
       if (numericFilters.length > 0) {
         additionalParams.numericFilters = numericFilters;
       }
-
       if (facetFilters.length > 0) {
         additionalParams.facetFilters = facetFilters;
       }
-
-      return sortObject(merge_1({}, state.getQueryParams(), additionalParams));
+      return sortObject(merge$1({}, state.getQueryParams(), additionalParams));
     },
-
     /**
      * 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 _getNumericFilters(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);
@@ -5000,74 +4569,64 @@
           }
         });
       });
-
       return numericFilters;
     },
-
     /**
-     * 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 _getTagFilters(state) {
       if (state.tagFilters) {
         return state.tagFilters;
       }
-
       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 _getFacetFilters(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) {
+      Object.keys(hierarchicalFacetsRefinements).forEach(function (facetName) {
         var facetValues = hierarchicalFacetsRefinements[facetName] || [];
         var facetValue = facetValues[0];
-
         if (facetValue === undefined) {
           return;
         }
-
         var hierarchicalFacet = state.getHierarchicalFacetByName(facetName);
         var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
         var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);
@@ -5078,11 +4637,9 @@
         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;
           }
-
           if (!rootPath) {
             attributesIndex = facetValue.split(separator).length - 2;
             facetValue = facetValue.slice(0, facetValue.lastIndexOf(separator));
@@ -5090,56 +4647,45 @@
             attributesIndex = rootPath.split(separator).length - 1;
             facetValue = rootPath;
           }
-
           attributeToRefine = hierarchicalFacet.attributes[attributesIndex];
         } else {
           attributesIndex = facetValue.split(separator).length - 1;
-
           attributeToRefine = hierarchicalFacet.attributes[attributesIndex];
         }
-
         if (attributeToRefine) {
           facetFilters.push([attributeToRefine + ':' + facetValue]);
         }
       });
-
       return facetFilters;
     },
-
-    _getHitsHierarchicalFacetsAttributes: function(state) {
+    _getHitsHierarchicalFacetsAttributes: function _getHitsHierarchicalFacetsAttributes(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];
-
-          // if no refinement, ask for root level
-          if (!hierarchicalRefinement) {
-            allAttributes.push(hierarchicalFacet.attributes[0]);
-            return allAttributes;
-          }
-
-          var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
-          var level = hierarchicalRefinement.split(separator).length;
-          var newAttributes = hierarchicalFacet.attributes.slice(0, level + 1);
-
-          return allAttributes.concat(newAttributes);
-        }, out);
+      // ask for as much levels as there's hierarchical refinements
+      function getHitsAttributesForHierarchicalFacet(allAttributes, hierarchicalFacet) {
+        var hierarchicalRefinement = state.getHierarchicalRefinement(hierarchicalFacet.name)[0];
+
+        // if no refinement, ask for root level
+        if (!hierarchicalRefinement) {
+          allAttributes.push(hierarchicalFacet.attributes[0]);
+          return allAttributes;
+        }
+        var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
+        var level = hierarchicalRefinement.split(separator).length;
+        var newAttributes = hierarchicalFacet.attributes.slice(0, level + 1);
+        return allAttributes.concat(newAttributes);
+      }, out);
     },
-
-    _getDisjunctiveHierarchicalFacetAttribute: function(state, hierarchicalFacet, rootLevel) {
+    _getDisjunctiveHierarchicalFacetAttribute: function _getDisjunctiveHierarchicalFacetAttribute(state, hierarchicalFacet, rootLevel) {
       var separator = state._getHierarchicalFacetSeparator(hierarchicalFacet);
       if (rootLevel === true) {
         var rootPath = state._getHierarchicalRootPath(hierarchicalFacet);
         var attributeIndex = 0;
-
         if (rootPath) {
           attributeIndex = rootPath.split(separator).length;
         }
         return [hierarchicalFacet.attributes[attributeIndex]];
       }
-
       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)
@@ -5147,11 +4693,8 @@
       var parentLevel = hierarchicalRefinement.split(separator).length - 1;
       return hierarchicalFacet.attributes.slice(0, parentLevel + 1);
     },
-
-    getSearchForFacetQuery: function(facetName, query, maxFacetHits, state) {
-      var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName) ?
-        state.clearRefinements(facetName) :
-        state;
+    getSearchForFacetQuery: function getSearchForFacetQuery(facetName, query, maxFacetHits, state) {
+      var stateForSearchForFacetValues = state.isDisjunctiveFacet(facetName) ? state.clearRefinements(facetName) : state;
       var searchForFacetSearchParameters = {
         facetQuery: query,
         facetName: facetName
@@ -5159,17 +4702,12 @@
       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$1 = '3.13.0';
+  var version$1 = '3.13.3';
 
   var escapeFacetValue$3 = escapeFacetValue_1.escapeFacetValue;
 
@@ -5280,7 +4818,6 @@
     if (typeof client.addAlgoliaAgent === 'function') {
       client.addAlgoliaAgent('JS Helper (' + version$1 + ')');
     }
-
     this.setClient(client);
     var opts = options || {};
     opts.index = index;
@@ -5291,7 +4828,6 @@
     this.derivedHelpers = [];
     this._currentNbQueries = 0;
   }
-
   inherits_1(AlgoliaSearchHelper, events);
 
   /**
@@ -5299,19 +4835,22 @@
    * 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;
   };
 
@@ -5320,7 +4859,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);
   };
@@ -5332,7 +4871,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 :
@@ -5361,41 +4900,32 @@
    *   // }
    * }
    */
-  AlgoliaSearchHelper.prototype.searchOnce = function(options, cb) {
+  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
     });
-
     if (cb) {
-      this.client
-        .search(queries)
-        .then(function(content) {
-          self._currentNbQueries--;
-          if (self._currentNbQueries === 0) {
-            self.emit('searchQueueEmpty');
-          }
-
-          cb(null, new SearchResults_1(tempState, content.results), tempState);
-        })
-        .catch(function(err) {
-          self._currentNbQueries--;
-          if (self._currentNbQueries === 0) {
-            self.emit('searchQueueEmpty');
-          }
-
-          cb(err, null, tempState);
-        });
-
+      this.client.search(queries).then(function (content) {
+        self._currentNbQueries--;
+        if (self._currentNbQueries === 0) {
+          self.emit('searchQueueEmpty');
+        }
+        cb(null, new SearchResults_1(tempState, content.results), tempState);
+      }).catch(function (err) {
+        self._currentNbQueries--;
+        if (self._currentNbQueries === 0) {
+          self.emit('searchQueueEmpty');
+        }
+        cb(err, null, tempState);
+      });
       return undefined;
     }
-
-    return this.client.search(queries).then(function(content) {
+    return this.client.search(queries).then(function (content) {
       self._currentNbQueries--;
       if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
       return {
@@ -5403,14 +4933,14 @@
         state: tempState,
         _originalResponse: content
       };
-    }, function(e) {
+    }, 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
@@ -5421,7 +4951,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];
@@ -5429,21 +4960,12 @@
       return Promise.resolve([]);
     }
     var derivedState = derivedHelper.getModifiedState(state);
-    var data = merge_1(
-      {
-        attributesForPrediction: options.attributesForPrediction,
-        nbHits: options.nbHits
-      },
-      {
-        params: omit$1(requestBuilder_1._getHitsSearchParams(derivedState), [
-          'attributesToSnippet',
-          'hitsPerPage',
-          'restrictSearchableAttributes',
-          'snippetEllipsisText' // FIXME remove this line once the engine is fixed.
-        ])
-      }
-    );
-
+    var data = merge$1({
+      attributesForPrediction: options.attributesForPrediction,
+      nbHits: options.nbHits
+    }, {
+      params: omit$1(requestBuilder_1._getHitsSearchParams(derivedState), ['attributesToSnippet', 'hitsPerPage', 'restrictSearchableAttributes', 'snippetEllipsisText'])
+    });
     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);
@@ -5489,75 +5011,56 @@
    * 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 (
-      !clientHasSFFV &&
-      !clientHasInitIndex &&
-      typeof this.client.search !== 'function'
-    ) {
-      throw new Error(
-        'search for facet values (searchable) was called, but this client does not have a function client.searchForFacetValues or client.initIndex(index).searchForFacetValues'
-      );
+    if (!clientHasSFFV && !clientHasInitIndex && typeof this.client.search !== 'function') {
+      throw new Error('search for facet values (searchable) was called, but this client does not have a function client.searchForFacetValues or client.initIndex(index).searchForFacetValues');
     }
-
     var state = this.state.setQueryParameters(userState || {});
     var isDisjunctive = state.isDisjunctiveFacet(facet);
     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}
-      ]);
+      searchForFacetValuesPromise = this.client.searchForFacetValues([{
+        indexName: state.index,
+        params: algoliaQuery
+      }]);
       // algoliasearch < 3.27.1
     } else if (clientHasInitIndex) {
-      searchForFacetValuesPromise = this.client
-        .initIndex(state.index)
-        .searchForFacetValues(algoliaQuery);
+      searchForFacetValuesPromise = this.client.initIndex(state.index).searchForFacetValues(algoliaQuery);
       // algoliasearch ~5.0.0
     } else {
       // @MAJOR only use client.search
       delete algoliaQuery.facetName;
-      searchForFacetValuesPromise = this.client
-        .search([
-          {
-            type: 'facet',
-            facet: facet,
-            indexName: state.index,
-            params: algoliaQuery
-          }
-        ])
-        .then(function processResponse(response) {
-          return response.results[0];
-        });
+      searchForFacetValuesPromise = this.client.search([{
+        type: 'facet',
+        facet: facet,
+        indexName: state.index,
+        params: algoliaQuery
+      }]).then(function processResponse(response) {
+        return response.results[0];
+      });
     }
-
     this.emit('searchForFacetValues', {
       state: state,
       facet: facet,
       query: query
     });
-
     return searchForFacetValuesPromise.then(function addIsRefined(content) {
       self._currentNbQueries--;
       if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
-
       content = Array.isArray(content) ? content[0] : content;
-
-      content.facetHits.forEach(function(f) {
+      content.facetHits.forEach(function (f) {
         f.escapedValue = escapeFacetValue$3(f.value);
-        f.isRefined = isDisjunctive
-          ? state.isDisjunctiveFacetRefined(facet, f.escapedValue)
-          : state.isFacetRefined(facet, f.escapedValue);
+        f.isRefined = isDisjunctive ? state.isDisjunctiveFacetRefined(facet, f.escapedValue) : state.isFacetRefined(facet, f.escapedValue);
       });
-
       return content;
-    }, function(e) {
+    }, function (e) {
       self._currentNbQueries--;
       if (self._currentNbQueries === 0) self.emit('searchQueueEmpty');
       throw e;
@@ -5569,16 +5072,15 @@
    *
    * 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
     });
-
     return this;
   };
 
@@ -5590,7 +5092,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
@@ -5605,12 +5107,11 @@
    *   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
     });
-
     return this;
   };
 
@@ -5618,16 +5119,15 @@
    * 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
     });
-
     return this;
   };
 
@@ -5638,23 +5138,23 @@
    * 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
     });
-
     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);
   };
 
@@ -5666,17 +5166,16 @@
    * 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),
+      state: this.state.resetPage().addHierarchicalFacetRefinement(facet, path),
       isPageReset: true
     });
-
     return this;
   };
 
@@ -5688,16 +5187,15 @@
    * @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
     });
-
     return this;
   };
 
@@ -5708,27 +5206,26 @@
    * 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
     });
-
     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.
@@ -5736,23 +5233,23 @@
    * 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
     });
-
     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);
   };
 
@@ -5762,16 +5259,15 @@
    *
    * 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
     });
-
     return this;
   };
 
@@ -5789,16 +5285,15 @@
    * @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
     });
-
     return this;
   };
 
@@ -5812,40 +5307,39 @@
    * 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
     });
-
     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
     });
-
     return this;
   };
 
@@ -5859,23 +5353,23 @@
    * 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
     });
-
     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);
   };
 
@@ -5889,23 +5383,23 @@
    * 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
     });
-
     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);
   };
 
@@ -5915,16 +5409,15 @@
    *
    * 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
     });
-
     return this;
   };
 
@@ -5935,23 +5428,23 @@
    * 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
     });
-
     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);
   };
 
@@ -5964,13 +5457,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);
   };
 
@@ -5983,24 +5476,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
    * @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
     });
-
     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);
   };
 
@@ -6010,29 +5503,28 @@
    *
    * 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
     });
-
     return this;
   };
 
   /**
    * 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);
   };
@@ -6040,28 +5532,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
     });
-
     return this;
   }
 
@@ -6069,7 +5563,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
    */
@@ -6079,7 +5573,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
    */
@@ -6090,16 +5584,15 @@
    *
    * 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
     });
-
     return this;
   };
 
@@ -6114,34 +5607,32 @@
    * 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
     });
-
     return this;
   };
 
   /**
    * 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
     });
-
     return this;
   };
 
@@ -6150,7 +5641,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
@@ -6162,7 +5653,7 @@
    *  }
    * @chainable
    */
-  AlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent = function(newState) {
+  AlgoliaSearchHelper.prototype.overrideStateWithoutTriggeringChangeEvent = function (newState) {
     this.state = new SearchParameters_1(newState);
     return this;
   };
@@ -6190,7 +5681,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)) {
@@ -6215,7 +5706,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
@@ -6228,45 +5719,45 @@
    * 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;
   };
-
   function getCurrentPage() {
     return this.state.page;
   }
@@ -6289,7 +5780,7 @@
    *
    * @return {string[]} The list of tags currently set.
    */
-  AlgoliaSearchHelper.prototype.getTags = function() {
+  AlgoliaSearchHelper.prototype.getTags = function () {
     return this.state.tagRefinements;
   };
 
@@ -6337,50 +5828,41 @@
    * //   }
    * // ]
    */
-  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'
         });
       });
-
       var excludeRefinements = this.state.getExcludeRefinements(facetName);
-
-      excludeRefinements.forEach(function(r) {
+      excludeRefinements.forEach(function (r) {
         refinements.push({
           value: r,
           type: 'exclude'
         });
       });
     } else if (this.state.isDisjunctiveFacet(facetName)) {
-      var disjRefinements = this.state.getDisjunctiveRefinements(facetName);
-
-      disjRefinements.forEach(function(r) {
+      var disjunctiveRefinements = this.state.getDisjunctiveRefinements(facetName);
+      disjunctiveRefinements.forEach(function (r) {
         refinements.push({
           value: r,
           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'
       });
     });
-
     return refinements;
   };
 
@@ -6390,7 +5872,7 @@
    * @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);
   };
 
@@ -6399,7 +5881,7 @@
    * @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);
   };
 
@@ -6408,72 +5890,60 @@
   /**
    * 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 = [];
-
     if (!options.onlyWithDerivedHelpers) {
       mainQueries = requestBuilder_1._getQueries(state.index, state);
-
       states.push({
         state: state,
         queriesCount: mainQueries.length,
         helper: this
       });
-
       this.emit('search', {
         state: state,
         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)
-        : [];
-
+      var derivedStateQueries = derivedState.index ? requestBuilder_1._getQueries(derivedState.index, derivedState) : [];
       states.push({
         state: derivedState,
         queriesCount: derivedStateQueries.length,
         helper: derivedHelper
       });
-
       derivedHelper.emit('search', {
         state: derivedState,
         results: derivedHelper.lastResults
       });
-
       return derivedStateQueries;
     });
-
     var queries = Array.prototype.concat.apply(mainQueries, derivedQueries);
-
     var queryId = this._queryId++;
     this._currentNbQueries++;
-
     if (!queries.length) {
-      return Promise.resolve({results: []}).then(
-        this._dispatchAlgoliaResponse.bind(this, states, queryId)
-      );
+      return Promise.resolve({
+        results: []
+      }).then(this._dispatchAlgoliaResponse.bind(this, states, queryId));
     }
-
     try {
-      this.client.search(queries)
-        .then(this._dispatchAlgoliaResponse.bind(this, states, queryId))
-        .catch(this._dispatchAlgoliaError.bind(this, queryId));
+      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
       });
     }
+    return undefined;
   };
 
   /**
@@ -6481,33 +5951,27 @@
    * 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;
       var specificResults = results.splice(0, queriesCount);
-
       if (!state.index) {
         helper.emit('result', {
           results: null,
@@ -6515,57 +5979,43 @@
         });
         return;
       }
-
-      var formattedResponse = helper.lastResults = new SearchResults_1(state, specificResults);
-
+      helper.lastResults = new SearchResults_1(state, specificResults);
       helper.emit('result', {
-        results: formattedResponse,
+        results: helper.lastResults,
         state: state
       });
     });
   };
-
-  AlgoliaSearchHelper.prototype._dispatchAlgoliaError = function(queryId, error) {
+  AlgoliaSearchHelper.prototype._dispatchAlgoliaError = function (queryId, error) {
     if (queryId < this._lastQueryIdReceived) {
       // Outdated answer
       return;
     }
-
     this._currentNbQueries -= queryId - this._lastQueryIdReceived;
     this._lastQueryIdReceived = queryId;
-
     this.emit('error', {
       error: error
     });
-
     if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');
   };
-
-  AlgoliaSearchHelper.prototype.containsRefinement = function(query, facetFilters, numericFilters, tagFilters) {
-    return query ||
-      facetFilters.length !== 0 ||
-      numericFilters.length !== 0 ||
-      tagFilters.length !== 0;
+  AlgoliaSearchHelper.prototype.containsRefinement = function (query, facetFilters, numericFilters, tagFilters) {
+    return query || facetFilters.length !== 0 || numericFilters.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;
-
     if (state !== this.state) {
       this.state = state;
-
       this.emit('change', {
         state: this.state,
         results: this.lastResults,
@@ -6576,10 +6026,10 @@
 
   /**
    * 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;
   };
 
@@ -6587,24 +6037,22 @@
    * 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') {
       newClient.addAlgoliaAgent('JS Helper (' + version$1 + ')');
     }
     this.client = newClient;
-
     return this;
   };
 
   /**
    * 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;
   };
 
@@ -6625,9 +6073,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;
@@ -6637,10 +6085,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);
@@ -6650,7 +6099,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;
   };
 
@@ -6701,7 +6150,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);
@@ -6734,7 +6183,6 @@
    * @type {SearchResults}
    */
   algoliasearchHelper.SearchResults = SearchResults_1;
-
   var algoliasearchHelper_1 = algoliasearchHelper;
 
   function createOptionalFilter(_ref) {