npm - @sonic-equipment/ui - Versions diffs - 220.0.0 → 221.0.0 - Mend

@sonic-equipment/ui 220.0.0 → 221.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (87) hide show

package/dist/node_modules/.pnpm/@algolia_autocomplete-core@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0_search-insights@2.17.3/node_modules/@algolia/autocomplete-core/dist/esm/utils/getActiveItem.js ADDED Viewed

@@ -0,0 +1,79 @@
+// We don't have access to the autocomplete source when we call `onKeyDown`
+// or `onClick` because those are native browser events.
+// However, we can get the source from the suggestion index.
+function getCollectionFromActiveItemId(state) {
+  // Given 3 sources with respectively 1, 2 and 3 suggestions: [1, 2, 3]
+  // We want to get the accumulated counts:
+  // [1, 1 + 2, 1 + 2 + 3] = [1, 3, 3 + 3] = [1, 3, 6]
+  var accumulatedCollectionsCount = state.collections.map(function (collections) {
+    return collections.items.length;
+  }).reduce(function (acc, collectionsCount, index) {
+    var previousValue = acc[index - 1] || 0;
+    var nextValue = previousValue + collectionsCount;
+    acc.push(nextValue);
+    return acc;
+  }, []);
+  // Based on the accumulated counts, we can infer the index of the suggestion.
+  var collectionIndex = accumulatedCollectionsCount.reduce(function (acc, current) {
+    if (current <= state.activeItemId) {
+      return acc + 1;
+    }
+    return acc;
+  }, 0);
+  return state.collections[collectionIndex];
+}
+/**
+ * Gets the highlighted index relative to a suggestion object (not the absolute
+ * highlighted index).
+ *
+ * Example:
+ *  [['a', 'b'], ['c', 'd', 'e'], ['f']]
+ *                      ↑
+ *         (absolute: 3, relative: 1)
+ */
+function getRelativeActiveItemId(_ref) {
+  var state = _ref.state,
+    collection = _ref.collection;
+  var isOffsetFound = false;
+  var counter = 0;
+  var previousItemsOffset = 0;
+  while (isOffsetFound === false) {
+    var currentCollection = state.collections[counter];
+    if (currentCollection === collection) {
+      isOffsetFound = true;
+      break;
+    }
+    previousItemsOffset += currentCollection.items.length;
+    counter++;
+  }
+  return state.activeItemId - previousItemsOffset;
+}
+function getActiveItem(state) {
+  var collection = getCollectionFromActiveItemId(state);
+  if (!collection) {
+    return null;
+  }
+  var item = collection.items[getRelativeActiveItemId({
+    state: state,
+    collection: collection
+  })];
+  var source = collection.source;
+  var itemInputValue = source.getItemInputValue({
+    item: item,
+    state: state
+  });
+  var itemUrl = source.getItemUrl({
+    item: item,
+    state: state
+  });
+  return {
+    item: item,
+    itemInputValue: itemInputValue,
+    itemUrl: itemUrl,
+    source: source
+  };
+}
+export { getActiveItem };

@@ -0,0 +1,12 @@
+/**
+ * Returns a full element id for an autocomplete element.
+ *
+ * @param autocompleteInstanceId The id of the autocomplete instance
+ * @param elementId The specific element id
+ * @param source The source of the element, when it needs to be scoped
+ */
+function getAutocompleteElementId(autocompleteInstanceId, elementId, source) {
+  return [autocompleteInstanceId, source === null || source === void 0 ? void 0 : source.sourceId, elementId].filter(Boolean).join('-').replace(/\s/g, '');
+}
+export { getAutocompleteElementId };

@@ -0,0 +1,5 @@
+function getNativeEvent(event) {
+  return event.nativeEvent || event;
+}
+export { getNativeEvent };

