react-instantsearch-core 6.40.4 → 7.0.1

package/dist/cjs/lib/useWidget.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useWidget = useWidget;
+var _react = require("react");
+var _dequal = require("./dequal");
+var _useInstantSearchContext = require("./useInstantSearchContext");
+var _useIsomorphicLayoutEffect = require("./useIsomorphicLayoutEffect");
+function useWidget(_ref) {
+  var widget = _ref.widget,
+    parentIndex = _ref.parentIndex,
+    props = _ref.props,
+    shouldSsr = _ref.shouldSsr;
+  var prevPropsRef = (0, _react.useRef)(props);
+  (0, _react.useEffect)(function () {
+    prevPropsRef.current = props;
+  }, [props]);
+  var prevWidgetRef = (0, _react.useRef)(widget);
+  (0, _react.useEffect)(function () {
+    prevWidgetRef.current = widget;
+  }, [widget]);
+  var cleanupTimerRef = (0, _react.useRef)(null);
+  var shouldAddWidgetEarly = shouldSsr && !parentIndex.getWidgets().includes(widget);
+  var search = (0, _useInstantSearchContext.useInstantSearchContext)();
+
+  // This effect is responsible for adding, removing, and updating the widget.
+  // We need to support scenarios where the widget is remounted quickly, like in
+  // Strict Mode, so that we don't lose its state, and therefore that we don't
+  // break routing.
+  (0, _useIsomorphicLayoutEffect.useIsomorphicLayoutEffect)(function () {
+    var previousWidget = prevWidgetRef.current;
+
+    // Scenario 1: the widget is added for the first time.
+    if (!cleanupTimerRef.current) {
+      if (!shouldAddWidgetEarly) {
+        parentIndex.addWidgets([widget]);
+      }
+    }
+    // Scenario 2: the widget is rerendered or updated.
+    else {
+      // We cancel the original effect cleanup because it may not be necessary if
+      // props haven't changed. (We manually call it if it is below.)
+      clearTimeout(cleanupTimerRef.current);
+
+      // Warning: if an unstable function prop is provided, `dequal` is not able
+      // to keep its reference and therefore will consider that props did change.
+      // This could unsollicitely remove/add the widget, therefore forget its state,
+      // and could be a source of confusion.
+      // If users face this issue, we should advise them to provide stable function
+      // references.
+      var arePropsEqual = (0, _dequal.dequal)(props, prevPropsRef.current);
+
+      // If props did change, then we execute the cleanup function instantly
+      // and then add the widget back. This lets us add the widget without
+      // waiting for the scheduled cleanup function to finish (that we canceled
+      // above).
+      if (!arePropsEqual) {
+        parentIndex.removeWidgets([previousWidget]);
+        parentIndex.addWidgets([widget]);
+      }
+    }
+    return function () {
+      // We don't remove the widget right away, but rather schedule it so that
+      // we're able to cancel it in the next effect.
+      cleanupTimerRef.current = setTimeout(function () {
+        search._schedule(function () {
+          if (search._preventWidgetCleanup) return;
+          parentIndex.removeWidgets([previousWidget]);
+        });
+      });
+    };
+  }, [parentIndex, widget, shouldAddWidgetEarly, search, props]);
+  if (shouldAddWidgetEarly) {
+    parentIndex.addWidgets([widget]);
+  }
+}

