react-instantsearch-core 7.47.0 → 7.48.0

package/dist/cjs/version.js

@@ -9,4 +9,4 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
-var _default = '7.47.0';
+var _default = '7.48.0';

package/dist/es/version.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "7.47.0";
+declare const _default: "7.48.0";
 export default _default;

package/dist/es/version.js

@@ -1,3 +1,3 @@
-var version = '7.47.0';
+var version = '7.48.0';
 
 export { version as default };

package/dist/umd/ReactInstantSearchCore.js

@@ -1,4 +1,4 @@
-/*! React InstantSearch Core 7.47.0 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
+/*! React InstantSearch Core 7.48.0 | © Algolia, Inc. and contributors; MIT License | https://github.com/algolia/instantsearch */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
     typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
@@ -24,7 +24,7 @@
 
     var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 
-    var version$2 = '7.47.0';
+    var version$2 = '7.48.0';
 
     function _define_property(obj, key, value) {
         if (key in obj) {
@@ -9418,7 +9418,7 @@
         });
     }
 
-    var version = '4.114.0';
+    var version = '4.115.0';
 
     var ANONYMOUS_TOKEN_COOKIE_KEY = '_ALGOLIA';
     function getCookie(name) {
@@ -16061,6 +16061,36 @@
             return typeof s === 'string';
         });
     }
+    // Key order is not significant to the request, so a plain `JSON.stringify` would
+    // report two identical payloads as different.
+    function stableKey(value) {
+        if (value === null || (typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object') {
+            var _JSON_stringify;
+            return (_JSON_stringify = JSON.stringify(value)) !== null && _JSON_stringify !== void 0 ? _JSON_stringify : 'null';
+        }
+        if (Array.isArray(value)) {
+            return "[".concat(value.map(stableKey).join(','), "]");
+        }
+        var record = value;
+        return "{".concat(Object.keys(record).sort().map(function(key) {
+            return "".concat(JSON.stringify(key), ":").concat(stableKey(record[key]));
+        }).join(','), "}");
+    }
+    /**
+     * Comparable identity of a task payload, or `null` when it cannot be compared.
+     */ function taskPayloadKey(payload) {
+        try {
+            // Round-trip first so the comparison sees what the request will actually
+            // carry: `JSON.stringify` applies `toJSON` (a `Date` becomes its ISO string)
+            // and drops the values the wire drops. Walking the raw object instead would
+            // read a `Date` as a key-less object and call two different instants equal.
+            return stableKey(JSON.parse(JSON.stringify(payload)));
+        } catch (unused) {
+            // Circular or otherwise unserializable. Never claim a match on a payload we
+            // could not read; let the request go out and fail where it does today.
+            return null;
+        }
+    }
     function buildSuggestionMessage(suggestion) {
         return "The user clicked this on-page suggestion. Use the current page context first, then search only if needed.\n\nSuggestion: ".concat(suggestion);
     }
@@ -16128,6 +16158,10 @@
             var error;
             var debounceTimer;
             var lastStateSignature = null;
+            // The payload of the last request that was actually sent. The automatic
+            // trigger keys on the search state, which is only a proxy for the payload,
+            // so this is what decides whether a request would ask anything new.
+            var lastSubmittedPayload = null;
             var latestRenderOptions = null;
             // Set in `dispose()`. A debounced or in-flight `fetch()` can resolve after
             // the widget is unmounted; this guard stops those late callbacks from
@@ -16138,6 +16172,10 @@
             // still-in-flight request from the previous state must not paint its
             // suggestions, its inner render is ignored until the new `submit` starts.
             var refetchPending = false;
+            // True when `refetchPending` made an inner render be dropped. The fetch
+            // that dropped it was expected to render in its place; if that fetch turns
+            // out to send nothing, it has to reconcile the dropped state instead.
+            var droppedInnerRender = false;
             var getStateSignature = function getStateSignature(results) {
                 var _buildFilters;
                 if (results.queryID) {
@@ -16224,19 +16262,62 @@
                     instantSearchInstance: renderOptions.instantSearchInstance
                 }), false);
             };
