@usereactify/search 5.0.0-beta.1 → 5.0.0-beta.2

package/dist/src/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("./useSortby"), exports);
+__exportStar(require("./usePagination"), exports);
+__exportStar(require("./usePaginationLoadMore"), exports);
+__exportStar(require("./useSearch"), exports);
+__exportStar(require("./useFilters"), exports);
+__exportStar(require("./useCuration"), exports);
+__exportStar(require("./useAnalytics"), exports);
+__exportStar(require("./useFilterStack"), exports);
+__exportStar(require("./useProductPrice"), exports);
+__exportStar(require("./useFilterListProps"), exports);
+__exportStar(require("./useFilterCollapsedState"), exports);
+__exportStar(require("./useConfig"), exports);
+__exportStar(require("./useReactifySearchContext"), exports);

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

@@ -0,0 +1,8 @@
+export * from "./useReactiveBaseProps";
+export * from "./useReactiveReactProp";
+export * from "./useReactiveFilterListProps";
+export * from "./useReactiveFilterRangeProps";
+export * from "./useReactiveFilterSliderProps";
+export * from "./useReactiveFilterSharedProps";
+export * from "./useReactiveResultStackProps";
+export * from "./useReactiveDataSearchProps";

package/dist/src/hooks/reactivesearch/index.js

@@ -0,0 +1,20 @@
+"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("./useReactiveFilterRangeProps"), exports);
+__exportStar(require("./useReactiveFilterSliderProps"), exports);
+__exportStar(require("./useReactiveFilterSharedProps"), exports);
+__exportStar(require("./useReactiveResultStackProps"), exports);
+__exportStar(require("./useReactiveDataSearchProps"), exports);

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

@@ -0,0 +1,7 @@
+export declare const useReactiveBaseProps: () => {
+    app: string;
+    url: string;
+    credentials: string;
+    theme: Record<string, unknown>;
+    transformResponse: (response: any) => Promise<any>;
+};

package/dist/src/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 hooks_1 = require("../../hooks");
+const useReactiveBaseProps = () => {
+    const { options } = (0, hooks_1.useReactifySearchContext)();
+    return react_1.default.useMemo(() => ({
+        app: options.index,
+        url: options.credentials.endpoint,
+        credentials: `${options.credentials.username}:${options.credentials.password}`,
+        theme: options.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;
+        }),
+    }), [options.credentials, options.theme]);
+};
+exports.useReactiveBaseProps = useReactiveBaseProps;

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

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

package/dist/src/hooks/reactivesearch/useReactiveDataSearchProps.js

@@ -0,0 +1,70 @@
+"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 debug = require("debug")("reactify-search:useReactiveDataSearchProps");
+const hooks_1 = require("../../hooks");
+// 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 = (options) => {
+    var _a;
+    const { config } = (0, hooks_1.useReactifySearchContext)();
+    const { searchQuery, submitSearch, setSearchQuery, setShowInstantSearchResults, } = (0, hooks_1.useSearch)();
+    const searchFields = react_1.default.useMemo(() => 0 < config.fields.length
+        ? config.fields.filter((field) => ["always_search", "instant_search"].includes(field.searchType))
+        : [defaultSearchField], []);
+    const handleKeyPress = react_1.default.useCallback((e) => {
+        if ("Enter" !== e.key)
+            return;
+        submitSearch();
+    }, [submitSearch]);
+    const { track } = (0, hooks_1.useAnalytics)();
+    const trackQuery = react_1.default.useCallback(() => {
+        if (!searchQuery || (searchQuery && searchQuery.length < 3))
+            return;
+        track({ eventName: "search", payload: { searchTerm: searchQuery } });
+    }, [searchQuery, track]);
+    const { run: runDebouncedTriggerQuery, cancel: cancelDebouncedTriggerQuery } = (0, ahooks_1.useDebounceFn)((triggerQuery) => {
+        triggerQuery();
+        trackQuery();
+    }, {
+        wait: (_a = options.debounce) !== null && _a !== void 0 ? _a : 300,
+    });
+    return react_1.default.useMemo(() => {
+        var _a;
+        return (Object.assign({ type: "search", showIcon: false, fuzziness: 1, queryFormat: "and", autosuggest: false, value: searchQuery !== null && searchQuery !== void 0 ? searchQuery : "", onKeyUp: handleKeyPress, componentId: "SearchInput", placeholder: (_a = options.placeholder) !== null && _a !== void 0 ? _a : "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: () => {
+                // setTimeout ensures that results are still clickable before close
+                setTimeout(() => setShowInstantSearchResults(false), 300);
+            }, onFocus: () => {
+                setShowInstantSearchResults(true);
+            }, innerClass: {
+                input: options.inputClassName,
+            } }, options));
+    }, [
+        searchQuery,
+        handleKeyPress,
+        options.placeholder,
+        searchFields,
+        setSearchQuery,
+        runDebouncedTriggerQuery,
+        cancelDebouncedTriggerQuery,
+    ]);
+};
+exports.useReactiveDataSearchProps = useReactiveDataSearchProps;

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

@@ -0,0 +1,73 @@
+import type { ConfigFilterOption } from "../../types/config";
+/**
+ * For use with @appbaseio/reactivesearch SingleList and MultiList components
+ */
+export declare const useReactiveFilterListProps: (filter: ConfigFilterOption) => {
+    size: number | undefined;
+    showFilter: boolean;
+    showLoadMore: boolean;
+    showSearch: boolean;
+    showRadio: boolean;
+    showCheckbox: boolean;
+    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[];
+    };
+};

package/dist/src/hooks/reactivesearch/useReactiveFilterListProps.js

