@usereactify/search 2.1.0-beta.2 → 2.1.0-beta.3

package/README.md

@@ -38,4 +38,9 @@ npm run storybook
 
 # release a version
 npm run release
+
+# release a beta version
+change the version in package.json or npm version prerelease --preid beta or npm version prerelease
+
+publish-beta
 ```

package/dist/filter/Filter.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import type { ConfigFilterOption } from "../types";
+import { useFilterListProps, useFilterCollapsedState } from "../hooks";
+declare type Props = {
+    noWrapper?: boolean;
+    filter: ConfigFilterOption;
+    renderFilterList?: (props: Omit<Props, "renderFilterList"> & {
+        filterListProps: ReturnType<typeof useFilterListProps>;
+    }) => JSX.Element;
+} & Partial<ReturnType<typeof useFilterCollapsedState>>;
+export declare const Filter: React.FC<Props>;
+export {};

package/dist/filter/Filter.js

@@ -0,0 +1,58 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Filter = void 0;
+const react_1 = __importDefault(require("react"));
+const MultiList_1 = __importDefault(require("@appbaseio/reactivesearch/lib/components/list/MultiList"));
+const SingleList_1 = __importDefault(require("@appbaseio/reactivesearch/lib/components/list/SingleList"));
+const FilterList_1 = require("./FilterList");
+const hooks_1 = require("../hooks");
+const Filter = (props) => {
+    const { filter } = props;
+    const reactiveFilterListProps = (0, hooks_1.useReactiveFilterListProps)(filter);
+    if ("single" === filter.displayType) {
+        return (react_1.default.createElement(SingleList_1.default, Object.assign({}, reactiveFilterListProps, { render: (reactivesearchFilterProps) => (react_1.default.createElement(FilterListInner, Object.assign({}, props, { reactivesearchFilterProps: reactivesearchFilterProps }))) })));
+    }
+    if ("multi" === filter.displayType) {
+        return (react_1.default.createElement(MultiList_1.default, Object.assign({ showCheckbox: false }, reactiveFilterListProps, { render: (reactivesearchFilterProps) => (react_1.default.createElement(FilterListInner, Object.assign({}, props, { reactivesearchFilterProps: reactivesearchFilterProps }))) })));
+    }
+    console.error(`filter with display type "${filter.displayType}" not yet supported`);
+    return null;
+};
+exports.Filter = Filter;
+// inner component exists only so we can use memos in reactivesearch render functions
+const FilterListInner = (props) => {
+    const { filter, noWrapper, renderFilterList, reactivesearchFilterProps } = props, otherProps = __rest(props, ["filter", "noWrapper", "renderFilterList", "reactivesearchFilterProps"]);
+    const filterListProps = (0, hooks_1.useFilterListProps)(filter, reactivesearchFilterProps);
+    // hide entire filter when no options available
+    if (0 === filterListProps.options.length)
+        return null;
+    if (renderFilterList) {
+        return renderFilterList(Object.assign({ filterListProps, filter }, otherProps));
+    }
+    if (noWrapper) {
+        return react_1.default.createElement(FilterList_1.FilterList, Object.assign({}, filterListProps));
+    }
+    return (react_1.default.createElement(FilterWrapper, Object.assign({}, props),
+        react_1.default.createElement(FilterList_1.FilterList, Object.assign({}, filterListProps))));
+};
+// wrap the filter with a clickable title
+const FilterWrapper = ({ filter, children, collapsed, shouldRender, collapsedToggle }) => {
+    return (react_1.default.createElement("div", null,
+        react_1.default.createElement("h1", { onClick: () => collapsedToggle && collapsedToggle() }, filter.name),
+        ("undefined" === typeof shouldRender || !!shouldRender) && (react_1.default.createElement("div", { style: { display: collapsed ? "none" : "block" } }, children)),
+        "undefined" !== typeof collapsed && !!collapsed && (react_1.default.createElement("div", null, "Filter is collapsed."))));
+};

package/dist/filter/FilterList.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { useFilterListProps } from "../hooks";
+export declare type Props = ReturnType<typeof useFilterListProps>;
+export declare const FilterList: React.FC<Props>;

package/dist/filter/FilterList.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterList = void 0;
+const react_1 = __importDefault(require("react"));
+const FilterList = ({ options, handleChange }) => (react_1.default.createElement("ul", null, options.map(({ key, doc_count, checked }) => (react_1.default.createElement("li", { key: key },
+    react_1.default.createElement("label", null,
+        react_1.default.createElement("input", { value: key, type: "checkbox", checked: checked, onChange: handleChange }),
+        key,
+        " (",
+        doc_count,
+        ")"))))));
+exports.FilterList = FilterList;

package/dist/filter/FilterStack.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import type { ConfigFilterOption } from "../types";
+import { useFilterCollapsedState } from "../hooks";
+declare type Props = {
+    render?: (filters: ConfigFilterOption[]) => JSX.Element;
+    renderFilter?: (props: {
+        filter: ConfigFilterOption;
+    } & ReturnType<typeof useFilterCollapsedState>) => JSX.Element;
+};
+export declare const FilterStack: React.FC<Props>;
+export {};

package/dist/filter/FilterStack.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterStack = void 0;
+const react_1 = __importDefault(require("react"));
+const Filter_1 = require("./Filter");
+const hooks_1 = require("../hooks");
+const FilterStack = (props) => {
+    const { render } = props;
+    const filters = (0, hooks_1.useFilters)();
+    if (0 === filters.length)
+        return null;
+    if (render)
+        return render(filters);
+    return (react_1.default.createElement(react_1.default.Fragment, null, filters.map((filter) => (react_1.default.createElement(FilterWithState, Object.assign({ key: filter.id, filter: filter }, props))))));
+};
+exports.FilterStack = FilterStack;
+const FilterWithState = ({ filter, renderFilter, }) => {
+    const collapsedProps = (0, hooks_1.useFilterCollapsedState)(filter);
+    if (renderFilter)
+        return renderFilter(Object.assign({ filter }, collapsedProps));
+    return react_1.default.createElement(Filter_1.Filter, Object.assign({ filter: filter }, collapsedProps));
+};

package/dist/filter/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Filter";
+export * from "./FilterList";
+export * from "./FilterStack";

package/dist/filter/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Filter"), exports);
+__exportStar(require("./FilterList"), exports);
+__exportStar(require("./FilterStack"), exports);

package/dist/hooks/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./reactivesearch";
+export * from "./useSort";
+export * from "./usePages";
+export * from "./useConfig";
+export * from "./useSearch";
+export * from "./useFilters";
+export * from "./useCuration";
+export * from "./useAnalytics";
+export * from "./useCollection";
+export * from "./useFilterStack";
+export * from "./useProductPrice";
+export * from "./useFilterListProps";
+export * from "./useCombinedResults";
+export * from "./useFilterCollapsedState";

package/dist/hooks/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./reactivesearch"), exports);
+__exportStar(require("./useSort"), exports);
+__exportStar(require("./usePages"), exports);
+__exportStar(require("./useConfig"), exports);
+__exportStar(require("./useSearch"), exports);
+__exportStar(require("./useFilters"), exports);
+__exportStar(require("./useCuration"), exports);
+__exportStar(require("./useAnalytics"), exports);
+__exportStar(require("./useCollection"), exports);
+__exportStar(require("./useFilterStack"), exports);
+__exportStar(require("./useProductPrice"), exports);
+__exportStar(require("./useFilterListProps"), exports);
+__exportStar(require("./useCombinedResults"), exports);
+__exportStar(require("./useFilterCollapsedState"), exports);

package/dist/hooks/reactivesearch/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./useReactiveBaseProps";
+export * from "./useReactiveReactProp";
+export * from "./useReactiveFilterListProps";
+export * from "./useReactiveResultListProps";
+export * from "./useReactiveDataSearchProps";

package/dist/hooks/reactivesearch/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useReactiveBaseProps"), exports);
+__exportStar(require("./useReactiveReactProp"), exports);
+__exportStar(require("./useReactiveFilterListProps"), exports);
+__exportStar(require("./useReactiveResultListProps"), exports);
+__exportStar(require("./useReactiveDataSearchProps"), exports);

package/dist/hooks/reactivesearch/useReactiveBaseProps.d.ts

@@ -0,0 +1,7 @@
+export declare const useReactiveBaseProps: () => {
+    app: string;
+    url: string;
+    credentials: string;
+    theme: import("../..").ConfigTheme | undefined;
+    transformResponse: (response: any) => Promise<any>;
+};

package/dist/hooks/reactivesearch/useReactiveBaseProps.js

@@ -0,0 +1,43 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReactiveBaseProps = void 0;
+const react_1 = __importDefault(require("react"));
+const provider_1 = require("../../provider");
+const useReactiveBaseProps = () => {
+    const { index, credentials, theme } = (0, provider_1.useContext)();
+    return react_1.default.useMemo(() => ({
+        app: index,
+        url: credentials.endpoint,
+        credentials: `${credentials.username}:${credentials.password}`,
+        theme,
+        transformResponse: (response) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            // support filtering inside nested aggregations by moving the inner aggregation
+            // up one level such that reactivesearch understands it
+            //
+            // see useReactiveFilterListProps > defaultQuery to see how a filter is being applied
+            // to variant aggregations to ensure that only in stock sizes are displayed as filter
+            // options, this involves a nested filter, which requires this fix
+            //
+            // https://github.com/appbaseio/reactivesearch/issues/1530
+            if ((_b = (_a = response === null || response === void 0 ? void 0 : response.aggregations) === null || _a === void 0 ? void 0 : _a.reactivesearch_nested) === null || _b === void 0 ? void 0 : _b.reactify_nested_outer) {
+                response.aggregations.reactivesearch_nested =
+                    (_d = (_c = response === null || response === void 0 ? void 0 : response.aggregations) === null || _c === void 0 ? void 0 : _c.reactivesearch_nested) === null || _d === void 0 ? void 0 : _d.reactify_nested_outer;
+            }
+            return response;
+        }),
+    }), [credentials, theme]);
+};
+exports.useReactiveBaseProps = useReactiveBaseProps;

package/dist/hooks/reactivesearch/useReactiveDataSearchProps.d.ts

@@ -0,0 +1,24 @@
+declare type Props = {
+    debounce?: number;
+    placeholder?: string;
+    inputClassName?: string;
+};
+export declare const useReactiveDataSearchProps: (props?: Props) => {
+    showIcon: boolean;
+    fuzziness: 0 | 1 | 2 | "AUTO";
+    queryFormat: "and" | "or";
+    autosuggest: boolean;
+    value: string;
+    onKeyUp: (e: any) => void;
+    componentId: string;
+    placeholder: string;
+    dataField: string[];
+    fieldWeights: number[];
+    onChange: (value: string, triggerQuery: () => {}) => void;
+    onBlur: () => void;
+    onFocus: () => void;
+    innerClass: {
+        input: string | undefined;
+    };
+};
+export {};

package/dist/hooks/reactivesearch/useReactiveDataSearchProps.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReactiveDataSearchProps = void 0;
+const react_1 = __importDefault(require("react"));
+const ahooks_1 = require("ahooks");
+const useAnalytics_1 = require("../useAnalytics");
+const debug = require("debug")("reactify-search:useReactiveDataSearchProps");
+const __1 = require("../");
+// default field for when zero search fields have been configured in Reactify
+const defaultSearchField = {
+    id: "title",
+    field: "title",
+    importance: 0,
+    searchType: "instant_search",
+};
+const useReactiveDataSearchProps = (props = {}) => {
+    const { debounce, placeholder, inputClassName } = props;
+    react_1.default.useEffect(() => {
+        debug("props", props);
+    }, [props]);
+    const { fields } = (0, __1.useConfig)();
+    const { searchQuery, submitSearch, setSearchQuery, setShowInstantSearchResults, } = (0, __1.useSearch)();
+    const searchFields = react_1.default.useMemo(() => 0 < fields.length
+        ? fields.filter((field) => ["always_search", "instant_search"].includes(field.searchType))
+        : [defaultSearchField], []);
+    react_1.default.useEffect(() => {
+        debug("searchFields", searchFields);
+    }, [searchFields]);
+    const handleKeyPress = react_1.default.useCallback((e) => {
+        if ("Enter" !== e.key)
+            return;
+        submitSearch();
+    }, [submitSearch]);
+    const { track } = (0, useAnalytics_1.useAnalytics)();
+    const trackQuery = react_1.default.useCallback(() => {
+        if (!searchQuery)
+            return;
+        track({ eventName: "search", searchTerm: searchQuery });
+    }, [searchQuery, track]);
+    const { run: runDebouncedTriggerQuery, cancel: cancelDebouncedTriggerQuery } = (0, ahooks_1.useDebounceFn)((triggerQuery) => {
+        triggerQuery();
+        trackQuery();
+    }, {
+        wait: debounce !== null && debounce !== void 0 ? debounce : 300,
+    });
+    return react_1.default.useMemo(() => ({
+        showIcon: false,
+        fuzziness: 1,
+        queryFormat: "and",
+        autosuggest: false,
+        value: searchQuery !== null && searchQuery !== void 0 ? searchQuery : "",
+        onKeyUp: handleKeyPress,
+        componentId: "SearchInput",
+        placeholder: placeholder !== null && placeholder !== void 0 ? placeholder : "Search for a product...",
+        dataField: searchFields.map((field) => field.field),
+        fieldWeights: searchFields.map((field) => field.importance),
+        onChange: (value, triggerQuery) => {
+            setSearchQuery(value);
+            if (!!value)
+                runDebouncedTriggerQuery(triggerQuery);
+            else
+                cancelDebouncedTriggerQuery();
+        },
+        onBlur: () => {
+            // requestAnimationFrame ensures that results are still clickable before close
+            window.requestAnimationFrame(() => setShowInstantSearchResults(false));
+        },
+        onFocus: () => {
+            setShowInstantSearchResults(true);
+        },
+        innerClass: {
+            input: inputClassName,
+        },
+    }), [
+        searchQuery,
+        handleKeyPress,
+        placeholder,
+        searchFields,
+        setSearchQuery,
+        runDebouncedTriggerQuery,
+        cancelDebouncedTriggerQuery,
+    ]);
+};
+exports.useReactiveDataSearchProps = useReactiveDataSearchProps;

package/dist/hooks/reactivesearch/useReactiveFilterListProps.d.ts

@@ -0,0 +1,68 @@
+import type { ConfigFilterOption } from "../../types";
+export declare const useReactiveFilterListProps: (filter: ConfigFilterOption) => {
+    nestedField: string | undefined;
+    customQuery: ((value?: string | string[] | undefined) => {
+        query?: undefined;
+    } | {
+        query: {
+            nested: {
+                path: string;
+                query: {
+                    bool: {
+                        must: ({
+                            match: {
+                                "variants.available": string;
+                            };
+                            terms?: undefined;
+                        } | {
+                            terms: {
+                                [x: string]: string[];
+                            };
+                            match?: undefined;
+                        })[];
+                    };
+                };
+            };
+        };
+    }) | undefined;
+    defaultQuery: (() => {
+        aggs: {
+            reactivesearch_nested: {
+                nested: {
+                    path: string;
+                };
+                aggs: {
+                    reactify_nested_outer: {
+                        filter: {
+                            match: {
+                                "variants.available": string;
+                            };
+                        };
+                        aggs: {
+                            [x: string]: {
+                                terms: {
+                                    field: string;
+                                    size: number;
+                                    order: {
+                                        _count: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    }) | undefined;
+    URLParams: boolean;
+    componentId: string;
+    dataField: string;
+    filterLabel: string;
+    react: {
+        and: string[];
+    };
+    size: number | undefined;
+    showFilter: true;
+    showLoadMore: boolean;
+    showSearch: boolean;
+};

package/dist/hooks/reactivesearch/useReactiveFilterListProps.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReactiveFilterListProps = void 0;
+const react_1 = __importDefault(require("react"));
+const useReactiveReactProp_1 = require("./useReactiveReactProp");
+const useReactiveFilterListProps = (filter) => {
+    const reactiveReactProp = (0, useReactiveReactProp_1.useReactiveReactProp)(filter.id);
+    const nestedField = react_1.default.useMemo(() => {
+        const nestedFields = ["variants"];
+        const topField = filter.field.split(".")[0];
+        if (nestedFields.includes(topField))
+            return topField;
+        return undefined;
+    }, [filter]);
+    // define a custom query for when settingsHideUnavailable is enabled and the target field is inside variants
+    // customQuery defines how this filter affects *other* components like the results component
+    const customQuery = react_1.default.useMemo(() => {
+        if (!filter.settingsHideUnavailable ||
+            !filter.field.startsWith("variants."))
+            return undefined;
+        return (value) => {
+            if (!value)
+                return {};
+            // reactivesearch sometimes returns string, sometimes string[]
+            const valueArray = "string" === typeof value ? [value] : value;
+            if (0 === valueArray.length)
+                return {};
+            return {
+                query: {
+                    nested: {
+                        path: "variants",
+                        query: {
+                            bool: {
+                                must: [
+                                    {
+                                        match: {
+                                            "variants.available": "true",
+                                        },
+                                    },
+                                    {
+                                        terms: {
+                                            [filter.field]: valueArray,
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+            };
+        };
+    }, [filter]);
+    // define a default query for when settingsHideUnavailable is enabled and the target field is inside variants
+    // defaultQuery defines how this filter affects itself i.e. the options displayed
+    const defaultQuery = react_1.default.useMemo(() => {
+        if (!filter.settingsHideUnavailable ||
+            !filter.field.startsWith("variants."))
+            return undefined;
+        // override the aggregation query to filter the results by the variants.available attribute
+        return () => {
+            return {
+                aggs: {
+                    reactivesearch_nested: {
+                        nested: { path: "variants" },
+                        aggs: {
+                            reactify_nested_outer: {
+                                filter: {
+                                    match: {
+                                        "variants.available": "true",
+                                    },
+                                },
+                                aggs: {
+                                    [filter.field]: {
+                                        terms: {
+                                            field: filter.field,
+                                            size: 100,
+                                            order: { _count: "desc" },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+        };
+    }, [filter]);
+    return react_1.default.useMemo(() => ({
+        nestedField,
+        customQuery,
+        defaultQuery,
+        URLParams: true,
+        componentId: filter.id,
+        dataField: filter.field,
+        filterLabel: filter.name,
+        react: reactiveReactProp,
+        size: parseInt(filter.displaySize) || undefined,
+        showFilter: filter.settingsShowFilter || true,
+        showLoadMore: filter.settingsShowMore || false,
+        showSearch: (filter === null || filter === void 0 ? void 0 : filter.settingsShowSearch) || false,
+    }), [filter, reactiveReactProp]);
+};
+exports.useReactiveFilterListProps = useReactiveFilterListProps;

package/dist/hooks/reactivesearch/useReactiveReactProp.d.ts

@@ -0,0 +1,3 @@
+export declare const useReactiveReactProp: (currentId?: string | undefined) => {
+    and: string[];
+};

package/dist/hooks/reactivesearch/useReactiveReactProp.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReactiveReactProp = void 0;
+const react_1 = __importDefault(require("react"));
+const sensor_1 = require("../../sensor");
+const useFilters_1 = require("../useFilters");
+const provider_1 = require("../../provider");
+const useReactiveReactProp = (currentId) => {
+    const filters = (0, useFilters_1.useFilters)();
+    const { additionalComponentIds } = (0, provider_1.useContext)();
+    return react_1.default.useMemo(() => {
+        return {
+            and: [
+                "SearchInput",
+                ...sensor_1.SENSOR_IDS,
+                ...(additionalComponentIds !== null && additionalComponentIds !== void 0 ? additionalComponentIds : []),
+                ...filters.map((filter) => filter.id),
+            ].filter((id) => id !== currentId),
+        };
+    }, [filters, currentId]);
+};
+exports.useReactiveReactProp = useReactiveReactProp;

package/dist/hooks/reactivesearch/useReactiveResultListProps.d.ts

@@ -0,0 +1,20 @@
+declare type Props = {
+    pageSize?: number;
+    pageSizeAdjust?: number;
+};
+export declare const useReactiveResultListProps: (props?: Props) => {
+    size: number;
+    URLParams: boolean;
+    showLoader: boolean;
+    dataField: string;
+    showResultStats: boolean;
+    react: {
+        and: string[];
+    };
+    componentId: string;
+    scrollOnChange: boolean;
+    pagination: boolean;
+    infiniteScroll: boolean;
+    renderNoResults: () => null;
+};
+export {};