+            // Copies an inner render's state into this widget's and re-renders on the
+            // client.
+            var adoptInnerState = function adoptInnerState(renderState) {
+                error = renderState.error;
+                if (renderState.error) {
+                    // A failed task (including a mid-stream `error` event) must not leave
+                    // any streamed partial visible.
+                    suggestions = [];
+                } else if (renderState.isLoading || renderState.output !== undefined) {
+                    // Only adopt the inner output once a request is loading or has
+                    // produced one, so the initial no-op render doesn't clobber pills.
+                    suggestions = parseSuggestions(renderState.output);
+                }
+                isLoading = renderState.isLoading;
+                if (!latestRenderOptions) return;
+                renderOutward(latestRenderOptions);
+            };
             var fetchAndRender = function fetchAndRender(results, renderOptions) {
+                var _ref = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, _ref_force = _ref.force, force = _ref_force === void 0 ? false : _ref_force;
                 var _results_hits;
                 if (disposed || !tasksState) return;
+                var hadDroppedInnerRender = droppedInnerRender;
                 refetchPending = false;
+                droppedInnerRender = false;
                 var hasContext = context !== undefined;
                 if (!hasContext && !(results === null || results === void 0 ? void 0 : (_results_hits = results.hits) === null || _results_hits === void 0 ? void 0 : _results_hits.length)) {
                     tasksState.invalidate();
                     suggestions = [];
                     isLoading = false;
+                    // The output is gone, so the same payload must be allowed to rebuild it.
+                    lastSubmittedPayload = null;
                     renderOutward(renderOptions);
                     return;
                 }
-                tasksState.submit(buildInput(results));
+                var input = buildInput(results);
+                var payload = taskPayloadKey(input);
+                // A moved search state does not always mean a different question: with an
+                // explicit `context` the payload ignores the results entirely, so a new
+                // `queryID` or a new hit order produces a byte-identical request. Sending
+                // it again spends a model call on an answer already on screen. Leave the
+                // current suggestions alone and send nothing. `force` is the explicit
+                // path (`refresh()`), which must always reach the network.
+                if (!force && payload !== null && payload === lastSubmittedPayload) {
+                    // Nothing goes out, so nothing will render — but the state change that
+                    // scheduled this fetch also made `handleInnerRender` drop the render
+                    // that was carrying the previous request's result. Reconcile it here or
+                    // the widget keeps that request's `isLoading: true` with no
+                    // suggestions, and nothing later clears it: `refresh()` is blocked by
+                    // its own `isLoading` guard and an unchanged payload keeps skipping.
+                    if (hadDroppedInnerRender) {
+                        adoptInnerState(tasksState);
+                    }
+                    return;
+                }
+                lastSubmittedPayload = payload;
+                tasksState.submit(input);
             };
             var refresh = function refresh() {
                 if (isLoading) return;
@@ -16244,7 +16325,9 @@
                 if (!results || !latestRenderOptions) return;
                 clearTimeout(debounceTimer);
                 lastStateSignature = getStateSignature(results);
-                fetchAndRender(results, latestRenderOptions);
+                fetchAndRender(results, latestRenderOptions, {
+                    force: true
+                });
             };
             var getWidgetRenderState = function getWidgetRenderState(renderOptions) {
                 var results = 'results' in renderOptions ? renderOptions.results : undefined;
@@ -16270,20 +16353,18 @@
             // resolve/error) into this widget's state and re-renders on the client.
             var handleInnerRender = function handleInnerRender(renderState) {
                 tasksState = renderState;
-                if (refetchPending) return;
-                error = renderState.error;
                 if (renderState.error) {
-                    // A failed task (including a mid-stream `error` event) must not leave
-                    // any streamed partial visible.
-                    suggestions = [];
-                } else if (renderState.isLoading || renderState.output !== undefined) {
-                    // Only adopt the inner output once a request is loading or has
-                    // produced one, so the initial no-op render doesn't clobber pills.
-                    suggestions = parseSuggestions(renderState.output);
+                    // Keep a failed payload retryable: without this the next automatic
+                    // attempt with the same payload would be skipped as a duplicate and
+                    // the error would have no way to clear. Set before the `refetchPending`
+                    // return so a failure that lands mid-refetch is not swallowed.
+                    lastSubmittedPayload = null;
+                }
+                if (refetchPending) {
+                    droppedInnerRender = true;
+                    return;
                 }
-                isLoading = renderState.isLoading;
-                if (!latestRenderOptions) return;
-                renderOutward(latestRenderOptions);
+                adoptInnerState(renderState);
             };
             var tasksParams;
             if (agentId) {