react-instantsearch-core 6.40.4 → 7.0.1

package/dist/es/lib/InstantSearchSSRContext.js

@@ -0,0 +1,5 @@
+import { createContext } from 'react';
+export var InstantSearchSSRContext = /*#__PURE__*/createContext(null);
+if (process.env.NODE_ENV === 'development') {
+  InstantSearchSSRContext.displayName = 'InstantSearchSSR';
+}

package/dist/es/lib/createSearchResults.d.ts

@@ -0,0 +1,3 @@
+import algoliasearchHelper from 'algoliasearch-helper';
+import type { SearchParameters } from 'algoliasearch-helper';
+export declare function createSearchResults<THit>(state: SearchParameters): algoliasearchHelper.SearchResults<THit>;

package/dist/es/lib/createSearchResults.js

@@ -0,0 +1,20 @@
+import algoliasearchHelper from 'algoliasearch-helper';
+export function createSearchResults(state) {
+  var _state$query, _state$page, _state$hitsPerPage;
+  return new algoliasearchHelper.SearchResults(state, [{
+    query: (_state$query = state.query) !== null && _state$query !== void 0 ? _state$query : '',
+    page: (_state$page = state.page) !== null && _state$page !== void 0 ? _state$page : 0,
+    hitsPerPage: (_state$hitsPerPage = state.hitsPerPage) !== null && _state$hitsPerPage !== void 0 ? _state$hitsPerPage : 20,
+    hits: [],
+    nbHits: 0,
+    nbPages: 0,
+    params: '',
+    exhaustiveNbHits: true,
+    exhaustiveFacetsCount: true,
+    processingTimeMS: 0,
+    index: state.index
+  }], {
+    /** used by connectors to prevent persisting these results */
+    __isArtificial: true
+  });
+}

package/dist/es/lib/dequal.d.ts

@@ -0,0 +1 @@
+export declare function dequal(foo: any, bar: any, compare?: (a: any, b: any) => boolean): boolean;

package/dist/es/lib/dequal.js

@@ -0,0 +1,47 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+/* eslint-disable complexity */
+
+/*
+ * Code taken from dequal/lite v2.0.0
+ * https://github.com/lukeed/dequal/blob/9aa73181ac7e081cd330cac67d313632ac04bb02/src/lite.js
+ *
+ * It adds a 3rd argument `compare(a, b)` that lets execute custom logic to
+ * compare values.
+ * We use it to skip comparing function references.
+ */
+
+// eslint-disable-next-line @typescript-eslint/unbound-method
+var has = Object.prototype.hasOwnProperty;
+export function dequal(foo, bar, compare) {
+  // start of custom implementation
+  if (compare !== null && compare !== void 0 && compare(foo, bar)) {
+    return true;
+  }
+  // end of custom implementation
+
+  var ctor;
+  var len;
+  if (foo === bar) return true;
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date) return foo.getTime() === bar.getTime();
+    if (ctor === RegExp) return foo.toString() === bar.toString();
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length) {
+        while (len-- && dequal(foo[len], bar[len], compare));
+      }
+      return len === -1;
+    }
+    if (!ctor || _typeof(foo) === 'object') {
+      len = 0;
+      // eslint-disable-next-line guard-for-in, no-restricted-syntax
+      for (ctor in foo) {
+        if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+        if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor], compare)) return false;
+      }
+      return Object.keys(bar).length === len;
+    }
+  }
+
+  // eslint-disable-next-line no-self-compare
+  return foo !== foo && bar !== bar;
+}

package/dist/es/lib/getIndexSearchResults.d.ts

@@ -0,0 +1,9 @@
+import type { IndexWidget } from 'instantsearch.js/es/widgets/index/index';
+export declare function getIndexSearchResults(indexWidget: IndexWidget): {
+    results: import("algoliasearch-helper").SearchResults<any>;
+    scopedResults: {
+        results: import("algoliasearch-helper").SearchResults<any>;
+        indexId: string;
+        helper: import("algoliasearch-helper").AlgoliaSearchHelper;
+    }[];
+};

package/dist/es/lib/getIndexSearchResults.js

