react-instantsearch-core 7.7.0 → 7.7.2

package/dist/umd/ReactInstantSearchCore.js

@@ -7,7 +7,7 @@
 
   var React__default = 'default' in React ? React['default'] : React;
 
-  var version = '7.7.0';
+  var version = '7.7.2';
 
   // Copyright Joyent, Inc. and other Node contributors.
   //
@@ -335,12 +335,15 @@
    *    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
+   * @param {function} fn the function to create the derived state for search
+   * @param {function} recommendFn the function to create the derived state for recommendations
    */
-  function DerivedHelper(mainHelper, fn) {
+  function DerivedHelper(mainHelper, fn, recommendFn) {
     this.main = mainHelper;
     this.fn = fn;
+    this.recommendFn = recommendFn;
     this.lastResults = null;
+    this.lastRecommendResults = null;
   }
 
   inherits_1(DerivedHelper, events);
@@ -359,6 +362,10 @@
     return this.fn(parameters);
   };
 
+  DerivedHelper.prototype.getModifiedRecommendState = function (parameters) {
+    return this.recommendFn(parameters);
+  };
+
   var DerivedHelper_1 = DerivedHelper;
 
   /**
@@ -497,6 +504,92 @@
 
   var omit = _objectWithoutPropertiesLoose;
 
+  /**
+   * RecommendParameters is the data structure that contains all the information
+   * usable for getting recommendations from the Algolia API. It doesn't do the
+   * search itself, nor does it contains logic about the parameters.
+   * It is an immutable object, therefore it has been created in a way that each
+   * changes does not change the object itself but returns a copy with the
+   * modification.
+   * This object should probably not be instantiated outside of the helper. It
+   * will be provided when needed.
+   * @constructor
+   * @classdesc contains all the parameters for recommendations
+   * @param {RecommendParametersOptions} opts the options to create the object
+   */
+  function RecommendParameters(opts) {
+    opts = opts || {};
+    this.params = opts.params || [];
+  }
+
+  RecommendParameters.prototype = {
+    constructor: RecommendParameters,
+
+    addParams: function (params) {
+      var newParams = this.params.slice();
+      var existingParamsIndex = this.params.findIndex(function (currentParams) {
+        return currentParams.$$id === params.$$id;
+      });
+
+      if (existingParamsIndex !== -1) {
+        newParams.splice(existingParamsIndex, 1, params);
+      } else {
+        newParams.push(params);
+      }
+
+      return new RecommendParameters({ params: newParams });
+    },
+
+    removeParams: function (id) {
+      return new RecommendParameters({
+        params: this.params.filter(function (param) {
+          return param.$$id !== id;
+        }),
+      });
+    },
+
+    addFrequentlyBoughtTogether: function (params) {
+      return this.addParams(
+        Object.assign({}, params, { model: 'bought-together' })
+      );
+    },
+
+    addRelatedProducts: function (params) {
+      return this.addParams(
+        Object.assign({}, params, { model: 'related-products' })
+      );
+    },
+
+    addTrendingItems: function (params) {
+      return this.addParams(
+        Object.assign({}, params, { model: 'trending-items' })
+      );
+    },
+
+    addTrendingFacets: function (params) {
+      return this.addParams(
+        Object.assign({}, params, { model: 'trending-facets' })
+      );
+    },
+
+    addLookingSimilar: function (params) {
+      return this.addParams(
+        Object.assign({}, params, { model: 'looking-similar' })
+      );
+    },
+
+    _buildQueries: function (indexName) {
+      return this.params.map(function (params) {
+        var query = Object.assign({}, params, { indexName: indexName });
+        delete query.$$id;
+
+        return query;
+      });
+    },
+  };
+
+  var RecommendParameters_1 = RecommendParameters;
+
   function sortObject(obj) {
     return Object.keys(obj)
       .sort()
@@ -4344,7 +4437,7 @@
 
   var SearchResults_1 = SearchResults;
 
-  var version$1 = '3.16.3';
+  var version$1 = '3.18.0';
 
   var escapeFacetValue$3 = escapeFacetValue_1.escapeFacetValue;
 
@@ -4356,6 +4449,7 @@
 
 
 
+
   /**
    * Event triggered when a parameter is set or updated
    * @event AlgoliaSearchHelper#event:change
@@ -4469,11 +4563,18 @@
     var opts = options || {};
     opts.index = index;
     this.state = SearchParameters_1.make(opts);
+    this.recommendState = new RecommendParameters_1({
+      params: opts.recommendState,
+    });
     this.lastResults = null;
+    this.lastRecommendResults = null;
     this._queryId = 0;
+    this._recommendQueryId = 0;
     this._lastQueryIdReceived = -1;
+    this._lastRecommendQueryIdReceived = -1;
     this.derivedHelpers = [];
     this._currentNbQueries = 0;
+    this._currentNbRecommendQueries = 0;
     this._searchResultsOptions = searchResultsOptions;
   }
 
@@ -4500,6 +4601,21 @@
     return this;
   };
 
+  /**
+   * Sends the recommendation queries set in the state. When the method is
+   * called, it triggers a `fetch` event. The results will be available through
+   * the `result` event. If an error occurs, an `error` will be fired instead.
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @fires fetch
+   * @fires result
+   * @fires error
+   * @chainable
+   */
+  AlgoliaSearchHelper.prototype.recommend = function () {
+    this._recommend();
+    return this;
+  };
+
   /**
    * Gets the search query parameters that would be sent to the Algolia Client
    * for the hits
@@ -4996,6 +5112,86 @@
     return this;
   };
 
+  /**
+   * Adds a "frequently bought together" recommendation query.
+   *
+   * @param {FrequentlyBoughtTogetherQuery} params the parameters for the recommendation
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @fires change
+   * @chainable
+   */
+  AlgoliaSearchHelper.prototype.addFrequentlyBoughtTogether = function (params) {
+    this._recommendChange({
+      state: this.recommendState.addFrequentlyBoughtTogether(params),
+    });
+
+    return this;
+  };
+
+  /**
+   * Adds a "related products" recommendation query.
+   *
+   * @param {RelatedProductsQuery} params the parameters for the recommendation
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @fires change
+   * @chainable
+   */
+  AlgoliaSearchHelper.prototype.addRelatedProducts = function (params) {
+    this._recommendChange({
+      state: this.recommendState.addRelatedProducts(params),
+    });
+
+    return this;
+  };
+
+  /**
+   * Adds a "trending items" recommendation query.
+   *
+   * @param {TrendingItemsQuery} params the parameters for the recommendation
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @fires change
+   * @chainable
+   */
+  AlgoliaSearchHelper.prototype.addTrendingItems = function (params) {
+    this._recommendChange({
+      state: this.recommendState.addTrendingItems(params),
+    });
+
+    return this;
+  };
+
+  /**
+   * Adds a "trending facets" recommendation query.
+   *
+   * @param {TrendingFacetsQuery} params the parameters for the recommendation
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @fires change
+   * @chainable
+   */
+  AlgoliaSearchHelper.prototype.addTrendingFacets = function (params) {
+    this._recommendChange({
+      state: this.recommendState.addTrendingFacets(params),
+    });
+
+    return this;
+  };
+
+  /**
+   * Adds a "looking similar" recommendation query.
+   *
+   * @param {LookingSimilarQuery} params the parameters for the recommendation
+   * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @fires change
+   * @chainable
+   */
+  AlgoliaSearchHelper.prototype.addLookingSimilar = function (params) {
+    this._recommendChange({
+      state: this.recommendState.addLookingSimilar(params),
+    });
+
+    return this;
+  };
+
   /**
    * Removes an numeric filter to an attribute with the `operator` and `value` provided. If the
    * filter is not set, it doesn't change the filters.
@@ -5165,6 +5361,86 @@
     return this;
   };
 
+  /**
+   * Removes a "frequently bought together" recommendation query.
+   *
+   * @param {string} id identifier of the recommendation widget
+   * @returns {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @fires change
+   * @chainable
+   */
+  AlgoliaSearchHelper.prototype.removeFrequentlyBoughtTogether = function (id) {
+    this._recommendChange({
+      state: this.recommendState.removeParams(id),
+    });
+
+    return this;
+  };
+
+  /**
+   * Removes a "related products" recommendation query.
+   *
+   * @param {string} id identifier of the recommendation widget
+   * @returns {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @fires change
+   * @chainable
+   */
+  AlgoliaSearchHelper.prototype.removeRelatedProducts = function (id) {
+    this._recommendChange({
+      state: this.recommendState.removeParams(id),
+    });
+
+    return this;
+  };
+
+  /**
+   * Removes a "trending items" recommendation query.
+   *
+   * @param {string} id identifier of the recommendation widget
+   * @returns {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @fires change
+   * @chainable
+   */
+  AlgoliaSearchHelper.prototype.removeTrendingItems = function (id) {
+    this._recommendChange({
+      state: this.recommendState.removeParams(id),
+    });
+
+    return this;
+  };
+
+  /**
+   * Removes a "trending facets" recommendation query.
+   *
+   * @param {string} id identifier of the recommendation widget
+   * @returns {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @fires change
+   * @chainable
+   */
+  AlgoliaSearchHelper.prototype.removeTrendingFacets = function (id) {
+    this._recommendChange({
+      state: this.recommendState.removeParams(id),
+    });
+
+    return this;
+  };
+
+  /**
+   * Removes a "looking similar" recommendation query.
+   *
+   * @param {string} id identifier of the recommendation widget
+   * @returns {AlgoliaSearchHelper} Method is chainable, it returns itself
+   * @fires change
+   * @chainable
+   */
+  AlgoliaSearchHelper.prototype.removeLookingSimilar = function (id) {
+    this._recommendChange({
+      state: this.recommendState.removeParams(id),
+    });
+
+    return this;
+  };
+
   /**
    * Adds or removes an exclusion filter to a faceted attribute with the `value` provided. If
    * the value is set then it removes it, otherwise it adds the filter.
@@ -5732,6 +6008,85 @@
     return undefined;
   };
 
+  AlgoliaSearchHelper.prototype._recommend = function () {
+    var searchState = this.state;
+    var recommendState = this.recommendState;
+    var index = this.getIndex();
+    var states = [{ state: recommendState, index: index, helper: this }];
+
+    this.emit('fetch', {
+      recommend: {
+        state: recommendState,
+        results: this.lastRecommendResults,
+      },
+    });
+
+    var derivedQueries = this.derivedHelpers.map(function (derivedHelper) {
+      var derivedIndex = derivedHelper.getModifiedState(searchState).index;
+      if (!derivedIndex) {
+        return [];
+      }
+
+      // Contrary to what is done when deriving the search state, we don't want to
+      // provide the current recommend state to the derived helper, as it would
+      // inherit unwanted queries. We instead provide an empty recommend state.
+      var derivedState = derivedHelper.getModifiedRecommendState(
+        new RecommendParameters_1()
+      );
+      states.push({
+        state: derivedState,
+        index: derivedIndex,
+        helper: derivedHelper,
+      });
+
+      derivedHelper.emit('fetch', {
+        recommend: {
+          state: derivedState,
+          results: derivedHelper.lastRecommendResults,
+        },
+      });
+
+      return derivedState._buildQueries(derivedIndex);
+    });
+
+    var queries = Array.prototype.concat.apply(
+      this.recommendState._buildQueries(index),
+      derivedQueries
+    );
+
+    if (queries.length === 0) {
+      return;
+    }
+
+    if (
+      queries.length > 0 &&
+      typeof this.client.getRecommendations === 'undefined'
+    ) {
+      // eslint-disable-next-line no-console
+      console.warn(
+        'Please update algoliasearch/lite to the latest version in order to use recommendations widgets.'
+      );
+      return;
+    }
+
+    var queryId = this._recommendQueryId++;
+    this._currentNbRecommendQueries++;
+
+    try {
+      this.client
+        .getRecommendations(queries)
+        .then(this._dispatchRecommendResponse.bind(this, queryId, states))
+        .catch(this._dispatchRecommendError.bind(this, queryId));
+    } catch (error) {
+      // If we reach this part, we're in an internal error state
+      this.emit('error', {
+        error: error,
+      });
+    }
+
+    return;
+  };
+
   /**
    * Transform the responses as sent by the server and transform them into a user
    * usable object that merge the results of all the batch requests. It will dispatch
@@ -5791,6 +6146,53 @@
     });
   };
 
+  AlgoliaSearchHelper.prototype._dispatchRecommendResponse = function (
+    queryId,
+    states,
+    content
+  ) {
+    // @TODO remove the number of outdated queries discarded instead of just one
+
+    if (queryId < this._lastRecommendQueryIdReceived) {
+      // Outdated answer
+      return;
+    }
+
+    this._currentNbRecommendQueries -=
+      queryId - this._lastRecommendQueryIdReceived;
+    this._lastRecommendQueryIdReceived = queryId;
+
+    if (this._currentNbRecommendQueries === 0) this.emit('recommendQueueEmpty');
+
+    var results = content.results.slice();
+
+    states.forEach(function (s) {
+      var state = s.state;
+      var helper = s.helper;
+
+      if (!s.index) {
+        // eslint-disable-next-line no-warning-comments
+        // TODO: emit "result" event when events for Recommend are implemented
+        helper.emit('recommend:result', {
+          results: null,
+          state: state,
+        });
+        return;
+      }
+
+      helper.lastRecommendResults = results;
+
+      // eslint-disable-next-line no-warning-comments
+      // TODO: emit "result" event when events for Recommend are implemented
+      helper.emit('recommend:result', {
+        recommend: {
+          results: helper.lastRecommendResults,
+          state: state,
+        },
+      });
+    });
+  };
+
   AlgoliaSearchHelper.prototype._dispatchAlgoliaError = function (
     queryId,
     error
@@ -5810,6 +6212,26 @@
     if (this._currentNbQueries === 0) this.emit('searchQueueEmpty');
   };
 
+  AlgoliaSearchHelper.prototype._dispatchRecommendError = function (
+    queryId,
+    error
+  ) {
+    if (queryId < this._lastRecommendQueryIdReceived) {
+      // Outdated answer
+      return;
+    }
+
+    this._currentNbRecommendQueries -=
+      queryId - this._lastRecommendQueryIdReceived;
+    this._lastRecommendQueryIdReceived = queryId;
+
+    this.emit('error', {
+      error: error,
+    });
+
+    if (this._currentNbRecommendQueries === 0) this.emit('recommendQueueEmpty');
+  };
+
   AlgoliaSearchHelper.prototype.containsRefinement = function (
     query,
     facetFilters,
@@ -5852,6 +6274,27 @@
     }
   };
 
+  AlgoliaSearchHelper.prototype._recommendChange = function (event) {
+    var state = event.state;
+
+    if (state !== this.recommendState) {
+      this.recommendState = state;
+
+      // eslint-disable-next-line no-warning-comments
+      // TODO: emit "change" event when events for Recommend are implemented
+      this.emit('recommend:change', {
+        search: {
+          results: this.lastResults,
+          state: this.state,
+        },
+        recommend: {
+          results: this.lastRecommendResults,
+          state: this.recommendState,
+        },
+      });
+    }
+  };
+
   /**
    * Clears the cache of the underlying Algolia client.
    * @return {AlgoliaSearchHelper} Method is chainable, it returns itself
@@ -5903,10 +6346,11 @@
    * and the SearchParameters that is returned by the call of the
    * parameter function.
    * @param {function} fn SearchParameters -> SearchParameters
+   * @param {function} recommendFn RecommendParameters -> RecommendParameters
    * @return {DerivedHelper} a new DerivedHelper
    */
-  AlgoliaSearchHelper.prototype.derive = function (fn) {
-    var derivedHelper = new DerivedHelper_1(this, fn);
+  AlgoliaSearchHelper.prototype.derive = function (fn, recommendFn) {
+    var derivedHelper = new DerivedHelper_1(this, fn, recommendFn);
     this.derivedHelpers.push(derivedHelper);
     return derivedHelper;
   };
@@ -6008,6 +6452,13 @@
    */
   algoliasearchHelper.SearchParameters = SearchParameters_1;
 
+  /**
+   * Constructor for the object containing all the parameters for Recommend.
+   * @member module:algoliasearchHelper.RecommendParameters
+   * @type {RecommendParameters}
+   */
+  algoliasearchHelper.RecommendParameters = RecommendParameters_1;
+
   /**
    * Constructor for the object containing the results of the search.
    * @member module:algoliasearchHelper.SearchResults
@@ -8438,7 +8889,7 @@
 
       // Scenario 1: the widget is added for the first time.
       if (!cleanupTimerRef.current) {
-        if (!shouldAddWidgetEarly) {
+        if (!shouldSsr) {
           parentIndex.addWidgets([widget]);
         }
       }
@@ -8475,7 +8926,7 @@
           });
         });
       };
-    }, [parentIndex, widget, shouldAddWidgetEarly, search, props]);
+    }, [parentIndex, widget, shouldSsr, search, props]);
     if (shouldAddWidgetEarly || (waitingForResultsRef === null || waitingForResultsRef === void 0 ? void 0 : (_waitingForResultsRef = waitingForResultsRef.current) === null || _waitingForResultsRef === void 0 ? void 0 : _waitingForResultsRef.status) === 'pending') {
       parentIndex.addWidgets([widget]);
     }
@@ -8875,7 +9326,8 @@
       return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
     }, _typeof$c(obj);
   }
-  var _excluded$3 = ["initialSearchParameters"];
+  var _excluded$3 = ["initialSearchParameters"],
+    _excluded2$1 = ["initialRecommendParameters"];
   function ownKeys$b(object, enumerableOnly) {
     var keys = Object.keys(object);
     if (Object.getOwnPropertySymbols) {
@@ -8987,6 +9439,7 @@
    */
   function privateHelperSetState(helper, _ref) {
     var state = _ref.state,
+      recommendState = _ref.recommendState,
       isPageReset = _ref.isPageReset,
       _uiState = _ref._uiState;
     if (state !== helper.state) {
@@ -8998,7 +9451,14 @@
         _uiState: _uiState
       });
     }
+    if (recommendState !== helper.recommendState) {
+      helper.recommendState = recommendState;
+
+      // eslint-disable-next-line no-warning-comments
+      // TODO: emit "change" event when events for Recommend are implemented
+    }
   }
