react-instantsearch-core 7.24.0 → 7.26.0

package/dist/es/lib/useInstantSearchApi.js

@@ -1,124 +1,124 @@
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-import InstantSearch, { INSTANTSEARCH_FUTURE_DEFAULTS } from "instantsearch.js/es/lib/InstantSearch.js";
-import { useCallback, useRef, version as ReactVersion } from 'react';
-import { useSyncExternalStore } from "use-sync-external-store/shim/index.js";
-import version from "../version.js";
-import { dequal } from "./dequal.js";
-import { useForceUpdate } from "./useForceUpdate.js";
-import { useInstantSearchServerContext } from "./useInstantSearchServerContext.js";
-import { useInstantSearchSSRContext } from "./useInstantSearchSSRContext.js";
-import { useRSCContext } from "./useRSCContext.js";
-import { warn } from "./warn.js";
-var defaultUserAgents = ["react (".concat(ReactVersion, ")"), "react-instantsearch (".concat(version, ")"), "react-instantsearch-core (".concat(version, ")")];
-var serverUserAgent = "react-instantsearch-server (".concat(version, ")");
+import { _ as _$1 } from '@swc/helpers/cjs/_object_spread.cjs';
+import { _ } from '@swc/helpers/cjs/_to_consumable_array.cjs';
+import InstantSearch, { INSTANTSEARCH_FUTURE_DEFAULTS } from 'instantsearch.js/es/lib/InstantSearch.js';
+import { useRef, useCallback, version } from 'react';
+import { useSyncExternalStore } from 'use-sync-external-store/shim/index.js';
+import version$1 from '../version.js';
+import { dequal } from './dequal.js';
+import { useForceUpdate } from './useForceUpdate.js';
+import { useInstantSearchServerContext } from './useInstantSearchServerContext.js';
+import { useInstantSearchSSRContext } from './useInstantSearchSSRContext.js';
+import { useRSCContext } from './useRSCContext.js';
+
+var defaultUserAgents = [
+    "react (".concat(version, ")"),
+    "react-instantsearch (".concat(version$1, ")"),
+    "react-instantsearch-core (".concat(version$1, ")")
+];
+var serverUserAgent = "react-instantsearch-server (".concat(version$1, ")");
 var nextUserAgent = function nextUserAgent(nextVersion) {
-  return nextVersion ? "next.js (".concat(nextVersion, ")") : null;
+    return nextVersion ? "next.js (".concat(nextVersion, ")") : null;
 };