@@ -0,0 +1,31 @@
+/**
+ * Returns the next active item ID from the current state.
+ *
+ * We allow circular keyboard navigation from the base index.
+ * The base index can either be `null` (nothing is highlighted) or `0`
+ * (the first item is highlighted).
+ * The base index is allowed to get assigned `null` only if
+ * `props.defaultActiveItemId` is `null`. This pattern allows to "stop"
+ * by the actual query before navigating to other suggestions as seen on
+ * Google or Amazon.
+ *
+ * @param moveAmount The offset to increment (or decrement) the last index
+ * @param baseIndex The current index to compute the next index from
+ * @param itemCount The number of items
+ * @param defaultActiveItemId The default active index to fallback to
+ */
+function getNextActiveItemId(moveAmount, baseIndex, itemCount, defaultActiveItemId) {
+  if (!itemCount) {
+    return null;
+  }
+  if (moveAmount < 0 && (baseIndex === null || defaultActiveItemId !== null && baseIndex === 0)) {
+    return itemCount + moveAmount;
+  }
+  var numericIndex = (baseIndex === null ? -1 : baseIndex) + moveAmount;
+  if (numericIndex <= -1 || numericIndex >= itemCount) {
+    return defaultActiveItemId === null ? null : 0;
+  }
+  return numericIndex;
+}
+export { getNextActiveItemId };

@@ -0,0 +1,53 @@
+import { invariant } from '../../../../../../../@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/invariant.js';
+import { decycle } from '../../../../../../../@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/decycle.js';
+import { noop } from '../../../../../../../@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/noop.js';
+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), true).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; }
+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; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+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); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+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 getNormalizedSources(getSources, params) {
+  var seenSourceIds = [];
+  return Promise.resolve(getSources(params)).then(function (sources) {
+    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.
+    .filter(function (maybeSource) {
+      return Boolean(maybeSource);
+    }).map(function (source) {
+      invariant(typeof source.sourceId === 'string', 'A source must provide a `sourceId` string.');
+      if (seenSourceIds.includes(source.sourceId)) {
+        throw new Error("[Autocomplete] The `sourceId` ".concat(JSON.stringify(source.sourceId), " is not unique."));
+      }
+      seenSourceIds.push(source.sourceId);
+      var defaultSource = {
+        getItemInputValue: function getItemInputValue(_ref) {
+          var state = _ref.state;
+          return state.query;
+        },
+        getItemUrl: function getItemUrl() {
+          return undefined;
+        },
+        onSelect: function onSelect(_ref2) {
+          var setIsOpen = _ref2.setIsOpen;
+          setIsOpen(false);
+        },
+        onActive: noop,
+        onResolve: noop
+      };
+      Object.keys(defaultSource).forEach(function (key) {
+        defaultSource[key].__default = true;
+      });
+      var normalizedSource = _objectSpread(_objectSpread({}, defaultSource), source);
+      return Promise.resolve(normalizedSource);
+    }));
+  });
+}
+export { getNormalizedSources };

