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

package/dist/provider.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContext = exports.Provider = void 0;
+const react_1 = __importDefault(require("react"));
+const UtilityAuthenticatedReactiveBase_1 = require("./utility/UtilityAuthenticatedReactiveBase");
+const debug = require("debug")("reactify-search:Provider");
+const Context = react_1.default.createContext(undefined);
+const defaultCredentials = {
+    username: "guest",
+    password: "password",
+    endpoint: "https://api.search.reactify.app",
+};
+const Provider = (props) => {
+    var _a;
+    const { index, config, shopName, children, collection, instantSearch, filterStackId, noReactiveBase, enableCallouts, additionalComponentIds, } = props;
+    const credentials = (_a = props.credentials) !== null && _a !== void 0 ? _a : defaultCredentials;
+    const theme = props.theme || {
+        typography: {
+            fontFamily: "inherit",
+            fontSize: "inherit",
+        },
+        colors: {
+            textColor: "inherit",
+            primaryTextColor: "inherit",
+            primaryColor: "inherit",
+            titleColor: "inherit",
+            alertColor: "inherit",
+        },
+    };
+    react_1.default.useEffect(() => {
+        debug("props", props);
+    }, [props]);
+    // @todo make this hackable with a prop
+    // https://gitlab.com/reactifyapps/reactify-search-frontend/-/issues/1
+    const searchQueryFromURL = react_1.default.useMemo(() => {
+        var _a;
+        if (typeof window === "undefined")
+            return undefined;
+        const urlParams = new URLSearchParams(window.location.search);
+        return (_a = urlParams.get("q")) !== null && _a !== void 0 ? _a : undefined;
+    }, []);
+    const [searchQuery, setSearchQuery] = react_1.default.useState(searchQueryFromURL);
+    const [showInstantSearchResults, setShowInstantSearchResults] = react_1.default.useState(false);
+    const submitSearch = react_1.default.useCallback((localSearchQuery) => {
+        const actualSearchQuery = localSearchQuery !== null && localSearchQuery !== void 0 ? localSearchQuery : searchQuery;
+        if (!actualSearchQuery)
+            return;
+        const redirect = config.redirects.find((redirect) => redirect.query.trim().toLowerCase() ===
+            actualSearchQuery.trim().toLowerCase());
+        if (redirect)
+            window.location.href = redirect.url;
+        else
+            window.location.href = `/search?q=${actualSearchQuery}`;
+    }, [searchQuery]);
+    const { sortOption, sortOptions, setSortOption } = useSortState(config, collection);
+    // do not attempt to resolve a filter stack if in instantSearch mode
+    const filterStack = instantSearch
+        ? undefined
+        : useFilterStack(config, collection, filterStackId);
+    const curation = useCuration(config, collection, searchQuery);
+    const contextValue = react_1.default.useMemo(() => ({
+        index,
+        config,
+        shopName,
+        collection,
+        credentials,
+        searchQuery,
+        filterStack,
+        sortOption,
+        sortOptions,
+        submitSearch,
+        setSortOption,
+        setSearchQuery,
+        setShowInstantSearchResults,
+        theme,
+        curation,
+        enableCallouts,
+        additionalComponentIds,
+        instantSearch: !!instantSearch,
+        showInstantSearchResults: !!showInstantSearchResults && !!searchQuery,
+    }), [
+        index,
+        config,
+        curation,
+        shopName,
+        collection,
+        credentials,
+        searchQuery,
+        filterStack,
+        sortOption,
+        sortOptions,
+        submitSearch,
+        instantSearch,
+        enableCallouts,
+        additionalComponentIds,
+        showInstantSearchResults,
+        theme,
+    ]);
+    react_1.default.useEffect(() => {
+        debug("contextValue", contextValue);
+    }, [contextValue]);
+    if (noReactiveBase) {
+        return react_1.default.createElement(Context.Provider, { value: contextValue }, children);
+    }
+    return (react_1.default.createElement(Context.Provider, { value: contextValue },
+        react_1.default.createElement(UtilityAuthenticatedReactiveBase_1.UtilityAuthenticatedReactiveBase, null, children)));
+};
+exports.Provider = Provider;
+const useContext = () => react_1.default.useContext(Context);
+exports.useContext = useContext;
+const useSortState = (config, collection) => {
+    const sortOptions = react_1.default.useMemo(() => {
+        const type = !!collection ? "collection" : "search";
+        return config.sort
+            .sort((a, b) => `${a.position}`.localeCompare(`${b.position}`))
+            .filter(({ visibility }) => ["all", type].includes(visibility));
+    }, [config, collection]);
+    const [sortOptionState, setSortOptionState] = react_1.default.useState(sortOptions[0].id);
+    const sortOption = react_1.default.useMemo(() => sortOptions.find(({ id }) => id === sortOptionState) || sortOptions[0], [sortOptions, sortOptionState]);
+    const setSortOption = react_1.default.useCallback((sortOptionId) => setSortOptionState(sortOptionId), []);
+    return react_1.default.useMemo(() => ({ sortOptions, sortOption, setSortOption }), [sortOption, sortOptions, setSortOption]);
+};
+// resolve the "filter" in use for this view
+// Reactify Search confusingly refers to the entire list of filters as a "filter"
+// and each filter within that list is called a "Filter Option"
+// @todo we need a better name for the overall page like "Filter Stack" or something,
+// each block is then called a filter so like Size would be a "Filter" and then each
+// value within it is a "Filter Option"
+const useFilterStack = (config, collection, filterStackId) => react_1.default.useMemo(() => {
+    var _a;
+    // manually select filter stack by ID if provided
+    if (filterStackId) {
+        const filterStack = config.filters.find((filter) => filterStackId === filter.id);
+        if (filterStack)
+            return filterStack;
+    }
+    const type = !!collection ? "collection" : "search";
+    return ((_a = config.filters.find((filter) => type === filter.type)) !== null && _a !== void 0 ? _a : config.filters[0]);
+}, [config, collection]);
+const useCuration = (config, collection, searchQuery) => react_1.default.useMemo(() => {
+    debug("resolveCuration.start", { config, collection, searchQuery });
+    const type = collection ? "collection" : "search";
+    const handleOrSearchTerm = collection
+        ? collection.handle
+        : searchQuery !== null && searchQuery !== void 0 ? searchQuery : "";
+    const normalisedHandleOrSearchTerm = handleOrSearchTerm
+        .toLowerCase()
+        .trim();
+    const curation = config.curations.find((curation) => {
+        var _a, _b;
+        const normalisedSearchTerm = (_a = curation.searchTerm) === null || _a === void 0 ? void 0 : _a.toLowerCase().trim();
+        const normalisedCollectionHandle = (_b = curation.collectionHandle) === null || _b === void 0 ? void 0 : _b.toLowerCase().trim();
+        if ("search" === type)
+            return ("search" === curation.type &&
+                normalisedHandleOrSearchTerm === normalisedSearchTerm);
+        if ("collection" === type)
+            return ("collection" === curation.type &&
+                normalisedHandleOrSearchTerm === normalisedCollectionHandle);
+        return false;
+    });
+    return curation ? curation : undefined;
+}, [config, collection, searchQuery]);

