@211la/search-react 0.12.0 → 0.13.0

package/dist/index.js

@@ -0,0 +1,506 @@
+import * as React from 'react';
+import React__default, { useRef, useMemo, useState, useCallback, useEffect } from 'react';
+import { connectRefinementList, connectHits } from 'react-instantsearch-dom';
+import { createConnector } from 'react-instantsearch-core';
+import { GoogleApiWrapper, Map as Map$1, Marker, InfoWindow } from 'google-maps-react';
+import PlacesAutocomplete, { geocodeByAddress, getLatLng } from 'react-places-autocomplete';
+
+var trim = function (prefix, suffix, text) {
+    var start = 0;
+    var end = 0;
+    if (text.startsWith(prefix)) {
+        start = prefix.length;
+    }
+    if (text.endsWith(suffix)) {
+        end = suffix.length;
+    }
+    return text.slice(start, text.length - end);
+};
+
+/**
+ * makeConnectFieldSearch is a factory for connectors that filter by concrete fields.
+ * @param exact should the component search for the exact value. Otherwise it keeps all fields that contain the search text as a prefix.
+ * In the exact search "homeless" matches only homeless, not "homeless migrants".
+ * When filtering by prefix value, "homeless" matches "homeless migrants" too.
+ * @param type type of the field data. Can be a number (for example, year or zip code) or a string (agency name).
+ */
+var makeConnectFieldSearch = function (exact, type) {
+    return function (Component) {
+        var surround = function (value) { return value; };
+        var trimSurround = function (value) { return value; };
+        if (typeof exact !== 'undefined' && exact) {
+            if (typeof type !== 'undefined' && type === 'number') {
+                surround = function (value) { return value; };
+                trimSurround = function (value) { return value; };
+            }
+            else {
+                surround = function (value) { return "\"" + value + "\""; };
+                trimSurround = function (value) { return trim("\"", "\"", value); };
+            }
+        }
+        else {
+            surround = function (value) { return value + "*"; };
+            trimSurround = function (value) { return trim("", "*", value); };
+        }
+        return connectRefinementList(function (_a) {
+            _a.items; var refine = _a.refine, currentRefinement = _a.currentRefinement;
+            var onChange = function (value) {
+                if (value) {
+                    refine([surround(value)]);
+                }
+                else {
+                    refine([]);
+                }
+            };
+            var value = trimSurround(currentRefinement.length === 0 ? '' : currentRefinement[0]);
+            return (React.createElement(Component, { type: type || 'search', value: value, onChange: onChange }));
+        });
+    };
+};
+/**
+ * connectStringFieldSearch makes components to search a string field for all values that start with the given one.
+ */
+var connectStringFieldSearch = makeConnectFieldSearch(false, 'string');
+/**
+ * connectExactStringFieldSearch makes components to search a string field for the exact value.
+ */
+var connectExactStringFieldSearch = makeConnectFieldSearch(true, 'string');
+/**
+ * connectExactNumberFieldSearch makes components to search a number field for the exact value.
+ */
+var connectExactNumberFieldSearch = makeConnectFieldSearch(true, 'number');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __rest(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;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * connectGeolocation helps to make components that specify proximity to the given location.
+ * It deals with the refinement in format of {aroundLatLng:{lat:100.50, lng:100.20}, aroundRadius: 20}
+ * the aroundRadius is specified in miles.
+ * the aroundLatLng is an empty map if unspecified. It contains 'lat' and 'lng' number fields otherwise.
+ */
+var connectGeolocation = createConnector({
+    displayName: 'ConnectGeolocation',
+    getProvidedProps: function (props, searchState) {
+        var currentRefinement = {
+            aroundLatLng: searchState.aroundLatLng || {},
+            aroundRadius: searchState.aroundRadius || 0,
+        };
+        return __assign({ currentRefinement: currentRefinement }, props);
+    },
+    refine: function (props, searchState, nextRefinement) {
+        var aroundLatLng = nextRefinement.aroundLatLng, aroundRadius = nextRefinement.aroundRadius;
+        var stringifyLatLng = function (_a) {
+            var lat = _a.lat, lng = _a.lng;
+            return (typeof lat !== 'number' ? '' : lat + ", " + lng);
+        };
+        return __assign(__assign({}, searchState), { aroundLatLng: aroundLatLng
+                ? stringifyLatLng(aroundLatLng)
+                : searchState.aroundLatLng, aroundRadius: typeof aroundRadius !== 'undefined'
+                ? aroundRadius
+                : searchState.aroundRadius });
+    },
+    getSearchParameters: function (searchParameters, props, searchState) {
+        return searchParameters.setQueryParameters({
+            aroundLatLng: searchState.aroundLatLng,
+            aroundRadius: searchState.aroundRadius,
+        });
+    },
+    cleanUp: function (props, searchState) {
+        searchState.aroundRadius; searchState.aroundLatLng; var nextSearchState = __rest(searchState, ["aroundRadius", "aroundLatLng"]);
+        return nextSearchState;
+    },
+});
+
+/**
+ * connectResources helps to make components to render results of the nexus211 resource search.
+ * It is just wrapper for the connectHits from Algolia.
+ * It's purpose is just to provide convenient typing for nexus resources, as it differs from the Algolia model.
+ * For the connectHits documentation please refer to https://community.algolia.com/react-instantsearch/connectors/connectHits.html
+ */
+var connectResources = function (Resources) {
+    return connectHits(function (_a) {
+        var hits = _a.hits;
+        return React.createElement(Resources, { resources: hits });
+    });
+};
+
+/**
+ * connectSearchBoxFields allows you to manipulate keyword search fields based on user input.
+ */
+var connectSearchBoxFields = createConnector({
+    displayName: 'ConnectWithSearchBoxFields',
+    getProvidedProps: function (props, searchState) {
+        var currentRefinements = searchState.searchFields || [];
+        var attributes = props.attributes;
+        return {
+            attributes: (attributes || []).map(function (attribute) { return (__assign(__assign({}, attribute), { isRefined: currentRefinements.includes(attribute.fieldName) })); }),
+        };
+    },
+    refine: function (props, searchState, nextRefinement) {
+        var searchBoxFields = searchState.searchFields || [];
+        return __assign(__assign({}, searchState), { searchFields: searchBoxFields.includes(nextRefinement)
+                ? searchBoxFields.filter(function (field) { return field !== nextRefinement; })
+                : __spreadArray(__spreadArray([], searchBoxFields), [nextRefinement]) });
+    },
+    getSearchParameters: function (searchParameters, props, searchState) {
+        if (!searchState.searchFields || !searchState.searchFields.length) {
+            return searchParameters.setQueryParameter('restrictSearchableAttributes');
+        }
+        return searchParameters.setQueryParameter('restrictSearchableAttributes', searchState.searchFields);
+    },
+    cleanUp: function (props, searchState) {
+        var newState = JSON.parse(JSON.stringify(searchState));
+        delete newState.searchFields;
+        return newState;
+    },
+});
+
+var ifStringToInt = function (v) {
+    switch (typeof v) {
+        case 'string':
+            return parseFloat(v);
+        case 'number':
+            return v;
+        default:
+            return null;
+    }
+};
+function transform(hits, transformer) {
+    return hits
+        .map(transformer)
+        .filter(function (entry) {
+        return entry !== null &&
+            entry !== undefined &&
+            entry.lat !== null &&
+            entry.lng !== null;
+    });
+}
+var defaultTransformer = function (hit) {
+    if (!hit.addresses || hit.addresses.length === 0) {
+        return null;
+    }
+    var address = hit.addresses[0];
+    return {
+        lat: ifStringToInt(address.latitude),
+        lng: ifStringToInt(address.longitude),
+        hit: hit,
+    };
+};
+var Map = function (props) {
+    var mapRef = useRef(null);
+    var markers = useMemo(function () { return transform(props.hits, props.transformMarkers || defaultTransformer); }, [props.hits, props.transformMarkers]);
+    var _a = useState(null), selectedMarker = _a[0], setSelectedMarker = _a[1];
+    var handleMarkerClick = useCallback(function (marker, hit) {
+        if (props.onMarkerClick) {
+            props.onMarkerClick(hit);
+        }
+        setSelectedMarker({
+            marker: marker,
+            hit: hit,
+        });
+    }, [props.onMarkerClick, setSelectedMarker]);
+    var UserInfoWindow = props.infoWindow;
+    useEffect(function () {
+        if (mapRef.current === null) {
+            return;
+        }
+        // Markers updated. Close the current window.
+        setSelectedMarker(null);
+        // Update bounds of the map
+        var bounds = markers.reduce(
+        //
+        function (bounds, marker) {
+            bounds.extend(new google.maps.LatLng(marker.lat, marker.lng));
+            return bounds;
+        }, new google.maps.LatLngBounds());
+        mapRef.current.map.fitBounds(bounds);
+    }, [mapRef, markers]);
+    return (React__default.createElement(Map$1, { ref: mapRef, google: props.google, disableDefaultUI: props.disableDefaultUI },
+        markers.map(function (data) { return (React__default.createElement(Marker, { key: data.hit.id, position: { lat: data.lat, lng: data.lng }, onClick: function (_, marker) {
+                if (marker) {
+                    handleMarkerClick(marker, data.hit);
+                }
+            } })); }),
+        !!selectedMarker && !!UserInfoWindow && (React__default.createElement(InfoWindow, { map: mapRef.current.map, visible: true, google: props.google, marker: selectedMarker.marker },
+            React__default.createElement(UserInfoWindow, { hit: selectedMarker.hit })))));
+};
+/**
+ * Creates a map component to display search results on a map.
+ *
+ * @param apiKey Google Maps API key
+ * @param options Options to customize the map
+ */
+var connectMap = function (apiKey) {
+    var Renderer = GoogleApiWrapper({
+        apiKey: apiKey,
+    })(function (props) {
+        return (React__default.createElement(Map, { google: props.google, hits: props.hits, infoWindow: props === null || props === void 0 ? void 0 : props.infoWindow, disableDefaultUI: (props === null || props === void 0 ? void 0 : props.disableDefaultUI) || true, transformMarkers: props === null || props === void 0 ? void 0 : props.transformMarkers, onMarkerClick: props === null || props === void 0 ? void 0 : props.onMarkerClick }));
+    });
+    return connectHits(Renderer);
+};
+
+/**
+ * LocationDistanceFilter allows to specify how close should the resource be located to be included in the search results.
+ * The location must be specified in other PlaceAutocomplete or a custom component with similar functionality.
+ */
+var LocationDistanceFilter = connectGeolocation(function (_a) {
+    var refine = _a.refine, currentRefinement = _a.currentRefinement, miles = _a.miles;
+    var aroundRadius = currentRefinement.aroundRadius;
+    var onChange = function (aroundRadius) { return refine({ aroundRadius: aroundRadius }); };
+    var distances = miles.map(function (distance) { return (React.createElement("li", { className: "ais-RefinementList-item", key: distance },
+        React.createElement("label", { className: "ais-RefinementList-label", onClick: onChange.bind(null, distance) },
+            React.createElement("input", { className: "ais-RefinementList-checkbox", type: "radio", checked: aroundRadius === distance }),
+            React.createElement("span", { className: "ais-RefinementList-labelText" },
+                ' ',
+                distance,
+                " miles",
+                ' ')))); });
+    var mile = (React.createElement("li", { className: "ais-RefinementList-item" },
+        React.createElement("label", { className: "ais-RefinementList-label", onClick: onChange.bind(null, 0) },
+            React.createElement("input", { className: "ais-RefinementList-checkbox", type: "radio", checked: !aroundRadius }),
+            React.createElement("span", { className: "ais-RefinementList-labelText" }, " Everywhere "))));
+    return (React.createElement("div", { className: "ais-RefinementList" },
+        React.createElement("ul", { className: "ais-RefinementList-list" },
+            distances,
+            mile)));
+});
+
+/**
+ * PlaceAutocomplete provides a place autocomplete powered by google maps engine. It selects the location to be used
+ * to query resources located nearby.
+ * The proximity limit should be specified in LocationDistanceFilter or a custom component with similar functionality.
+ */
+var PlaceAutocomplete = connectGeolocation(function (_a) {
+    var refine = _a.refine;
+    var _b = useState({ address: '' }), state = _b[0], setState = _b[1];
+    var handleChange = function (address) {
+        setState({ address: address });
+    };
+    var handleSelect = function (address) {
+        handleChange(address);
+        if (address === '') {
+            refine({ aroundLatLng: {} });
+            return;
+        }
+        geocodeByAddress(address)
+            .then(function (results) {
+            return getLatLng(results[0]).then(function (aroundLatLng) {
+                refine({ aroundLatLng: aroundLatLng });
+            });
+        })
+            .catch(function (error) { return console.error('Error', error); });
+    };
+    return (React.createElement(PlacesAutocomplete, { value: state.address, onChange: handleChange, onSelect: handleSelect }, function (_a) {
+        _a.getInputProps; var suggestions = _a.suggestions, getSuggestionItemProps = _a.getSuggestionItemProps, loading = _a.loading;
+        return (React.createElement("div", null,
+            React.createElement("div", { className: "autocomplete-dropdown-container" },
+                loading && React.createElement("div", null, "Loading..."),
+                suggestions.map(function (suggestion) {
+                    var className = suggestion.active
+                        ? 'suggestion-item--active'
+                        : 'suggestion-item';
+                    // inline style for demonstration purpose
+                    var style = suggestion.active
+                        ? { backgroundColor: '#fafafa', cursor: 'pointer' }
+                        : { backgroundColor: '#ffffff', cursor: 'pointer' };
+                    return (React.createElement("div", __assign({}, getSuggestionItemProps(suggestion, {
+                        className: className,
+                        style: style,
+                    }), { key: suggestion.description }),
+                        React.createElement("span", null, suggestion.description)));
+                }))));
+    }));
+});
+
+/**
+ * SearchBoxFields specifies a list of fields to be included in the search.
+ * @param attributes a list of fields in format of {title: string, fieldName: string}.
+ * Title specifies visible user-friendly for the field checkbox. fieldName is the field name in the resource object.
+ */
+var SearchBoxFields = connectSearchBoxFields(function (_a) {
+    var attributes = _a.attributes, refine = _a.refine;
+    var rendered = attributes.map(function (attribute) {
+        var id = '211cs_search_field_' + attribute.fieldName.replaceAll('.', '__');
+        return (React.createElement("li", { className: "ais-RefinementList-item", key: attribute.title },
+            React.createElement("label", { className: "ais-RefinementList-label", htmlFor: id },
+                React.createElement("input", { id: id, className: "ais-RefinementList-checkbox", type: 'checkbox', checked: attribute.isRefined, onChange: function () { return refine(attribute.fieldName); } }),
+                React.createElement("span", { className: "ais-RefinementList-labelText" }, attribute.title))));
+    });
+    return (React.createElement("div", { className: "ais-RefinementList" },
+        React.createElement("ul", { className: "ais-RefinementList-list" }, rendered)));
+});
+
+/**
+ * StringFieldSearch provides an input to filter field value by the given string prefix.
+ * To configure the number of hits being shown, use the HitsPerPage widget, connectHitsPerPage connector or the Configure widget.
+ *
+ * https://community.algolia.com/react-instantsearch/widgets/Hits.html
+ */
+var StringFieldSearch = connectStringFieldSearch(function (_a) {
+    var value = _a.value, onChange = _a.onChange;
+    return (React.createElement("div", { className: "ais-SearchBox" },
+        React.createElement("form", { noValidate: true, className: "ais-SearchBox-form", action: "", role: "search" },
+            React.createElement("input", { type: "search", placeholder: "Search here\u2026", autoComplete: "off", autoCorrect: "off", autoCapitalize: "off", spellCheck: "false", maxLength: 512, className: "ais-SearchBox-input", value: value, onChange: function (e) { return onChange(e.target.value); }, required: true }))));
+});
+
+/**
+ * ExactStringFieldSearch provides an input to filter by the exact string field value.
+ */
+var ExactStringFieldSearch = connectExactStringFieldSearch(function (_a) {
+    var value = _a.value, onChange = _a.onChange;
+    return (React.createElement("div", { className: "ais-SearchBox" },
+        React.createElement("form", { noValidate: true, className: "ais-SearchBox-form", action: "", role: "search" },
+            React.createElement("input", { type: "search", placeholder: "Search here\u2026", autoComplete: "off", autoCorrect: "off", autoCapitalize: "off", spellCheck: "false", maxLength: 512, className: "ais-SearchBox-input", value: value, onChange: function (e) { return onChange(e.target.value); }, required: true }))));
+});
+
+/**
+ * ExactNumberFieldSearch provides an input to filter by the exact number field value
+ */
+var ExactNumberFieldSearch = connectExactNumberFieldSearch(function (_a) {
+    var value = _a.value, onChange = _a.onChange;
+    return (React.createElement("div", { className: "ais-SearchBox" },
+        React.createElement("form", { noValidate: true, className: "ais-SearchBox-form", action: "", role: "search" },
+            React.createElement("input", { type: "number", placeholder: "Search here\u2026", autoComplete: "off", autoCorrect: "off", autoCapitalize: "off", spellCheck: "false", maxLength: 512, className: "ais-SearchBox-input", value: value, onChange: function (e) { return onChange(e.target.value); }, required: true }))));
+});
+
+var connectTaxonomyRefinementList = createConnector({
+    displayName: 'ConnectTaxonomyRefinementList',
+    getProvidedProps: function (props) {
+        var items = props.items;
+        return {
+            items: items,
+        };
+    },
+    refine: function (props, searchState, nextRefinement) {
+        var _a;
+        var _b;
+        var items = ((_b = searchState.taxonomyRefinementList) === null || _b === void 0 ? void 0 : _b[props.attribute]) || [];
+        var newItems = __spreadArray([], items);
+        nextRefinement.split('|').forEach(function (item) {
+            var index = newItems.findIndex(function (x) { return x === item; });
+            if (index >= 0) {
+                // If found, remove...
+                newItems.splice(index, 1);
+            }
+            else {
+                // Otherwise, add
+                newItems.push(item);
+            }
+        });
+        return __assign(__assign({}, searchState), { taxonomyRefinementList: __assign(__assign({}, searchState.taxonomyRefinementList), (_a = {}, _a[props.attribute] = newItems, _a)) });
+    },
+    getSearchParameters: function (searchParameters, props, searchState) {
+        var _a;
+        var nextParameters = searchParameters.addDisjunctiveFacet(props.attribute);
+        var items = ((_a = searchState.taxonomyRefinementList) === null || _a === void 0 ? void 0 : _a[props.attribute]) || [];
+        return items.reduce(function (state, item) {
+            return state.addDisjunctiveFacetRefinement(props.attribute, item);
+        }, nextParameters);
+    },
+    cleanUp: function (props, searchState) {
+        var newState = JSON.parse(JSON.stringify(searchState));
+        delete newState.taxonomyRefinementList;
+        return newState;
+    },
+});
+
+var TaxonomyRefinementList = connectTaxonomyRefinementList(function (_a) {
+    var items = _a.items, refine = _a.refine;
+    return (React__default.createElement("div", { className: "ais-RefinementList" },
+        React__default.createElement("ul", { className: "ais-RefinementList-list" }, items.map(function (item) { return (React__default.createElement("li", { key: item.value, className: "ais-RefinementList-item" },
+            React__default.createElement("label", { className: "ais-RefinementList-label" },
+                React__default.createElement("input", { className: "ais-RefinementList-checkbox", type: "checkbox", value: item.value, onChange: function () {
+                        refine(item.value);
+                    } })),
+            React__default.createElement("span", { className: "ais-RefinementList-labelText" }, item.label))); }))));
+});
+
+var connectOpenCloseHours = createConnector({
+    displayName: 'ConnectOpenCloseHours',
+    getProvidedProps: function (props, searchState) {
+        var currentRefinement = {
+            openNow: searchState.openNow || false,
+            openAtDay: searchState.openAtDay || undefined,
+            openAtMinute: searchState.openAtMinute || undefined,
+        };
+        return __assign({ currentRefinement: currentRefinement }, props);
+    },
+    refine: function (props, searchState, nextRefinement) {
+        var openNow = nextRefinement.openNow, openAtDay = nextRefinement.openAtDay, openAtMinute = nextRefinement.openAtMinute;
+        var now = new Date();
+        var day = now.getDay();
+        var hours = now.getHours();
+        var minutes = now.getMinutes();
+        var totalMinutes = (hours * 60) + minutes;
+        return __assign(__assign({}, searchState), { openNow: openNow, openAtDay: openNow ? (openAtDay || day) : undefined, openAtMinute: openNow ? (openAtMinute || totalMinutes) : undefined });
+    },
+    getSearchParameters: function (searchParameters, props, searchState) {
+        var params = searchParameters.setQueryParameters({
+            openNow: searchState.openNow,
+        });
+        if (searchState.openNow) {
+            return params.setQueryParameters({
+                openAtDay: searchState.openAtDay,
+                openAtMinute: searchState.openAtMinute
+            });
+        }
+        return params;
+    },
+    cleanUp: function (props, searchState) {
+        searchState.openNow; searchState.openAtDay; searchState.openAtMinute; var nextSearchState = __rest(searchState, ["openNow", "openAtDay", "openAtMinute"]);
+        return nextSearchState;
+    },
+});
+
+export { ExactNumberFieldSearch, ExactStringFieldSearch, LocationDistanceFilter, PlaceAutocomplete, SearchBoxFields, StringFieldSearch, TaxonomyRefinementList, connectExactNumberFieldSearch, connectExactStringFieldSearch, connectGeolocation, connectMap, connectOpenCloseHours, connectResources, connectSearchBoxFields, connectStringFieldSearch, connectTaxonomyRefinementList, makeConnectFieldSearch };

package/dist/types/ExactNumberFieldSearch.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+/**
+ * ExactNumberFieldSearch provides an input to filter by the exact number field value
+ */
+export declare const ExactNumberFieldSearch: React.ComponentClass<import("react-instantsearch-core").RefinementListExposed, any>;

package/dist/types/ExactStringFieldSearch.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+/**
+ * ExactStringFieldSearch provides an input to filter by the exact string field value.
+ */
+export declare const ExactStringFieldSearch: React.ComponentClass<import("react-instantsearch-core").RefinementListExposed, any>;

package/dist/types/LocationDistanceFilter.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+/**
+ * LocationDistanceFilter allows to specify how close should the resource be located to be included in the search results.
+ * The location must be specified in other PlaceAutocomplete or a custom component with similar functionality.
+ */
+export declare const LocationDistanceFilter: React.ComponentClass<any, any>;

package/dist/types/Map.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { IndexedResource } from '@211la/search-client';
+import type { Hit, HitsProvided } from 'react-instantsearch-core';
+export declare type MarkerData = {
+    lat: number;
+    lng: number;
+} & {
+    hit: Hit<IndexedResource>;
+};
+interface ConnectedMapProps extends HitsProvided<IndexedResource> {
+    google: any;
+    infoWindow?: any;
+    disableDefaultUI?: boolean;
+    transformMarkers?: any;
+    onMarkerClick?: any;
+}
+/**
+ * Creates a map component to display search results on a map.
+ *
+ * @param apiKey Google Maps API key
+ * @param options Options to customize the map
+ */
+export declare const connectMap: (apiKey: string) => React.ComponentClass<Omit<ConnectedMapProps, 'google' | 'hits'>>;
+export {};

package/dist/types/PlaceAutocomplete.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+/**
+ * PlaceAutocomplete provides a place autocomplete powered by google maps engine. It selects the location to be used
+ * to query resources located nearby.
+ * The proximity limit should be specified in LocationDistanceFilter or a custom component with similar functionality.
+ */
+export declare const PlaceAutocomplete: React.ComponentClass<any, any>;

package/dist/types/SearchBoxFields.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+/**
+ * SearchBoxFields specifies a list of fields to be included in the search.
+ * @param attributes a list of fields in format of {title: string, fieldName: string}.
+ * Title specifies visible user-friendly for the field checkbox. fieldName is the field name in the resource object.
+ */
+export declare const SearchBoxFields: React.ComponentClass<any, any>;

package/dist/types/StringFieldSearch.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+/**
+ * StringFieldSearch provides an input to filter field value by the given string prefix.
+ * To configure the number of hits being shown, use the HitsPerPage widget, connectHitsPerPage connector or the Configure widget.
+ *
+ * https://community.algolia.com/react-instantsearch/widgets/Hits.html
+ */
+export declare const StringFieldSearch: React.ComponentClass<import("react-instantsearch-core").RefinementListExposed, any>;

package/dist/types/Util.d.ts

@@ -0,0 +1 @@
+export declare const trim: (prefix: string, suffix: string, text: string) => string;

package/dist/types/connectFieldSearch.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+declare type FieldSearchProps = {
+    value: string;
+    onChange: (name: string) => any;
+    type: string;
+};
+/**
+ * makeConnectFieldSearch is a factory for connectors that filter by concrete fields.
+ * @param exact should the component search for the exact value. Otherwise it keeps all fields that contain the search text as a prefix.
+ * In the exact search "homeless" matches only homeless, not "homeless migrants".
+ * When filtering by prefix value, "homeless" matches "homeless migrants" too.
+ * @param type type of the field data. Can be a number (for example, year or zip code) or a string (agency name).
+ */
+export declare const makeConnectFieldSearch: (exact: boolean, type?: "string" | "number" | undefined) => (Component: React.FunctionComponent<FieldSearchProps>) => React.ComponentClass<import("react-instantsearch-core").RefinementListExposed, any>;
+/**
+ * connectStringFieldSearch makes components to search a string field for all values that start with the given one.
+ */
+export declare const connectStringFieldSearch: (Component: React.FunctionComponent<FieldSearchProps>) => React.ComponentClass<import("react-instantsearch-core").RefinementListExposed, any>;
+/**
+ * connectExactStringFieldSearch makes components to search a string field for the exact value.
+ */
+export declare const connectExactStringFieldSearch: (Component: React.FunctionComponent<FieldSearchProps>) => React.ComponentClass<import("react-instantsearch-core").RefinementListExposed, any>;
+/**
+ * connectExactNumberFieldSearch makes components to search a number field for the exact value.
+ */
+export declare const connectExactNumberFieldSearch: (Component: React.FunctionComponent<FieldSearchProps>) => React.ComponentClass<import("react-instantsearch-core").RefinementListExposed, any>;
+export {};

package/dist/types/connectGeolocation.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+/**
+ * connectGeolocation helps to make components that specify proximity to the given location.
+ * It deals with the refinement in format of {aroundLatLng:{lat:100.50, lng:100.20}, aroundRadius: 20}
+ * the aroundRadius is specified in miles.
+ * the aroundLatLng is an empty map if unspecified. It contains 'lat' and 'lng' number fields otherwise.
+ */
+export declare const connectGeolocation: ((stateless: import("react").FunctionComponent<any>) => import("react").ComponentClass<any, any>) & (<TProps extends Partial<any>>(Composed: import("react").ComponentType<TProps>) => import("react-instantsearch-core").ConnectedComponentClass<TProps, any, any>);

package/dist/types/connectOpenCloseHours.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const connectOpenCloseHours: ((stateless: import("react").FunctionComponent<any>) => import("react").ComponentClass<any, any>) & (<TProps extends Partial<any>>(Composed: import("react").ComponentType<TProps>) => import("react-instantsearch-core").ConnectedComponentClass<TProps, any, any>);

package/dist/types/connectResources.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { IndexedResource } from '@211la/search-client';
+/**
+ * connectResources helps to make components to render results of the nexus211 resource search.
+ * It is just wrapper for the connectHits from Algolia.
+ * It's purpose is just to provide convenient typing for nexus resources, as it differs from the Algolia model.
+ * For the connectHits documentation please refer to https://community.algolia.com/react-instantsearch/connectors/connectHits.html
+ */
+export declare const connectResources: (Resources: React.FunctionComponent<{
+    resources: IndexedResource[];
+}>) => React.ComponentClass<{}, any>;

package/dist/types/connectSearchBoxFields.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+/**
+ * connectSearchBoxFields allows you to manipulate keyword search fields based on user input.
+ */
+export declare const connectSearchBoxFields: ((stateless: import("react").FunctionComponent<import("react-instantsearch-core").ConnectorProvided<{
+    attributes: any;
+}>>) => import("react").ComponentClass<any, any>) & (<TProps extends Partial<import("react-instantsearch-core").ConnectorProvided<{
+    attributes: any;
+}>>>(Composed: import("react").ComponentType<TProps>) => import("react-instantsearch-core").ConnectedComponentClass<TProps, import("react-instantsearch-core").ConnectorProvided<{
+    attributes: any;
+}>, any>);

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+export { makeConnectFieldSearch, connectExactStringFieldSearch, connectExactNumberFieldSearch, connectStringFieldSearch, } from './connectFieldSearch';
+export { connectGeolocation } from './connectGeolocation';
+export { connectResources } from './connectResources';
+export { connectSearchBoxFields } from './connectSearchBoxFields';
+export { connectMap, MarkerData } from './Map';
+export { LocationDistanceFilter } from './LocationDistanceFilter';
+export { PlaceAutocomplete } from './PlaceAutocomplete';
+export { SearchBoxFields } from './SearchBoxFields';
+export { StringFieldSearch } from './StringFieldSearch';
+export { ExactStringFieldSearch } from './ExactStringFieldSearch';
+export { ExactNumberFieldSearch } from './ExactNumberFieldSearch';
+export { connectTaxonomyRefinementList } from './taxonomyRefinementList/connectTaxonomyRefinementList';
+export { TaxonomyRefinementList } from './taxonomyRefinementList/TaxonomyRefinementList';
+export { connectOpenCloseHours } from './connectOpenCloseHours';

package/dist/types/taxonomyRefinementList/TaxonomyRefinementList.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare const TaxonomyRefinementList: React.ComponentClass<{
+    attribute: string;
+    items: {
+        label: string;
+        value: string;
+    }[];
+}, any>;

package/dist/types/taxonomyRefinementList/connectTaxonomyRefinementList.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="react" />
+declare type TaxonomyRefinementListProps = {
+    attribute: string;
+    items: {
+        label: string;
+        value: string;
+    }[];
+};
+export declare const connectTaxonomyRefinementList: ((stateless: import("react").FunctionComponent<import("react-instantsearch-core").ConnectorProvided<{
+    items: {
+        label: string;
+        value: string;
+    }[];
+}>>) => import("react").ComponentClass<TaxonomyRefinementListProps, any>) & (<TProps extends Partial<import("react-instantsearch-core").ConnectorProvided<{
+    items: {
+        label: string;
+        value: string;
+    }[];
+}>>>(Composed: import("react").ComponentType<TProps>) => import("react-instantsearch-core").ConnectedComponentClass<TProps, import("react-instantsearch-core").ConnectorProvided<{
+    items: {
+        label: string;
+        value: string;
+    }[];
+}>, TaxonomyRefinementListProps>);
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@211la/search-react",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "main": "dist/index.js",
   "types": "dist/types/index.d.ts",
   "files": [
@@ -27,13 +27,13 @@
     "rollup": "^2.48.0",
     "rollup-plugin-peer-deps-external": "^2.2.4",
     "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-typescript2": "^0.30.0",
+    "rollup-plugin-typescript2": "^0.32.1",
     "ts-loader": "^8.0.12",
     "tslib": "^2.3.0",
     "typescript": "^4.0.5"
   },
   "peerDependencies": {
-    "@211la/search-client": "^0.12.0",
+    "@211la/search-client": "^0.13.0",
     "react": ">=16.8.0",
     "react-dom": ">=16.8.0",
     "react-instantsearch-core": ">=6.11.1",