react-instantsearch-core 6.40.3 → 7.0.0

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

@@ -0,0 +1,8 @@
+import type { Widget } from 'instantsearch.js';
+import type { IndexWidget } from 'instantsearch.js/es/widgets/index/index';
+export declare function useWidget<TWidget extends Widget | IndexWidget, TProps>({ widget, parentIndex, props, shouldSsr, }: {
+    widget: TWidget;
+    parentIndex: IndexWidget;
+    props: TProps;
+    shouldSsr: boolean;
+}): void;

package/dist/es/lib/useWidget.js

@@ -0,0 +1,72 @@
+import { useEffect, useRef } from 'react';
+import { dequal } from "./dequal.js";
+import { useInstantSearchContext } from "./useInstantSearchContext.js";
+import { useIsomorphicLayoutEffect } from "./useIsomorphicLayoutEffect.js";
+export function useWidget(_ref) {
+  var widget = _ref.widget,
+    parentIndex = _ref.parentIndex,
+    props = _ref.props,
+    shouldSsr = _ref.shouldSsr;
+  var prevPropsRef = useRef(props);
+  useEffect(function () {
+    prevPropsRef.current = props;
+  }, [props]);
+  var prevWidgetRef = useRef(widget);
+  useEffect(function () {
+    prevWidgetRef.current = widget;
+  }, [widget]);
+  var cleanupTimerRef = useRef(null);
+  var shouldAddWidgetEarly = shouldSsr && !parentIndex.getWidgets().includes(widget);
+  var search = 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.
+  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 = 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/es/lib/warn.d.ts

@@ -0,0 +1,10 @@
+type WarnCache = {
+    current: Record<string, boolean>;
+};
+export declare const warnCache: WarnCache;
+/**
+ * Logs a warning if the condition is not met.
+ * This is used to log issues in development environment only.
+ */
+export declare function warn(condition: boolean, message: string): void;
+export {};

package/dist/es/lib/warn.js

@@ -0,0 +1,33 @@
+/* eslint-disable no-console, no-empty */
+
+export var warnCache = {
+  current: {}
+};
+
+/**
+ * Logs a warning if the condition is not met.
+ * This is used to log issues in development environment only.
+ */
+export 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/es/server/getServerState.d.ts

@@ -0,0 +1,10 @@
+import type { InstantSearchServerState } from '..';
+import type { ReactNode } from 'react';
+export type RenderToString = (element: JSX.Element) => unknown;
+export type GetServerStateOptions = {
+    renderToString: RenderToString;
+};
+/**
+ * Returns the InstantSearch server state from a component.
+ */
+export declare function getServerState(children: ReactNode, { renderToString }: GetServerStateOptions): Promise<InstantSearchServerState>;

package/dist/es/server/getServerState.js

@@ -0,0 +1,86 @@
+import { getInitialResults, waitForResults } from "instantsearch.js/es/lib/server.js";
+import { walkIndex } from "instantsearch.js/es/lib/utils/index.js";
+import React from 'react';
+import { InstantSearchServerContext, InstantSearchSSRProvider } from "../index.js";
+/**
+ * Returns the InstantSearch server state from a component.
+ */
+export 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.
+    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.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.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 waitForResults(searchRef.current);
+  }).then(function () {
+    return {
+      initialResults: getInitialResults(searchRef.current.mainIndex)
+    };
+  });
+}

package/dist/es/server/index.d.ts

@@ -0,0 +1 @@
+export * from './getServerState';

package/dist/es/server/index.js

@@ -0,0 +1 @@
+export * from "./getServerState.js";

package/dist/es/version.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "7.0.0";
+export default _default;

package/dist/es/version.js

@@ -0,0 +1 @@
+export default '7.0.0';