package/dist/result/ResultCard.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { Product } from "../types";
+import { useProductPrice } from "../hooks";
+declare type Props = {
+    product: Product;
+    pagePosition: number;
+    render?: (props: Omit<Props, "render"> & ReturnType<typeof useProductPrice>) => JSX.Element;
+};
+export declare const ResultCard: React.FC<Props>;
+export {};

package/dist/result/ResultCard.js

@@ -0,0 +1,45 @@
+"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.ResultCard = void 0;
+const react_1 = __importDefault(require("react"));
+const hooks_1 = require("../hooks");
+const ResultCard = (_a) => {
+    var { render } = _a, props = __rest(_a, ["render"]);
+    const { product } = props;
+    const productPrice = (0, hooks_1.useProductPrice)(product);
+    if (render)
+        return render(Object.assign(Object.assign({}, props), productPrice));
+    const { formattedPrice, formattedCompareAtPrice, onSale } = productPrice;
+    const { track } = (0, hooks_1.useAnalytics)();
+    const handleClick = react_1.default.useCallback((e) => {
+        e.preventDefault();
+        const { id } = product;
+        console.log("tracking click product event");
+        track({
+            eventName: "select_item",
+            id,
+        }).then(() => {
+            console.log("tracking click product event finished");
+            window.location.href = `/products/${product.handle}`;
+        });
+    }, [track, product]);
+    return (react_1.default.createElement("article", null,
+        react_1.default.createElement("a", { onClick: handleClick }, product.title),
+        react_1.default.createElement("span", null, formattedPrice),
+        onSale && (react_1.default.createElement("span", { style: { textDecoration: "line-through" } }, formattedCompareAtPrice))));
+};
+exports.ResultCard = ResultCard;