@@ -0,0 +1,39 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+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 _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; }
+/**
+ * If a plugin is configured to await a submit event, this returns a promise
+ * for either the max timeout value found or until it completes.
+ * Otherwise, return undefined.
+ */
+var getPluginSubmitPromise = function getPluginSubmitPromise(plugins, pendingRequests) {
+  var waitUntilComplete = false;
+  var timeouts = [];
+  var _iterator = _createForOfIteratorHelper(plugins),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _plugin$__autocomplet, _plugin$__autocomplet2, _plugin$__autocomplet3;
+      var plugin = _step.value;
+      var value = (_plugin$__autocomplet = plugin.__autocomplete_pluginOptions) === null || _plugin$__autocomplet === void 0 ? void 0 : (_plugin$__autocomplet2 = (_plugin$__autocomplet3 = _plugin$__autocomplet).awaitSubmit) === null || _plugin$__autocomplet2 === void 0 ? void 0 : _plugin$__autocomplet2.call(_plugin$__autocomplet3);
+      if (typeof value === 'number') {
+        timeouts.push(value);
+      } else if (value === true) {
+        waitUntilComplete = true;
+        break; // break loop as bool overrides num array below
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  if (waitUntilComplete) {
+    return pendingRequests.wait();
+  } else if (timeouts.length > 0) {
+    return pendingRequests.wait(Math.max.apply(Math, timeouts));
+  }
+  return undefined;
+};
+export { getPluginSubmitPromise };

@@ -0,0 +1,5 @@
+function isOrContainsNode(parent, child) {
+  return parent === child || parent.contains(child);
+}
+export { isOrContainsNode };

@@ -0,0 +1,6 @@
+var regex = /((gt|sm)-|galaxy nexus)|samsung[- ]|samsungbrowser/i;
+function isSamsung(userAgent) {
+  return Boolean(userAgent && userAgent.match(regex));
+}
+export { isSamsung };

@@ -0,0 +1,25 @@
+function mapToAlgoliaResponse(rawResults) {
+  return {
+    results: rawResults,
+    hits: rawResults.map(function (result) {
+      return result.hits;
+    }).filter(Boolean),
+    facetHits: rawResults.map(function (result) {
+      var _facetHits;
+      return (_facetHits = result.facetHits) === null || _facetHits === void 0 ? void 0 : _facetHits.map(function (facetHit) {
+        // Bring support for the highlighting components.
+        return {
+          label: facetHit.value,
+          count: facetHit.count,
+          _highlightResult: {
+            label: {
+              value: facetHit.highlighted
+            }
+          }
+        };
+      });
+    }).filter(Boolean)
+  };
+}
+export { mapToAlgoliaResponse };

package/dist/node_modules/.pnpm/@algolia_autocomplete-js@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0_search-insights@2.17.3/node_modules/@algolia/autocomplete-js/dist/esm/requesters/createAlgoliaRequester.js ADDED Viewed

@@ -0,0 +1,16 @@
+import { createRequester, fetchAlgoliaResults } from '@algolia/autocomplete-preset-algolia';
+import { userAgents } from '../userAgents.js';
+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 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), true).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; }
+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; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+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); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var createAlgoliaRequester = createRequester(function (params) {
+  return fetchAlgoliaResults(_objectSpread(_objectSpread({}, params), {}, {
+    userAgents: userAgents
+  }));
+}, 'algolia');
+export { createAlgoliaRequester };

@@ -0,0 +1,12 @@
+import { createAlgoliaRequester } from './createAlgoliaRequester.js';
+/**
+ * Retrieves Algolia results from multiple indices.
+ */
+var getAlgoliaResults = createAlgoliaRequester({
+  transformResponse: function transformResponse(response) {
+    return response.hits;
+  }
+});
+export { getAlgoliaResults };

@@ -0,0 +1,8 @@
+import { version } from '../../../../../../@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/version.js';
+var userAgents = [{
+  segment: 'autocomplete-js',
+  version: version
+}];
+export { userAgents };

package/dist/node_modules/.pnpm/@algolia_autocomplete-plugin-algolia-insights@1.19.2_@algolia_client-search@4.24.0_algoliasea_57b3nqmtgbeobm4sw3iw2qdpxy/node_modules/@algolia/autocomplete-plugin-algolia-insights/dist/esm/createAlgoliaInsightsPlugin.js ADDED Viewed

