@algolia/autocomplete-core 1.2.2 → 1.5.0

package/dist/umd/index.development.js

@@ -1,49 +1,22 @@
-/*! @algolia/autocomplete-core 1.2.2 | MIT License | © Algolia, Inc. and contributors | https://github.com/algolia/autocomplete */
+/*! @algolia/autocomplete-core 1.5.0 | MIT License | © Algolia, Inc. and contributors | https://github.com/algolia/autocomplete */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global['@algolia/autocomplete-core'] = {}));
 }(this, (function (exports) { 'use strict';
 
-  function _typeof(obj) {
-    "@babel/helpers - typeof";
-
-    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
-      _typeof = function (obj) {
-        return typeof obj;
-      };
-    } else {
-      _typeof = function (obj) {
-        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
-      };
-    }
-
-    return _typeof(obj);
-  }
-
-  function _defineProperty(obj, key, value) {
-    if (key in obj) {
-      Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      });
-    } else {
-      obj[key] = value;
-    }
-
-    return obj;
-  }
-
   function ownKeys(object, enumerableOnly) {
     var keys = Object.keys(object);
 
     if (Object.getOwnPropertySymbols) {
       var symbols = Object.getOwnPropertySymbols(object);
-      if (enumerableOnly) symbols = symbols.filter(function (sym) {
-        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-      });
+
+      if (enumerableOnly) {
+        symbols = symbols.filter(function (sym) {
+          return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+        });
+      }
+
       keys.push.apply(keys, symbols);
     }
 
@@ -70,6 +43,37 @@
     return target;
   }
 
+  function _typeof(obj) {
+    "@babel/helpers - typeof";
+
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof = function (obj) {
+        return typeof obj;
+      };
+    } else {
+      _typeof = function (obj) {
+        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+      };
+    }
+
+    return _typeof(obj);
+  }
+
+  function _defineProperty(obj, key, value) {
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+
+    return obj;
+  }
+
   function _objectWithoutPropertiesLoose(source, excluded) {
     if (source == null) return {};
     var target = {};
@@ -115,7 +119,7 @@
   }
 
   function _iterableToArray(iter) {
-    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
   }
 
   function _unsupportedIterableToArray(o, minLen) {
@@ -139,6 +143,122 @@
     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 _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray$1(arr, i) || _nonIterableRest();
+  }
+
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  function _unsupportedIterableToArray$1(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray$1(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$1(o, minLen);
+  }
+
+  function _arrayLikeToArray$1(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 _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+
+    var _s, _e;
+
+    try {
+      for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+        _arr.push(_s.value);
+
+        if (i && _arr.length === i) break;
+      }
+    } catch (err) {
+      _d = true;
+      _e = err;
+    } finally {
+      try {
+        if (!_n && _i["return"] != null) _i["return"]();
+      } finally {
+        if (_d) throw _e;
+      }
+    }
+
+    return _arr;
+  }
+
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+
+  function _typeof$1(obj) {
+    "@babel/helpers - typeof";
+
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof$1 = function _typeof(obj) {
+        return typeof obj;
+      };
+    } else {
+      _typeof$1 = function _typeof(obj) {
+        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+      };
+    }
+
+    return _typeof$1(obj);
+  }
+  /**
+   * Decycles objects with circular references.
+   * This is used to print cyclic structures in development environment only.
+   */
+
+
+  function decycle(obj) {
+    var seen = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Set();
+
+    if ( !obj || _typeof$1(obj) !== 'object') {
+      return obj;
+    }
+
+    if (seen.has(obj)) {
+      return '[Circular]';
+    }
+
+    var newSeen = seen.add(obj);
+
+    if (Array.isArray(obj)) {
+      return obj.map(function (x) {
+        return decycle(x, newSeen);
+      });
+    }
+
+    return Object.fromEntries(Object.entries(obj).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+          key = _ref2[0],
+          value = _ref2[1];
+
+      return [key, decycle(value, newSeen)];
+    }));
+  }
+
+  function flatten(values) {
+    return values.reduce(function (a, b) {
+      return a.concat(b);
+    }, []);
+  }
+
   var autocompleteId = 0;
   function generateAutocompleteId() {
     return "autocomplete-".concat(autocompleteId++);
@@ -162,10 +282,19 @@
   function invariant(condition, message) {
 
     if (!condition) {
-      throw new Error("[Autocomplete] ".concat(message));
+      throw new Error("[Autocomplete] ".concat(typeof message === 'function' ? message() : message));
     }
   }
 
+  var noop = function noop() {};
+
+  var version = '1.5.0';
+
+  var userAgents = [{
+    segment: 'autocomplete-core',
+    version: version
+  }];
+
   var warnCache = {
     current: {}
   };
@@ -216,10 +345,91 @@
     };
   }
 
