@appbaseio/reactivesearch-vue 3.0.0-rc.4 → 3.0.0-rc.5.alpha.2

package/dist/es/helper-39773859.js

@@ -0,0 +1,558 @@
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+function _objectWithoutProperties(source, excluded) {
+  if (source == null) return {};
+  var target = _objectWithoutPropertiesLoose(source, excluded);
+  var key, i;
+  if (Object.getOwnPropertySymbols) {
+    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+    for (i = 0; i < sourceSymbolKeys.length; i++) {
+      key = sourceSymbolKeys[i];
+      if (excluded.indexOf(key) >= 0) continue;
+      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var componentTypes = {
+  reactiveList: 'REACTIVELIST',
+  // search components
+  dataSearch: 'DATASEARCH',
+  categorySearch: 'CATEGORYSEARCH',
+  searchBox: 'SEARCHBOX',
+  // list components
+  singleList: 'SINGLELIST',
+  multiList: 'MULTILIST',
+  singleDataList: 'SINGLEDATALIST',
+  tabDataList: 'TABDATALIST',
+  singleDropdownList: 'SINGLEDROPDOWNLIST',
+  multiDataList: 'MULTIDATALIST',
+  multiDropdownList: 'MULTIDROPDOWNLIST',
+  singleDropdownRange: 'SINGLEDROPDOWNRANGE',
+  treeList: 'TREELIST',
+  // basic components
+  numberBox: 'NUMBERBOX',
+  tagCloud: 'TAGCLOUD',
+  toggleButton: 'TOGGLEBUTTON',
+  reactiveComponent: 'REACTIVECOMPONENT',
+  // range components
+  datePicker: 'DATEPICKER',
+  dateRange: 'DATERANGE',
+  dynamicRangeSlider: 'DYNAMICRANGESLIDER',
+  multiDropdownRange: 'MULTIDROPDOWNRANGE',
+  singleRange: 'SINGLERANGE',
+  multiRange: 'MULTIRANGE',
+  rangeSlider: 'RANGESLIDER',
+  ratingsFilter: 'RATINGSFILTER',
+  rangeInput: 'RANGEINPUT',
+  // map components
+  geoDistanceDropdown: 'GEO_DISTANCE_DROPDOWN',
+  geoDistanceSlider: 'GEO_DISTANCE_SLIDER',
+  reactiveMap: 'REACTIVE_MAP',
+  // chart components
+  reactiveChart: 'REACTIVE_CHART'
+};
+var _componentTypeToDefau;
+var _excluded = ["query"],
+  _excluded3 = ["query"],
+  _excluded4 = ["headers", "body"];
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+var updateCustomQuery = function updateCustomQuery(componentId, props, value) {
+  if (props.customQuery && typeof props.customQuery === 'function') {
+    props.setCustomQuery(componentId, props.customQuery(value, props));
+  }
+};
+var updateDefaultQuery = function updateDefaultQuery(componentId, props, value) {
+  if (props.defaultQuery && typeof props.defaultQuery === 'function') {
+    props.setDefaultQuery(componentId, props.defaultQuery(value, props));
+  }
+};
+function isEqual(x, y) {
+  if (x === y) return true;
+  if (!(x instanceof Object) || !(y instanceof Object)) return false;
+  if (x.constructor !== y.constructor) return false;
+
+  /* eslint-disable */
+  for (var p in x) {
+    if (!x.hasOwnProperty(p)) continue;
+    if (!y.hasOwnProperty(p)) return false;
+    if (x[p] === y[p]) continue;
+    if (_typeof(x[p]) !== 'object') return false;
+    if (!isEqual(x[p], y[p])) return false;
+  }
+  for (var _p in y) {
+    if (y.hasOwnProperty(_p) && !x.hasOwnProperty(_p)) return false;
+  }
+  /* eslint-enable */
+  return true;
+}
+function getQueryOptions(props) {
+  var options = {};
+  if (props.size !== undefined) {
+    options.size = props.size;
+  }
+  if (props.includeFields || props.excludeFields) {
+    var source = {};
+    if (props.includeFields) {
+      source.includes = props.includeFields;
+    }
+    if (props.excludeFields) {
+      source.excludes = props.excludeFields;
+    }
+    options._source = source;
+  }
+  return options;
+}
+
+// checks and executes beforeValueChange for sensors
+function checkValueChange(componentId, value, beforeValueChange, performUpdate) {
+  var selectedValue = value;
+  // To ensure that the returned values are consistent across all the components
+  // null is returned in case of an empty array
+  if (Array.isArray(value) && !value.length) {
+    selectedValue = null;
+  }
+  var handleError = function handleError(e) {
+    console.warn("".concat(componentId, " - beforeValueChange rejected the promise with "), e);
+  };
+  if (beforeValueChange) {
+    try {
+      var promise = beforeValueChange(selectedValue);
+      if (promise instanceof Promise) {
+        promise.then(performUpdate)["catch"](handleError);
+      } else {
+        performUpdate();
+      }
+    } catch (e) {
+      handleError(e);
+    }
+  } else {
+    performUpdate();
+  }
+}
+function getAggsOrder(sortBy) {
+  if (sortBy === 'count') {
+    return {
+      _count: 'desc'
+    };
+  }
+  return {
+    _key: sortBy
+  };
+}
+var getClassName = function getClassName(classMap, component) {
+  return classMap && classMap[component] || '';
+};
+
+/**
+ * To extract query options from custom or default query
+ * @param {Object} customQuery
+ */
+var getOptionsFromQuery = function getOptionsFromQuery() {
+  var customQuery = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if (customQuery) {
+    customQuery.query;
+    var rest = _objectWithoutProperties(customQuery, _excluded);
+    return Object.keys(rest).length ? rest : null;
+  }
+  return null;
+};
+var componentTypeToDefaultValue = (_componentTypeToDefau = {}, _defineProperty(_componentTypeToDefau, componentTypes.singleList, ''), _defineProperty(_componentTypeToDefau, componentTypes.multiList, []), _defineProperty(_componentTypeToDefau, componentTypes.singleDataList, ''), _defineProperty(_componentTypeToDefau, componentTypes.singleDropdownList, ''), _defineProperty(_componentTypeToDefau, componentTypes.multiDataList, []), _defineProperty(_componentTypeToDefau, componentTypes.multiDropdownList, []), _defineProperty(_componentTypeToDefau, componentTypes.tagCloud, ''), _defineProperty(_componentTypeToDefau, componentTypes.toggleButton, ''), _defineProperty(_componentTypeToDefau, componentTypes.singleDropdownRange, ''), _defineProperty(_componentTypeToDefau, componentTypes.multiDropdownRange, []), _defineProperty(_componentTypeToDefau, componentTypes.singleRange, ''), _defineProperty(_componentTypeToDefau, componentTypes.multiRange, []), _componentTypeToDefau);
+/**
+ * Updates the query for the internal component
+ */
+var updateInternalQuery = function updateInternalQuery(componentId, queryOptions, value, props, defaultQueryToExecute, queryParams) {
+  var defaultQuery = props.defaultQuery;
+  var defaultQueryOptions;
+  var query = defaultQueryToExecute;
+  if (defaultQuery) {
+    var queryTobeSet = defaultQuery(value, props);
+    var _ref3 = queryTobeSet || {};
+    query = _ref3.query;
+    defaultQueryOptions = getOptionsFromQuery(queryTobeSet);
+    // Update calculated default query in store
+    updateDefaultQuery(componentId, props, value);
+  }
+  if (query) {
+    props.setQueryOptions(componentId, _objectSpread(_objectSpread({}, defaultQueryOptions), queryOptions || defaultQueryToExecute));
+    props.updateQuery(_objectSpread({
+      componentId: componentId,
+      query: query,
+      value: value
+    }, queryParams));
+  } else {
+    props.setQueryOptions(componentId, _objectSpread(_objectSpread({}, defaultQueryOptions), queryOptions || defaultQueryToExecute));
+  }
+};
+// extracts query options from defaultQuery if set
+var extractQueryFromDefaultQuery = function extractQueryFromDefaultQuery(props, value) {
+  var queryToBeReturned = {};
+  var defaultQuery = props.defaultQuery;
+  /*
+   do not call props.defaultQuery() directly as the client may be accessing props directly
+   E.g.
+   <MultiList defaultQuery={(value, props) => ({query: [props.dataField]: value})} />
+  */
+  if (defaultQuery) {
+    var evaluateQuery = defaultQuery(value, props);
+    if (evaluateQuery) {
+      // we should only retrieve and set the query options here.
+      // [Not implemented yet] `query` key should be handled separately for
+      // adding it to `queryList` in the redux store
+      evaluateQuery.query;
+      var options = _objectWithoutProperties(evaluateQuery, _excluded3);
+      if (options) {
+        queryToBeReturned = options;
+      }
+    }
+  }
+  return queryToBeReturned;
+};
+var getAggsQuery = function getAggsQuery(value, query, props) {
+  var clonedQuery = query;
+  var dataField = props.dataField,
+    size = props.size,
+    sortBy = props.sortBy,
+    showMissing = props.showMissing,
+    missingLabel = props.missingLabel,
+    aggregationSize = props.aggregationSize;
+  clonedQuery.size = 0;
+  if (typeof dataField === 'string') {
+    clonedQuery.aggs = _defineProperty({}, dataField, {
+      terms: _objectSpread({
+        field: dataField,
+        size: size,
+        aggregationSize: aggregationSize,
+        order: getAggsOrder(sortBy || 'count')
+      }, showMissing ? {
+        missing: missingLabel
+      } : {})
+    });
+  } else {
+    var aggs;
+    _toConsumableArray(dataField).reverse().forEach(function (dataFieldItem) {
+      aggs = _defineProperty({}, dataFieldItem, {
+        terms: _objectSpread({
+          field: dataFieldItem,
+          size: size,
+          aggregationSize: aggregationSize,
+          order: getAggsOrder(sortBy || 'count')
+        }, showMissing ? {
+          missing: missingLabel
+        } : {}),
+        aggs: aggs
+      });
+    });
+    clonedQuery.aggs = aggs;
+  }
+  if (props.nestedField) {
+    clonedQuery.aggs = {
+      reactivesearch_nested: {
+        nested: {
+          path: props.nestedField
+        },
+        aggs: clonedQuery.aggs
+      }
+    };
+  }
+  return _objectSpread(_objectSpread({}, clonedQuery), extractQueryFromDefaultQuery(props, value));
+};
+/**
+ * Adds click ids in the hits(useful for trigger analytics)
+ */
+var withClickIds = function withClickIds() {
+  var results = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return results.map(function (result, index) {
+    return _objectSpread(_objectSpread({}, result), {}, {
+      _click_id: index
+    });
+  });
+};
+var suggestionTypes = {
+  Popular: 'popular',
+  Index: 'index',
+  Recent: 'recent',
+  Promoted: 'promoted',
+  Featured: 'featured'
+};
+/**
+ * To determine wether an element is a function
+ * @param {any} element
+ */
+var isFunction = function isFunction(element) {
+  return typeof element === 'function';
+};
+
+/**
+ * Extracts the render prop from props and returns a valid React element
+ * @param {Object} data
+ * @param {Object} props
+ */
+var getComponent = function getComponent() {
+  var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var children = props.children,
+    render = props.render;
+  // Render function as child
+  if (isFunction(children)) {
+    return children(data);
+  }
+  // Render function as render prop
+  if (isFunction(render)) {
+    return render(data);
+  }
+  return null;
+};
+
+/**
+ * Recursively look for a path in a nested object
+ */
+var recLookup = function recLookup(obj, path) {
+  var separator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '.';
+  try {
+    var parts = path.split(separator);
+    if (parts.length === 1) {
+      return obj[parts[0]];
+    }
+    return recLookup(obj[parts[0]], parts.slice(1).join(separator), separator);
+  } catch (e) {
+    return false;
+  }
+};
+
+/**
+ * Dynamically sets a deeply nested value in an object.
+ * has been modified to comply with TreeList component implementation
+ * https://stackoverflow.com/a/49754647/10822996
+ */
+function setDeep(obj, path, value) {
+  var setrecursively = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  path.reduce(function (acc, currentItem, level) {
+    if (setrecursively && _typeof(acc[currentItem]) !== 'object' && level !== path.length - 1) {
+      acc[currentItem] = {};
+      return acc[currentItem];
+    }
+    if (level === path.length - 1) {
+      acc[currentItem] = value;
+      return value;
+    }
+    return _typeof(acc[currentItem]) === 'object' ? acc[currentItem] : {};
+  }, obj);
+}
+
+// transforms rawData into local state
+// [
+// 	{
+// 		key: 'COMPACT DISC',
+// 		count: 70654,
+// 		level: 0,
+// 		list: [
+// 			{
+// 				key: 'VINYL',
+// 				count: 69731,
+// 				level: 1,
+// 				list: [
+// 					{
+// 						key: 'SPORTS & FITNESS',
+// 						count: 12553,
+// 						level: 2,
+// 					},
+// 				],
+// 			},
+// 		],
+// 	},
+// ];
+// ⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️
+// [
+//     {
+//         "key": "COMPACT DISC",
+//         "count": 70654,
+//         "level": 0,
+//         "list": [
+//             {
+//                 "key": "VINYL",
+//                 "count": 69731,
+//                 "level": 1,
+//                 "list": [
+//                     {
+//                         "key": "SPORTS & FITNESS",
+//                         "count": 12553,
+//                         "level": 2
+//                     }
+//                 ]
+//             }
+//         ]
+//     }
+// ]
+var transformRawTreeListData = function transformRawTreeListData(data, dataField) {
+  var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var newState = [];
+  if (data instanceof Object) {
+    var aggsKeys = Object.keys(data);
+    aggsKeys.forEach(function (key) {
+      if (Array.isArray(data[key].buckets)) {
+        data[key].buckets.forEach(function (bucket) {
+          newState.push(_objectSpread({
+            key: bucket.key,
+            count: bucket.doc_count,
+            level: level
+          }, bucket[dataField[level + 1]] instanceof Object ? {
+            list: transformRawTreeListData(_defineProperty({}, dataField[level + 1], bucket[dataField[level + 1]]), dataField, level + 1)
+          } : {}));
+        });
+      }
+    });
+  }
+  return newState;
+};
+
+// transforms local selected data into query compatible format
+// const object = {
+//   "COMPACT DISC": {
+//     "VINYL": {
+//       "DRAMA/DR": true,
+//       "MUSIC DVD": true,
+//       "CHILDRENS-FAMILY": false
+//     },
+//     "MUSIC DVD": true,
+//     "ROCK-ELECTRONIC": true
+//   }
+// };
+// ⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️⬇️
+// [
+//     "COMPACT DISC > VINYL > DRAMA/DR",
+//     "COMPACT DISC > VINYL > MUSIC DVD",
+//     "COMPACT DISC > MUSIC DVD",
+//     "COMPACT DISC > ROCK-ELECTRONIC"
+// ]
+var transformTreeListLocalStateIntoQueryComptaibleFormat = function transformTreeListLocalStateIntoQueryComptaibleFormat(obj) {
+  var currentPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  var result = [];
+  if (obj instanceof Object) {
+    if (Object.keys(obj).length) {
+      Object.keys(obj).forEach(function (key) {
+        if (obj[key] instanceof Object) {
+          result.push.apply(result, _toConsumableArray(transformTreeListLocalStateIntoQueryComptaibleFormat(obj[key], currentPath ? "".concat(currentPath, " > ").concat(key) : key)));
+        }
+        if (obj[key] === true) {
+          result.push(currentPath ? "".concat(currentPath, " > ").concat(key) : key);
+        }
+      });
+    } else if (currentPath) {
+      result.push(currentPath);
+    }
+  }
+  return result;
+};
+
+// transform request when endpoint prop is defined
+var transformRequestUsingEndpoint = function transformRequestUsingEndpoint(request, endpointParam) {
+  if (endpointParam instanceof Object) {
+    var _endpointParam$header = endpointParam.headers,
+      headers = _endpointParam$header === void 0 ? {} : _endpointParam$header,
+      body = endpointParam.body,
+      rest = _objectWithoutProperties(endpointParam, _excluded4);
+    var endpointModifiedRequest = _objectSpread(_objectSpread(_objectSpread({}, request), rest), {}, {
+      headers: _objectSpread(_objectSpread({}, request.headers), headers)
+    }, body instanceof Object ? {
+      body: JSON.stringify(body)
+    } : {});
+    return endpointModifiedRequest;
+  }
+  return request;
+};
+
+export { getClassName as a, updateDefaultQuery as b, transformTreeListLocalStateIntoQueryComptaibleFormat as c, transformRawTreeListData as d, setDeep as e, getComponent as f, getQueryOptions as g, getOptionsFromQuery as h, isEqual as i, checkValueChange as j, getAggsQuery as k, updateInternalQuery as l, isFunction as m, recLookup as r, suggestionTypes as s, transformRequestUsingEndpoint as t, updateCustomQuery as u, withClickIds as w };

package/dist/es/{index-882489e1.js → index-b2212b15.js}

@@ -1,8 +1,72 @@
 import { helper } from '@appbaseio/reactivecore';
-import { validProps } from '@appbaseio/reactivecore/lib/utils/constants';
-import { a as _extends } from './_rollupPluginBabelHelpers-ded08042.js';
+import { _ as _extends } from './_rollupPluginBabelHelpers-dac426db.js';
 import { bindActionCreators } from 'redux';
 
+var componentTypes = {
+  reactiveList: 'REACTIVELIST',
+  // search components
+  dataSearch: 'DATASEARCH',
+  categorySearch: 'CATEGORYSEARCH',
+  searchBox: 'SEARCHBOX',
+  // list components
+  singleList: 'SINGLELIST',
+  multiList: 'MULTILIST',
+  singleDataList: 'SINGLEDATALIST',
+  tabDataList: 'TABDATALIST',
+  singleDropdownList: 'SINGLEDROPDOWNLIST',
+  multiDataList: 'MULTIDATALIST',
+  multiDropdownList: 'MULTIDROPDOWNLIST',
+  singleDropdownRange: 'SINGLEDROPDOWNRANGE',
+  treeList: 'TREELIST',
+  // basic components
+  numberBox: 'NUMBERBOX',
+  tagCloud: 'TAGCLOUD',
+  toggleButton: 'TOGGLEBUTTON',
+  reactiveComponent: 'REACTIVECOMPONENT',
+  // range components
+  datePicker: 'DATEPICKER',
+  dateRange: 'DATERANGE',
+  dynamicRangeSlider: 'DYNAMICRANGESLIDER',
+  multiDropdownRange: 'MULTIDROPDOWNRANGE',
+  singleRange: 'SINGLERANGE',
+  multiRange: 'MULTIRANGE',
+  rangeSlider: 'RANGESLIDER',
+  ratingsFilter: 'RATINGSFILTER',
+  rangeInput: 'RANGEINPUT',
+  // map components
+  geoDistanceDropdown: 'GEO_DISTANCE_DROPDOWN',
+  geoDistanceSlider: 'GEO_DISTANCE_SLIDER',
+  reactiveMap: 'REACTIVE_MAP',
+  // chart components
+  reactiveChart: 'REACTIVE_CHART'
+};
+var validProps = [
+// common
+'type', 'componentType', 'aggregationField', 'aggregationSize', 'distinctField', 'distinctFieldConfig', 'index', 'aggregations',
+// Specific to ReactiveList
+'dataField', 'includeFields', 'excludeFields', 'size', 'from', 'sortBy', 'sortOptions', 'pagination',
+// Specific to DataSearch
+'autoFocus', 'autosuggest', 'debounce', 'defaultValue', 'defaultSuggestions', 'fieldWeights', 'filterLabel', 'fuzziness', 'highlight', 'highlightConfig', 'highlightField', 'nestedField', 'placeholder', 'queryFormat', 'searchOperators', 'enableSynonyms', 'enableQuerySuggestions', 'queryString',
+// Specific to Category Search
+'categoryField', 'strictSelection',
+// Specific to List Components
+'selectAllLabel', 'showCheckbox', 'showFilter', 'showSearch', 'showCount', 'showLoadMore', 'loadMoreLabel', 'showMissing', 'missingLabel', 'data', 'showRadio',
+// TagCloud and ToggleButton
+'multiSelect',
+// Range Components
+'includeNullValues', 'interval', 'showHistogram', 'snap', 'stepValue', 'range', 'showSlider', 'parseDate', 'calendarInterval',
+// Map components
+'unit',
+// Specific to searchBox
+'enablePopularSuggestions', 'enableRecentSuggestions', 'popularSuggestionsConfig', 'recentSuggestionsConfig', 'indexSuggestionsConfig', 'featuredSuggestionsConfig', 'enablePredictiveSuggestions', 'applyStopwords', 'customStopwords', 'enableIndexSuggestions', 'enableFeaturedSuggestions', 'searchboxId', 'endpoint', 'enableEndpointSuggestions'];
+
+// search components modes
+var SEARCH_COMPONENTS_MODES = {
+  SELECT: 'select',
+  TAG: 'tag'
+};
+var TREELIST_VALUES_PATH_SEPARATOR = '◐◑◒◓';
+
 // Credit to React-Redux for this util function
 // https://github.com/reactjs/react-redux/blob/573db0bfc8d1d50fdb6e2a98bd8a7d4675fecf11/src/utils/shallowEqual.js
 
@@ -306,4 +370,4 @@ function decodeHtml(str) {
   });
 }
 
-export { X_SEARCH_CLIENT as X, isFunction as a, getCamelCase as b, connect as c, getValidPropsKeys as d, composeThemeObject as e, decodeHtml as f, getComponent as g, hasCustomRenderer as h, isQueryIdentical as i, updateCustomQuery as j, isEmpty as k, extractModifierKeysFromFocusShortcuts as l, isEvent as m, parseValueArray as n, parseFocusShortcuts as p, updateDefaultQuery as u };
+export { SEARCH_COMPONENTS_MODES as S, TREELIST_VALUES_PATH_SEPARATOR as T, X_SEARCH_CLIENT as X, componentTypes as a, isFunction as b, connect as c, getCamelCase as d, getValidPropsKeys as e, composeThemeObject as f, getComponent as g, hasCustomRenderer as h, isQueryIdentical as i, decodeHtml as j, updateCustomQuery as k, isEmpty as l, extractModifierKeysFromFocusShortcuts as m, isEvent as n, parseValueArray as o, parseFocusShortcuts as p, updateDefaultQuery as u };

package/dist/es/index-b9203a60.js

@@ -0,0 +1,10 @@
+var transformOn = function transformOn(obj) {
+  var result = {};
+  Object.keys(obj).forEach(function (evt) {
+    result["on" + evt[0].toUpperCase() + evt.substr(1)] = obj[evt];
+  });
+  return result;
+};
+var babelHelperVueTransformOn = transformOn;
+
+export { babelHelperVueTransformOn as _ };