package/dist/result/ResultCardCallout.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { ConfigCallout } from "../types";
+declare type Props = {
+    callout: ConfigCallout;
+    pagePosition: number;
+    render?: (props: Omit<Props, "render">) => JSX.Element;
+};
+export declare const ResultCardCallout: React.FC<Props>;
+export {};

package/dist/result/ResultCardCallout.js

@@ -0,0 +1,38 @@
+"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.ResultCardCallout = void 0;
+const react_1 = __importDefault(require("react"));
+const ResultCardCallout = (props) => {
+    const { callout } = props;
+    const styleProp = react_1.default.useMemo(() => {
+        var _a, _b;
+        return ({
+            gridRow: `span ${(_a = callout.displayRows) !== null && _a !== void 0 ? _a : 1}`,
+            gridColumn: `span ${(_b = callout.displayColumns) !== null && _b !== void 0 ? _b : 1}`,
+        });
+    }, [callout]);
+    return (react_1.default.createElement("article", { style: styleProp },
+        react_1.default.createElement(ResultCardCalloutInner, Object.assign({}, props))));
+};
+exports.ResultCardCallout = ResultCardCallout;
+const ResultCardCalloutInner = (_a) => {
+    var { render } = _a, props = __rest(_a, ["render"]);
+    const { callout } = props;
+    if (render)
+        return render(props);
+    return react_1.default.createElement("p", null, callout.title);
+};

package/dist/result/ResultList.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+import { ResultCard } from "./ResultCard";
+import { ResultPagination } from "./ResultPagination";
+import { ResultCardCallout } from "./ResultCardCallout";
+import { ResultLoadMoreButton } from "./ResultLoadMoreButton";
+import { ResultPaginationNextPrev } from "./ResultPaginationNextPrev";
+import { ResultCombined, ReactivesearchError, ReactivesearchResultProps } from "../types";
+declare type ResultProps = ReactivesearchResultProps & {
+    results: ResultCombined[];
+};
+declare type Props = {
+    pageSize?: number;
+    gridColumns?: number;
+    listClassName?: string;
+    renderLoading?: () => JSX.Element | null;
+    renderNoResults?: () => JSX.Element | null;
+    renderResultCard?: Parameters<typeof ResultCard>[0]["render"];
+    renderPagination?: Parameters<typeof ResultPagination>[0]["render"];
+    renderResultCardCallout?: Parameters<typeof ResultCardCallout>[0]["render"];
+    renderAfter?: (props: ResultProps) => JSX.Element | null;
+    renderBefore?: (props: ResultProps) => JSX.Element | null;
+    renderResults?: (props: ResultProps) => JSX.Element | null;
+    renderError?: (props: {
+        error: ReactivesearchError;
+    }) => JSX.Element | null;
+    renderLoadMoreButton?: Parameters<typeof ResultLoadMoreButton>[0]["render"];
+    renderPaginationNextPrev?: Parameters<typeof ResultPaginationNextPrev>[0]["render"];
+};
+export declare const ResultList: React.FC<Props>;
+export {};