-export function useInstantSearchApi(props) {
-  var forceUpdate = useForceUpdate();
-  var serverContext = useInstantSearchServerContext();
-  var serverState = useInstantSearchSSRContext();
-  var _useRSCContext = useRSCContext(),
-    waitForResultsRef = _useRSCContext.waitForResultsRef;
-  var initialResults = serverState === null || serverState === void 0 ? void 0 : serverState.initialResults;
-  var prevPropsRef = useRef(props);
-  var shouldRenderAtOnce = serverContext || initialResults || waitForResultsRef;
-  var searchRef = useRef(null);
-  // As we need to render on mount with SSR, using the local ref above in `StrictMode` will
-  // create and start two instances of InstantSearch. To avoid this, we instead discard it and use
-  // an upward ref from `InstantSearchSSRContext` as it has already been mounted a second time at this point.
-  if (serverState !== null && serverState !== void 0 && serverState.ssrSearchRef) {
-    searchRef = serverState.ssrSearchRef;
-  }
-  if (searchRef.current === null) {
-    // We don't use the `instantsearch()` function because it comes with other
-    // top-level APIs that we don't need.
-    // See https://github.com/algolia/instantsearch/blob/5b529f43d8acc680f85837eaaa41f7fd03a3f833/src/index.es.ts#L63-L86
-    var search = new InstantSearch(props);
-    search._schedule = function _schedule(cb) {
-      search._schedule.queue.push(cb);
-      clearTimeout(search._schedule.timer);
-      search._schedule.timer = setTimeout(function () {
-        search._schedule.queue.forEach(function (callback) {
-          callback();
-        });
-        search._schedule.queue = [];
-      }, 0);
-    };
-    search._schedule.queue = [];
-    if (shouldRenderAtOnce) {
-      // InstantSearch.js has a private Initial Results API that lets us inject
-      // results on the search instance.
-      // On the server, we default the initial results to an empty object so that
-      // InstantSearch.js doesn't schedule a search that isn't used, leading to
-      // an additional network request. (This is equivalent to monkey-patching
-      // `scheduleSearch` to a noop.)
-      search._initialResults = initialResults || {};
-      // We don't rely on the `defer` to reset the schedule search, but will call
-      // `search._resetScheduleSearch()` manually in the effect after children
-      // mount in `InstantSearch`.
-      search._manuallyResetScheduleSearch = true;
-    }
-    addAlgoliaAgents(props.searchClient, [].concat(defaultUserAgents, [serverContext && serverUserAgent, nextUserAgent(getNextVersion())]));
-
-    // On the server, we start the search early to compute the search parameters.
-    // On SSR, we start the search early to directly catch up with the lifecycle
-    // and render.
-    if (shouldRenderAtOnce) {
-      search.start();
-    }
-    if (serverContext) {
-      // We notify `getServerState()` of the InstantSearch internals to retrieve
-      // the server state and pass it to the render on SSR.
-      serverContext.notifyServer({
-        search: search
-      });
-    }
-    warnNextRouter(props.routing);
-    warnNextAppDir(Boolean(waitForResultsRef));
-    searchRef.current = search;
-  }
-  {
-    var _search = searchRef.current;
-    var prevProps = prevPropsRef.current;
-    if (prevProps.indexName !== props.indexName) {
-      _search.helper.setIndex(props.indexName || '').search();
-      prevPropsRef.current = props;
+function useInstantSearchApi(props) {
+    var forceUpdate = useForceUpdate();
+    var serverContext = useInstantSearchServerContext();
+    var serverState = useInstantSearchSSRContext();
+    var waitForResultsRef = useRSCContext().waitForResultsRef;
+    var initialResults = serverState === null || serverState === void 0 ? void 0 : serverState.initialResults;
+    var prevPropsRef = useRef(props);
+    var shouldRenderAtOnce = serverContext || initialResults || waitForResultsRef;
+    var searchRef = useRef(null);
+    // As we need to render on mount with SSR, using the local ref above in `StrictMode` will
+    // create and start two instances of InstantSearch. To avoid this, we instead discard it and use
+    // an upward ref from `InstantSearchSSRContext` as it has already been mounted a second time at this point.
+    if (serverState === null || serverState === void 0 ? void 0 : serverState.ssrSearchRef) {
+        searchRef = serverState.ssrSearchRef;
     }
-    if (prevProps.searchClient !== props.searchClient) {
-      process.env.NODE_ENV === 'development' ? warn(false, 'The `searchClient` prop of `<InstantSearch>` changed between renders, which may cause more search requests than necessary. If this is an unwanted behavior, please provide a stable reference: https://www.algolia.com/doc/api-reference/widgets/instantsearch/react/#widget-param-searchclient') : void 0;
-      addAlgoliaAgents(props.searchClient, [].concat(defaultUserAgents, [serverContext && serverUserAgent]));
-      _search.mainHelper.setClient(props.searchClient).search();
-      prevPropsRef.current = props;
-    }
-    if (prevProps.onStateChange !== props.onStateChange) {
-      _search.onStateChange = props.onStateChange;
-      prevPropsRef.current = props;
-    }
-    if (prevProps.searchFunction !== props.searchFunction) {
-      // Updating the `searchFunction` to `undefined` is not supported by
-      // InstantSearch.js, so it will throw an error.
-      // This is a fair behavior until we add an update API in InstantSearch.js.
-      _search._searchFunction = props.searchFunction;
-      prevPropsRef.current = props;
-    }
-    if (prevProps.stalledSearchDelay !== props.stalledSearchDelay) {
-      var _props$stalledSearchD;
-      // The default `stalledSearchDelay` in InstantSearch.js is 200ms.
-      // We need to reset it when it's undefined to get back to the original value.
-      _search._stalledSearchDelay = (_props$stalledSearchD = props.stalledSearchDelay) !== null && _props$stalledSearchD !== void 0 ? _props$stalledSearchD : 200;
-      prevPropsRef.current = props;
-    }
-    if (!dequal(prevProps.future, props.future)) {
-      _search.future = _objectSpread(_objectSpread({}, INSTANTSEARCH_FUTURE_DEFAULTS), props.future);
-      prevPropsRef.current = props;
+    if (searchRef.current === null) {
+        // We don't use the `instantsearch()` function because it comes with other
+        // top-level APIs that we don't need.
+        // See https://github.com/algolia/instantsearch/blob/5b529f43d8acc680f85837eaaa41f7fd03a3f833/src/index.es.ts#L63-L86
+        var search = new InstantSearch(props);
+        search._schedule = function _schedule(cb) {
+            search._schedule.queue.push(cb);
+            clearTimeout(search._schedule.timer);
+            search._schedule.timer = setTimeout(function() {
+                search._schedule.queue.forEach(function(callback) {
+                    callback();
+                });
+                search._schedule.queue = [];
+            }, 0);
+        };
+        search._schedule.queue = [];
+        if (shouldRenderAtOnce) {
+            // InstantSearch.js has a private Initial Results API that lets us inject
+            // results on the search instance.
+            // On the server, we default the initial results to an empty object so that
+            // InstantSearch.js doesn't schedule a search that isn't used, leading to
+            // an additional network request. (This is equivalent to monkey-patching
+            // `scheduleSearch` to a noop.)
+            search._initialResults = initialResults || {};
+            // We don't rely on the `defer` to reset the schedule search, but will call
+            // `search._resetScheduleSearch()` manually in the effect after children
+            // mount in `InstantSearch`.
+            search._manuallyResetScheduleSearch = true;
+        }
+        addAlgoliaAgents(props.searchClient, _(defaultUserAgents).concat([
+            serverContext && serverUserAgent,
+            nextUserAgent(getNextVersion())
+        ]));
+        // On the server, we start the search early to compute the search parameters.
+        // On SSR, we start the search early to directly catch up with the lifecycle
+        // and render.
+        if (shouldRenderAtOnce) {
+            search.start();
+        }
+        if (serverContext) {
+            // We notify `getServerState()` of the InstantSearch internals to retrieve
+            // the server state and pass it to the render on SSR.
+            serverContext.notifyServer({
+                search: search
+            });
+        }
+        warnNextRouter(props.routing);
+        searchRef.current = search;
     }
-
+    {
+        var search1 = searchRef.current;
+        var prevProps = prevPropsRef.current;
+        if (prevProps.indexName !== props.indexName) {
+            search1.helper.setIndex(props.indexName || '').search();
+            prevPropsRef.current = props;
+        }
+        if (prevProps.searchClient !== props.searchClient) {
+            addAlgoliaAgents(props.searchClient, _(defaultUserAgents).concat([
+                serverContext && serverUserAgent
+            ]));
+            search1.mainHelper.setClient(props.searchClient).search();
+            prevPropsRef.current = props;
+        }
+        if (prevProps.onStateChange !== props.onStateChange) {
+            search1.onStateChange = props.onStateChange;
+            prevPropsRef.current = props;
+        }
+        if (prevProps.searchFunction !== props.searchFunction) {
+            // Updating the `searchFunction` to `undefined` is not supported by
+            // InstantSearch.js, so it will throw an error.
+            // This is a fair behavior until we add an update API in InstantSearch.js.
+            search1._searchFunction = props.searchFunction;
+            prevPropsRef.current = props;
+        }
+        if (prevProps.stalledSearchDelay !== props.stalledSearchDelay) {
+            var _props_stalledSearchDelay;
+            // The default `stalledSearchDelay` in InstantSearch.js is 200ms.
+            // We need to reset it when it's undefined to get back to the original value.
+            search1._stalledSearchDelay = (_props_stalledSearchDelay = props.stalledSearchDelay) !== null && _props_stalledSearchDelay !== void 0 ? _props_stalledSearchDelay : 200;
+            prevPropsRef.current = props;
+        }
+        if (!dequal(prevProps.future, props.future)) {
+            search1.future = _$1({}, INSTANTSEARCH_FUTURE_DEFAULTS, props.future);
+            prevPropsRef.current = props;
+        }
     // Updating the `routing` prop is not supported because InstantSearch.js
     // doesn't let us change it. This might not be a problem though, because `routing`
     // shouldn't need to be dynamic.
@@ -126,87 +126,70 @@ export function useInstantSearchApi(props) {
     // it privately on the InstantSearch instance. Another way would be to
     // manually inject the routing middleware in this library, and not rely
     // on the provided `routing` prop.
-  }
-  var cleanupTimerRef = useRef(null);
-  var store = useSyncExternalStore(useCallback(function () {
-    var search = searchRef.current;
-
-    // Scenario 1: the component mounts.
-    if (cleanupTimerRef.current === null) {
-      // On SSR, the instance is already started so we don't start it again.
-      if (!search.started) {
-        search.start();
-        forceUpdate();
-      }
-    }
-    // Scenario 2: the component updates.
-    else {
-      // We cancel the previous cleanup function because we don't want to
-      // dispose the search during an update.
-      clearTimeout(cleanupTimerRef.current);
-      search._preventWidgetCleanup = false;
     }
-    return function () {
-      if (serverState !== null && serverState !== void 0 && serverState.ssrSearchRef) {
-        return;
-      }
-      function cleanup() {
-        search.dispose();
-      }
-      clearTimeout(search._schedule.timer);
-      // We clean up only when the component that uses this subscription unmounts,
-      // but not when it updates, because it would dispose the instance, which
-      // would remove all the widgets and break routing.
-      // Executing the cleanup function in a `setTimeout()` lets us cancel it
-      // in the next effect.
-      // (There might be better ways to do this.)
-      cleanupTimerRef.current = setTimeout(cleanup);
-      // We need to prevent the `useWidget` cleanup function so that widgets
-      // are not removed before the instance is disposed, triggering
-      // an unwanted search request.
-      search._preventWidgetCleanup = true;
-    };
-  }, [forceUpdate, serverState]), function () {
-    return searchRef.current;
-  }, function () {
-    return searchRef.current;
-  });
-  return store;
+    var cleanupTimerRef = useRef(null);
+    var store = useSyncExternalStore(useCallback(function() {
+        var search = searchRef.current;
+        // Scenario 1: the component mounts.
+        if (cleanupTimerRef.current === null) {
+            // On SSR, the instance is already started so we don't start it again.
+            if (!search.started) {
+                search.start();
+                forceUpdate();
+            }
+        } else {
+            // We cancel the previous cleanup function because we don't want to
+            // dispose the search during an update.
+            clearTimeout(cleanupTimerRef.current);
+            search._preventWidgetCleanup = false;
+        }
+        return function() {
+            if (serverState === null || serverState === void 0 ? void 0 : serverState.ssrSearchRef) {
+                return;
+            }
+            function cleanup() {
+                search.dispose();
+            }
+            clearTimeout(search._schedule.timer);
+            // We clean up only when the component that uses this subscription unmounts,
+            // but not when it updates, because it would dispose the instance, which
+            // would remove all the widgets and break routing.
+            // Executing the cleanup function in a `setTimeout()` lets us cancel it
+            // in the next effect.
+            // (There might be better ways to do this.)
+            cleanupTimerRef.current = setTimeout(cleanup);
+            // We need to prevent the `useWidget` cleanup function so that widgets
+            // are not removed before the instance is disposed, triggering
+            // an unwanted search request.
+            search._preventWidgetCleanup = true;
+        };
+    }, [
+        forceUpdate,
+        serverState
+    ]), function() {
+        return searchRef.current;
+    }, function() {
+        return searchRef.current;
+    });
+    return store;
 }
 function addAlgoliaAgents(searchClient, userAgents) {
-  if (typeof searchClient.addAlgoliaAgent !== 'function') {
-    return;
-  }
-  userAgents.filter(Boolean).forEach(function (userAgent) {
-    searchClient.addAlgoliaAgent(userAgent);
-  });
-}
-function warnNextRouter(routing) {
-  if (process.env.NODE_ENV === 'development') {
-    var _routing$router;
-    if (!routing || typeof window === 'undefined' || !('__NEXT_DATA__' in window)) {
-      return;
+    if (typeof searchClient.addAlgoliaAgent !== 'function') {
+        return;
     }
-    var isUsingNextRouter =
-    // @ts-expect-error: _isNextRouter is only set on the Next.js router
-    routing !== true && (routing === null || routing === void 0 ? void 0 : (_routing$router = routing.router) === null || _routing$router === void 0 ? void 0 : _routing$router._isNextRouter);
-    process.env.NODE_ENV === 'development' ? warn(isUsingNextRouter, "\nYou are using Next.js with InstantSearch without the \"react-instantsearch-router-nextjs\" package.\nThis package is recommended to make the routing work correctly with Next.js.\nPlease check its usage instructions: https://github.com/algolia/instantsearch/tree/master/packages/react-instantsearch-router-nextjs\n\nYou can ignore this warning if you are using a custom router that suits your needs, it won't be outputted in production builds.") : void 0;
-  }
+    userAgents.filter(Boolean).forEach(function(userAgent) {
+        searchClient.addAlgoliaAgent(userAgent);
+    });
 }
-function warnNextAppDir(isRscContextDefined) {
-  var _next;
-  if (!(process.env.NODE_ENV === 'development') || typeof window === 'undefined' || isRscContextDefined) {
-    return;
-  }
-  process.env.NODE_ENV === 'development' ? warn(Boolean((_next = window.next) === null || _next === void 0 ? void 0 : _next.appDir) === false, "\nWe've detected you are using Next.js with the App Router.\nWe released a package called \"react-instantsearch-nextjs\" that makes SSR work with the App Router.\nPlease check its usage instructions: https://www.algolia.com/doc/guides/building-search-ui/going-further/server-side-rendering/react/#with-nextjs-app-router\n\nThis warning will not be outputted in production builds.") : void 0;
+function warnNextRouter(routing) {
 }
-
 /**
  * Gets the version of Next.js if it is available in the `window` object,
  * otherwise it returns the NEXT_RUNTIME environment variable (in SSR),
  * which is either `nodejs` or `edge`.
- */
-function getNextVersion() {
-  var _next2, _process$env;
-  return typeof window !== 'undefined' && ((_next2 = window.next) === null || _next2 === void 0 ? void 0 : _next2.version) || (typeof process !== 'undefined' ? (_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env.NEXT_RUNTIME : undefined);
-}
+ */ function getNextVersion() {
+    var _window_next, _process_env;
+    return typeof window !== 'undefined' && ((_window_next = window.next) === null || _window_next === void 0 ? void 0 : _window_next.version) || (typeof process !== 'undefined' ? (_process_env = process.env) === null || _process_env === void 0 ? void 0 : _process_env.NEXT_RUNTIME : undefined);
+}
+
+export { useInstantSearchApi };

package/dist/es/lib/useInstantSearchContext.js

@@ -1,8 +1,11 @@
 import { useContext } from 'react';
-import { InstantSearchContext } from "./InstantSearchContext.js";
-import { invariant } from "./invariant.js";
-export function useInstantSearchContext() {
-  var search = useContext(InstantSearchContext);
-  invariant(search !== null, 'Hooks must be used inside the <InstantSearch> component.\n\n' + 'They are not compatible with the `react-instantsearch-core@6.x` and `react-instantsearch-dom` packages, so make sure to use the <InstantSearch> component from `react-instantsearch-core@7.x`.');
-  return search;
-}
+import { InstantSearchContext } from './InstantSearchContext.js';
+import { invariant } from './invariant.js';
+
+function useInstantSearchContext() {
+    var search = useContext(InstantSearchContext);
+    invariant(search !== null);
+    return search;
+}
+
+export { useInstantSearchContext };

package/dist/es/lib/useInstantSearchSSRContext.js

@@ -1,5 +1,8 @@
 import { useContext } from 'react';
-import { InstantSearchSSRContext } from "./InstantSearchSSRContext.js";
-export function useInstantSearchSSRContext() {
-  return useContext(InstantSearchSSRContext);
-}
+import { InstantSearchSSRContext } from './InstantSearchSSRContext.js';
+
+function useInstantSearchSSRContext() {
+    return useContext(InstantSearchSSRContext);
+}
+
+export { useInstantSearchSSRContext };

package/dist/es/lib/useInstantSearchServerContext.js

@@ -1,5 +1,8 @@
 import { useContext } from 'react';
-import { InstantSearchServerContext } from "../components/InstantSearchServerContext.js";
-export function useInstantSearchServerContext() {
-  return useContext(InstantSearchServerContext);
-}
+import { InstantSearchServerContext } from '../components/InstantSearchServerContext.js';
+
+function useInstantSearchServerContext() {
+    return useContext(InstantSearchServerContext);
+}
+
+export { useInstantSearchServerContext };

package/dist/es/lib/useIsomorphicLayoutEffect.js

@@ -1,8 +1,9 @@
-import { useEffect, useLayoutEffect } from 'react';
+import { useLayoutEffect, useEffect } from 'react';
 
 /**
  * `useLayoutEffect` that doesn't show a warning when server-side rendering.
  *
  * It uses `useEffect` on the server (no-op), and `useLayoutEffect` on the browser.
- */
-export var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;
+ */ var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? useLayoutEffect : useEffect;
+
+export { useIsomorphicLayoutEffect };

package/dist/es/lib/useRSCContext.js

@@ -1,5 +1,8 @@
 import { useContext } from 'react';
-import { InstantSearchRSCContext } from "./InstantSearchRSCContext.js";
-export function useRSCContext() {
-  return useContext(InstantSearchRSCContext);
-}
+import { InstantSearchRSCContext } from './InstantSearchRSCContext.js';
+
+function useRSCContext() {
+    return useContext(InstantSearchRSCContext);
+}
+
+export { useRSCContext };

package/dist/es/lib/useSearchResults.js

@@ -1,59 +1,55 @@
-function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
-function _nonIterableRest() { 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 _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
-function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
-import { isIndexWidget } from "instantsearch.js/es/lib/utils/index.js";
-import { useEffect, useState } from 'react';
-import { getIndexSearchResults } from "./getIndexSearchResults.js";
-import { useIndexContext } from "./useIndexContext.js";
-import { useInstantSearchContext } from "./useInstantSearchContext.js";
-export function useSearchResults() {
-  var search = useInstantSearchContext();
-  var searchIndex = useIndexContext();
-  var _useState = useState(function () {
-      var indexSearchResults = getIndexSearchResults(searchIndex);
-      // We do this not to leak `recommendResults` in the API.
-      return {
-        results: indexSearchResults.results,
-        scopedResults: indexSearchResults.scopedResults
-      };
-    }),
-    _useState2 = _slicedToArray(_useState, 2),
-    searchResults = _useState2[0],
-    setSearchResults = _useState2[1];
-  useEffect(function () {
-    function handleRender() {
-      var results = searchIndex.getResults();
+import { _ } from '@swc/helpers/cjs/_sliced_to_array.cjs';
+import { isIndexWidget } from 'instantsearch.js/es/lib/utils/index.js';
+import { useState, useEffect } from 'react';
+import { getIndexSearchResults } from './getIndexSearchResults.js';
+import { useIndexContext } from './useIndexContext.js';
+import { useInstantSearchContext } from './useInstantSearchContext.js';
 
-      // Results can be `null` when the first search is stalled.
-      // In this case, we skip the update.
-      // See: https://github.com/algolia/instantsearch/blob/20996c7a159988c58e00ff24d2d2dc98af8b980f/src/widgets/index/index.ts#L652-L657
-      if (results !== null) {
-        setSearchResults({
-          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);
+function useSearchResults() {
+    var search = useInstantSearchContext();
+    var searchIndex = useIndexContext();
+    var _useState = _(useState(function() {
+        var indexSearchResults = getIndexSearchResults(searchIndex);
+        // We do this not to leak `recommendResults` in the API.
+        return {
+            results: indexSearchResults.results,
+            scopedResults: indexSearchResults.scopedResults
+        };
+    }), 2), searchResults = _useState[0], setSearchResults = _useState[1];
+    useEffect(function() {
+        function handleRender() {
+            var results = searchIndex.getResults();
+            // Results can be `null` when the first search is stalled.
+            // In this case, we skip the update.
+            // See: https://github.com/algolia/instantsearch/blob/20996c7a159988c58e00ff24d2d2dc98af8b980f/src/widgets/index/index.ts#L652-L657
+            if (results !== null) {
+                setSearchResults({
+                    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);
+        // Force setting results to mitigate potential race conditions where
+        // render listener is added after search results have been returned.
+        // This edge case is currently not covered by the tests.
+        handleRender();
+        return function() {
+            search.removeListener('render', handleRender);
+        };
+    }, [
+        search,
+        searchIndex
+    ]);
+    return searchResults;
+}
 
-    // Force setting results to mitigate potential race conditions where
-    // render listener is added after search results have been returned.
-    // This edge case is currently not covered by the tests.
-    handleRender();
-    return function () {
-      search.removeListener('render', handleRender);
-    };
-  }, [search, searchIndex]);
-  return searchResults;
-}
+export { useSearchResults };