@@ -0,0 +1,26 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { createSearchResults } from "./createSearchResults.js";
+export function getIndexSearchResults(indexWidget) {
+  var helper = indexWidget.getHelper();
+  var results =
+  // On SSR, we get the results injected on the Index.
+  indexWidget.getResults() ||
+  // On the browser, we create fallback results based on the helper state.
+  createSearchResults(helper.state);
+  var scopedResults = indexWidget.getScopedResults().map(function (scopedResult) {
+    var fallbackResults = scopedResult.indexId === indexWidget.getIndexId() ? results : createSearchResults(scopedResult.helper.state);
+    return _objectSpread(_objectSpread({}, scopedResult), {}, {
+      // We keep `results` from being `null`.
+      results: scopedResult.results || fallbackResults
+    });
+  });
+  return {
+    results: results,
+    scopedResults: scopedResults
+  };
+}

package/dist/es/lib/invariant.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Throws an error if the condition is not met.
+ *
+ * The error is exhaustive in development, and becomes generic in production.
+ *
+ * This is used to make development a better experience to provide guidance as
+ * to where the error comes from.
+ */
+export declare function invariant(condition: boolean, message: string | (() => string)): asserts condition;

package/dist/es/lib/invariant.js

@@ -0,0 +1,19 @@
+/**
+ * Throws an error if the condition is not met.
+ *
+ * The error is exhaustive in development, and becomes generic in production.
+ *
+ * This is used to make development a better experience to provide guidance as
+ * to where the error comes from.
+ */
+export function invariant(condition, message) {
+  if (condition) {
+    return;
+  }
+  if (!(process.env.NODE_ENV === 'development')) {
+    throw new Error('Invariant failed');
+  }
+  if (process.env.NODE_ENV === 'development') {
+    throw new Error("[InstantSearch] ".concat(typeof message === 'function' ? message() : message));
+  }
+}

package/dist/es/lib/noop.d.ts

@@ -0,0 +1 @@
+export declare const noop: (..._args: any[]) => void;

package/dist/es/lib/noop.js

@@ -0,0 +1 @@
+export var noop = function noop() {};

package/dist/es/lib/useForceUpdate.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+/**
+ * Forces a React update that triggers a rerender.
+ * @link https://reactjs.org/docs/hooks-faq.html#is-there-something-like-forceupdate
+ */
+export declare function useForceUpdate(): import("react").DispatchWithoutAction;

package/dist/es/lib/useForceUpdate.js

