@usereactify/search 2.1.0-beta.0 → 2.1.0-beta.4

package/dist/sensor/SensorCollection.js

@@ -0,0 +1,41 @@
+"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 collection = (0, hooks_1.useCollection)();
+    if (!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": collection.handle },
+                                },
+                            },
+                        },
+                        {
+                            nested: {
+                                path: "curations",
+                                query: {
+                                    term: {
+                                        "curations.collectionHandle.keyword": collection.handle,
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                },
+            },
+        }) }));
+};
+exports.SensorCollection = SensorCollection;

package/dist/sensor/SensorInventoryAvailable.d.ts

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

package/dist/sensor/SensorInventoryAvailable.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.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: {
+                nested: {
+                    path: "variants",
+                    query: {
+                        match: { "variants.available": true },
+                    },
+                },
+            },
+        }) }));
+};
+exports.SensorInventoryAvailable = SensorInventoryAvailable;

package/dist/sensor/SensorPublished.d.ts

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

package/dist/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/sensor/SensorSearch.d.ts

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

package/dist/sensor/SensorSearch.js

@@ -0,0 +1,81 @@
+"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 { fields } = (0, hooks_1.useConfig)();
+    const { searchQuery } = (0, hooks_1.useSearch)();
+    // ignore search fields only set for instant search
+    const searchFields = react_1.default.useMemo(() => fields.filter((field) => ["always_search", "search_page"].includes(field.searchType)), []);
+    if (!searchQuery)
+        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/sensor/SensorSort.d.ts

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

package/dist/sensor/SensorSort.js

@@ -0,0 +1,144 @@
+"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 config = (0, hooks_1.useConfig)();
+    const curation = (0, hooks_1.useCuration)();
+    const { sortOption } = (0, hooks_1.useSort)();
+    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, curation, sortOption),
+            query: buildQuery(curation),
+        };
+    }, [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 = (config, curation, sortState) => {
+    var _a;
+    debug("buildSortQuery.start", {
+        config,
+        curation,
+        sortState,
+    });
+    // return default collection position if unset
+    if (!sortState) {
+        return [{ "collections.position": "asc" }];
+    }
+    // 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 (!["collections.position", "_score"].includes(sortState.field)) {
+        return [{ [sortState.field]: sortState.direction }];
+    }
+    // no matching curation, return default sort order
+    if (!curation) {
+        return [{ [sortState.field]: sortState.direction }];
+    }
+    const sorts = [];
+    // show pins first
+    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, sort by elastic score or index order
+    // using index order ensures a consistent output order for queries which don't really
+    // use a relevance score like collections
+    if ("collection" === curation.type)
+        sorts.push("_doc");
+    else
+        sorts.push("_score");
+    return sorts;
+};
+const buildQuery = (curation) => {
+    var _a;
+    if (!curation)
+        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,
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+        },
+    };
+};

package/dist/sensor/SensorSortScore.d.ts

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

package/dist/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/sensor/SensorStack.d.ts

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