package/dist/cjs/lib/warn.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.warn = warn;
+exports.warnCache = void 0;
+/* eslint-disable no-console, no-empty */
+
+var warnCache = {
+  current: {}
+};
+
+/**
+ * Logs a warning if the condition is not met.
+ * This is used to log issues in development environment only.
+ */
+exports.warnCache = warnCache;
+function warn(condition, message) {
+  if (!(process.env.NODE_ENV === 'development')) {
+    return;
+  }
+  if (condition) {
+    return;
+  }
+  var sanitizedMessage = message.trim();
+  var hasAlreadyPrinted = warnCache.current[sanitizedMessage];
+  if (!hasAlreadyPrinted) {
+    warnCache.current[sanitizedMessage] = true;
+    var warning = "[InstantSearch] ".concat(sanitizedMessage);
+    console.warn(warning);
+    try {
+      // Welcome to debugging InstantSearch.
+      //
+      // This error was thrown as a convenience so that you can find the source
+      // of the warning that appears in the console by enabling "Pause on exceptions"
+      // in your debugger.
+      throw new Error(warning);
+    } catch (error) {}
+  }
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs", "sideEffects": false }

package/dist/cjs/server/getServerState.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getServerState = getServerState;
+var _server = require("instantsearch.js/cjs/lib/server");
+var _utils = require("instantsearch.js/cjs/lib/utils");
+var _react = _interopRequireDefault(require("react"));
+var _ = require("..");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Returns the InstantSearch server state from a component.
+ */
+function getServerState(children, _ref) {
+  var renderToString = _ref.renderToString;
+  var searchRef = {
+    current: undefined
+  };
+  var createNotifyServer = function createNotifyServer() {
+    var hasBeenNotified = false;
+    var notifyServer = function notifyServer(_ref2) {
+      var search = _ref2.search;
+      if (hasBeenNotified) {
+        throw new Error('getServerState should be called with a single InstantSearchSSRProvider and a single InstantSearch component.');
+      }
+      hasBeenNotified = true;
+      searchRef.current = search;
+    };
+    return notifyServer;
+  };
+  return execute({
+    children: children,
+    renderToString: renderToString,
+    searchRef: searchRef,
+    notifyServer: createNotifyServer()
+  }).then(function (serverState) {
+    var shouldRefetch = false;
+
+    // <DynamicWidgets> requires another query to retrieve the dynamic widgets
+    // to render.
+    (0, _utils.walkIndex)(searchRef.current.mainIndex, function (index) {
+      shouldRefetch = shouldRefetch || index.getWidgets().some(function (widget) {
+        return widget.$$type === 'ais.dynamicWidgets';
+      });
+    });
+    if (shouldRefetch) {
+      return execute({
+        children: /*#__PURE__*/_react.default.createElement(_.InstantSearchSSRProvider, serverState, children),
+        renderToString: renderToString,
+        searchRef: searchRef,
+        notifyServer: createNotifyServer()
+      });
+    }
+    return serverState;
+  });
+}
+function execute(_ref3) {
+  var children = _ref3.children,
+    renderToString = _ref3.renderToString,
+    notifyServer = _ref3.notifyServer,
+    searchRef = _ref3.searchRef;
+  return Promise.resolve().then(function () {
+    renderToString( /*#__PURE__*/_react.default.createElement(_.InstantSearchServerContext.Provider, {
+      value: {
+        notifyServer: notifyServer
+      }
+    }, children));
+  }).then(function () {
+    return (
+      // We wait for the component to mount so that `notifyServer()` is called.
+      new Promise(function (resolve) {
+        return setTimeout(resolve, 0);
+      })
+    );
+  }).then(function () {
+    // If `notifyServer()` is not called by then, it means that <InstantSearch>
+    // wasn't within the `children`.
+    // We decide to go with a strict behavior in that case; throwing. If users have
+    // some routes that don't mount the <InstantSearch> component, they would need
+    // to try/catch the `getServerState()` call.
+    // If this behavior turns out to be too strict for many users, we can decide
+    // to warn instead of throwing.
+    if (!searchRef.current) {
+      throw new Error("Unable to retrieve InstantSearch's server state in `getServerState()`. Did you mount the <InstantSearch> component?");
+    }
+    return (0, _server.waitForResults)(searchRef.current);
+  }).then(function () {
+    return {
+      initialResults: (0, _server.getInitialResults)(searchRef.current.mainIndex)
+    };
+  });
+}

package/dist/cjs/{types → server}/index.js

@@ -3,14 +3,14 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _translatable = require("./translatable");
-Object.keys(_translatable).forEach(function (key) {
+var _getServerState = require("./getServerState");
+Object.keys(_getServerState).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _translatable[key]) return;
+  if (key in exports && exports[key] === _getServerState[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function get() {
-      return _translatable[key];
+      return _getServerState[key];
     }
   });
 });