package/dist/result/ResultList.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultList = void 0;
+const react_1 = __importDefault(require("react"));
+const ReactiveList_1 = __importDefault(require("@appbaseio/reactivesearch/lib/components/result/ReactiveList"));
+const ResultCard_1 = require("./ResultCard");
+const ResultPagination_1 = require("./ResultPagination");
+const ResultCardCallout_1 = require("./ResultCardCallout");
+const ResultLoadMoreButton_1 = require("./ResultLoadMoreButton");
+const ResultPaginationNextPrev_1 = require("./ResultPaginationNextPrev");
+const provider_1 = require("../provider");
+const hooks_1 = require("../hooks");
+const ResultList = (props) => {
+    var _a, _b;
+    const { pageSize } = props;
+    const curation = (0, hooks_1.useCuration)();
+    const { enableCallouts } = (0, provider_1.useContext)();
+    const reactiveResultListProps = (0, hooks_1.useReactiveResultListProps)({
+        pageSize,
+        pageSizeAdjust: enableCallouts ? (_b = (_a = curation === null || curation === void 0 ? void 0 : curation.callouts) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0 : 0,
+    });
+    return (react_1.default.createElement(ReactiveList_1.default, Object.assign({}, reactiveResultListProps, { renderPagination: (reactivesearchPaginationProps) => (react_1.default.createElement(ResultPaginationInner, Object.assign({}, props, reactivesearchPaginationProps))), render: (reactivesearchResultProps) => (react_1.default.createElement(ResultListInner, Object.assign({}, props, { reactivesearchResultProps: reactivesearchResultProps }))) })));
+};
+exports.ResultList = ResultList;
+const ResultListInner = (props) => {
+    var _a;
+    const { gridColumns, renderError, renderAfter, renderBefore, renderLoading, listClassName, renderResults, renderNoResults, renderResultCard, renderLoadMoreButton, renderResultCardCallout, reactivesearchResultProps, } = props;
+    const curation = (0, hooks_1.useCuration)();
+    const filterStack = (0, hooks_1.useFilterStack)();
+    const { instantSearch } = (0, hooks_1.useSearch)();
+    const { enableCallouts } = (0, provider_1.useContext)();
+    const initialSearchHasRun = react_1.default.useMemo(() => "undefined" !==
+        typeof reactivesearchResultProps.resultStats.numberOfResults, [reactivesearchResultProps]);
+    const combinedResults = (0, hooks_1.useCombinedResults)({
+        callouts: (_a = curation === null || curation === void 0 ? void 0 : curation.callouts) !== null && _a !== void 0 ? _a : [],
+        products: reactivesearchResultProps.data,
+    });
+    const resultProps = react_1.default.useMemo(() => {
+        return Object.assign(Object.assign({}, reactivesearchResultProps), { results: combinedResults });
+    }, [combinedResults, reactivesearchResultProps]);
+    const styleProp = react_1.default.useMemo(() => !!enableCallouts
+        ? {
+            display: "grid",
+            gridTemplateColumns: `repeat(${gridColumns !== null && gridColumns !== void 0 ? gridColumns : 4}, minmax(0, 1fr))`,
+        }
+        : {}, [curation]);
+    if (reactivesearchResultProps.error) {
+        if (renderError)
+            return renderError({ error: reactivesearchResultProps.error });
+        return react_1.default.createElement("div", null,
+            "Error: ",
+            reactivesearchResultProps.error.statusText);
+    }
+    if (!initialSearchHasRun) {
+        if (renderLoading)
+            return renderLoading();
+        return react_1.default.createElement("div", null, "Loading...");
+    }
+    if (!reactivesearchResultProps.resultStats.numberOfResults) {
+        if (renderNoResults)
+            return renderNoResults();
+        return react_1.default.createElement("div", null, "No results");
+    }
+    if (renderResults) {
+        return renderResults(resultProps);
+    }
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        renderBefore && renderBefore(resultProps),
+        react_1.default.createElement("section", { className: listClassName, style: styleProp }, combinedResults.map((result, key) => {
+            if ("product" === result.type) {
+                return (react_1.default.createElement(ResultCard_1.ResultCard, { product: result.data, pagePosition: key + 1, render: renderResultCard, key: `product-${result.data._id}` }));
+            }
+            if (!!enableCallouts && "callout" === result.type) {
+                return (react_1.default.createElement(ResultCardCallout_1.ResultCardCallout, { callout: result.data, pagePosition: key + 1, render: renderResultCardCallout, key: `callout-${result.data.id}` }));
+            }
+            return null;
+        })),
+        !instantSearch && "load_more" === (filterStack === null || filterStack === void 0 ? void 0 : filterStack.paginationType) && (react_1.default.createElement(ResultLoadMoreButton_1.ResultLoadMoreButton, Object.assign({}, reactivesearchResultProps, { render: renderLoadMoreButton }))),
+        renderAfter && renderAfter(resultProps)));
+};
+const ResultPaginationInner = (props) => {
+    const { renderPagination, renderPaginationNextPrev } = props;
+    const filterStack = (0, hooks_1.useFilterStack)();
+    const { instantSearch } = (0, hooks_1.useSearch)();
+    // do not show pagination in instant search mode
+    if (instantSearch)
+        return null;
+    // load more button is rendered inside the main render prop, as the loadMore prop is not available in renderPagination
+    if ("load_more" === (filterStack === null || filterStack === void 0 ? void 0 : filterStack.paginationType)) {
+        return null;
+    }
+    if ("next_prev" === (filterStack === null || filterStack === void 0 ? void 0 : filterStack.paginationType)) {
+        return (react_1.default.createElement(ResultPaginationNextPrev_1.ResultPaginationNextPrev, Object.assign({}, props, { render: renderPaginationNextPrev })));
+    }
+    return react_1.default.createElement(ResultPagination_1.ResultPagination, Object.assign({}, props, { render: renderPagination }));
+};