@@ -0,0 +1,252 @@
+import { createClickedEvent } from './createClickedEvent.js';
+import { createSearchInsightsApi } from './createSearchInsightsApi.js';
+import { createViewedEvents } from './createViewedEvents.js';
+import { isAlgoliaInsightsHit } from './isAlgoliaInsightsHit.js';
+import { safelyRunOnBrowser } from '../../../../../../@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/safelyRunOnBrowser.js';
+import { debounce } from '../../../../../../@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/debounce.js';
+import { isEqual } from '../../../../../../@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/isEqual.js';
+import { createRef } from '../../../../../../@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/createRef.js';
+import { noop } from '../../../../../../@algolia_autocomplete-shared@1.19.2_@algolia_client-search@4.24.0_algoliasearch@4.24.0/node_modules/@algolia/autocomplete-shared/dist/esm/noop.js';
+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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+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 _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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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 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), true).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; }
+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; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+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); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var VIEW_EVENT_DELAY = 400;
+var ALGOLIA_INSIGHTS_VERSION = '2.15.0';
+var ALGOLIA_INSIGHTS_SRC = "https://cdn.jsdelivr.net/npm/search-insights@".concat(ALGOLIA_INSIGHTS_VERSION, "/dist/search-insights.min.js");
+var sendViewedObjectIDs = debounce(function (_ref) {
+  var onItemsChange = _ref.onItemsChange,
+    items = _ref.items,
+    insights = _ref.insights,
+    state = _ref.state;
+  onItemsChange({
+    insights: insights,
+    insightsEvents: createViewedEvents({
+      items: items
+    }).map(function (event) {
+      return _objectSpread({
+        eventName: 'Items Viewed'
+      }, event);
+    }),
+    state: state
+  });
+}, VIEW_EVENT_DELAY);
+function createAlgoliaInsightsPlugin(options) {
+  var _getOptions = getOptions(options),
+    providedInsightsClient = _getOptions.insightsClient,
+    insightsInitParams = _getOptions.insightsInitParams,
+    onItemsChange = _getOptions.onItemsChange,
+    onSelectEvent = _getOptions.onSelect,
+    onActiveEvent = _getOptions.onActive,
+    __autocomplete_clickAnalytics = _getOptions.__autocomplete_clickAnalytics;
+  var insightsClient = providedInsightsClient;
+  if (!providedInsightsClient) {
+    safelyRunOnBrowser(function (_ref2) {
+      var window = _ref2.window;
+      var pointer = window.AlgoliaAnalyticsObject || 'aa';
+      if (typeof pointer === 'string') {
+        insightsClient = window[pointer];
+      }
+      if (!insightsClient) {
+        window.AlgoliaAnalyticsObject = pointer;
+        if (!window[pointer]) {
+          window[pointer] = function () {
+            if (!window[pointer].queue) {
+              window[pointer].queue = [];
+            }
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+            window[pointer].queue.push(args);
+          };
+        }
+        window[pointer].version = ALGOLIA_INSIGHTS_VERSION;
+        insightsClient = window[pointer];
+        loadInsights(window);
+      }
+    });
+  }
+  // We return an empty plugin if `insightsClient` is still undefined at
+  // this stage, which can happen in server environments.
+  if (!insightsClient) {
+    return {};
+  }
+  if (insightsInitParams) {
+    insightsClient('init', _objectSpread({
+      partial: true
+    }, insightsInitParams));
+  }
+  var insights = createSearchInsightsApi(insightsClient);
+  var previousItems = createRef([]);
+  var debouncedOnStateChange = debounce(function (_ref3) {
+    var state = _ref3.state;
+    if (!state.isOpen) {
+      return;
+    }
+    var items = state.collections.reduce(function (acc, current) {
+      return [].concat(_toConsumableArray(acc), _toConsumableArray(current.items));
+    }, []).filter(isAlgoliaInsightsHit);
+    if (!isEqual(previousItems.current.map(function (x) {
+      return x.objectID;
+    }), items.map(function (x) {
+      return x.objectID;
+    }))) {
+      previousItems.current = items;
+      if (items.length > 0) {
+        sendViewedObjectIDs({
+          onItemsChange: onItemsChange,
+          items: items,
+          insights: insights,
+          state: state
+        });
+      }
+    }
+  }, 0);
+  return {
+    name: 'aa.algoliaInsightsPlugin',
+    subscribe: function subscribe(_ref4) {
+      var setContext = _ref4.setContext,
+        onSelect = _ref4.onSelect,
+        onActive = _ref4.onActive;
+      function setInsightsContext(userToken) {
+        setContext({
+          algoliaInsightsPlugin: {
+            __algoliaSearchParameters: _objectSpread(_objectSpread({}, __autocomplete_clickAnalytics ? {
+              clickAnalytics: true
+            } : {}), userToken ? {
+              userToken: normalizeUserToken(userToken)
+            } : {}),
+            insights: insights
+          }
+        });
+      }
+      insightsClient('addAlgoliaAgent', 'insights-plugin');
+      setInsightsContext();
+      // Handles user token changes
+      insightsClient('onUserTokenChange', function (userToken) {
+        setInsightsContext(userToken);
+      });
+      insightsClient('getUserToken', null, function (_error, userToken) {
+        setInsightsContext(userToken);
+      });
+      onSelect(function (_ref5) {
+        var item = _ref5.item,
+          state = _ref5.state,
+          event = _ref5.event,
+          source = _ref5.source;
+        if (!isAlgoliaInsightsHit(item)) {
+          return;
+        }
+        onSelectEvent({
+          state: state,
+          event: event,
+          insights: insights,
+          item: item,
+          insightsEvents: [_objectSpread({
+            eventName: 'Item Selected'
+          }, createClickedEvent({
+            item: item,
+            items: source.getItems().filter(isAlgoliaInsightsHit)
+          }))]
+        });
+      });
+      onActive(function (_ref6) {
+        var item = _ref6.item,
+          source = _ref6.source,
+          state = _ref6.state,
+          event = _ref6.event;
+        if (!isAlgoliaInsightsHit(item)) {
+          return;
+        }
+        onActiveEvent({
+          state: state,
+          event: event,
+          insights: insights,
+          item: item,
+          insightsEvents: [_objectSpread({
+            eventName: 'Item Active'
+          }, createClickedEvent({
+            item: item,
+            items: source.getItems().filter(isAlgoliaInsightsHit)
+          }))]
+        });
+      });
+    },
+    onStateChange: function onStateChange(_ref7) {
+      var state = _ref7.state;
+      debouncedOnStateChange({
+        state: state
+      });
+    },
+    __autocomplete_pluginOptions: options
+  };
+}
+function getAlgoliaSources() {
+  var _context$algoliaInsig;
+  var algoliaSourceBase = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var context = arguments.length > 1 ? arguments[1] : undefined;
+  return [].concat(_toConsumableArray(algoliaSourceBase), ['autocomplete-internal'], _toConsumableArray((_context$algoliaInsig = context.algoliaInsightsPlugin) !== null && _context$algoliaInsig !== void 0 && _context$algoliaInsig.__automaticInsights ? ['autocomplete-automatic'] : []));
+}
+function getOptions(options) {
+  return _objectSpread({
+    onItemsChange: function onItemsChange(_ref8) {
+      var insights = _ref8.insights,
+        insightsEvents = _ref8.insightsEvents,
+        state = _ref8.state;
+      insights.viewedObjectIDs.apply(insights, _toConsumableArray(insightsEvents.map(function (event) {
+        return _objectSpread(_objectSpread({}, event), {}, {
+          algoliaSource: getAlgoliaSources(event.algoliaSource, state.context)
+        });
+      })));
+    },
+    onSelect: function onSelect(_ref9) {
+      var insights = _ref9.insights,
+        insightsEvents = _ref9.insightsEvents,
+        state = _ref9.state;
+      insights.clickedObjectIDsAfterSearch.apply(insights, _toConsumableArray(insightsEvents.map(function (event) {
+        return _objectSpread(_objectSpread({}, event), {}, {
+          algoliaSource: getAlgoliaSources(event.algoliaSource, state.context)
+        });
+      })));
+    },
+    onActive: noop,
+    __autocomplete_clickAnalytics: true
+  }, options);
+}
+function loadInsights(environment) {
+  var errorMessage = "[Autocomplete]: Could not load search-insights.js. Please load it manually following https://alg.li/insights-autocomplete";
+  try {
+    var script = environment.document.createElement('script');
+    script.async = true;
+    script.src = ALGOLIA_INSIGHTS_SRC;
+    script.onerror = function () {
+      // eslint-disable-next-line no-console
+      console.error(errorMessage);
+    };
+    document.body.appendChild(script);
+  } catch (cause) {
+    // eslint-disable-next-line no-console
+    console.error(errorMessage);
+  }
+}
+/**
+ * While `search-insights` supports both string and number user tokens,
+ * the Search API only accepts strings. This function normalizes the user token.
+ */
+function normalizeUserToken(userToken) {
+  return typeof userToken === 'number' ? userToken.toString() : userToken;
+}
+export { createAlgoliaInsightsPlugin };

@@ -0,0 +1,16 @@
+function createClickedEvent(_ref) {
+  var item = _ref.item,
+    _ref$items = _ref.items,
+    items = _ref$items === void 0 ? [] : _ref$items;
+  return {
+    index: item.__autocomplete_indexName,
+    items: [item],
+    positions: [1 + items.findIndex(function (x) {
+      return x.objectID === item.objectID;
+    })],
+    queryID: item.__autocomplete_queryID,
+    algoliaSource: ['autocomplete']
+  };
+}
+export { createClickedEvent };