package/dist/cjs/{core/version.js → version.js}

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _default = '6.40.4';
+var _default = '7.0.1';
 exports.default = _default;

package/dist/es/components/Configure.d.ts

@@ -0,0 +1,3 @@
+import type { UseConfigureProps } from '../connectors/useConfigure';
+export type ConfigureProps = UseConfigureProps;
+export declare function Configure(props: ConfigureProps): null;

package/dist/es/components/Configure.js

@@ -0,0 +1,7 @@
+import { useConfigure } from "../connectors/useConfigure.js";
+export function Configure(props) {
+  useConfigure(props, {
+    $$widgetType: 'ais.configure'
+  });
+  return null;
+}

package/dist/es/components/DynamicWidgets.d.ts

@@ -0,0 +1,13 @@
+import type { DynamicWidgetsConnectorParams } from 'instantsearch.js/es/connectors/dynamic-widgets/connectDynamicWidgets';
+import type { ComponentType, ReactNode } from 'react';
+type AtLeastOne<TTarget, TMapped = {
+    [Key in keyof TTarget]: Pick<TTarget, Key>;
+}> = Partial<TTarget> & TMapped[keyof TMapped];
+export type DynamicWidgetsProps = Omit<DynamicWidgetsConnectorParams, 'widgets' | 'fallbackWidget'> & AtLeastOne<{
+    children: ReactNode;
+    fallbackComponent: ComponentType<{
+        attribute: string;
+    }>;
+}>;
+export declare function DynamicWidgets({ children, fallbackComponent: Fallback, ...props }: DynamicWidgetsProps): JSX.Element;
+export {};

package/dist/es/components/DynamicWidgets.js

@@ -0,0 +1,55 @@
+var _excluded = ["children", "fallbackComponent"];
+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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { Fragment } from 'react';
+import { useDynamicWidgets } from "../connectors/useDynamicWidgets.js";
+import { invariant } from "../lib/invariant.js";
+import { warn } from "../lib/warn.js";
+function DefaultFallbackComponent() {
+  return null;
+}
+export function DynamicWidgets(_ref) {
+  var children = _ref.children,
+    _ref$fallbackComponen = _ref.fallbackComponent,
+    Fallback = _ref$fallbackComponen === void 0 ? DefaultFallbackComponent : _ref$fallbackComponen,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var FallbackComponent = React.useRef(Fallback);
+  process.env.NODE_ENV === 'development' ? warn(Fallback === FallbackComponent.current, 'The `fallbackComponent` prop of `DynamicWidgets` changed between renders. Please provide a stable reference, as described in https://www.algolia.com/doc/api-reference/widgets/dynamic-facets/react/#widget-param-fallbackcomponent') : void 0;
+  var _useDynamicWidgets = useDynamicWidgets(props, {
+      $$widgetType: 'ais.dynamicWidgets'
+    }),
+    attributesToRender = _useDynamicWidgets.attributesToRender;
+  var widgets = new Map();
+  React.Children.forEach(children, function (child) {
+    var attribute = getWidgetAttribute(child);
+    invariant(attribute !== undefined, "<DynamicWidgets> only supports InstantSearch widgets with an `attribute` or `attributes` prop.");
+    widgets.set(attribute, child);
+  });
+  return /*#__PURE__*/React.createElement(React.Fragment, null, attributesToRender.map(function (attribute) {
+    return /*#__PURE__*/React.createElement(Fragment, {
+      key: attribute
+    }, widgets.get(attribute) || /*#__PURE__*/React.createElement(FallbackComponent.current, {
+      attribute: attribute
+    }));
+  }));
+}
+function isReactElement(element) {
+  return _typeof(element) === 'object' && element.props;
+}
+function getWidgetAttribute(element) {
+  if (!isReactElement(element)) {
+    return undefined;
+  }
+  if (element.props.attribute) {
+    return element.props.attribute;
+  }
+  if (Array.isArray(element.props.attributes)) {
+    return element.props.attributes[0];
+  }
+  if (element.props.children) {
+    invariant(React.Children.count(element.props.children) === 1, "<DynamicWidgets> only supports a single component in nested components. Make sure to not render multiple children in a parent component.\n\nExample of an unsupported scenario:\n\n```\n<DynamicWidgets>\n  <MyComponent>\n    <RefinementList attribute=\"brand\" />\n    <Menu attribute=\"categories\" />\n  </MyComponent>\n</DynamicWidgets>\n```\n");
+    return getWidgetAttribute(React.Children.only(element.props.children));
+  }
+  return undefined;
+}