@@ -0,0 +1,20 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(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(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useReducer } from 'react';
+
+/**
+ * Forces a React update that triggers a rerender.
+ * @link https://reactjs.org/docs/hooks-faq.html#is-there-something-like-forceupdate
+ */
+export function useForceUpdate() {
+  var _useReducer = useReducer(function (x) {
+      return x + 1;
+    }, 0),
+    _useReducer2 = _slicedToArray(_useReducer, 2),
+    forceUpdate = _useReducer2[1];
+  return forceUpdate;
+}

package/dist/es/lib/useIndex.d.ts

@@ -0,0 +1,3 @@
+import type { IndexWidgetParams } from 'instantsearch.js/es/widgets/index/index';
+export type UseIndexProps = IndexWidgetParams;
+export declare function useIndex(props: UseIndexProps): import("instantsearch.js/es/widgets/index/index").IndexWidget<import("instantsearch.js").UiState>;

package/dist/es/lib/useIndex.js

@@ -0,0 +1,31 @@
+import index from "instantsearch.js/es/widgets/index/index.js";
+import { useMemo } from 'react';
+import { useIndexContext } from "./useIndexContext.js";
+import { useForceUpdate } from "./useForceUpdate.js";
+import { useInstantSearchServerContext } from "./useInstantSearchServerContext.js";
+import { useInstantSearchSSRContext } from "./useInstantSearchSSRContext.js";
+import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect.js";
+import { useStableValue } from "./useStableValue.js";
+import { useWidget } from "./useWidget.js";
+export function useIndex(props) {
+  var serverContext = useInstantSearchServerContext();
+  var ssrContext = useInstantSearchSSRContext();
+  var initialResults = ssrContext === null || ssrContext === void 0 ? void 0 : ssrContext.initialResults;
+  var parentIndex = useIndexContext();
+  var stableProps = useStableValue(props);
+  var indexWidget = useMemo(function () {
+    return index(stableProps);
+  }, [stableProps]);
+  var helper = indexWidget.getHelper();
+  var forceUpdate = useForceUpdate();
+  useIsomorphicLayoutEffect(function () {
+    forceUpdate();
+  }, [helper, forceUpdate]);
+  useWidget({
+    widget: indexWidget,
+    parentIndex: parentIndex,
+    props: stableProps,
+    shouldSsr: Boolean(serverContext || initialResults)
+  });
+  return indexWidget;
+}

package/dist/es/lib/useIndexContext.d.ts

@@ -0,0 +1,2 @@
+import type { IndexWidget, UiState } from 'instantsearch.js';
+export declare function useIndexContext<TUiState extends UiState = UiState>(): IndexWidget<TUiState>;

package/dist/es/lib/useIndexContext.js

@@ -0,0 +1,8 @@
+import { useContext } from 'react';
+import { invariant } from "./invariant.js";
+import { IndexContext } from "./IndexContext.js";
+export function useIndexContext() {
+  var context = useContext(IndexContext);
+  invariant(context !== null, 'The <Index> component must be used within <InstantSearch>.');
+  return context;
+}

package/dist/es/lib/useInstantSearchApi.d.ts

@@ -0,0 +1,21 @@
+import InstantSearch from 'instantsearch.js/es/lib/InstantSearch';
+import type { InstantSearchOptions, UiState } from 'instantsearch.js';
+export type UseInstantSearchApiProps<TUiState extends UiState, TRouteState> = InstantSearchOptions<TUiState, TRouteState>;
+export type InternalInstantSearch<TUiState extends UiState, TRouteState = TUiState> = InstantSearch<TUiState, TRouteState> & {
+    /**
+     * Schedule a function to be called on the next timer tick
+     * @private
+     */
+    _schedule: {
+        (cb: () => void): void;
+        queue: Array<() => void>;
+        timer: ReturnType<typeof setTimeout> | undefined;
+    };
+    /**
+     * Used inside useWidget, which ensures that removeWidgets is not called.
+     * This prevents a search from being triggered when InstantSearch is also unmounted.
+     * @private
+     */
+    _preventWidgetCleanup?: boolean;
+};
+export declare function useInstantSearchApi<TUiState extends UiState, TRouteState>(props: UseInstantSearchApiProps<TUiState, TRouteState>): InstantSearch<TUiState, TRouteState>;

package/dist/es/lib/useInstantSearchApi.js

@@ -0,0 +1,184 @@
+import InstantSearch 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 { useInstantSearchServerContext } from "./useInstantSearchServerContext.js";
+import { useInstantSearchSSRContext } from "./useInstantSearchSSRContext.js";
+import version from "../version.js";
+import { useForceUpdate } from "./useForceUpdate.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, ")");
+var nextUserAgent = function nextUserAgent(nextVersion) {
+  return nextVersion ? "next.js (".concat(nextVersion, ")") : null;
+};
+export function useInstantSearchApi(props) {
+  var forceUpdate = useForceUpdate();
+  var serverContext = useInstantSearchServerContext();
+  var serverState = useInstantSearchSSRContext();
+  var initialResults = serverState === null || serverState === void 0 ? void 0 : serverState.initialResults;
+  var prevPropsRef = useRef(props);
+  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) {
+    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.js/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 (serverContext || initialResults) {
+      // 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 || {};
+    }
+    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 (serverContext || initialResults) {
+      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 _search = searchRef.current;
+    var prevProps = prevPropsRef.current;
+    if (prevProps.indexName !== props.indexName) {
+      _search.helper.setIndex(props.indexName || '').search();
+      prevPropsRef.current = props;
+    }
+    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;
+    }
+
+    // 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.
+    // If we find scenarios where `routing` needs to change, we can always expose
+    // 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 () {
+      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]), 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;
+    }
+    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;
+  }
+}
+
+/**
+ * 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 _next, _process$env;
+  return typeof window !== 'undefined' && ((_next = window.next) === null || _next === void 0 ? void 0 : _next.version) || (typeof process !== 'undefined' ? (_process$env = process.env) === null || _process$env === void 0 ? void 0 : _process$env.NEXT_RUNTIME : undefined);
+}

package/dist/es/lib/useInstantSearchContext.d.ts

@@ -0,0 +1,3 @@
+import type { InternalInstantSearch } from './useInstantSearchApi';
+import type { UiState } from 'instantsearch.js';
+export declare function useInstantSearchContext<TUiState extends UiState, TRouteState = TUiState>(): InternalInstantSearch<TUiState, TRouteState>;

package/dist/es/lib/useInstantSearchContext.js

@@ -0,0 +1,8 @@
+import { useContext } from 'react';
+import { invariant } from "./invariant.js";
+import { InstantSearchContext } from "./InstantSearchContext.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;
+}

package/dist/es/lib/useInstantSearchSSRContext.d.ts

@@ -0,0 +1,3 @@
+import type { InstantSearchSSRContextApi } from './InstantSearchSSRContext';
+import type { UiState } from 'instantsearch.js';
+export declare function useInstantSearchSSRContext<TUiState extends UiState, TRouteState = TUiState>(): InstantSearchSSRContextApi<TUiState, TRouteState> | null;

package/dist/es/lib/useInstantSearchSSRContext.js

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

package/dist/es/lib/useInstantSearchServerContext.d.ts

@@ -0,0 +1,3 @@
+import type { InstantSearchServerContextApi } from '../components/InstantSearchServerContext';
+import type { UiState } from 'instantsearch.js';
+export declare function useInstantSearchServerContext<TUiState extends UiState, TRouteState = TUiState>(): InstantSearchServerContextApi<TUiState, TRouteState> | null;

package/dist/es/lib/useInstantSearchServerContext.js

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

package/dist/es/lib/useIsomorphicLayoutEffect.d.ts

@@ -0,0 +1,7 @@
+import { useLayoutEffect } 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 declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;

package/dist/es/lib/useIsomorphicLayoutEffect.js

@@ -0,0 +1,8 @@
+import { useEffect, useLayoutEffect } 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;

package/dist/es/lib/useSearchResults.d.ts

@@ -0,0 +1,7 @@
+import type { SearchResults } from 'algoliasearch-helper';
+import type { ScopedResult } from 'instantsearch.js';
+export type SearchResultsApi = {
+    results: SearchResults<any>;
+    scopedResults: ScopedResult[];
+};
+export declare function useSearchResults(): SearchResultsApi;

package/dist/es/lib/useSearchResults.js

@@ -0,0 +1,40 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(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(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+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 () {
+      return getIndexSearchResults(searchIndex);
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    searchResults = _useState2[0],
+    setSearchResults = _useState2[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.js/blob/20996c7a159988c58e00ff24d2d2dc98af8b980f/src/widgets/index/index.ts#L652-L657
+      if (results !== null) {
+        setSearchResults({
+          results: results,
+          scopedResults: searchIndex.getScopedResults()
+        });
+      }
+    }
+    search.addListener('render', handleRender);
+    return function () {
+      search.removeListener('render', handleRender);
+    };
+  }, [search, searchIndex]);
+  return searchResults;
+}

package/dist/es/lib/useSearchState.d.ts

@@ -0,0 +1,8 @@
+import type { InstantSearch, UiState, IndexWidget } from 'instantsearch.js';
+export type SearchStateApi<TUiState extends UiState> = {
+    uiState: TUiState;
+    setUiState: InstantSearch<TUiState>['setUiState'];
+    indexUiState: TUiState[string];
+    setIndexUiState: IndexWidget<TUiState>['setIndexUiState'];
+};
+export declare function useSearchState<TUiState extends UiState>(): SearchStateApi<TUiState>;

package/dist/es/lib/useSearchState.js

@@ -0,0 +1,42 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _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(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(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(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; if (null != _i) { var _s, _e, _x, _r, _arr = [], _n = !0, _d = !1; try { if (_x = (_i = _i.call(arr)).next, 0 === i) { if (Object(_i) !== _i) return; _n = !1; } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); } catch (err) { _d = !0, _e = err; } finally { try { if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; } finally { if (_d) throw _e; } } return _arr; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { useCallback, useEffect, useState } from 'react';
+import { useIndexContext } from "./useIndexContext.js";
+import { useInstantSearchContext } from "./useInstantSearchContext.js";
+export function useSearchState() {
+  var search = useInstantSearchContext();
+  var searchIndex = useIndexContext();
+  var indexId = searchIndex.getIndexId();
+  var _useState = useState(function () {
+      return search.getUiState();
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    uiState = _useState2[0],
+    setLocalUiState = _useState2[1];
+  var indexUiState = uiState[indexId];
+  var setUiState = useCallback(function (nextUiState) {
+    search.setUiState(nextUiState);
+  }, [search]);
+  var setIndexUiState = useCallback(function (nextIndexUiState) {
+    searchIndex.setIndexUiState(nextIndexUiState);
+  }, [searchIndex]);
+  useEffect(function () {
+    function handleRender() {
+      setLocalUiState(search.getUiState());
+    }
+    search.addListener('render', handleRender);
+    return function () {
+      search.removeListener('render', handleRender);
+    };
+  }, [search]);
+  return {
+    uiState: uiState,
+    setUiState: setUiState,
+    indexUiState: indexUiState,
+    setIndexUiState: setIndexUiState
+  };
+}

package/dist/es/lib/useStableValue.d.ts

@@ -0,0 +1 @@
+export declare function useStableValue<TValue>(value: TValue): TValue;