@@ -0,0 +1,21 @@
+"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 useReactiveFilterSharedProps_1 = require("./useReactiveFilterSharedProps");
+const useReactiveReactProp_1 = require("./useReactiveReactProp");
+/**
+ * For use with @appbaseio/reactivesearch SingleList and MultiList components
+ */
+const useReactiveFilterListProps = (filter) => {
+    const reactiveReactProp = (0, useReactiveReactProp_1.useReactiveReactProp)(filter.handle);
+    const reactiveFilterSharedProps = (0, useReactiveFilterSharedProps_1.useReactiveFilterSharedProps)(filter);
+    return react_1.default.useMemo(() => {
+        var _a, _b, _c;
+        return (Object.assign(Object.assign({}, reactiveFilterSharedProps), { size: parseInt(filter.displaySize) || undefined, showFilter: (_a = filter.settingsShowFilter) !== null && _a !== void 0 ? _a : true, showLoadMore: (_b = filter.settingsShowMore) !== null && _b !== void 0 ? _b : false, showSearch: (_c = filter.settingsShowSearch) !== null && _c !== void 0 ? _c : false, showRadio: false, showCheckbox: false }));
+    }, [filter, reactiveReactProp]);
+};
+exports.useReactiveFilterListProps = useReactiveFilterListProps;

package/dist/src/hooks/reactivesearch/useReactiveFilterRangeProps.d.ts

@@ -0,0 +1,70 @@
+import type { ConfigFilterOption } from "../../types/config";
+/**
+ * For use with @appbaseio/reactivesearch SingleRange and MultiRange components
+ */
+export declare const useReactiveFilterRangeProps: (filter: ConfigFilterOption) => {
+    showFilter: boolean;
+    showRadio: boolean;
+    showCheckbox: boolean;
+    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[];
+    };
+};

package/dist/src/hooks/reactivesearch/useReactiveFilterRangeProps.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReactiveFilterRangeProps = void 0;
+const react_1 = __importDefault(require("react"));
+const useReactiveFilterSharedProps_1 = require("./useReactiveFilterSharedProps");
+const useReactiveReactProp_1 = require("./useReactiveReactProp");
+/**
+ * For use with @appbaseio/reactivesearch SingleRange and MultiRange components
+ */
+const useReactiveFilterRangeProps = (filter) => {
+    const reactiveReactProp = (0, useReactiveReactProp_1.useReactiveReactProp)(filter.handle);
+    const reactiveFilterSharedProps = (0, useReactiveFilterSharedProps_1.useReactiveFilterSharedProps)(filter);
+    return react_1.default.useMemo(() => {
+        var _a;
+        return (Object.assign(Object.assign({}, reactiveFilterSharedProps), { showFilter: (_a = filter.settingsShowFilter) !== null && _a !== void 0 ? _a : true, showRadio: false, showCheckbox: false }));
+    }, [filter, reactiveReactProp]);
+};
+exports.useReactiveFilterRangeProps = useReactiveFilterRangeProps;

package/dist/src/hooks/reactivesearch/useReactiveFilterSharedProps.d.ts

@@ -0,0 +1,67 @@
+import type { ConfigFilterOption } from "../../types/config";
+/**
+ * For use with all @appbaseio/reactivesearch filter components
+ */
+export declare const useReactiveFilterSharedProps: (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[];
+    };
+};

package/dist/src/hooks/reactivesearch/useReactiveFilterSharedProps.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReactiveFilterSharedProps = void 0;
+const react_1 = __importDefault(require("react"));
+const useReactiveReactProp_1 = require("./useReactiveReactProp");
+/**
+ * For use with all @appbaseio/reactivesearch filter components
+ */
+const useReactiveFilterSharedProps = (filter) => {
+    const reactiveReactProp = (0, useReactiveReactProp_1.useReactiveReactProp)(filter.handle);
+    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.handle,
+        dataField: filter.field,
+        filterLabel: filter.name,
+        react: reactiveReactProp,
+    }), [filter, reactiveReactProp]);
+};
+exports.useReactiveFilterSharedProps = useReactiveFilterSharedProps;

package/dist/src/hooks/reactivesearch/useReactiveFilterSliderProps.d.ts

@@ -0,0 +1,68 @@
+import type { ConfigFilterOption } from "../../types/config";
+/**
+ * For use with @appbaseio/reactivesearch RangeSlider component
+ */
+export declare const useReactiveFilterSliderProps: (filter: ConfigFilterOption) => {
+    showFilter: boolean;
+    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[];
+    };
+};

package/dist/src/hooks/reactivesearch/useReactiveFilterSliderProps.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReactiveFilterSliderProps = void 0;
+const react_1 = __importDefault(require("react"));
+const useReactiveFilterSharedProps_1 = require("./useReactiveFilterSharedProps");
+const useReactiveReactProp_1 = require("./useReactiveReactProp");
+/**
+ * For use with @appbaseio/reactivesearch RangeSlider component
+ */
+const useReactiveFilterSliderProps = (filter) => {
+    const reactiveReactProp = (0, useReactiveReactProp_1.useReactiveReactProp)(filter.handle);
+    const reactiveFilterSharedProps = (0, useReactiveFilterSharedProps_1.useReactiveFilterSharedProps)(filter);
+    return react_1.default.useMemo(() => {
+        var _a;
+        return (Object.assign(Object.assign({}, reactiveFilterSharedProps), { showFilter: (_a = filter.settingsShowFilter) !== null && _a !== void 0 ? _a : true }));
+    }, [filter, reactiveReactProp]);
+};
+exports.useReactiveFilterSliderProps = useReactiveFilterSliderProps;

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

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