package/dist/es/components/Index.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import type { UseIndexProps } from '../lib/useIndex';
+export type IndexProps = UseIndexProps & {
+    children?: React.ReactNode;
+};
+export declare function Index({ children, ...props }: IndexProps): JSX.Element | null;

package/dist/es/components/Index.js

@@ -0,0 +1,17 @@
+var _excluded = ["children"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import { IndexContext } from "../lib/IndexContext.js";
+import { useIndex } from "../lib/useIndex.js";
+export function Index(_ref) {
+  var children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var index = useIndex(props);
+  if (index.getHelper() === null) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(IndexContext.Provider, {
+    value: index
+  }, children);
+}

package/dist/es/components/InstantSearch.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { UseInstantSearchApiProps } from '../lib/useInstantSearchApi';
+import type { UiState } from 'instantsearch.js';
+export type InstantSearchProps<TUiState extends UiState = UiState, TRouteState = TUiState> = UseInstantSearchApiProps<TUiState, TRouteState> & {
+    children?: React.ReactNode;
+};
+export declare function InstantSearch<TUiState extends UiState = UiState, TRouteState = TUiState>({ children, ...props }: InstantSearchProps<TUiState, TRouteState>): JSX.Element | null;

package/dist/es/components/InstantSearch.js

@@ -0,0 +1,20 @@
+var _excluded = ["children"];
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import { IndexContext } from "../lib/IndexContext.js";
+import { InstantSearchContext } from "../lib/InstantSearchContext.js";
+import { useInstantSearchApi } from "../lib/useInstantSearchApi.js";
+export function InstantSearch(_ref) {
+  var children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var search = useInstantSearchApi(props);
+  if (!search.started) {
+    return null;
+  }
+  return /*#__PURE__*/React.createElement(InstantSearchContext.Provider, {
+    value: search
+  }, /*#__PURE__*/React.createElement(IndexContext.Provider, {
+    value: search.mainIndex
+  }, children));
+}

package/dist/es/components/InstantSearchSSRProvider.d.ts

@@ -0,0 +1,13 @@
+import type { InitialResults, UiState } from 'instantsearch.js';
+import type { ReactNode } from 'react';
+export type InstantSearchServerState = {
+    initialResults: InitialResults;
+};
+export type InstantSearchSSRProviderProps = Partial<InstantSearchServerState> & {
+    children?: ReactNode;
+};
+/**
+ * Provider to pass the server state retrieved from `getServerState()` to
+ * <InstantSearch>.
+ */
+export declare function InstantSearchSSRProvider<TUiState extends UiState, TRouteState = TUiState>({ children, ...props }: InstantSearchSSRProviderProps): JSX.Element;

package/dist/es/{connectors/connectConfigure.js → components/InstantSearchSSRProvider.js}

@@ -1,6 +1,5 @@
 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); }
-var _excluded = ["children", "contextValue", "indexContextValue"],
-  _excluded2 = ["children", "contextValue", "indexContextValue"];
+var _excluded = ["children"];
 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; }
@@ -8,63 +7,29 @@ function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _ty
 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 _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
 function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