+
   function getLocalWidgetsUiState(widgets, widgetStateOptions) {
     var initialUiState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     return widgets.reduce(function (uiState, widget) {
@@ -9017,15 +9477,26 @@
   function getLocalWidgetsSearchParameters(widgets, widgetSearchParametersOptions) {
     var initialSearchParameters = widgetSearchParametersOptions.initialSearchParameters,
       rest = _objectWithoutProperties$2(widgetSearchParametersOptions, _excluded$3);
-    return widgets.filter(function (widget) {
-      return !isIndexWidget(widget);
-    }).reduce(function (state, widget) {
-      if (!widget.getWidgetSearchParameters) {
+    return widgets.reduce(function (state, widget) {
+      if (!widget.getWidgetSearchParameters || isIndexWidget(widget)) {
         return state;
       }
+      if (widget.dependsOn === 'search' && widget.getWidgetParameters) {
+        return widget.getWidgetParameters(state, rest);
+      }
       return widget.getWidgetSearchParameters(state, rest);
     }, initialSearchParameters);
   }
+  function getLocalWidgetsRecommendParameters(widgets, widgetRecommendParametersOptions) {
+    var initialRecommendParameters = widgetRecommendParametersOptions.initialRecommendParameters,
+      rest = _objectWithoutProperties$2(widgetRecommendParametersOptions, _excluded2$1);
+    return widgets.reduce(function (state, widget) {
+      if (!isIndexWidget(widget) && widget.dependsOn === 'recommend' && widget.getWidgetParameters) {
+        return widget.getWidgetParameters(state, rest);
+      }
+      return state;
+    }, initialRecommendParameters);
+  }
   function resetPageFromWidgets(widgets) {
     var indexWidgets = widgets.filter(isIndexWidget);
     if (indexWidgets.length === 0) {
@@ -9035,6 +9506,7 @@
       var widgetHelper = widget.getHelper();
       privateHelperSetState(widgetHelper, {
         state: widgetHelper.state.resetPage(),
+        recommendState: widgetHelper.recommendState,
         isPageReset: true
       });
       resetPageFromWidgets(widget.getWidgets());
@@ -9130,6 +9602,10 @@
               uiState: localUiState,
               initialSearchParameters: helper.state
             }),
+            recommendState: getLocalWidgetsRecommendParameters(localWidgets, {
+              uiState: localUiState,
+              initialRecommendParameters: helper.recommendState
+            }),
             _uiState: localUiState
           });
 
@@ -9226,11 +9702,16 @@
             index: indexName
           })
         });