package/dist/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 { instantSearch } = (0, hooks_1.useSearch)();
+    // instant search mode
+    if (instantSearch) {
+        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/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/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/types/config.d.ts

@@ -0,0 +1,130 @@
+export interface Config {
+    sort: ConfigSort[];
+    fields: ConfigField[];
+    filters: ConfigFilter[];
+    curations: ConfigCuration[];
+    redirects: ConfigRedirect[];
+}
+export interface ConfigSort {
+    id: string;
+    name: string;
+    field: string;
+    position: number;
+    visibility: string;
+    direction: "asc" | "desc";
+}
+export interface ConfigField {
+    id: string;
+    field: string;
+    importance: number;
+    searchType: "always_search" | "search_page" | "instant_search";
+}
+export interface ConfigFilter {
+    id: string;
+    name: string;
+    type: string;
+    pageSize: number;
+    defaultSort: string;
+    paginationType: "pagination" | "load_more" | "next_prev" | "infinite_scroll";
+    options: ConfigFilterOption[];
+    inventoryVisibility: "show_all" | "hide_products" | "hide_variants" | "hide_all";
+}
+export interface ConfigFilterOption {
+    id: string;
+    name: string;
+    field: string;
+    position: number;
+    displaySize: string;
+    displaySliderStep: string;
+    displaySliderInterval: string;
+    displayView: ConfigFilterOptionDisplayView;
+    displayType: ConfigFilterOptionDisplayType;
+    settingsShowMore: boolean;
+    settingsUppercase: boolean;
+    settingsShowFilter: boolean;
+    settingsShowSearch: boolean;
+    settingsHideUnavailable: boolean;
+    settingsCollapsedMobile: boolean;
+    settingsCollapsedDesktop: boolean;
+    valuesShow: string;
+    valuesExclude: string[];
+    valuesManual: string[];
+}
+export declare type ConfigFilterOptionDisplayView = "list" | "check" | "box" | "swatch";
+export declare type ConfigFilterOptionDisplayType = "multi" | "single" | "range" | "slider";
+export interface ConfigCuration {
+    id: string;
+    title: string;
+    status: string;
+    published: boolean;
+    searchTerm?: string;
+    collectionHandle?: string;
+    type: "collection" | "search";
+    boosting: {
+        groupings: ConfigBoostGrouping[];
+        sortings: ConfigBoostSorting[];
+    };
+    callouts?: ConfigCallout[];
+}
+export interface ConfigBoostGrouping {
+    key: string;
+    value: string;
+    field: string;
+    query: string;
+    position: number;
+    operation: string;
+}
+export interface ConfigBoostSorting {
+    key: string;
+    field: string;
+    query: string;
+    position: number;
+    direction: string;
+}
+export interface ConfigCallout {
+    id: string;
+    link: string;
+    title: string;
+    type: "callout";
+    content: string;
+    position: number;
+    textColor: string;
+    mobileImage: string;
+    mobileVideo: string;
+    desktopVideo: string;
+    desktopImage: string;
+    backgroundColor: string;
+    visibility: "desktop" | "mobile" | "all";
+    displayColumns: string;
+    displayRows: string;
+}
+export interface ConfigRedirect {
+    id: string;
+    url: string;
+    query: string;
+}
+export interface ConfigCredentials {
+    username: string;
+    password: string;
+    endpoint: string;
+}
+interface ConfigThemeTypography {
+    fontFamily?: string;
+    fontSize?: string;
+}
+interface ConfigThemeColors {
+    alertColor?: string;
+    backgroundColor?: string;
+    borderColor?: string;
+    extColor?: string;
+    primaryTextColor?: string;
+    primaryColor?: string;
+    textColor?: string;
+    titleColor?: string;
+}
+export interface ConfigTheme {
+    typography?: ConfigThemeTypography;
+    colors?: ConfigThemeColors;
+    component?: any;
+}
+export {};

package/dist/types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -0,0 +1,79 @@
+export * from "./config";
+export * from "./results";
+import { Hit, Product } from "./results";
+export interface ReactivesearchFilterProps {
+    loading: boolean;
+    error: Error | null;
+    handleChange: () => void;
+    data: {
+        doc_count: number;
+        key: string;
+    }[];
+    value: string | {
+        [key: string]: boolean;
+    };
+}
+export interface ReactivesearchPaginationProps {
+    pages: number;
+    showEndPage: false;
+    totalPages: number;
+    currentPage: number;
+    setPage: (page: number) => void;
+}
+export interface ReactivesearchResultProps<T = Product> {
+    error?: ReactivesearchError;
+    loading: boolean;
+    data: (Hit & T)[];
+    loadMore: () => void;
+    customData: unknown;
+    promotedData: unknown;
+    aggregationData: unknown;
+    rawData?: {
+        _shards: {
+            failed: number;
+            skipped: number;
+            successful: number;
+            total: number;
+        };
+        took: number;
+        status: number;
+        timed_out: boolean;
+        hits: Hit & {
+            _source: T;
+        };
+    };
+    resultStats: {
+        time: number;
+        hidden: number;
+        promoted: number;
+        currentPage: number;
+        numberOfPages: number;
+        numberOfResults?: number;
+        displayedResults: number;
+    };
+    streamData: unknown;
+    triggerAnalytics: unknown;
+    triggerClickAnalytics: unknown;
+}
+export interface ReactivesearchSearchStatePage {
+    isLoading: boolean;
+    hits: {
+        hidden: number;
+        time: number;
+        total: number;
+        hits: Hit & {
+            _source: Product;
+        };
+    };
+    resultStats: {
+        hidden: number;
+        numberOfResults?: number;
+        promoted: number;
+        time: number;
+    };
+    error?: ReactivesearchError;
+}
+export interface ReactivesearchError {
+    status: number;
+    statusText: string;
+}

package/dist/types/index.js

@@ -0,0 +1,14 @@
+"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("./config"), exports);
+__exportStar(require("./results"), exports);