algolia-experiences 1.8.23 → 1.8.25

package/dist/algolia-experiences.development.js

@@ -1,4 +1,4 @@
-/*! algolia-experiences 1.8.23 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
+/*! algolia-experiences 1.8.25 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
 (function (factory) {
     typeof define === 'function' && define.amd ? define(factory) :
     factory();
@@ -1118,6 +1118,43 @@
         return target;
     }
 
+    function _array_with_holes(arr) {
+        if (Array.isArray(arr)) return arr;
+    }
+
+    function _iterable_to_array_limit(arr, i) {
+        var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+        if (_i == null) return;
+
+        var _arr = [];
+        var _n = true;
+        var _d = false;
+        var _s, _e;
+
+        try {
+            for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+                _arr.push(_s.value);
+                if (i && _arr.length === i) break;
+            }
+        } catch (err) {
+            _d = true;
+            _e = err;
+        } finally {
+            try {
+                if (!_n && _i["return"] != null) _i["return"]();
+            } finally {
+                if (_d) throw _e;
+            }
+        }
+
+        return _arr;
+    }
+
+    function _non_iterable_rest() {
+        throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+
     function _array_like_to_array(arr, len) {
         if (len == null || len > arr.length) len = arr.length;
 
@@ -1126,6 +1163,21 @@
         return arr2;
     }
 
+    function _unsupported_iterable_to_array(o, minLen) {
+        if (!o) return;
+        if (typeof o === "string") return _array_like_to_array(o, minLen);
+
+        var n = Object.prototype.toString.call(o).slice(8, -1);
+
+        if (n === "Object" && o.constructor) n = o.constructor.name;
+        if (n === "Map" || n === "Set") return Array.from(n);
+        if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+    }
+
+    function _sliced_to_array(arr, i) {
+        return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+    }
+
     function _array_without_holes(arr) {
         if (Array.isArray(arr)) return _array_like_to_array(arr);
     }
@@ -1140,17 +1192,6 @@
         throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
     }
 
-    function _unsupported_iterable_to_array(o, minLen) {
-        if (!o) return;
-        if (typeof o === "string") return _array_like_to_array(o, minLen);
-
-        var n = Object.prototype.toString.call(o).slice(8, -1);
-
-        if (n === "Object" && o.constructor) n = o.constructor.name;
-        if (n === "Map" || n === "Set") return Array.from(n);
-        if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-    }
-
     function _to_consumable_array(arr) {
         return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
     }
@@ -6832,47 +6873,6 @@
         return target;
     }
 
-    function _array_with_holes(arr) {
-        if (Array.isArray(arr)) return arr;
-    }
-
-    function _iterable_to_array_limit(arr, i) {
-        var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
-
-        if (_i == null) return;
-
-        var _arr = [];
-        var _n = true;
-        var _d = false;
-        var _s, _e;
-
-        try {
-            for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
-                _arr.push(_s.value);
-                if (i && _arr.length === i) break;
-            }
-        } catch (err) {
-            _d = true;
-            _e = err;
-        } finally {
-            try {
-                if (!_n && _i["return"] != null) _i["return"]();
-            } finally {
-                if (_d) throw _e;
-            }
-        }
-
-        return _arr;
-    }
-
-    function _non_iterable_rest() {
-        throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-    }
-
-    function _sliced_to_array(arr, i) {
-        return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
-    }
-
     /**
      * Create UUID according to
      * https://www.ietf.org/rfc/rfc4122.txt.
@@ -6886,7 +6886,7 @@
         });
     }
 
-    var version = '4.113.0';
+    var version = '4.115.0';
 
     var ANONYMOUS_TOKEN_COOKIE_KEY = '_ALGOLIA';
     function getCookie(name) {
@@ -8996,23 +8996,33 @@
     }
 
     var nextMicroTask = Promise.resolve();
-    function defer(callback) {
+    function defer(callback, // arguments: the first caller of the window decides what the single run
+    // receives. Pass this to fold every later argument into the pending ones
+    // instead.
+    mergeArguments) {
         var progress = null;
         var cancelled = false;
+        var pendingArgs = null;
         var fn = function fn() {
             for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
                 args[_key] = arguments[_key];
             }
             if (progress !== null) {
+                if (mergeArguments && pendingArgs !== null) {
+                    pendingArgs = mergeArguments(pendingArgs, args);
+                }
                 return;
             }
+            pendingArgs = args;
             progress = nextMicroTask.then(function() {
                 progress = null;
+                var runArgs = pendingArgs;
+                pendingArgs = null;
                 if (cancelled) {
                     cancelled = false;
                     return;
                 }
-                callback.apply(void 0, _to_consumable_array(args));
+                callback.apply(void 0, _to_consumable_array(runArgs));
             });
         };
         fn.wait = function() {
@@ -9381,6 +9391,11 @@
         var helper = null;
         var derivedHelper = null;
         var lastValidSearchParameters = null;
+        // The error this index has already rolled back for. Renders also happen for
+        // reasons unrelated to a search (a chat panel opening, a recommend result,
+        // the stalled timer), and rolling back on every one of them would discard
+        // state written after the failed search.
+        var restoredForError;
         var recomputeLocalRequestDependencies = function recomputeLocalRequestDependencies() {
             if (localInstantSearchInstance) {
                 recomputeInstantSearchRequestDependencies(localInstantSearchInstance);
@@ -9520,6 +9535,92 @@
                 }
                 return this;
             },
+            updateWidget: function updateWidget(previousWidget, nextWidget) {
+                if (typeof previousWidget.dispose !== 'function') {
+                    throw new Error(withUsage$K('The widget definition expects a `dispose` method.'));
+                }
+                if (typeof nextWidget.init !== 'function' && typeof nextWidget.render !== 'function') {
+                    throw new Error(withUsage$K('The widget definition expects a `render` and/or an `init` method.'));
+                }
+                // The `uiState` as it is before the previous widget is detached, so that
+                // the state it owns can be handed over to the next widget.
+                var previousUiState = localUiState;
+                previousWidget.parent = undefined;
+                nextWidget.parent = this;
+                if (!isIndexWidget(nextWidget)) {
+                    addWidgetId(nextWidget);
+                }
+                // The next widget takes the place of the previous one, so that the order
+                // in which widgets contribute to the search parameters is unchanged.
+                var nextWidgets = localWidgets.slice();
+                var position = nextWidgets.indexOf(previousWidget);
+                if (position === -1) {
+                    nextWidgets.push(nextWidget);
+                } else {
+                    nextWidgets[position] = nextWidget;
+                }
+                localWidgets = nextWidgets;
+                recomputeLocalRequestDependencies();
+                if (!localInstantSearchInstance) {
+                    return this;
+                }
+                // We still dispose the previous widget, for its side effects. The search
+                // state it returns is only used as a base when shared state isn't preserved
+                // on unmount, like in `removeWidgets`.
+                var disposedState = previousWidget.dispose({
+                    helper: helper,
+                    state: helper.state,
+                    recommendState: helper.recommendState,
+                    parent: this
+                });
+                var cleanedRecommendState = _instanceof(disposedState, algoliasearchHelper.RecommendParameters) ? disposedState : helper.recommendState;
+                var cleanedSearchState = disposedState && !_instanceof(disposedState, algoliasearchHelper.RecommendParameters) ? disposedState : helper.state;
+                var initialSearchParameters = localInstantSearchInstance.future.preserveSharedStateOnUnmount ? new algoliasearchHelper.SearchParameters({
+                    index: this.getIndexName()
+                }) : cleanedSearchState;
+                // We hand the previous `uiState` over to the next widgets, then read the
+                // `uiState` back from them. Widgets only pick up the state they claim, so
+                // this drops state that no mounted widget owns anymore (an attribute that
+                // changed, for instance) instead of seeding it with `previousUiState`.
+                localUiState = getLocalWidgetsUiState(localWidgets, {
+                    searchParameters: getLocalWidgetsSearchParameters(localWidgets, {
+                        uiState: previousUiState,
+                        initialSearchParameters: initialSearchParameters
+                    }),
+                    helper: helper
+                });
+                // The search parameters are then computed again from that narrowed
+                // `uiState`, so that they can't hold state the `uiState` doesn't describe.
+                var newState = getLocalWidgetsSearchParameters(localWidgets, {
+                    uiState: localUiState,
+                    initialSearchParameters: initialSearchParameters
+                });
+                privateHelperSetState(helper, {
+                    state: newState,
+                    recommendState: getLocalWidgetsRecommendParameters(localWidgets, {
+                        uiState: localUiState,
+                        initialRecommendParameters: cleanedRecommendState
+                    }),
+                    _uiState: localUiState
+                });
+                if (nextWidget.getRenderState) {
+                    var renderState = nextWidget.getRenderState(localInstantSearchInstance.renderState[this.getIndexId()] || {}, createInitArgs(localInstantSearchInstance, this, localInstantSearchInstance._initialUiState));
+                    storeRenderState({
+                        renderState: renderState,
+                        instantSearchInstance: localInstantSearchInstance,
+                        parent: this
+                    });
+                }
+                if (nextWidget.init) {
+                    nextWidget.init(createInitArgs(localInstantSearchInstance, this, localInstantSearchInstance._initialUiState));
+                }
+                if (isolated) {
+                    this.scheduleLocalSearch();
+                } else {
+                    localInstantSearchInstance.scheduleSearch();
+                }
+                return this;
+            },
             removeWidgets: function removeWidgets(widgets) {
                 var _this = this;
                 if (!Array.isArray(widgets)) {
@@ -9771,7 +9872,10 @@
                 var instantSearchInstance = param.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) {
+                if (instantSearchInstance.status !== 'error') {
+                    restoredForError = undefined;
+                } else if (instantSearchInstance.error !== restoredForError && !instantSearchInstance.mainHelper.hasPendingRequests() && lastValidSearchParameters) {
+                    restoredForError = instantSearchInstance.error;
                     helper.setState(lastValidSearchParameters);
                 }
                 // We only render index widgets if there are no results.
@@ -10422,6 +10526,14 @@
                     instantSearchInstance: _this
                 });
                 _this.emit('render');
+            }, // status reset accumulates instead of letting the first caller decide: a
+            // render scheduled for a reason unrelated to the search must not cancel the
+            // one a search result asks for, or it would strand the status on `loading`.
+            function(param, param1) {
+                var _param = _sliced_to_array(param, 1), tmp = _param[0], shouldResetStatus = tmp === void 0 ? true : tmp, _param1 = _sliced_to_array(param1, 1), tmp1 = _param1[0], nextShouldResetStatus = tmp1 === void 0 ? true : tmp1;
+                return [
+                    shouldResetStatus || nextShouldResetStatus
+                ];
             })), _define_property(_this, "onInternalStateChange", defer(function() {
                 var nextUiState = _this.mainIndex.getWidgetUiState({});
                 _this.middleware.forEach(function(param) {