-import createConnector from "../core/createConnector.js";
-import { refineValue, getIndexId, hasMultipleIndices } from "../core/indexUtils.js";
-import { omit } from "../core/utils.js";
-function getId() {
-  return 'configure';
-}
-export default createConnector({
-  displayName: 'AlgoliaConfigure',
-  $$type: 'ais.configure',
-  getProvidedProps: function getProvidedProps() {
-    return {};
-  },
-  getSearchParameters: function getSearchParameters(searchParameters, props) {
-    var children = props.children,
-      contextValue = props.contextValue,
-      indexContextValue = props.indexContextValue,
-      items = _objectWithoutProperties(props, _excluded);
-    return searchParameters.setQueryParameters(items);
-  },
-  transitionState: function transitionState(props, prevSearchState, nextSearchState) {
-    var id = getId();
-    var children = props.children,
-      contextValue = props.contextValue,
-      indexContextValue = props.indexContextValue,
-      items = _objectWithoutProperties(props, _excluded2);
-    var propKeys = Object.keys(props);
-    var nonPresentKeys = this._props ? Object.keys(this._props).filter(function (prop) {
-      return propKeys.indexOf(prop) === -1;
-    }) : [];
-    this._props = props;
-    var nextValue = _defineProperty({}, id, _objectSpread(_objectSpread({}, omit(nextSearchState[id], nonPresentKeys)), items));
-    return refineValue(nextSearchState, nextValue, {
-      ais: props.contextValue,
-      multiIndexContext: props.indexContextValue
-    });
-  },
-  cleanUp: function cleanUp(props, searchState) {
-    var id = getId();
-    var indexId = getIndexId({
-      ais: props.contextValue,
-      multiIndexContext: props.indexContextValue
-    });
-    var subState = hasMultipleIndices({
-      ais: props.contextValue,
-      multiIndexContext: props.indexContextValue
-    }) && searchState.indices ? searchState.indices[indexId] : searchState;
-    var configureKeys = subState && subState[id] ? Object.keys(subState[id]) : [];
-    var configureState = configureKeys.reduce(function (acc, item) {
-      if (!props[item]) {
-        acc[item] = subState[id][item];
-      }
-      return acc;
-    }, {});
-    var nextValue = _defineProperty({}, id, configureState);
-    return refineValue(searchState, nextValue, {
-      ais: props.contextValue,
-      multiIndexContext: props.indexContextValue
-    });
+import React from 'react';
+import { InstantSearchSSRContext } from "../lib/InstantSearchSSRContext.js";
+/**
+ * Provider to pass the server state retrieved from `getServerState()` to
+ * <InstantSearch>.
+ */
+export function InstantSearchSSRProvider(_ref) {
+  var children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  // This is used in `useInstantSearchApi()` to avoid creating and starting multiple instances of
+  // `InstantSearch` on mount.
+  var ssrSearchRef = React.useRef(null);
+
+  // When <DynamicWidgets> is mounted, a second provider is used above the user-land
+  // <InstantSearchSSRProvider> in `getServerState()`.
+  // To avoid the user's provider overriding the context value with an empty object,
+  // we skip this provider.
+  if (Object.keys(props).length === 0) {
+    return /*#__PURE__*/React.createElement(React.Fragment, null, children);
   }
-});
+  return /*#__PURE__*/React.createElement(InstantSearchSSRContext.Provider, {
+    value: _objectSpread(_objectSpread({}, props), {}, {
+      ssrSearchRef: ssrSearchRef
+    })
+  }, children);
+}

package/dist/es/components/InstantSearchServerContext.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import type { InstantSearch, UiState } from 'instantsearch.js';
+export type InstantSearchServerContextApi<TUiState extends UiState, TRouteState = TUiState> = {
+    /**
+     * Fowards search internals to the server execution context to access them
+     * in `getServerState()`.
+     */
+    notifyServer: (params: {
+        search: InstantSearch<TUiState, TRouteState>;
+    }) => void;
+};
+export declare const InstantSearchServerContext: import("react").Context<InstantSearchServerContextApi<UiState, UiState> | null>;

package/dist/es/components/InstantSearchServerContext.js

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

package/dist/es/connectors/useBreadcrumb.d.ts

@@ -0,0 +1,4 @@
+import type { AdditionalWidgetProperties } from '../hooks/useConnector';
+import type { BreadcrumbConnectorParams } from 'instantsearch.js/es/connectors/breadcrumb/connectBreadcrumb';
+export type UseBreadcrumbProps = BreadcrumbConnectorParams;
+export declare function useBreadcrumb(props: UseBreadcrumbProps, additionalWidgetProperties?: AdditionalWidgetProperties): import("instantsearch.js/es/connectors/breadcrumb/connectBreadcrumb").BreadcrumbRenderState;

package/dist/es/connectors/useBreadcrumb.js

@@ -0,0 +1,5 @@
+import connectBreadcrumb from "instantsearch.js/es/connectors/breadcrumb/connectBreadcrumb.js";
+import { useConnector } from "../hooks/useConnector.js";
+export function useBreadcrumb(props, additionalWidgetProperties) {
+  return useConnector(connectBreadcrumb, props, additionalWidgetProperties);
+}

package/dist/es/connectors/useClearRefinements.d.ts

@@ -0,0 +1,4 @@
+import type { AdditionalWidgetProperties } from '../hooks/useConnector';
+import type { ClearRefinementsConnectorParams } from 'instantsearch.js/es/connectors/clear-refinements/connectClearRefinements';
+export type UseClearRefinementsProps = ClearRefinementsConnectorParams;
+export declare function useClearRefinements(props?: UseClearRefinementsProps, additionalWidgetProperties?: AdditionalWidgetProperties): import("instantsearch.js/es/connectors/clear-refinements/connectClearRefinements").ClearRefinementsRenderState;

package/dist/es/connectors/useClearRefinements.js

@@ -0,0 +1,5 @@
+import connectClearRefinements from "instantsearch.js/es/connectors/clear-refinements/connectClearRefinements.js";
+import { useConnector } from "../hooks/useConnector.js";
+export function useClearRefinements(props, additionalWidgetProperties) {
+  return useConnector(connectClearRefinements, props, additionalWidgetProperties);
+}

package/dist/es/connectors/useConfigure.d.ts

@@ -0,0 +1,4 @@
+import type { AdditionalWidgetProperties } from '../hooks/useConnector';
+import type { ConfigureConnectorParams } from 'instantsearch.js/es/connectors/configure/connectConfigure';
+export type UseConfigureProps = ConfigureConnectorParams['searchParameters'];
+export declare function useConfigure(props: UseConfigureProps, additionalWidgetProperties?: AdditionalWidgetProperties): import("instantsearch.js/es/connectors/configure/connectConfigure").ConfigureRenderState;

package/dist/es/connectors/useConfigure.js

@@ -0,0 +1,7 @@
+import connectConfigure from "instantsearch.js/es/connectors/configure/connectConfigure.js";
+import { useConnector } from "../hooks/useConnector.js";
+export function useConfigure(props, additionalWidgetProperties) {
+  return useConnector(connectConfigure, {
+    searchParameters: props
+  }, additionalWidgetProperties);
+}

package/dist/es/connectors/useCurrentRefinements.d.ts

@@ -0,0 +1,4 @@
+import type { AdditionalWidgetProperties } from '../hooks/useConnector';
+import type { CurrentRefinementsConnectorParams } from 'instantsearch.js/es/connectors/current-refinements/connectCurrentRefinements';
+export type UseCurrentRefinementsProps = CurrentRefinementsConnectorParams;
+export declare function useCurrentRefinements(props?: UseCurrentRefinementsProps, additionalWidgetProperties?: AdditionalWidgetProperties): import("instantsearch.js/es/connectors/current-refinements/connectCurrentRefinements").CurrentRefinementsRenderState;

package/dist/es/connectors/useCurrentRefinements.js

@@ -0,0 +1,5 @@
+import connectCurrentRefinements from "instantsearch.js/es/connectors/current-refinements/connectCurrentRefinements.js";
+import { useConnector } from "../hooks/useConnector.js";
+export function useCurrentRefinements(props, additionalWidgetProperties) {
+  return useConnector(connectCurrentRefinements, props, additionalWidgetProperties);
+}

package/dist/es/connectors/useDynamicWidgets.d.ts

@@ -0,0 +1,4 @@
+import type { AdditionalWidgetProperties } from '../hooks/useConnector';
+import type { DynamicWidgetsConnectorParams } from 'instantsearch.js/es/connectors/dynamic-widgets/connectDynamicWidgets';
+export type UseDynamicWidgetsProps = Omit<DynamicWidgetsConnectorParams, 'widgets' | 'fallbackWidget'>;
+export declare function useDynamicWidgets(props?: UseDynamicWidgetsProps, additionalWidgetProperties?: AdditionalWidgetProperties): import("instantsearch.js/es/connectors/dynamic-widgets/connectDynamicWidgets").DynamicWidgetsRenderState;

package/dist/es/connectors/useDynamicWidgets.js

@@ -0,0 +1,15 @@
+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 connectDynamicWidgets from "instantsearch.js/es/connectors/dynamic-widgets/connectDynamicWidgets.js";
+import { useConnector } from "../hooks/useConnector.js";
+export function useDynamicWidgets(props, additionalWidgetProperties) {
+  return useConnector(connectDynamicWidgets, _objectSpread(_objectSpread({}, props), {}, {
+    // We don't rely on InstantSearch.js for rendering widgets because React
+    // directly manipulates the children.
+    widgets: []
+  }), additionalWidgetProperties);
+}

package/dist/es/connectors/useGeoSearch.d.ts

@@ -0,0 +1,6 @@
+import type { AdditionalWidgetProperties } from '../hooks/useConnector';
+import type { BaseHit } from 'instantsearch.js';
+import type { GeoSearchConnectorParams } from 'instantsearch.js/es/connectors/geo-search/connectGeoSearch';
+export type { GeoHit } from 'instantsearch.js/es/connectors/geo-search/connectGeoSearch';
+export type UseGeoSearchProps<THit extends BaseHit = BaseHit> = GeoSearchConnectorParams<THit>;
+export declare function useGeoSearch<THit extends BaseHit>(props?: UseGeoSearchProps<THit>, additionalWidgetProperties?: AdditionalWidgetProperties): import("instantsearch.js/es/connectors/geo-search/connectGeoSearch").GeoSearchRenderState<THit>;

package/dist/es/connectors/useGeoSearch.js

@@ -0,0 +1,5 @@
+import connectGeoSearch from "instantsearch.js/es/connectors/geo-search/connectGeoSearch.js";
+import { useConnector } from "../hooks/useConnector.js";
+export function useGeoSearch(props, additionalWidgetProperties) {
+  return useConnector(connectGeoSearch, props, additionalWidgetProperties);
+}

package/dist/es/connectors/useHierarchicalMenu.d.ts

@@ -0,0 +1,4 @@
+import type { AdditionalWidgetProperties } from '../hooks/useConnector';
+import type { HierarchicalMenuConnectorParams } from 'instantsearch.js/es/connectors/hierarchical-menu/connectHierarchicalMenu';
+export type UseHierarchicalMenuProps = HierarchicalMenuConnectorParams;
+export declare function useHierarchicalMenu(props: UseHierarchicalMenuProps, additionalWidgetProperties?: AdditionalWidgetProperties): import("instantsearch.js/es/connectors/hierarchical-menu/connectHierarchicalMenu").HierarchicalMenuRenderState;

package/dist/es/connectors/useHierarchicalMenu.js

@@ -0,0 +1,5 @@
+import connectHierarchicalMenu from "instantsearch.js/es/connectors/hierarchical-menu/connectHierarchicalMenu.js";
+import { useConnector } from "../hooks/useConnector.js";
+export function useHierarchicalMenu(props, additionalWidgetProperties) {
+  return useConnector(connectHierarchicalMenu, props, additionalWidgetProperties);
+}