+        var recommendParameters = getLocalWidgetsRecommendParameters(localWidgets, {
+          uiState: localUiState,
+          initialRecommendParameters: new algoliasearchHelper_1.RecommendParameters()
+        });
 
         // This Helper is only used for state management we do not care about the
         // `searchClient`. Only the "main" Helper created at the `InstantSearch`
         // level is aware of the client.
         helper = algoliasearchHelper_1({}, parameters.index, parameters);
+        helper.recommendState = recommendParameters;
 
         // We forward the call to `search` to the "main" instance of the Helper
         // which is responsible for managing the queries (it's the only one that is
@@ -9261,6 +9742,8 @@
         };
         derivedHelper = mainHelper.derive(function () {
           return mergeSearchParameters.apply(void 0, [mainHelper.state].concat(_toConsumableArray$1(resolveSearchParameters(_this3))));
+        }, function () {
+          return _this3.getHelper().recommendState;
         });
         var indexInitialResults = (_instantSearchInstanc = instantSearchInstance._initialResults) === null || _instantSearchInstanc === void 0 ? void 0 : _instantSearchInstanc[this.getIndexId()];
         if (indexInitialResults) {
@@ -9303,6 +9786,21 @@
           lastValidSearchParameters = results === null || results === void 0 ? void 0 : results._state;
         });
 