package/dist/result/ResultLoadMoreButton.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import { ReactivesearchResultProps } from "../types";
+declare type Props = ReactivesearchResultProps & {
+    render?: (props: Omit<Props, "render"> & {
+        hasMore: boolean;
+    }) => JSX.Element;
+};
+export declare const ResultLoadMoreButton: React.FC<Props>;
+export {};

package/dist/result/ResultLoadMoreButton.js

@@ -0,0 +1,27 @@
+"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.ResultLoadMoreButton = void 0;
+const react_1 = __importDefault(require("react"));
+const ResultLoadMoreButton = (_a) => {
+    var { render } = _a, props = __rest(_a, ["render"]);
+    const { resultStats, loadMore } = props;
+    const hasMore = react_1.default.useMemo(() => resultStats.displayedResults !== resultStats.numberOfResults, [resultStats]);
+    if (render)
+        return render(Object.assign(Object.assign({}, props), { hasMore }));
+    return react_1.default.createElement("button", { onClick: () => loadMore() }, "Load more");
+};
+exports.ResultLoadMoreButton = ResultLoadMoreButton;

package/dist/result/ResultPagination.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { usePages } from "../hooks";
+import { ReactivesearchPaginationProps } from "../types";
+declare type Props = ReactivesearchPaginationProps & {
+    render?: (props: Omit<Props, "render"> & ReturnType<typeof usePages>) => JSX.Element;
+};
+export declare const ResultPagination: React.FC<Props>;
+export {};

package/dist/result/ResultPagination.js

@@ -0,0 +1,50 @@
+"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.ResultPagination = void 0;
+const react_1 = __importDefault(require("react"));
+const hooks_1 = require("../hooks");
+const ResultPagination = (_a) => {
+    var { render } = _a, props = __rest(_a, ["render"]);
+    const pageProps = (0, hooks_1.usePages)(props);
+    if (render)
+        return render(Object.assign(Object.assign({}, props), pageProps));
+    const { pagesToShow, buildPagePath } = pageProps;
+    const { currentPage, totalPages, setPage } = props;
+    const handlePageChange = react_1.default.useCallback((event, newPage) => {
+        event.preventDefault();
+        setPage(newPage);
+    }, [setPage]);
+    if (!totalPages)
+        return null;
+    return (react_1.default.createElement("nav", null,
+        currentPage > 0 && (react_1.default.createElement("a", { rel: "prev", href: buildPagePath(currentPage), onClick: (event) => handlePageChange(event, currentPage - 1) }, "Prev")),
+        !pagesToShow.includes(0) && (react_1.default.createElement("a", { href: buildPagePath(1), onClick: (event) => handlePageChange(event, 0), rel: 0 === currentPage - 1 ? `prev` : undefined }, "1")),
+        !pagesToShow.includes(1) && react_1.default.createElement("span", null, "..."),
+        pagesToShow.map((page) => page === currentPage ? (react_1.default.createElement("span", { key: page + 1 }, page + 1)) : (react_1.default.createElement("a", { key: page + 1, href: buildPagePath(page + 1), onClick: (event) => handlePageChange(event, page), rel: page === currentPage + 1
+                ? `next`
+                : page === currentPage - 1
+                    ? `prev`
+                    : undefined }, page + 1))),
+        !pagesToShow.includes(totalPages - 2) && react_1.default.createElement("span", null, "..."),
+        !pagesToShow.includes(totalPages - 1) && (react_1.default.createElement("a", { href: buildPagePath(totalPages), onClick: (event) => handlePageChange(event, totalPages - 1), rel: totalPages - 1 === currentPage + 1
+                ? `next`
+                : totalPages - 1 === currentPage - 1
+                    ? `prev`
+                    : undefined }, totalPages)),
+        currentPage + 1 < totalPages && (react_1.default.createElement("a", { rel: "next", href: buildPagePath(currentPage + 2), onClick: (event) => handlePageChange(event, currentPage + 1) }, "Next"))));
+};
+exports.ResultPagination = ResultPagination;

