react-instantsearch-core 7.7.1 → 7.7.3

package/dist/umd/ReactInstantSearchCore.js

@@ -7,7 +7,7 @@
 
   var React__default = 'default' in React ? React['default'] : React;
 
-  var version = '7.7.1';
+  var version = '7.7.3';
 
   // 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;
 
   /**
@@ -519,7 +526,18 @@
     constructor: RecommendParameters,
 
     addParams: function (params) {
-      return new RecommendParameters({ params: this.params.concat(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) {
@@ -529,6 +547,45 @@
         }),
       });
     },
+
+    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;
@@ -4380,7 +4437,7 @@
 
   var SearchResults_1 = SearchResults;
 
-  var version$1 = '3.17.0';
+  var version$1 = '3.19.0';
 
   var escapeFacetValue$3 = escapeFacetValue_1.escapeFacetValue;
 
@@ -4510,10 +4567,14 @@
       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;
   }
 
@@ -4540,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
@@ -5036,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.
@@ -5205,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.
@@ -5772,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
@@ -5831,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
@@ -5850,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,
@@ -5900,6 +6282,16 @@
 
       // 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,
+        },
+      });
     }
   };
 
@@ -5954,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;
   };
@@ -6059,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
@@ -8926,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) {
@@ -9038,6 +9439,7 @@
    */
   function privateHelperSetState(helper, _ref) {
     var state = _ref.state,
+      recommendState = _ref.recommendState,
       isPageReset = _ref.isPageReset,
       _uiState = _ref._uiState;
     if (state !== helper.state) {
@@ -9049,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) {
@@ -9068,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) {
@@ -9086,6 +9506,7 @@
       var widgetHelper = widget.getHelper();
       privateHelperSetState(widgetHelper, {
         state: widgetHelper.state.resetPage(),
+        recommendState: widgetHelper.recommendState,
         isPageReset: true
       });
       resetPageFromWidgets(widget.getWidgets());
@@ -9144,9 +9565,18 @@
       },
       getScopedResults: function getScopedResults() {
         var widgetParent = this.getParent();
-
-        // If the widget is the root, we consider itself as the only sibling.
-        var widgetSiblings = widgetParent ? widgetParent.getWidgets() : [this];
+        var widgetSiblings;
+        if (widgetParent) {
+          widgetSiblings = widgetParent.getWidgets();
+        } else if (indexName.length === 0) {
+          // The widget is the root but has no index name:
+          // we resolve results from its children index widgets
+          widgetSiblings = this.getWidgets();
+        } else {
+          // The widget is the root and has an index name:
+          // we consider itself as the only sibling
+          widgetSiblings = [this];
+        }
         return resolveScopedResultsFromWidgets(widgetSiblings);
       },
       getParent: function getParent() {
@@ -9181,6 +9611,10 @@
               uiState: localUiState,
               initialSearchParameters: helper.state
             }),
+            recommendState: getLocalWidgetsRecommendParameters(localWidgets, {
+              uiState: localUiState,
+              initialRecommendParameters: helper.recommendState
+            }),
             _uiState: localUiState
           });
 
@@ -9277,11 +9711,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
@@ -9312,6 +9751,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) {
@@ -9354,6 +9795,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`.
@@ -9400,9 +9856,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) {
@@ -9412,6 +9868,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));
@@ -9469,8 +9933,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
@@ -9490,10 +9954,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)));
   }
@@ -11758,7 +12222,7 @@
     };
   }
 
-  var version$2 = '4.66.1';
+  var version$2 = '4.68.0';
 
   function _typeof$k(obj) {
     "@babel/helpers - typeof";
@@ -12252,7 +12716,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
@@ -14212,6 +14676,7 @@
           });
         },
         getWidgetRenderState: function getWidgetRenderState(_ref2) {
+          var _results$renderingCon, _results$renderingCon2, _results$renderingCon3;
           var results = _ref2.results,
             helper = _ref2.helper,
             instantSearchInstance = _ref2.instantSearchInstance;
@@ -14237,6 +14702,7 @@
             return {
               hits: [],
               results: undefined,
+              banner: undefined,
               sendEvent: sendEvent,
               bindEvent: bindEvent,
               widgetParams: widgetParams
@@ -14250,9 +14716,11 @@
           var transformedHits = transformItems(hitsWithAbsolutePositionAndQueryID, {
             results: results
           });
+          var banner = (_results$renderingCon = results.renderingContent) === null || _results$renderingCon === void 0 ? void 0 : (_results$renderingCon2 = _results$renderingCon.widgets) === null || _results$renderingCon2 === void 0 ? void 0 : (_results$renderingCon3 = _results$renderingCon2.banners) === null || _results$renderingCon3 === void 0 ? void 0 : _results$renderingCon3[0];
           return {
             hits: transformedHits,
             results: results,
+            banner: banner,
             sendEvent: sendEvent,
             bindEvent: bindEvent,
             widgetParams: widgetParams
@@ -14516,7 +14984,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) {
@@ -14632,7 +15100,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() {
@@ -16571,7 +17039,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) {
@@ -16756,7 +17224,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
@@ -17800,6 +18268,14 @@
             results: results,
             scopedResults: searchIndex.getScopedResults()
           });
+        } else if (search.mainIndex.getIndexName().length === 0) {
+          // If the main index has no name, we get the scoped results from
+          // the first child index instead.
+          var childIndex = search.mainIndex.getWidgets().find(isIndexWidget);
+          childIndex && setSearchResults({
+            results: getIndexSearchResults(searchIndex).results,
+            scopedResults: childIndex.getScopedResults()
+          });
         }
       }
       search.addListener('render', handleRender);