-  function flatten(values) {
-    return values.reduce(function (a, b) {
-      return a.concat(b);
-    }, []);
+  function getAutocompleteSetters(_ref) {
+    var store = _ref.store;
+
+    var setActiveItemId = function setActiveItemId(value) {
+      store.dispatch('setActiveItemId', value);
+    };
+
+    var setQuery = function setQuery(value) {
+      store.dispatch('setQuery', value);
+    };
+
+    var setCollections = function setCollections(rawValue) {
+      var baseItemId = 0;
+      var value = rawValue.map(function (collection) {
+        return _objectSpread2(_objectSpread2({}, collection), {}, {
+          // We flatten the stored items to support calling `getAlgoliaResults`
+          // from the source itself.
+          items: flatten(collection.items).map(function (item) {
+            return _objectSpread2(_objectSpread2({}, item), {}, {
+              __autocomplete_id: baseItemId++
+            });
+          })
+        });
+      });
+      store.dispatch('setCollections', value);
+    };
+
+    var setIsOpen = function setIsOpen(value) {
+      store.dispatch('setIsOpen', value);
+    };
+
+    var setStatus = function setStatus(value) {
+      store.dispatch('setStatus', value);
+    };
+
+    var setContext = function setContext(value) {
+      store.dispatch('setContext', value);
+    };
+
+    return {
+      setActiveItemId: setActiveItemId,
+      setQuery: setQuery,
+      setCollections: setCollections,
+      setIsOpen: setIsOpen,
+      setStatus: setStatus,
+      setContext: setContext
+    };
+  }
+
+  /**
+   * Creates a runner that executes promises in a concurrent-safe way.
+   *
+   * This is useful to prevent older promises to resolve after a newer promise,
+   * otherwise resulting in stale resolved values.
+   */
+  function createConcurrentSafePromise() {
+    var basePromiseId = -1;
+    var latestResolvedId = -1;
+    var latestResolvedValue = undefined;
+    return function runConcurrentSafePromise(promise) {
+      basePromiseId++;
+      var currentPromiseId = basePromiseId;
+      return Promise.resolve(promise).then(function (x) {
+        // The promise might take too long to resolve and get outdated. This would
+        // result in resolving stale values.
+        // When this happens, we ignore the promise value and return the one
+        // coming from the latest resolved value.
+        //
+        // +----------------------------------+
+        // |        100ms                     |
+        // | run(1) +--->  R1                 |
+        // |        300ms                     |
+        // | run(2) +-------------> R2 (SKIP) |
+        // |        200ms                     |
+        // | run(3) +--------> R3             |
+        // +----------------------------------+
+        if (latestResolvedValue && currentPromiseId < latestResolvedId) {
+          return latestResolvedValue;
+        }
+
+        latestResolvedId = currentPromiseId;
+        latestResolvedValue = x;
+        return x;
+      });
+    };
   }
 
   /**
@@ -256,12 +466,12 @@
     return numericIndex;
   }
 
-  var noop = function noop() {};
-
   function getNormalizedSources(getSources, params) {
     var seenSourceIds = [];
     return Promise.resolve(getSources(params)).then(function (sources) {
-      invariant(Array.isArray(sources), "The `getSources` function must return an array of sources but returned type ".concat(JSON.stringify(_typeof(sources)), ":\n\n").concat(JSON.stringify(sources, null, 2)));
+      invariant(Array.isArray(sources), function () {
+        return "The `getSources` function must return an array of sources but returned type ".concat(JSON.stringify(_typeof(sources)), ":\n\n").concat(JSON.stringify(decycle(sources), null, 2));
+      });
       return Promise.all(sources // We allow `undefined` and `false` sources to allow users to use
       // `Boolean(query) && source` (=> `false`).
       // We need to remove these values at this point.
@@ -424,55 +634,6 @@
     };
   }
 
-  function getAutocompleteSetters(_ref) {
-    var store = _ref.store;
-
-    var setActiveItemId = function setActiveItemId(value) {
-      store.dispatch('setActiveItemId', value);
-    };
-
-    var setQuery = function setQuery(value) {
-      store.dispatch('setQuery', value);
-    };
-
-    var setCollections = function setCollections(rawValue) {
-      var baseItemId = 0;
-      var value = rawValue.map(function (collection) {
-        return _objectSpread2(_objectSpread2({}, collection), {}, {
-          // We flatten the stored items to support calling `getAlgoliaResults`
-          // from the source itself.
-          items: flatten(collection.items).map(function (item) {
-            return _objectSpread2(_objectSpread2({}, item), {}, {
-              __autocomplete_id: baseItemId++
-            });
-          })
-        });
-      });
-      store.dispatch('setCollections', value);
-    };
-
-    var setIsOpen = function setIsOpen(value) {
-      store.dispatch('setIsOpen', value);
-    };
-
-    var setStatus = function setStatus(value) {
-      store.dispatch('setStatus', value);
-    };
-
-    var setContext = function setContext(value) {
-      store.dispatch('setContext', value);
-    };
-
-    return {
-      setActiveItemId: setActiveItemId,
-      setQuery: setQuery,
-      setCollections: setCollections,
-      setIsOpen: setIsOpen,
-      setStatus: setStatus,
-      setContext: setContext
-    };
-  }
-
   function getDefaultProps(props, pluginSubscribers) {
     var _props$id;
 
@@ -492,6 +653,10 @@
       shouldPanelOpen: function shouldPanelOpen(_ref) {
         var state = _ref.state;
         return getItemsCount(state) > 0;
+      },
+      reshape: function reshape(_ref2) {
+        var sources = _ref2.sources;
+        return sources;
       }
     }, props), {}, {
       // Since `generateAutocompleteId` triggers a side effect (it increments
@@ -569,23 +734,51 @@
         });
       },
       navigator: _objectSpread2({
-        navigate: function navigate(_ref2) {
-          var itemUrl = _ref2.itemUrl;
+        navigate: function navigate(_ref3) {
+          var itemUrl = _ref3.itemUrl;
           environment.location.assign(itemUrl);
         },
-        navigateNewTab: function navigateNewTab(_ref3) {
-          var itemUrl = _ref3.itemUrl;
+        navigateNewTab: function navigateNewTab(_ref4) {
+          var itemUrl = _ref4.itemUrl;
           var windowReference = environment.open(itemUrl, '_blank', 'noopener');
           windowReference === null || windowReference === void 0 ? void 0 : windowReference.focus();
         },
-        navigateNewWindow: function navigateNewWindow(_ref4) {
-          var itemUrl = _ref4.itemUrl;
+        navigateNewWindow: function navigateNewWindow(_ref5) {
+          var itemUrl = _ref5.itemUrl;
           environment.open(itemUrl, '_blank', 'noopener');
         }
       }, props.navigator)
     });
   }
 
+  function reshape(_ref) {
+    var collections = _ref.collections,
+        props = _ref.props,
+        state = _ref.state;
+    // Sources are grouped by `sourceId` to conveniently pick them via destructuring.
+    // Example: `const { recentSearchesPlugin } = sourcesBySourceId`
+    var sourcesBySourceId = collections.reduce(function (acc, collection) {
+      return _objectSpread2(_objectSpread2({}, acc), {}, _defineProperty({}, collection.source.sourceId, _objectSpread2(_objectSpread2({}, collection.source), {}, {
+        getItems: function getItems() {
+          // We provide the resolved items from the collection to the `reshape` prop.
+          return flatten(collection.items);
+        }
+      })));
+    }, {});
+    var reshapeSources = props.reshape({
+      sources: Object.values(sourcesBySourceId),
+      sourcesBySourceId: sourcesBySourceId,
+      state: state
+    }); // We reconstruct the collections with the items modified by the `reshape` prop.
+
+    return flatten(reshapeSources).filter(Boolean).map(function (source) {
+      return {
+        source: source,
+        items: source.getItems()
+      };
+    });
+  }
+
   function isDescription(item) {
     return Boolean(item.execute);
   }
@@ -670,7 +863,9 @@
       });
       var transform = matches[0].transformResponse;
       var items = transform ? transform(mapToAlgoliaResponse(results)) : results;
-      invariant(Array.isArray(items), "The `getItems` function from source \"".concat(source.sourceId, "\" must return an array of items but returned type ").concat(JSON.stringify(_typeof(items)), ":\n\n").concat(JSON.stringify(items, null, 2), ".\n\nSee: https://www.algolia.com/doc/ui-libraries/autocomplete/core-concepts/sources/#param-getitems"));
+      invariant(Array.isArray(items), function () {
+        return "The `getItems` function from source \"".concat(source.sourceId, "\" must return an array of items but returned type ").concat(JSON.stringify(_typeof(items)), ":\n\n").concat(JSON.stringify(decycle(items), null, 2), ".\n\nSee: https://www.algolia.com/doc/ui-libraries/autocomplete/core-concepts/sources/#param-getitems");
+      });
       invariant(items.every(Boolean), "The `getItems` function from source \"".concat(source.sourceId, "\" must return an array of items but returned ").concat(JSON.stringify(undefined), ".\n\nDid you forget to return items?\n\nSee: https://www.algolia.com/doc/ui-libraries/autocomplete/core-concepts/sources/#param-getitems"));
       return {
         source: source,
@@ -679,7 +874,9 @@
     });
   }
 
+  var _excluded = ["event", "nextState", "props", "query", "refresh", "store"];
   var lastStalledId = null;
+  var runConcurrentSafePromise = createConcurrentSafePromise();
   function onInput(_ref) {
     var event = _ref.event,
         _ref$nextState = _ref.nextState,
@@ -688,7 +885,7 @@
         query = _ref.query,
         refresh = _ref.refresh,
         store = _ref.store,
-        setters = _objectWithoutProperties(_ref, ["event", "nextState", "props", "query", "refresh", "store"]);
+        setters = _objectWithoutProperties(_ref, _excluded);
 
     if (lastStalledId) {
       props.environment.clearTimeout(lastStalledId);
@@ -705,28 +902,40 @@
     if (!query && props.openOnFocus === false) {
       var _nextState$isOpen;
 
-      setStatus('idle');
-      setCollections(store.getState().collections.map(function (collection) {
+      var collections = store.getState().collections.map(function (collection) {
         return _objectSpread2(_objectSpread2({}, collection), {}, {
           items: []
         });
-      }));
+      });
+      setStatus('idle');
+      setCollections(collections);
       setIsOpen((_nextState$isOpen = nextState.isOpen) !== null && _nextState$isOpen !== void 0 ? _nextState$isOpen : props.shouldPanelOpen({
         state: store.getState()
-      }));
-      return Promise.resolve();
+      })); // We make sure to update the latest resolved value of the tracked
+      // promises to keep late resolving promises from "cancelling" the state
+      // updates performed in this code path.
+      // We chain with a void promise to respect `onInput`'s expected return type.
+
+      return runConcurrentSafePromise(collections).then(function () {
+        return Promise.resolve();
+      });
     }
 
     setStatus('loading');
     lastStalledId = props.environment.setTimeout(function () {
       setStatus('stalled');
-    }, props.stallThreshold);
-    return props.getSources(_objectSpread2({
+    }, props.stallThreshold); // We track the entire promise chain triggered by `onInput` before mutating
+    // the Autocomplete state to make sure that any state manipulation is based on
+    // fresh data regardless of when promises individually resolve.
+    // We don't track nested promises and only rely on the full chain resolution,
+    // meaning we should only ever manipulate the state once this concurrent-safe
+    // promise is resolved.
+
+    return runConcurrentSafePromise(props.getSources(_objectSpread2({
       query: query,
       refresh: refresh,
       state: store.getState()
     }, setters)).then(function (sources) {
-      setStatus('loading');
       return Promise.all(sources.map(function (source) {
         return Promise.resolve(source.getItems(_objectSpread2({
           query: query,
@@ -738,45 +947,52 @@
       })).then(resolve).then(function (responses) {
         return postResolve(responses, sources);
       }).then(function (collections) {
-        var _nextState$isOpen2;
-
-        setStatus('idle');
-        setCollections(collections);
-        var isPanelOpen = props.shouldPanelOpen({
+        return reshape({
+          collections: collections,
+          props: props,
           state: store.getState()
         });
-        setIsOpen((_nextState$isOpen2 = nextState.isOpen) !== null && _nextState$isOpen2 !== void 0 ? _nextState$isOpen2 : props.openOnFocus && !query && isPanelOpen || isPanelOpen);
-        var highlightedItem = getActiveItem(store.getState());
+      });
+    })).then(function (collections) {
+      var _nextState$isOpen2;
 
-        if (store.getState().activeItemId !== null && highlightedItem) {
-          var item = highlightedItem.item,
-              itemInputValue = highlightedItem.itemInputValue,
-              itemUrl = highlightedItem.itemUrl,
-              source = highlightedItem.source;
-          source.onActive(_objectSpread2({
-            event: event,
-            item: item,
-            itemInputValue: itemInputValue,
-            itemUrl: itemUrl,
-            refresh: refresh,
-            source: source,
-            state: store.getState()
-          }, setters));
-        }
-      }).finally(function () {
-        if (lastStalledId) {
-          props.environment.clearTimeout(lastStalledId);
-        }
+      setStatus('idle');
+      setCollections(collections);
+      var isPanelOpen = props.shouldPanelOpen({
+        state: store.getState()
       });
+      setIsOpen((_nextState$isOpen2 = nextState.isOpen) !== null && _nextState$isOpen2 !== void 0 ? _nextState$isOpen2 : props.openOnFocus && !query && isPanelOpen || isPanelOpen);
+      var highlightedItem = getActiveItem(store.getState());
+
+      if (store.getState().activeItemId !== null && highlightedItem) {
+        var item = highlightedItem.item,
+            itemInputValue = highlightedItem.itemInputValue,
+            itemUrl = highlightedItem.itemUrl,
+            source = highlightedItem.source;
+        source.onActive(_objectSpread2({
+          event: event,
+          item: item,
+          itemInputValue: itemInputValue,
+          itemUrl: itemUrl,
+          refresh: refresh,
+          source: source,
+          state: store.getState()
+        }, setters));
+      }
+    }).finally(function () {
+      if (lastStalledId) {
+        props.environment.clearTimeout(lastStalledId);
+      }
     });
   }
 
+  var _excluded$1 = ["event", "props", "refresh", "store"];
   function onKeyDown(_ref) {
     var event = _ref.event,
         props = _ref.props,
         refresh = _ref.refresh,
         store = _ref.store,
-        setters = _objectWithoutProperties(_ref, ["event", "props", "refresh", "store"]);
+        setters = _objectWithoutProperties(_ref, _excluded$1);
 
     if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {
       // eslint-disable-next-line no-inner-declarations
@@ -942,17 +1158,22 @@
     }
   }
 
+  var _excluded$2 = ["props", "refresh", "store"],
+      _excluded2 = ["inputElement", "formElement", "panelElement"],
+      _excluded3 = ["inputElement"],
+      _excluded4 = ["inputElement", "maxLength"],
+      _excluded5 = ["item", "source"];
   function getPropGetters(_ref) {
     var props = _ref.props,
         refresh = _ref.refresh,
         store = _ref.store,
-        setters = _objectWithoutProperties(_ref, ["props", "refresh", "store"]);
+        setters = _objectWithoutProperties(_ref, _excluded$2);
 
     var getEnvironmentProps = function getEnvironmentProps(providedProps) {
       var inputElement = providedProps.inputElement,
           formElement = providedProps.formElement,
           panelElement = providedProps.panelElement,
-          rest = _objectWithoutProperties(providedProps, ["inputElement", "formElement", "panelElement"]);
+          rest = _objectWithoutProperties(providedProps, _excluded2);
 
       return _objectSpread2({
         // On touch devices, we do not rely on the native `blur` event of the
@@ -960,15 +1181,15 @@
         // outside of the autocomplete elements.
         // This ensures a working experience on mobile because we blur the input
         // on touch devices when the user starts scrolling (`touchmove`).
+        // @TODO: support cases where there are multiple Autocomplete instances.
+        // Right now, a second instance makes this computation return false.
         onTouchStart: function onTouchStart(event) {
           if (store.getState().isOpen === false || event.target === inputElement) {
             return;
-          } // @TODO: support cases where there are multiple Autocomplete instances.
-          // Right now, a second instance makes this computation return false.
-
+          }
 
           var isTargetWithinAutocomplete = [formElement, panelElement].some(function (contextNode) {
-            return isOrContainsNode(contextNode, event.target) || isOrContainsNode(contextNode, props.environment.document.activeElement);
+            return isOrContainsNode(contextNode, event.target);
           });
 
           if (isTargetWithinAutocomplete === false) {
@@ -1001,7 +1222,7 @@
 
     var getFormProps = function getFormProps(providedProps) {
       var inputElement = providedProps.inputElement,
-          rest = _objectWithoutProperties(providedProps, ["inputElement"]);
+          rest = _objectWithoutProperties(providedProps, _excluded3);
 
       return _objectSpread2({
         action: '',
@@ -1057,7 +1278,7 @@
           inputElement = _ref2.inputElement,
           _ref2$maxLength = _ref2.maxLength,
           maxLength = _ref2$maxLength === void 0 ? 512 : _ref2$maxLength,
-          rest = _objectWithoutProperties(_ref2, ["inputElement", "maxLength"]);
+          rest = _objectWithoutProperties(_ref2, _excluded4);
 
       var activeItem = getActiveItem(store.getState());
       return _objectSpread2({
@@ -1148,7 +1369,7 @@
     var getItemProps = function getItemProps(providedProps) {
       var item = providedProps.item,
           source = providedProps.source,
-          rest = _objectWithoutProperties(providedProps, ["item", "source"]);
+          rest = _objectWithoutProperties(providedProps, _excluded5);
 
       return _objectSpread2({
         id: "".concat(props.id, "-item-").concat(item.__autocomplete_id),
@@ -1235,6 +1456,44 @@
     };
   }
 
+  function getMetadata(_ref) {
+    var _, _options$__autocomple, _options$__autocomple2, _options$__autocomple3;
+
+    var plugins = _ref.plugins,
+        options = _ref.options;
+    var optionsKey = (_ = (((_options$__autocomple = options.__autocomplete_metadata) === null || _options$__autocomple === void 0 ? void 0 : _options$__autocomple.userAgents) || [])[0]) === null || _ === void 0 ? void 0 : _.segment;
+    var extraOptions = optionsKey ? _defineProperty({}, optionsKey, Object.keys(((_options$__autocomple2 = options.__autocomplete_metadata) === null || _options$__autocomple2 === void 0 ? void 0 : _options$__autocomple2.options) || {})) : {};
+    return {
+      plugins: plugins.map(function (plugin) {
+        return {
+          name: plugin.name,
+          options: Object.keys(plugin.__autocomplete_pluginOptions || [])
+        };
+      }),
+      options: _objectSpread2({
+        'autocomplete-core': Object.keys(options)
+      }, extraOptions),
+      ua: userAgents.concat(((_options$__autocomple3 = options.__autocomplete_metadata) === null || _options$__autocomple3 === void 0 ? void 0 : _options$__autocomple3.userAgents) || [])
+    };
+  }
+  function injectMetadata(_ref3) {
+    var _environment$navigato;
+
+    var metadata = _ref3.metadata,
+        environment = _ref3.environment;
+    var isMetadataEnabled = (_environment$navigato = environment.navigator) === null || _environment$navigato === void 0 ? void 0 : _environment$navigato.userAgent.includes('Algolia Crawler');
+
+    if (isMetadataEnabled) {
+      var metadataContainer = environment.document.createElement('meta');
+      var headRef = environment.document.querySelector('head');
+      metadataContainer.name = 'algolia:metadata';
+      setTimeout(function () {
+        metadataContainer.content = JSON.stringify(metadata);
+        headRef.appendChild(metadataContainer);
+      }, 0);
+    }
+  }
+
   function getCompletion(_ref) {
     var _getActiveItem;
 
@@ -1454,16 +1713,20 @@
         }
       }));
     });
+    injectMetadata({
+      metadata: getMetadata({
+        plugins: props.plugins,
+        options: options
+      }),
+      environment: props.environment
+    });
     return _objectSpread2(_objectSpread2({
       refresh: refresh
     }, propGetters), setters);
   }
 
-  var version = '1.2.2';
-
   exports.createAutocomplete = createAutocomplete;
   exports.getDefaultProps = getDefaultProps;
-  exports.version = version;
 
   Object.defineProperty(exports, '__esModule', { value: true });