react-instantsearch-core 6.40.3 → 7.0.0

package/dist/cjs/lib/IndexContext.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexContext = void 0;
+var _react = require("react");
+var IndexContext = /*#__PURE__*/(0, _react.createContext)(null);
+exports.IndexContext = IndexContext;
+if (process.env.NODE_ENV === 'development') {
+  IndexContext.displayName = 'Index';
+}

package/dist/cjs/lib/InstantSearchContext.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InstantSearchContext = void 0;
+var _react = require("react");
+var InstantSearchContext = /*#__PURE__*/(0, _react.createContext)(null);
+exports.InstantSearchContext = InstantSearchContext;
+if (process.env.NODE_ENV === 'development') {
+  InstantSearchContext.displayName = 'InstantSearch';
+}

package/dist/cjs/lib/InstantSearchSSRContext.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InstantSearchSSRContext = void 0;
+var _react = require("react");
+var InstantSearchSSRContext = /*#__PURE__*/(0, _react.createContext)(null);
+exports.InstantSearchSSRContext = InstantSearchSSRContext;
+if (process.env.NODE_ENV === 'development') {
+  InstantSearchSSRContext.displayName = 'InstantSearchSSR';
+}

package/dist/cjs/lib/createSearchResults.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSearchResults = createSearchResults;
+var _algoliasearchHelper = _interopRequireDefault(require("algoliasearch-helper"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function createSearchResults(state) {
+  var _state$query, _state$page, _state$hitsPerPage;
+  return new _algoliasearchHelper.default.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/cjs/lib/dequal.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dequal = dequal;
+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;
+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/cjs/lib/getIndexSearchResults.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getIndexSearchResults = getIndexSearchResults;
+var _createSearchResults = require("./createSearchResults");
+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); }
+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.
+  (0, _createSearchResults.createSearchResults)(helper.state);
+  var scopedResults = indexWidget.getScopedResults().map(function (scopedResult) {
+    var fallbackResults = scopedResult.indexId === indexWidget.getIndexId() ? results : (0, _createSearchResults.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/cjs/lib/invariant.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.invariant = invariant;
+/**
+ * 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.
+ */
+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/cjs/lib/noop.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.noop = void 0;
+var noop = function noop() {};
+exports.noop = noop;

package/dist/cjs/lib/useForceUpdate.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useForceUpdate = useForceUpdate;
+var _react = require("react");
+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; }
+/**
+ * Forces a React update that triggers a rerender.
+ * @link https://reactjs.org/docs/hooks-faq.html#is-there-something-like-forceupdate
+ */
+function useForceUpdate() {
+  var _useReducer = (0, _react.useReducer)(function (x) {
+      return x + 1;
+    }, 0),
+    _useReducer2 = _slicedToArray(_useReducer, 2),
+    forceUpdate = _useReducer2[1];
+  return forceUpdate;
+}

package/dist/cjs/lib/useIndex.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIndex = useIndex;
+var _index = _interopRequireDefault(require("instantsearch.js/cjs/widgets/index/index"));
+var _react = require("react");
+var _useIndexContext = require("../lib/useIndexContext");
+var _useForceUpdate = require("./useForceUpdate");
+var _useInstantSearchServerContext = require("./useInstantSearchServerContext");
+var _useInstantSearchSSRContext = require("./useInstantSearchSSRContext");
+var _useIsomorphicLayoutEffect = require("./useIsomorphicLayoutEffect");
+var _useStableValue = require("./useStableValue");
+var _useWidget = require("./useWidget");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function useIndex(props) {
+  var serverContext = (0, _useInstantSearchServerContext.useInstantSearchServerContext)();
+  var ssrContext = (0, _useInstantSearchSSRContext.useInstantSearchSSRContext)();
+  var initialResults = ssrContext === null || ssrContext === void 0 ? void 0 : ssrContext.initialResults;
+  var parentIndex = (0, _useIndexContext.useIndexContext)();
+  var stableProps = (0, _useStableValue.useStableValue)(props);
+  var indexWidget = (0, _react.useMemo)(function () {
+    return (0, _index.default)(stableProps);
+  }, [stableProps]);
+  var helper = indexWidget.getHelper();
+  var forceUpdate = (0, _useForceUpdate.useForceUpdate)();
+  (0, _useIsomorphicLayoutEffect.useIsomorphicLayoutEffect)(function () {
+    forceUpdate();
+  }, [helper, forceUpdate]);
+  (0, _useWidget.useWidget)({
+    widget: indexWidget,
+    parentIndex: parentIndex,
+    props: stableProps,
+    shouldSsr: Boolean(serverContext || initialResults)
+  });
+  return indexWidget;
+}

package/dist/cjs/lib/useIndexContext.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIndexContext = useIndexContext;
+var _react = require("react");
+var _invariant = require("../lib/invariant");
+var _IndexContext = require("./IndexContext");
+function useIndexContext() {
+  var context = (0, _react.useContext)(_IndexContext.IndexContext);
+  (0, _invariant.invariant)(context !== null, 'The <Index> component must be used within <InstantSearch>.');
+  return context;
+}

package/dist/cjs/lib/useInstantSearchApi.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useInstantSearchApi = useInstantSearchApi;
+var _InstantSearch = _interopRequireDefault(require("instantsearch.js/cjs/lib/InstantSearch"));
+var _react = require("react");
+var _shim = require("use-sync-external-store/shim");
+var _useInstantSearchServerContext = require("../lib/useInstantSearchServerContext");
+var _useInstantSearchSSRContext = require("../lib/useInstantSearchSSRContext");
+var _version = _interopRequireDefault(require("../version"));
+var _useForceUpdate = require("./useForceUpdate");
+var _warn = require("./warn");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var defaultUserAgents = ["react (".concat(_react.version, ")"), "react-instantsearch (".concat(_version.default, ")"), "react-instantsearch-core (".concat(_version.default, ")")];
+var serverUserAgent = "react-instantsearch-server (".concat(_version.default, ")");
+var nextUserAgent = function nextUserAgent(nextVersion) {
+  return nextVersion ? "next.js (".concat(nextVersion, ")") : null;
+};
+function useInstantSearchApi(props) {
+  var forceUpdate = (0, _useForceUpdate.useForceUpdate)();
+  var serverContext = (0, _useInstantSearchServerContext.useInstantSearchServerContext)();
+  var serverState = (0, _useInstantSearchSSRContext.useInstantSearchSSRContext)();
+  var initialResults = serverState === null || serverState === void 0 ? void 0 : serverState.initialResults;
+  var prevPropsRef = (0, _react.useRef)(props);
+  var searchRef = (0, _react.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.default(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' ? (0, _warn.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 = (0, _react.useRef)(null);
+  var store = (0, _shim.useSyncExternalStore)((0, _react.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' ? (0, _warn.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/cjs/lib/useInstantSearchContext.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useInstantSearchContext = useInstantSearchContext;
+var _react = require("react");
+var _invariant = require("../lib/invariant");
+var _InstantSearchContext = require("./InstantSearchContext");
+function useInstantSearchContext() {
+  var search = (0, _react.useContext)(_InstantSearchContext.InstantSearchContext);
+  (0, _invariant.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/cjs/lib/useInstantSearchSSRContext.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useInstantSearchSSRContext = useInstantSearchSSRContext;
+var _react = require("react");
+var _InstantSearchSSRContext = require("./InstantSearchSSRContext");
+function useInstantSearchSSRContext() {
+  return (0, _react.useContext)(_InstantSearchSSRContext.InstantSearchSSRContext);
+}

package/dist/cjs/lib/useInstantSearchServerContext.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useInstantSearchServerContext = useInstantSearchServerContext;
+var _react = require("react");
+var _InstantSearchServerContext = require("../components/InstantSearchServerContext");
+function useInstantSearchServerContext() {
+  return (0, _react.useContext)(_InstantSearchServerContext.InstantSearchServerContext);
+}

package/dist/cjs/lib/useIsomorphicLayoutEffect.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIsomorphicLayoutEffect = void 0;
+var _react = require("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.
+ */
+var useIsomorphicLayoutEffect = typeof window !== 'undefined' ? _react.useLayoutEffect : _react.useEffect;
+exports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;

package/dist/cjs/lib/useSearchResults.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSearchResults = useSearchResults;
+var _react = require("react");
+var _getIndexSearchResults = require("./getIndexSearchResults");
+var _useIndexContext = require("./useIndexContext");
+var _useInstantSearchContext = require("./useInstantSearchContext");
+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; }
+function useSearchResults() {
+  var search = (0, _useInstantSearchContext.useInstantSearchContext)();
+  var searchIndex = (0, _useIndexContext.useIndexContext)();
+  var _useState = (0, _react.useState)(function () {
+      return (0, _getIndexSearchResults.getIndexSearchResults)(searchIndex);
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    searchResults = _useState2[0],
+    setSearchResults = _useState2[1];
+  (0, _react.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/cjs/lib/useSearchState.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSearchState = useSearchState;
+var _react = require("react");
+var _useIndexContext = require("./useIndexContext");
+var _useInstantSearchContext = require("./useInstantSearchContext");
+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; }
+function useSearchState() {
+  var search = (0, _useInstantSearchContext.useInstantSearchContext)();
+  var searchIndex = (0, _useIndexContext.useIndexContext)();
+  var indexId = searchIndex.getIndexId();
+  var _useState = (0, _react.useState)(function () {
+      return search.getUiState();
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    uiState = _useState2[0],
+    setLocalUiState = _useState2[1];
+  var indexUiState = uiState[indexId];
+  var setUiState = (0, _react.useCallback)(function (nextUiState) {
+    search.setUiState(nextUiState);
+  }, [search]);
+  var setIndexUiState = (0, _react.useCallback)(function (nextIndexUiState) {
+    searchIndex.setIndexUiState(nextIndexUiState);
+  }, [searchIndex]);
+  (0, _react.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/cjs/lib/useStableValue.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useStableValue = useStableValue;
+var _react = require("react");
+var _dequal = require("../lib/dequal");
+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; }
+function useStableValue(value) {
+  var _useState = (0, _react.useState)(function () {
+      return value;
+    }),
+    _useState2 = _slicedToArray(_useState, 2),
+    stableValue = _useState2[0],
+    setStableValue = _useState2[1];
+  if (!(0, _dequal.dequal)(stableValue, value)) {
+    setStableValue(value);
+  }
+  return stableValue;
+}