@atlaskit/editor-plugin-type-ahead 0.5.0 → 0.7.0

package/dist/cjs/ui/hooks/use-load-items.js

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useLoadItems = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = require("react");
+var _updateListItems = require("../../commands/update-list-items");
+var EMPTY_LIST_ITEM = [];
+var useLoadItems = exports.useLoadItems = function useLoadItems(triggerHandler, editorView, query) {
+  var _useState = (0, _react.useState)(EMPTY_LIST_ITEM),
+    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
+    items = _useState2[0],
+    setItems = _useState2[1];
+  var componentIsMounted = (0, _react.useRef)(true);
+  var editorViewRef = (0, _react.useRef)(editorView);
+  (0, _react.useEffect)(function () {
+    var getItems = triggerHandler === null || triggerHandler === void 0 ? void 0 : triggerHandler.getItems;
+    if (!getItems) {
+      setItems(EMPTY_LIST_ITEM);
+      return;
+    }
+    var options = {
+      query: query || '',
+      editorState: editorView.state
+    };
+    var view = editorViewRef.current;
+    getItems(options).then(function (result) {
+      var list = result.length > 0 ? result : EMPTY_LIST_ITEM;
+      if (componentIsMounted.current) {
+        setItems(list);
+      }
+      queueMicrotask(function () {
+        (0, _updateListItems.updateListItem)(list)(view.state, view.dispatch);
+      });
+    });
+
+    // ignore because EditorView is mutable but we don't want to
+    // call loadItems when it changes, only when the query changes
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [triggerHandler, query]);
+  (0, _react.useEffect)(function () {
+    return function () {
+      componentIsMounted.current = false;
+    };
+  }, []);
+  return items;
+};

package/dist/cjs/ui/hooks/use-on-force-select.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useOnForceSelect = void 0;
+var _react = require("react");
+var _typeAhead = require("@atlaskit/editor-common/type-ahead");
+var _insertTypeAheadItem = require("../../commands/insert-type-ahead-item");
+var useOnForceSelect = exports.useOnForceSelect = function useOnForceSelect(_ref) {
+  var triggerHandler = _ref.triggerHandler,
+    items = _ref.items,
+    query = _ref.query,
+    editorView = _ref.editorView,
+    closePopup = _ref.closePopup;
+  var editorViewRef = (0, _react.useRef)(editorView);
+  (0, _react.useLayoutEffect)(function () {
+    if (!query || typeof triggerHandler.forceSelect !== 'function') {
+      return;
+    }
+    var item = triggerHandler.forceSelect({
+      items: items,
+      query: query,
+      editorState: editorViewRef.current.state
+    });
+    if (!item) {
+      return;
+    }
+    var view = editorViewRef.current;
+    closePopup();
+    queueMicrotask(function () {
+      (0, _insertTypeAheadItem.insertTypeAheadItem)(view)({
+        item: item,
+        mode: _typeAhead.SelectItemMode.SPACE,
+        query: query,
+        handler: triggerHandler,
+        sourceListItem: items
+      });
+    });
+  }, [triggerHandler, closePopup, query, items]);
+};

package/dist/cjs/utils.js

@@ -0,0 +1,130 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moveSelectedIndex = exports.isTypeAheadOpen = exports.isTypeAheadHandler = exports.isTypeAheadAllowed = exports.getTypeAheadQuery = exports.getTypeAheadListAriaLabels = exports.getTypeAheadHandler = exports.getPluginState = exports.findHandlerByTrigger = exports.findHandler = void 0;
+var _typeAhead = require("@atlaskit/editor-common/type-ahead");
+var _updateSelectedIndex = require("./commands/update-selected-index");
+var _messages = require("./messages");
+var _key = require("./pm-plugins/key");
+var _statsModifier = require("./stats-modifier");
+var isTypeAheadHandler = exports.isTypeAheadHandler = function isTypeAheadHandler(handler) {
+  return handler && Object.values(_typeAhead.TypeAheadAvailableNodes).includes(handler.id) && typeof handler.trigger === 'string' && typeof handler.selectItem === 'function' && typeof handler.getItems === 'function';
+};
+
+/** Is a typeahead plugin open? */
+var isTypeAheadOpen = exports.isTypeAheadOpen = function isTypeAheadOpen(editorState) {
+  var _typeAheadPluginKey$g;
+  return !!(_key.pluginKey !== null && _key.pluginKey !== void 0 && (_typeAheadPluginKey$g = _key.pluginKey.getState(editorState)) !== null && _typeAheadPluginKey$g !== void 0 && (_typeAheadPluginKey$g = _typeAheadPluginKey$g.decorationSet) !== null && _typeAheadPluginKey$g !== void 0 && _typeAheadPluginKey$g.find().length);
+};
+var getPluginState = exports.getPluginState = function getPluginState(editorState) {
+  return _key.pluginKey.getState(editorState);
+};
+var getTypeAheadHandler = exports.getTypeAheadHandler = function getTypeAheadHandler(editorState) {
+  var _typeAheadPluginKey$g2;
+  return (_typeAheadPluginKey$g2 = _key.pluginKey.getState(editorState)) === null || _typeAheadPluginKey$g2 === void 0 ? void 0 : _typeAheadPluginKey$g2.triggerHandler;
+};
+var getTypeAheadQuery = exports.getTypeAheadQuery = function getTypeAheadQuery(editorState) {
+  var _typeAheadPluginKey$g3;
+  return (_typeAheadPluginKey$g3 = _key.pluginKey.getState(editorState)) === null || _typeAheadPluginKey$g3 === void 0 ? void 0 : _typeAheadPluginKey$g3.query;
+};
+var isTypeAheadAllowed = exports.isTypeAheadAllowed = function isTypeAheadAllowed(state) {
+  var isOpen = isTypeAheadOpen(state);
+  // if the TypeAhead is open
+  // we should not allow it
+  return !isOpen;
+};
+var findHandler = exports.findHandler = function findHandler(id, state) {
+  var pluginState = _key.pluginKey.getState(state);
+  if (!pluginState || !pluginState.typeAheadHandlers || pluginState.typeAheadHandlers.length === 0) {
+    return null;
+  }
+  var typeAheadHandlers = pluginState.typeAheadHandlers;
+  return typeAheadHandlers.find(function (h) {
+    return h.id === id;
+  }) || null;
+};
+var findHandlerByTrigger = exports.findHandlerByTrigger = function findHandlerByTrigger(_ref) {
+  var trigger = _ref.trigger,
+    editorState = _ref.editorState;
+  var pluginState = _key.pluginKey.getState(editorState);
+  if (!pluginState || !pluginState.typeAheadHandlers || pluginState.typeAheadHandlers.length === 0) {
+    return null;
+  }
+  var typeAheadHandlers = pluginState.typeAheadHandlers;
+  return typeAheadHandlers.find(function (h) {
+    return h.trigger === trigger;
+  }) || null;
+};
+var moveSelectedIndex = exports.moveSelectedIndex = function moveSelectedIndex(_ref2) {
+  var editorView = _ref2.editorView,
+    direction = _ref2.direction;
+  return function () {
+    var typeAheadState = getPluginState(editorView.state);
+    if (!typeAheadState) {
+      return;
+    }
+    var selectedIndex = typeAheadState.selectedIndex,
+      items = typeAheadState.items;
+    var stats = typeAheadState.stats instanceof _statsModifier.StatsModifier ? typeAheadState.stats : new _statsModifier.StatsModifier();
+    var nextIndex;
+    if (direction === 'next') {
+      stats.increaseArrowDown();
+
+      /**
+       * See: https://product-fabric.atlassian.net/browse/ED-17200
+       * `selectedIndex` is forced to -1 now to not immediately focus the typeahead
+       * and only do so when there is explicit logic to focus into the typeahead
+       * options.
+       *
+       * This check for "set index to 1 when -1"
+       * - is a temporary workaround to get back the previous behaviour without
+       *    entirely reverting the a11y improvements
+       *
+       */
+      if (selectedIndex === -1 && items.length > 1) {
+        nextIndex = 1;
+      } else {
+        nextIndex = selectedIndex >= items.length - 1 ? 0 : selectedIndex + 1;
+      }
+    } else {
+      stats.increaseArrowUp();
+      nextIndex = selectedIndex <= 0 ? items.length - 1 : selectedIndex - 1;
+    }
+    (0, _updateSelectedIndex.updateSelectedIndex)(nextIndex)(editorView.state, editorView.dispatch);
+  };
+};
+var getTypeAheadListAriaLabels = exports.getTypeAheadListAriaLabels = function getTypeAheadListAriaLabels(trigger, intl, item) {
+  var _item$mention, _item$mention2, _item$emoji, _item$emoji2, _item$emoji3;
+  switch (trigger) {
+    case '@':
+      return {
+        popupAriaLabel: intl.formatMessage(_messages.typeAheadListMessages.mentionPopupLabel),
+        listItemAriaLabel: intl.formatMessage(_messages.typeAheadListMessages.metionListItemLabel, {
+          name: (item === null || item === void 0 || (_item$mention = item.mention) === null || _item$mention === void 0 ? void 0 : _item$mention.name) || '',
+          shortName: (item === null || item === void 0 || (_item$mention2 = item.mention) === null || _item$mention2 === void 0 ? void 0 : _item$mention2.mentionName) || ''
+        })
+      };
+    case '/':
+      return {
+        popupAriaLabel: intl.formatMessage(_messages.typeAheadListMessages.quickInsertPopupLabel),
+        listItemAriaLabel: intl.formatMessage(_messages.typeAheadListMessages.emojiListItemLabel, {
+          name: (item === null || item === void 0 ? void 0 : item.title) || '',
+          shortcut: (item === null || item === void 0 || (_item$emoji = item.emoji) === null || _item$emoji === void 0 ? void 0 : _item$emoji.shortName) || ''
+        })
+      };
+    case ':':
+      return {
+        popupAriaLabel: intl.formatMessage(_messages.typeAheadListMessages.emojiPopupLabel),
+        listItemAriaLabel: intl.formatMessage(_messages.typeAheadListMessages.emojiListItemLabel, {
+          name: (item === null || item === void 0 || (_item$emoji2 = item.emoji) === null || _item$emoji2 === void 0 ? void 0 : _item$emoji2.name) || '',
+          shortcut: (item === null || item === void 0 || (_item$emoji3 = item.emoji) === null || _item$emoji3 === void 0 ? void 0 : _item$emoji3.shortName) || ''
+        })
+      };
+    default:
+      return {
+        popupAriaLabel: intl.formatMessage(_messages.typeAheadListMessages.typeAheadPopupLabel)
+      };
+  }
+};

package/dist/es2019/api.js

@@ -0,0 +1,205 @@
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { SelectItemMode, TypeAheadAvailableNodes } from '@atlaskit/editor-common/type-ahead';
+import { insertTypeAheadItem } from './commands/insert-type-ahead-item';
+import { updateQuery } from './commands/update-query';
+import { closeTypeAhead } from './transforms/close-type-ahead';
+import { openTypeAheadAtCursor } from './transforms/open-typeahead-at-cursor';
+import { findHandler, getTypeAheadHandler, getTypeAheadQuery, isTypeAheadOpen } from './utils';
+const open = ({
+  editorView
+}) => itemType => inputMethod => {
+  const {
+    state
+  } = editorView;
+  const handler = findHandler(itemType, state);
+  if (!handler) {
+    return false;
+  }
+  const {
+    tr
+  } = state;
+  openTypeAheadAtCursor({
+    triggerHandler: handler,
+    inputMethod
+  })({
+    tr
+  });
+  editorView.dispatch(tr);
+  return true;
+};
+const defaultCloseOptions = {
+  insertCurrentQueryAsRawText: false
+};
+const close = ({
+  editorView
+}) => (options = defaultCloseOptions) => {
+  const {
+    state
+  } = editorView;
+  const currentQuery = getTypeAheadQuery(editorView.state);
+  let tr = state.tr;
+  if (options.attachCommand) {
+    const fakeDispatch = customTr => {
+      tr = customTr;
+    };
+    options.attachCommand(state, fakeDispatch);
+  }
+  closeTypeAhead(tr);
+  if (options.insertCurrentQueryAsRawText && currentQuery && currentQuery.length > 0) {
+    const handler = getTypeAheadHandler(state);
+    const text = handler.trigger.concat(currentQuery);
+    tr.replaceSelectionWith(state.schema.text(text));
+  }
+  editorView.dispatch(tr);
+  if (!editorView.hasFocus()) {
+    editorView.focus();
+  }
+  return true;
+};
+const search = ({
+  editorView
+}) => itemType => (query = '') => {
+  const {
+    state
+  } = editorView;
+  const handler = findHandler(itemType, state);
+  if (!handler) {
+    throw new Error(`Handler not found, did you load the ${itemType} plugin properly`);
+  }
+  open({
+    editorView
+  })(itemType)(INPUT_METHOD.KEYBOARD);
+  updateQuery(query)(editorView.state, editorView.dispatch);
+  const lastQuery = {
+    current: query
+  };
+  const last = handler.getItems({
+    query,
+    editorState: state
+  }).then(items => {
+    if (!handler.forceSelect) {
+      return items;
+    }
+    const forceSelectedItem = handler.forceSelect({
+      items,
+      query,
+      editorState: state
+    });
+    if (!forceSelectedItem) {
+      return items;
+    }
+    insertTypeAheadItem(editorView)({
+      handler,
+      item: forceSelectedItem,
+      query,
+      mode: SelectItemMode.SELECTED,
+      sourceListItem: items
+    });
+  });
+  const results = {
+    last
+  };
+  return {
+    type: appendValue => {
+      if (!appendValue) {
+        return;
+      }
+      lastQuery.current += appendValue;
+      updateQuery(lastQuery.current)(editorView.state, editorView.dispatch);
+      const promise = handler.getItems({
+        query: lastQuery.current,
+        editorState: state
+      });
+      results.last = promise;
+      return promise;
+    },
+    result: () => results.last,
+    close: close({
+      editorView
+    }),
+    insert: ({
+      index,
+      mode
+    }) => {
+      return results.last.then(result => {
+        const item = result ? result[index] : null;
+        if (result && item) {
+          insertTypeAheadItem(editorView)({
+            handler,
+            item,
+            query,
+            mode: mode || SelectItemMode.SELECTED,
+            sourceListItem: result
+          });
+        }
+      });
+    }
+  };
+};
+const insertItem = ({
+  editorView
+}) => itemType => ({
+  contentItem,
+  query,
+  sourceListItem
+}) => {
+  const {
+    state
+  } = editorView;
+  const handler = findHandler(itemType, state);
+  if (!handler) {
+    return false;
+  }
+  insertTypeAheadItem(editorView)({
+    handler,
+    item: contentItem,
+    mode: SelectItemMode.SELECTED,
+    query,
+    sourceListItem
+  });
+  return true;
+};
+const isOpen = ({
+  editorView
+}) => () => {
+  if (!isTypeAheadOpen(editorView.state)) {
+    return false;
+  }
+  const handler = getTypeAheadHandler(editorView.state);
+  if (!handler) {
+    return false;
+  }
+  return handler;
+};
+const currentQuery = ({
+  editorView
+}) => () => {
+  return getTypeAheadQuery(editorView.state);
+};
+
+/**
+ * Please do not use it. Ping #help-editor and talk to the Lego team before use it.
+ *
+ * @private
+ * @deprecated
+ *
+ */
+export const createTypeAheadTools = editorView => {
+  const props = {
+    editorView
+  };
+  return {
+    isOpen: isOpen(props),
+    currentQuery: currentQuery(props),
+    close: close(props),
+    openMention: open(props)(TypeAheadAvailableNodes.MENTION),
+    searchMention: search(props)(TypeAheadAvailableNodes.MENTION),
+    openQuickInsert: open(props)(TypeAheadAvailableNodes.QUICK_INSERT),
+    searchQuickInsert: search(props)(TypeAheadAvailableNodes.QUICK_INSERT),
+    openEmoji: open(props)(TypeAheadAvailableNodes.EMOJI),
+    searchEmoji: search(props)(TypeAheadAvailableNodes.EMOJI),
+    insertItemMention: insertItem(props)(TypeAheadAvailableNodes.MENTION),
+    insertItemEmoji: insertItem(props)(TypeAheadAvailableNodes.EMOJI),
+    insertItemQuickInsert: insertItem(props)(TypeAheadAvailableNodes.QUICK_INSERT)
+  };
+};

package/dist/es2019/commands/insert-type-ahead-item.js

@@ -0,0 +1,204 @@
+import { InsertTypeAheadStages, InsertTypeAheadStep } from '@atlaskit/adf-schema/steps';
+import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
+import { closeHistory } from '@atlaskit/editor-prosemirror/history';
+import { Fragment, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { insertBlockNode, insertInlineNodeOrFragment } from '../insert-utils';
+import { ACTIONS } from '../pm-plugins/actions';
+import { pluginKey } from '../pm-plugins/key';
+import { StatsModifier } from '../stats-modifier';
+import { closeTypeAhead } from '../transforms/close-type-ahead';
+import { getPluginState } from '../utils';
+const validateNode = ({
+  schema,
+  maybeNode
+}) => {
+  if (!maybeNode) {
+    return null;
+  }
+  if (maybeNode instanceof PMNode || maybeNode instanceof Fragment) {
+    return maybeNode;
+  }
+  if (typeof maybeNode === 'string') {
+    return schema.text(maybeNode);
+  }
+  try {
+    return PMNode.fromJSON(schema, maybeNode);
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    return null;
+  }
+};
+const createInsertCallback = ({
+  editorState: state,
+  handler,
+  query,
+  wasInsertedBySpace,
+  selectedIndex,
+  textStartPosition,
+  textInserted
+}) => (maybeNode, opts = {}) => {
+  const {
+    tr
+  } = state;
+  const position = {
+    start: textStartPosition,
+    end: textStartPosition + (wasInsertedBySpace ? textInserted.length : 0)
+  };
+  const node = validateNode({
+    schema: state.schema,
+    maybeNode
+  });
+  if (!node) {
+    closeTypeAhead(tr);
+    // In this kind of situation we need to
+    // delete the raw text query
+    tr.delete(position.start, position.end);
+    return tr;
+  }
+  node instanceof PMNode && node.isBlock ? insertBlockNode({
+    node,
+    tr,
+    position
+  }) : insertInlineNodeOrFragment({
+    maybeFragment: node,
+    tr,
+    position,
+    selectInlineNode: Boolean(opts.selectInlineNode)
+  });
+  closeHistory(tr);
+  if (wasInsertedBySpace) {
+    return tr;
+  }
+  const config = {
+    stage: InsertTypeAheadStages.INSERTING_ITEM,
+    query,
+    selectedIndex,
+    trigger: handler.trigger
+  };
+  tr.step(new InsertTypeAheadStep(config));
+  return tr;
+};
+const createDeleteRawTextCallback = ({
+  trigger,
+  selectedIndex,
+  position,
+  query,
+  wasInsertedBySpace,
+  insertItem
+}) => {
+  return newState => {
+    const tr = newState.tr;
+    closeHistory(tr);
+    if (!wasInsertedBySpace) {
+      tr.delete(position.start, position.end);
+      const config = {
+        stage: InsertTypeAheadStages.DELETING_RAW_QUERY,
+        selectedIndex,
+        query,
+        trigger
+      };
+      tr.step(new InsertTypeAheadStep(config));
+    }
+    tr.setMeta(pluginKey, {
+      action: ACTIONS.INSERT_ITEM,
+      params: insertItem
+    });
+    return tr;
+  };
+};
+export const insertTypeAheadItem = view => ({
+  item,
+  handler,
+  mode,
+  query,
+  sourceListItem
+}) => {
+  const pluginState = getPluginState(view.state);
+  if (!pluginState) {
+    return;
+  }
+  const stats = (pluginState.stats || new StatsModifier()).serialize();
+  const meta = {
+    mode,
+    query,
+    stats,
+    sourceListItem
+  };
+  const {
+    tr
+  } = view.state;
+  const trigger = handler.trigger;
+  let text = `${trigger}${query}`;
+  if (mode === SelectItemMode.SPACE) {
+    text = text.trim().concat(' ');
+  }
+
+  // We want to always persist selectedIndex as -1 upon selecting an item from typeahead
+  // in order to retain exist focus behaviour when undoing
+  const selectedIndex = -1;
+  const wasInsertedBySpace = mode === SelectItemMode.SPACE;
+  const {
+    selection: {
+      from: textStartPosition
+    }
+  } = tr;
+  const insertItem = newEditorSate => {
+    const insertCallback = createInsertCallback({
+      editorState: newEditorSate,
+      query,
+      mode,
+      handler,
+      wasInsertedBySpace,
+      selectedIndex,
+      textInserted: text,
+      textStartPosition
+    });
+    let wasInsertCallbackCalled = false;
+    // Some wierd plugins doesn't call the insert item callback
+    // For example, the link quick insert item
+    // For those cases we need to make sure we are closing the typeahead
+    const proxyHandler = {
+      apply: function (target, _thisContext, argumentsList) {
+        wasInsertCallbackCalled = true;
+        return target(...argumentsList);
+      }
+    };
+    const insertCallbackProxy = new Proxy(insertCallback, proxyHandler);
+    const nextTr = handler.selectItem(newEditorSate, item, insertCallbackProxy, meta);
+    if (!wasInsertCallbackCalled && nextTr) {
+      closeHistory(nextTr);
+
+      // In some cases we need to re-open the typeahead
+      // e.g.: addign mentions from the quick insert
+      //
+      // Today, the QuickInsert API doesn't have a tool
+      // to help on this. So the code below will close the typeahead
+      // only if there is no previous metadata about typeahead in the
+      // next transaction
+      if (!nextTr.getMeta(pluginKey)) {
+        closeTypeAhead(nextTr);
+      }
+    }
+    return nextTr;
+  };
+  const position = {
+    start: tr.selection.from,
+    end: tr.selection.from + text.length
+  };
+  tr.setMeta(pluginKey, {
+    action: ACTIONS.INSERT_RAW_QUERY,
+    params: createDeleteRawTextCallback({
+      wasInsertedBySpace,
+      selectedIndex,
+      insertItem,
+      position,
+      query,
+      trigger
+    })
+  });
+  tr.insertText(text);
+  closeHistory(tr);
+  view.dispatch(tr);
+  view.focus();
+};

package/dist/es2019/commands/update-list-items.js

@@ -0,0 +1,17 @@
+import { ACTIONS } from '../pm-plugins/actions';
+import { pluginKey as typeAheadPluginKey } from '../pm-plugins/key';
+export const updateListItem = items => {
+  return (state, dispatch) => {
+    const tr = state.tr;
+    tr.setMeta(typeAheadPluginKey, {
+      action: ACTIONS.UPDATE_LIST_ITEMS,
+      params: {
+        items
+      }
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
+};

package/dist/es2019/commands/update-query.js

@@ -0,0 +1,21 @@
+import { ACTIONS } from '../pm-plugins/actions';
+import { pluginKey as typeAheadPluginKey } from '../pm-plugins/key';
+export const updateQuery = query => {
+  return (state, dispatch) => {
+    const pluginState = typeAheadPluginKey.getState(state);
+    if ((pluginState === null || pluginState === void 0 ? void 0 : pluginState.query) === query) {
+      return false;
+    }
+    const tr = state.tr;
+    tr.setMeta(typeAheadPluginKey, {
+      action: ACTIONS.CHANGE_QUERY,
+      params: {
+        query
+      }
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
+};

package/dist/es2019/commands/update-selected-index.js

@@ -0,0 +1,21 @@
+import { ACTIONS } from '../pm-plugins/actions';
+import { pluginKey as typeAheadPluginKey } from '../pm-plugins/key';
+export const updateSelectedIndex = selectedIndex => {
+  return (state, dispatch) => {
+    const pluginState = typeAheadPluginKey.getState(state);
+    if ((pluginState === null || pluginState === void 0 ? void 0 : pluginState.selectedIndex) === selectedIndex) {
+      return false;
+    }
+    const tr = state.tr;
+    tr.setMeta(typeAheadPluginKey, {
+      action: ACTIONS.UPDATE_SELECTED_INDEX,
+      params: {
+        selectedIndex
+      }
+    });
+    if (dispatch) {
+      dispatch(tr);
+    }
+    return true;
+  };
+};