package/dist/result/ResultPaginationNextPrev.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import { usePages } from "../hooks";
+import { ReactivesearchPaginationProps } from "../types";
+declare type Props = ReactivesearchPaginationProps & {
+    render?: (props: Omit<Props, "render"> & ReturnType<typeof usePages>) => JSX.Element;
+};
+export declare const ResultPaginationNextPrev: React.FC<Props>;
+export {};

package/dist/result/ResultPaginationNextPrev.js

@@ -0,0 +1,30 @@
+"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.ResultPaginationNextPrev = void 0;
+const react_1 = __importDefault(require("react"));
+const hooks_1 = require("../hooks");
+const ResultPaginationNextPrev = (_a) => {
+    var { render } = _a, props = __rest(_a, ["render"]);
+    const pageProps = (0, hooks_1.usePages)(props);
+    if (render)
+        return render(Object.assign(Object.assign({}, props), pageProps));
+    const { hasNextPage, buildPagePath, handleNextPage, hasPreviousPage, actualCurrentPage, handlePreviousPage, } = pageProps;
+    return (react_1.default.createElement("nav", null,
+        hasPreviousPage && (react_1.default.createElement("a", { rel: "prev", onClick: handlePreviousPage, href: buildPagePath(actualCurrentPage - 1) }, "Prev")),
+        hasNextPage && (react_1.default.createElement("a", { rel: "next", onClick: handleNextPage, href: buildPagePath(actualCurrentPage + 1) }, "Next"))));
+};
+exports.ResultPaginationNextPrev = ResultPaginationNextPrev;

package/dist/result/ResultStateProvider.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { ReactivesearchSearchStatePage } from "../types";
+declare type Props = {
+    render: (props: ReactivesearchSearchStatePage) => JSX.Element | null;
+};
+export declare const ResultStateProvider: React.FC<Props>;
+export {};

package/dist/result/ResultStateProvider.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultStateProvider = void 0;
+const react_1 = __importDefault(require("react"));
+const StateProvider_1 = __importDefault(require("@appbaseio/reactivesearch/lib/components/basic/StateProvider"));
+const ResultStateProvider = ({ render }) => (react_1.default.createElement(StateProvider_1.default, { componentIds: ["page"], includeKeys: ["isLoading", "hits", "resultStats", "error"], render: (state) => render(state.searchState.page) }));
+exports.ResultStateProvider = ResultStateProvider;

package/dist/result/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./ResultList";
+export * from "./ResultCard";
+export * from "./ResultPagination";
+export * from "./ResultStateProvider";
+export * from "./ResultLoadMoreButton";

package/dist/result/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("./ResultList"), exports);
+__exportStar(require("./ResultCard"), exports);
+__exportStar(require("./ResultPagination"), exports);
+__exportStar(require("./ResultStateProvider"), exports);
+__exportStar(require("./ResultLoadMoreButton"), exports);

package/dist/search/SearchInput.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+declare type Props = {
+    debounce?: number;
+    placeholder?: string;
+    inputClassName?: string;
+};
+export declare const SearchInput: React.FC<Props>;
+export {};

package/dist/search/SearchInput.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchInput = 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 SearchInput = (props) => {
+    const { debounce, placeholder, inputClassName } = props;
+    const reactiveDataSearchProps = (0, hooks_1.useReactiveDataSearchProps)({
+        debounce,
+        placeholder,
+        inputClassName,
+    });
+    return react_1.default.createElement(DataSearch_1.default, Object.assign({}, reactiveDataSearchProps));
+};
+exports.SearchInput = SearchInput;

package/dist/search/index.d.ts

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

package/dist/search/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("./SearchInput"), exports);

package/dist/sensor/SensorCollection.d.ts

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