+        // eslint-disable-next-line no-warning-comments
+        // TODO: listen to "result" event when events for Recommend are implemented
+        derivedHelper.on('recommend:result', function (_ref5) {
+          var recommend = _ref5.recommend;
+          // The index does not render the results it schedules a new render
+          // to let all the other indices emit their own results. It allows us to
+          // run the render process in one pass.
+          instantSearchInstance.scheduleRender();
+
+          // the derived helper is the one which actually searches, but the helper
+          // which is exposed e.g. via instance.helper, doesn't search, and thus
+          // does not have access to lastRecommendResults.
+          helper.lastRecommendResults = recommend.results;
+        });
+
         // We compute the render state before calling `init` in a separate loop
         // to construct the whole render state object that is then passed to
         // `init`.
@@ -9349,9 +9847,9 @@
           instantSearchInstance.scheduleRender();
         }
       },
-      render: function render(_ref5) {
+      render: function render(_ref6) {
         var _this4 = this;
-        var instantSearchInstance = _ref5.instantSearchInstance;
+        var instantSearchInstance = _ref6.instantSearchInstance;
         // we can't attach a listener to the error event of search, as the error
         // then would no longer be thrown for global handlers.
         if (instantSearchInstance.status === 'error' && !instantSearchInstance.mainHelper.hasPendingRequests() && lastValidSearchParameters) {
@@ -9361,6 +9859,14 @@
         // We only render index widgets if there are no results.
         // This makes sure `render` is never called with `results` being `null`.
         var widgetsToRender = this.getResults() ? localWidgets : localWidgets.filter(isIndexWidget);
+        widgetsToRender = widgetsToRender.filter(function (widget) {
+          if (!widget.shouldRender) {
+            return true;
+          }
+          return widget.shouldRender({
+            instantSearchInstance: instantSearchInstance
+          });
+        });
         widgetsToRender.forEach(function (widget) {
           if (widget.getRenderState) {
             var renderState = widget.getRenderState(instantSearchInstance.renderState[_this4.getIndexId()] || {}, createRenderArgs(instantSearchInstance, _this4));
@@ -9418,8 +9924,8 @@
       getWidgetState: function getWidgetState(uiState) {
         return this.getWidgetUiState(uiState);
       },
-      getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, _ref6) {
-        var uiState = _ref6.uiState;
+      getWidgetSearchParameters: function getWidgetSearchParameters(searchParameters, _ref7) {
+        var uiState = _ref7.uiState;
         return getLocalWidgetsSearchParameters(localWidgets, {
           uiState: uiState,
           initialSearchParameters: searchParameters
@@ -9439,10 +9945,10 @@
       }
     };
   };
-  function storeRenderState(_ref7) {
-    var renderState = _ref7.renderState,
-      instantSearchInstance = _ref7.instantSearchInstance,
-      parent = _ref7.parent;
+  function storeRenderState(_ref8) {
+    var renderState = _ref8.renderState,
+      instantSearchInstance = _ref8.instantSearchInstance,
+      parent = _ref8.parent;
     var parentIndexName = parent ? parent.getIndexId() : instantSearchInstance.mainIndex.getIndexId();
     instantSearchInstance.renderState = _objectSpread$a(_objectSpread$a({}, instantSearchInstance.renderState), {}, _defineProperty$b({}, parentIndexName, _objectSpread$a(_objectSpread$a({}, instantSearchInstance.renderState[parentIndexName]), renderState)));
   }
@@ -11707,7 +12213,7 @@
     };
   }
 
-  var version$2 = '4.66.0';
+  var version$2 = '4.67.0';
 
   function _typeof$k(obj) {
     "@babel/helpers - typeof";
@@ -12201,7 +12707,7 @@
           // under the hood, we have a different implementation. It should be
           // completely transparent for the rest of the codebase. Only this module
           // is impacted.
-          return mainHelper.searchOnlyWithDerivedHelpers();
+          return mainHelper.searchOnlyWithDerivedHelpers() && mainHelper.recommend();
         };
         if (this._searchFunction) {
           // this client isn't used to actually search, but required for the helper
@@ -14221,6 +14727,8 @@
           if (!escapeHTML) {
             return state;
           }
+
+          // @MAJOR: set this globally, not in the Hits widget to allow Hits to be conditionally used
           return state.setQueryParameters(TAG_PLACEHOLDER);
         }
       };
@@ -14463,7 +14971,7 @@
     }, _typeof$s(obj);
   }
   var _excluded$9 = ["page"],
-    _excluded2$1 = ["clickAnalytics", "userToken"];
+    _excluded2$2 = ["clickAnalytics", "userToken"];
   function ownKeys$o(object, enumerableOnly) {
     var keys = Object.keys(object);
     if (Object.getOwnPropertySymbols) {
@@ -14579,7 +15087,7 @@
     var _ref2 = state || {},
       clickAnalytics = _ref2.clickAnalytics,
       userToken = _ref2.userToken,
-      rest = _objectWithoutProperties$5(_ref2, _excluded2$1);
+      rest = _objectWithoutProperties$5(_ref2, _excluded2$2);
     return rest;
   }
   function getInMemoryCache() {
@@ -14800,6 +15308,7 @@
           var uiState = _ref10.uiState;
           var widgetSearchParameters = searchParameters;
           if (escapeHTML) {
+            // @MAJOR: set this globally, not in the InfiniteHits widget to allow InfiniteHits to be conditionally used
             widgetSearchParameters = searchParameters.setQueryParameters(TAG_PLACEHOLDER);
           }
 
@@ -16517,7 +17026,7 @@
     }, _typeof$z(obj);
   }
   var _excluded$b = ["name", "escapedValue"],
-    _excluded2$2 = ["escapedValue", "value"];
+    _excluded2$3 = ["escapedValue", "value"];
   function ownKeys$u(object, enumerableOnly) {
     var keys = Object.keys(object);
     if (Object.getOwnPropertySymbols) {
@@ -16702,7 +17211,7 @@
                 var normalizedFacetValues = transformItems(facetValues.map(function (_ref3) {
                   var escapedValue = _ref3.escapedValue,
                     value = _ref3.value,
-                    item = _objectWithoutProperties$7(_ref3, _excluded2$2);
+                    item = _objectWithoutProperties$7(_ref3, _excluded2$3);
                   return _objectSpread$t(_objectSpread$t({}, item), {}, {
                     value: escapedValue,
                     label: value