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

package/dist/src/components/Sensor/SensorCollection.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SensorCollection = void 0;
+const react_1 = __importDefault(require("react"));
+const ReactiveComponent_1 = __importDefault(require("@appbaseio/reactivesearch/lib/components/basic/ReactiveComponent"));
+const hooks_1 = require("../../hooks");
+const SensorCollection = () => {
+    const { options } = (0, hooks_1.useReactifySearchContext)();
+    if (options.mode !== "collection") {
+        return null;
+    }
+    return (react_1.default.createElement(ReactiveComponent_1.default, { componentId: "SensorCollection", customQuery: () => ({
+            query: {
+                bool: {
+                    should: [
+                        {
+                            nested: {
+                                path: "collections",
+                                query: {
+                                    term: {
+                                        "collections.handle.keyword": options.collection.handle,
+                                    },
+                                },
+                            },
+                        },
+                        {
+                            nested: {
+                                path: "curations",
+                                query: {
+                                    term: {
+                                        "curations.collectionHandle.keyword": options.collection.handle,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+            },
+        }) }));
+};
+exports.SensorCollection = SensorCollection;

package/dist/src/components/Sensor/SensorInventoryAvailable.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const SensorInventoryAvailable: React.FC;

package/dist/src/components/Sensor/SensorInventoryAvailable.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SensorInventoryAvailable = void 0;
+const react_1 = __importDefault(require("react"));
+const ReactiveComponent_1 = __importDefault(require("@appbaseio/reactivesearch/lib/components/basic/ReactiveComponent"));
+const hooks_1 = require("../../hooks");
+const SensorInventoryAvailable = () => {
+    const filterStack = (0, hooks_1.useFilterStack)();
+    if (!filterStack || "show_all" === filterStack.inventoryVisibility)
+        return null;
+    return (react_1.default.createElement(ReactiveComponent_1.default, { componentId: "SensorInventoryAvailable", customQuery: () => ({
+            query: {
+                bool: {
+                    should: [
+                        {
+                            bool: {
+                                must: [
+                                    {
+                                        term: {
+                                            type: {
+                                                value: "product",
+                                            },
+                                        },
+                                    },
+                                    {
+                                        nested: {
+                                            path: "variants",
+                                            query: {
+                                                match: { "variants.available": true },
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                        {
+                            term: {
+                                type: {
+                                    value: "callout",
+                                },
+                            },
+                        },
+                    ],
+                    minimum_should_match: "1",
+                },
+            },
+        }) }));
+};
+exports.SensorInventoryAvailable = SensorInventoryAvailable;

package/dist/src/components/Sensor/SensorPublished.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const SensorPublished: React.FC;

package/dist/src/components/Sensor/SensorPublished.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SensorPublished = void 0;
+const react_1 = __importDefault(require("react"));
+const ReactiveComponent_1 = __importDefault(require("@appbaseio/reactivesearch/lib/components/basic/ReactiveComponent"));
+const SensorPublished = () => (react_1.default.createElement(ReactiveComponent_1.default, { componentId: "SensorPublished", customQuery: () => ({
+        query: {
+            match: {
+                published: true,
+            },
+        },
+    }) }));
+exports.SensorPublished = SensorPublished;

package/dist/src/components/Sensor/SensorSearch.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const SensorSearch: React.FC;

package/dist/src/components/Sensor/SensorSearch.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SensorSearch = void 0;
+const react_1 = __importDefault(require("react"));
+const DataSearch_1 = __importDefault(require("@appbaseio/reactivesearch/lib/components/search/DataSearch"));
+const hooks_1 = require("../../hooks");
+const SensorSearch = () => {
+    const { config } = (0, hooks_1.useReactifySearchContext)();
+    const { searchQuery } = (0, hooks_1.useSearch)();
+    // ignore search fields only set for instant search
+    const searchFields = react_1.default.useMemo(() => config.fields.filter((field) => ["always_search", "search_page"].includes(field.searchType)), [config.fields]);
+    if (!searchQuery || !searchFields.length) {
+        return null;
+    }
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement(DataSearch_1.default, { fuzziness: 1, queryFormat: "and", autosuggest: false, value: searchQuery, componentId: "SensorSearch", style: { display: "none" }, dataField: searchFields.map((field) => field.field), fieldWeights: searchFields.map((field) => field.importance), customQuery: (value, props) => {
+                const { dataField, fieldWeights } = props;
+                const fieldsCrossFields = dataField.map((field, index) => `${field}^${fieldWeights[index]}`);
+                const fieldsPhrase = dataField.map((field, index) => `${field}^${fieldWeights[index]}`);
+                const fieldsPhrasePrefix = dataField
+                    .filter((field) => !field.includes("."))
+                    .map((field, index) => `${field}^${fieldWeights[index]}`);
+                const query = {
+                    bool: {
+                        should: [
+                            {
+                                nested: {
+                                    path: "curations",
+                                    query: {
+                                        term: {
+                                            "curations.searchTerm.keyword": value === null || value === void 0 ? void 0 : value.toLowerCase(),
+                                        },
+                                    },
+                                },
+                            },
+                            ...(fieldsCrossFields.length > 0
+                                ? [
+                                    {
+                                        multi_match: {
+                                            query: value,
+                                            fields: fieldsCrossFields,
+                                            type: "cross_fields",
+                                            operator: "and",
+                                        },
+                                    },
+                                ]
+                                : []),
+                            ...(fieldsPhrase.length > 0
+                                ? [
+                                    {
+                                        multi_match: {
+                                            query: value,
+                                            fields: fieldsPhrase,
+                                            type: "phrase",
+                                            operator: "and",
+                                        },
+                                    },
+                                ]
+                                : []),
+                            ...(fieldsPhrasePrefix.length > 0
+                                ? [
+                                    {
+                                        multi_match: {
+                                            query: value,
+                                            fields: fieldsPhrasePrefix,
+                                            type: "phrase_prefix",
+                                            operator: "and",
+                                        },
+                                    },
+                                ]
+                                : []),
+                        ],
+                        minimum_should_match: "1",
+                    },
+                };
+                return { query };
+            } })));
+};
+exports.SensorSearch = SensorSearch;

package/dist/src/components/Sensor/SensorSort.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const SensorSort: React.FC;

package/dist/src/components/Sensor/SensorSort.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SensorSort = void 0;
+const react_1 = __importDefault(require("react"));
+const ReactiveComponent_1 = __importDefault(require("@appbaseio/reactivesearch/lib/components/basic/ReactiveComponent"));
+const hooks_1 = require("../../hooks");
+const debug = require("debug")("reactify-search:SensorSort");
+const SensorSort = () => {
+    const { options, config } = (0, hooks_1.useReactifySearchContext)();
+    const curation = (0, hooks_1.useCuration)();
+    const globalCuration = (curation === null || curation === void 0 ? void 0 : curation.id) === "global";
+    const { sortOption } = (0, hooks_1.useSortby)();
+    const searchQuery = react_1.default.useMemo(() => {
+        if (typeof window === "undefined")
+            return "";
+        const urlParams = new URLSearchParams(window.location.search);
+        return urlParams.get("q") || "";
+    }, []);
+    const { sort, query } = react_1.default.useMemo(() => {
+        return {
+            sort: buildSort({
+                config,
+                sortOption,
+                collection: options.mode === "collection" ? options.collection : undefined,
+                curation,
+                globalCuration,
+            }),
+            query: buildQuery({
+                sortOption,
+                curation,
+                globalCuration,
+            }),
+        };
+    }, [config, sortOption, curation]);
+    react_1.default.useEffect(() => {
+        debug("searchQuery", searchQuery);
+        debug("sort", sort);
+        debug("query", query);
+    }, [searchQuery, sort]);
+    return (react_1.default.createElement(ReactiveComponent_1.default, { componentId: "SensorSort", customQuery: () => ({
+            sort,
+            query,
+        }) }));
+};
+exports.SensorSort = SensorSort;
+const buildSort = (args) => {
+    var _a;
+    const { config, curation, sortOption, collection, globalCuration } = args;
+    debug("buildSortQuery.start", {
+        config,
+        curation,
+        sortOption,
+    });
+    // return default sort option if unset
+    if (!sortOption) {
+        return collection
+            ? mapCollectionPositionSortClause(collection)
+            : ["_score"];
+    }
+    // curation positions are only applied for the default `collections.position` or `_score` sort
+    // if the sort is something else, apply a normal sort which applies what the user has requested
+    if (!["_score", "collections.position"].includes(sortOption.field)) {
+        return [{ [sortOption.field]: sortOption.direction }];
+    }
+    // no matching curation, return default sort clause
+    if (!curation) {
+        return collection
+            ? mapCollectionPositionSortClause(collection)
+            : ["_score"];
+    }
+    const sorts = [];
+    // show pins first
+    if (globalCuration && collection) {
+        sorts.push(...mapCollectionPositionSortClause(collection));
+    }
+    else {
+        sorts.push({
+            "curations.position": {
+                unmapped_type: "long",
+                order: "asc",
+                nested: {
+                    path: "curations",
+                    filter: {
+                        term: {
+                            [`curations.${"collection" === curation.type
+                                ? "collectionHandle"
+                                : "searchTerm"}.keyword`]: "collection" === curation.type
+                                ? curation.collectionHandle
+                                : (_a = curation.searchTerm) === null || _a === void 0 ? void 0 : _a.toLowerCase(),
+                        },
+                    },
+                },
+            },
+        });
+    }
+    if (0 < curation.boosting.groupings.length) {
+        const groupings = curation.boosting.groupings.sort((a, b) => a.position > b.position ? 1 : -1);
+        for (const grouping of groupings) {
+            try {
+                const query = JSON.parse(grouping.query);
+                if (query)
+                    sorts.push(query);
+            }
+            catch (_b) {
+                console.error(`query could not be parsed for boost grouping`, grouping);
+            }
+        }
+    }
+    if (0 < curation.boosting.sortings.length) {
+        const sortings = curation.boosting.sortings.sort((a, b) => a.position > b.position ? 1 : -1);
+        for (const sorting of sortings) {
+            try {
+                const query = JSON.parse(sorting.query);
+                if (query)
+                    sorts.push(query);
+            }
+            catch (_c) {
+                console.error(`query could not be parsed for boost sorting`, sorting);
+            }
+        }
+    }
+    // finally, for collections, if no other sorting is defined, sort by index order to provide
+    // a consistent order
+    if ("collection" === curation.type && sorts.length === 0) {
+        sorts.push("_doc");
+    }
+    // finally, for search, sort by score
+    if ("search" === curation.type) {
+        sorts.push("_score");
+    }
+    return sorts;
+};
+/**
+ * Return a sort clause which sorts by position within the given collection.
+ */
+function mapCollectionPositionSortClause(collection) {
+    return [
+        {
+            "collections.position": {
+                order: "asc",
+                nested: {
+                    path: "collections",
+                    filter: {
+                        term: {
+                            "collections.handle.keyword": collection.handle,
+                        },
+                    },
+                },
+            },
+        },
+    ];
+}
+const buildQuery = (args) => {
+    var _a;
+    const { curation, sortOption, globalCuration } = args;
+    if (!curation || globalCuration) {
+        return undefined;
+    }
+    return {
+        bool: {
+            must_not: [
+                {
+                    nested: {
+                        path: "curations",
+                        query: {
+                            bool: {
+                                must: [
+                                    {
+                                        term: {
+                                            [`curations.${"collection" === curation.type
+                                                ? "collectionHandle"
+                                                : "searchTerm"}.keyword`]: "collection" === curation.type
+                                                ? curation.collectionHandle
+                                                : (_a = curation.searchTerm) === null || _a === void 0 ? void 0 : _a.toLowerCase(),
+                                        },
+                                    },
+                                    {
+                                        term: {
+                                            "curations.hidden": true,
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+                // hide callout when not sorting by _score or collections.position
+                ...(sortOption &&
+                    !["_score", "collections.position"].includes(sortOption.field)
+                    ? [
+                        {
+                            term: {
+                                type: "callout",
+                            },
+                        },
+                    ]
+                    : []),
+            ],
+        },
+    };
+};

package/dist/src/components/Sensor/SensorSortScore.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const SensorSortScore: React.FC;

package/dist/src/components/Sensor/SensorSortScore.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SensorSortScore = void 0;
+const react_1 = __importDefault(require("react"));
+const ReactiveComponent_1 = __importDefault(require("@appbaseio/reactivesearch/lib/components/basic/ReactiveComponent"));
+const SensorSortScore = () => (react_1.default.createElement(ReactiveComponent_1.default, { componentId: "SensorSortScore", customQuery: () => ({
+        sort: { _score: "desc" },
+    }) }));
+exports.SensorSortScore = SensorSortScore;

package/dist/src/components/Sensor/SensorStack.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+export declare type SensorStackProps = {};
+export declare const SensorStack: React.FC<SensorStackProps>;

package/dist/src/components/Sensor/SensorStack.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SensorStack = void 0;
+const react_1 = __importDefault(require("react"));
+const hooks_1 = require("../../hooks");
+const SensorSort_1 = require("./SensorSort");
+const SensorSearch_1 = require("./SensorSearch");
+const SensorSortScore_1 = require("./SensorSortScore");
+const SensorPublished_1 = require("./SensorPublished");
+const SensorCollection_1 = require("./SensorCollection");
+const SensorInventoryAvailable_1 = require("./SensorInventoryAvailable");
+const SensorStack = () => {
+    const { options } = (0, hooks_1.useReactifySearchContext)();
+    // instant search mode
+    if (options.mode === "instant-search") {
+        return (react_1.default.createElement(react_1.default.Fragment, null,
+            react_1.default.createElement(SensorPublished_1.SensorPublished, null),
+            react_1.default.createElement(SensorSortScore_1.SensorSortScore, null)));
+    }
+    // result grid mode
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement(SensorSort_1.SensorSort, null),
+        react_1.default.createElement(SensorSearch_1.SensorSearch, null),
+        react_1.default.createElement(SensorPublished_1.SensorPublished, null),
+        react_1.default.createElement(SensorCollection_1.SensorCollection, null),
+        react_1.default.createElement(SensorInventoryAvailable_1.SensorInventoryAvailable, null)));
+};
+exports.SensorStack = SensorStack;

package/dist/src/components/Sensor/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./SensorSort";
+export * from "./SensorSearch";
+export * from "./SensorPublished";
+export * from "./SensorSortScore";
+export * from "./SensorCollection";
+export * from "./SensorInventoryAvailable";
+export * from "./SensorStack";
+export declare const SENSOR_IDS: string[];

package/dist/src/components/Sensor/index.js

@@ -0,0 +1,29 @@
+"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 });
+exports.SENSOR_IDS = void 0;
+__exportStar(require("./SensorSort"), exports);
+__exportStar(require("./SensorSearch"), exports);
+__exportStar(require("./SensorPublished"), exports);
+__exportStar(require("./SensorSortScore"), exports);
+__exportStar(require("./SensorCollection"), exports);
+__exportStar(require("./SensorInventoryAvailable"), exports);
+__exportStar(require("./SensorStack"), exports);
+// this is consumed by the react prop in various components
+exports.SENSOR_IDS = [
+    "SensorSort",
+    "SensorSearch",
+    "SensorSortScore",
+    "SensorPublished",
+    "SensorCollection",
+    "SensorInventoryAvailable",
+];

package/dist/src/components/Sortby/Sortby.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { useSortby } from "../../hooks";
+export declare type SortbyProps = {
+    /** Render method called once for all sort options */
+    renderSortOptions?: React.FC<ReturnType<typeof useSortby>>;
+};
+export declare const Sortby: React.FC<SortbyProps>;

package/dist/src/components/Sortby/Sortby.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sortby = void 0;
+const react_1 = __importDefault(require("react"));
+const hooks_1 = require("../../hooks");
+const components_1 = require("../../components");
+const Sortby = (props) => {
+    var _a;
+    const sortbyData = (0, hooks_1.useSortby)();
+    const RenderSortOptionsComponent = (_a = props.renderSortOptions) !== null && _a !== void 0 ? _a : components_1.ExampleSortby;
+    return (react_1.default.createElement(RenderSortOptionsComponent, Object.assign({}, sortbyData)));
+};
+exports.Sortby = Sortby;

package/dist/src/components/Sortby/index.d.ts

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

package/dist/src/components/Sortby/index.js

@@ -0,0 +1,13 @@
+"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("./Sortby"), exports);

package/dist/src/components/Utility/UtilityAuthenticatedReactiveBase.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const UtilityAuthenticatedReactiveBase: React.FC;

package/dist/src/components/Utility/UtilityAuthenticatedReactiveBase.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UtilityAuthenticatedReactiveBase = void 0;
+const react_1 = __importDefault(require("react"));
+const hooks_1 = require("../../hooks");
+const ReactiveBase_1 = __importDefault(require("@appbaseio/reactivesearch/lib/components/basic/ReactiveBase"));
+const UtilityAuthenticatedReactiveBase = ({ children }) => {
+    const props = (0, hooks_1.useReactiveBaseProps)();
+    return react_1.default.createElement(ReactiveBase_1.default, Object.assign({}, props), children);
+};
+exports.UtilityAuthenticatedReactiveBase = UtilityAuthenticatedReactiveBase;

package/dist/src/components/Utility/index.d.ts

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

package/dist/src/components/Utility/index.js

@@ -0,0 +1,13 @@
+"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("./UtilityAuthenticatedReactiveBase"), exports);

package/dist/src/components/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./Example";
+export * from "./Filter";
+export * from "./ReactifySearchBase";
+export * from "./Result";
+export * from "./Search";
+export * from "./Sensor";
+export * from "./Sortby";
+export * from "./Utility";

package/dist/src/components/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("./Example"), exports);
+__exportStar(require("./Filter"), exports);
+__exportStar(require("./ReactifySearchBase"), exports);
+__exportStar(require("./Result"), exports);
+__exportStar(require("./Search"), exports);
+__exportStar(require("./Sensor"), exports);
+__exportStar(require("./Sortby"), exports);
+__exportStar(require("./Utility"), exports);

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

@@ -0,0 +1,14 @@
+export * from "./reactivesearch";
+export * from "./useSortby";
+export * from "./usePagination";
+export * from "./usePaginationLoadMore";
+export * from "./useSearch";
+export * from "./useFilters";
+export * from "./useCuration";
+export * from "./useAnalytics";
+export * from "./useFilterStack";
+export * from "./useProductPrice";
+export * from "./useFilterListProps";
+export * from "./useFilterCollapsedState";
+export * from "./useConfig";
+export * from "./useReactifySearchContext";