@atlaskit/editor-core 188.9.0 → 188.9.5

package/dist/es2019/plugins/type-ahead/ui/TypeAheadPopup.js

@@ -1,233 +0,0 @@
-/** @jsx jsx */
-import React, { useCallback, useEffect, useMemo, useState, useLayoutEffect, useRef } from 'react';
-import { css, jsx } from '@emotion/react';
-import rafSchedule from 'raf-schd';
-import { akEditorFloatingDialogZIndex } from '@atlaskit/editor-shared-styles';
-import { findOverflowScrollParent, Popup } from '@atlaskit/editor-common/ui';
-import { borderRadius } from '@atlaskit/theme/constants';
-import { N0, N60A, N50A } from '@atlaskit/theme/colors';
-import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
-import { CloseSelectionOptions, TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE, TYPE_AHEAD_POPUP_CONTENT_CLASS } from '../constants';
-import { TypeAheadList } from './TypeAheadList';
-import { ITEM_PADDING } from './TypeAheadListItem';
-const DEFAULT_TYPEAHEAD_MENU_HEIGHT = 380;
-const typeAheadContent = css`
-  background: ${`var(--ds-surface-overlay, ${N0})`};
-  border-radius: ${borderRadius()}px;
-  box-shadow: ${`var(--ds-shadow-overlay, ${`0 0 1px ${N60A}, 0 4px 8px -2px ${N50A}`})`};
-  padding: ${"var(--ds-space-050, 4px)"} 0;
-  width: 320px;
-  max-height: 380px; /* ~5.5 visibile items */
-  overflow-y: auto;
-  -ms-overflow-style: -ms-autohiding-scrollbar;
-  position: relative;
-`;
-const Highlight = ({
-  state,
-  triggerHandler
-}) => {
-  if (!(triggerHandler !== null && triggerHandler !== void 0 && triggerHandler.getHighlight)) {
-    return null;
-  }
-  return triggerHandler.getHighlight(state);
-};
-const OFFSET = [0, 8];
-export const TypeAheadPopup = /*#__PURE__*/React.memo(props => {
-  const {
-    editorView,
-    triggerHandler,
-    anchorElement,
-    popupsMountPoint,
-    popupsBoundariesElement,
-    popupsScrollableElement,
-    items,
-    selectedIndex,
-    onItemInsert,
-    fireAnalyticsCallback,
-    isEmptyQuery,
-    cancel
-  } = props;
-  const ref = useRef(null);
-  const startTime = useMemo(() => performance.now(),
-  // In case those props changes
-  // we need to recreate the startTime
-  [items, isEmptyQuery, fireAnalyticsCallback, triggerHandler] // eslint-disable-line react-hooks/exhaustive-deps
-  );
-
-  useEffect(() => {
-    if (!fireAnalyticsCallback) {
-      return;
-    }
-    const stopTime = performance.now();
-    const time = stopTime - startTime;
-    fireAnalyticsCallback({
-      payload: {
-        action: ACTION.RENDERED,
-        actionSubject: ACTION_SUBJECT.TYPEAHEAD,
-        eventType: EVENT_TYPE.OPERATIONAL,
-        attributes: {
-          time,
-          items: items.length,
-          initial: isEmptyQuery
-        }
-      }
-    });
-  }, [startTime, items, fireAnalyticsCallback, isEmptyQuery,
-  // In case the current triggerHandler changes
-  // e.g: Inserting a mention using the quick insert
-  // we need to send the event again
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  triggerHandler]);
-  useEffect(() => {
-    if (!fireAnalyticsCallback) {
-      return;
-    }
-    fireAnalyticsCallback({
-      payload: {
-        action: ACTION.VIEWED,
-        actionSubject: ACTION_SUBJECT.TYPEAHEAD_ITEM,
-        eventType: EVENT_TYPE.OPERATIONAL,
-        attributes: {
-          index: selectedIndex,
-          items: items.length
-        }
-      }
-    });
-  }, [items, fireAnalyticsCallback, selectedIndex,
-  // In case the current triggerHandler changes
-  // e.g: Inserting a mention using the quick insert
-  // we need to send the event again
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  triggerHandler]);
-  const [fitHeight, setFitHeight] = useState(DEFAULT_TYPEAHEAD_MENU_HEIGHT);
-  const getFitHeight = useCallback(() => {
-    if (!anchorElement || !popupsMountPoint) {
-      return;
-    }
-    const target = anchorElement;
-    const {
-      top: targetTop,
-      height: targetHeight
-    } = target.getBoundingClientRect();
-    const boundariesElement = document.body;
-    const {
-      height: boundariesHeight,
-      top: boundariesTop
-    } = boundariesElement.getBoundingClientRect();
-
-    // Calculating the space above and space below our decoration
-    const spaceAbove = targetTop - (boundariesTop - boundariesElement.scrollTop);
-    const spaceBelow = boundariesTop + boundariesHeight - (targetTop + targetHeight);
-
-    // Keep default height if more than enough space
-    if (spaceBelow >= DEFAULT_TYPEAHEAD_MENU_HEIGHT) {
-      return setFitHeight(DEFAULT_TYPEAHEAD_MENU_HEIGHT);
-    }
-
-    // Determines whether typeahead will fit above or below decoration
-    // and return the space available.
-    const newFitHeight = spaceBelow >= spaceAbove ? spaceBelow : spaceAbove;
-
-    // Each typeahead item has some padding
-    // We want to leave some space at the top so first item
-    // is not partially cropped
-    const fitHeightWithSpace = newFitHeight - ITEM_PADDING * 2;
-
-    // Ensure typeahead height is max its default height
-    const minFitHeight = Math.min(DEFAULT_TYPEAHEAD_MENU_HEIGHT, fitHeightWithSpace);
-    return setFitHeight(minFitHeight);
-  }, [anchorElement, popupsMountPoint]);
-  const getFitHeightDebounced = rafSchedule(getFitHeight);
-  useLayoutEffect(() => {
-    const scrollableElement = popupsScrollableElement || findOverflowScrollParent(anchorElement);
-    getFitHeight();
-    window.addEventListener('resize', getFitHeightDebounced);
-    if (scrollableElement) {
-      scrollableElement.addEventListener('scroll', getFitHeightDebounced);
-    }
-    return () => {
-      window.removeEventListener('resize', getFitHeightDebounced);
-      if (scrollableElement) {
-        scrollableElement.removeEventListener('scroll', getFitHeightDebounced);
-      }
-    };
-  }, [anchorElement, popupsScrollableElement, getFitHeightDebounced, getFitHeight]);
-  useLayoutEffect(() => {
-    const focusOut = event => {
-      var _window$getSelection;
-      const {
-        relatedTarget
-      } = event;
-
-      // Given the user is changing the focus
-      // When the target is inside the TypeAhead Popup
-      // Then the popup should stay open
-      if (relatedTarget instanceof HTMLElement && relatedTarget.closest && (relatedTarget.closest(`.${TYPE_AHEAD_POPUP_CONTENT_CLASS}`) || relatedTarget.closest(`[data-type-ahead="${TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE}"]`))) {
-        return;
-      }
-      if (!(((_window$getSelection = window.getSelection()) === null || _window$getSelection === void 0 ? void 0 : _window$getSelection.type) === 'Range')) {
-        return;
-      }
-      cancel({
-        addPrefixTrigger: true,
-        setSelectionAt: CloseSelectionOptions.AFTER_TEXT_INSERTED,
-        forceFocusOnEditor: false
-      });
-    };
-    const {
-      current: element
-    } = ref;
-    element === null || element === void 0 ? void 0 : element.addEventListener('focusout', focusOut);
-    return () => {
-      element === null || element === void 0 ? void 0 : element.removeEventListener('focusout', focusOut);
-    };
-  }, [ref, cancel]);
-
-  // ED-17443 When you press escape on typeahead panel, it should remove focus and close the panel
-  // This is the expected keyboard behaviour advised by the Accessibility team
-  useLayoutEffect(() => {
-    const escape = event => {
-      if (event.key === 'Escape') {
-        cancel({
-          addPrefixTrigger: true,
-          setSelectionAt: CloseSelectionOptions.AFTER_TEXT_INSERTED,
-          forceFocusOnEditor: true
-        });
-      }
-    };
-    const {
-      current: element
-    } = ref;
-    element === null || element === void 0 ? void 0 : element.addEventListener('keydown', escape);
-    return () => {
-      element === null || element === void 0 ? void 0 : element.removeEventListener('keydown', escape);
-    };
-  }, [ref, cancel]);
-  return jsx(Popup, {
-    zIndex: akEditorFloatingDialogZIndex,
-    target: anchorElement,
-    mountTo: popupsMountPoint,
-    boundariesElement: popupsBoundariesElement,
-    scrollableElement: popupsScrollableElement,
-    fitHeight: fitHeight,
-    fitWidth: 340,
-    offset: OFFSET
-  }, jsx("div", {
-    css: typeAheadContent,
-    tabIndex: 0,
-    className: TYPE_AHEAD_POPUP_CONTENT_CLASS,
-    ref: ref
-  }, jsx(Highlight, {
-    state: editorView.state,
-    triggerHandler: triggerHandler
-  }), jsx(TypeAheadList, {
-    items: items,
-    selectedIndex: selectedIndex,
-    onItemClick: onItemInsert,
-    fitHeight: fitHeight,
-    editorView: editorView,
-    decorationElement: anchorElement,
-    triggerHandler: triggerHandler
-  })));
-});
-TypeAheadPopup.displayName = 'TypeAheadPopup';

package/dist/es2019/plugins/type-ahead/ui/WrapperTypeAhead.js

@@ -1,109 +0,0 @@
-import React, { useMemo, useEffect, useLayoutEffect, useCallback, useRef, useState } from 'react';
-import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
-import { moveSelectedIndex, getPluginState } from '../utils';
-import { updateQuery } from '../commands/update-query';
-import { InputQuery } from './InputQuery';
-import { useLoadItems } from './hooks/use-load-items';
-import { useItemInsert } from './hooks/use-item-insert';
-import { useOnForceSelect } from './hooks/use-on-force-select';
-export const WrapperTypeAhead = /*#__PURE__*/React.memo(({
-  triggerHandler,
-  editorView,
-  anchorElement,
-  shouldFocusCursorInsideQuery,
-  popupsMountPoint,
-  popupsBoundariesElement,
-  popupsScrollableElement,
-  createAnalyticsEvent,
-  inputMethod,
-  getDecorationPosition,
-  reopenQuery,
-  onUndoRedo
-}) => {
-  const [closed, setClosed] = useState(false);
-  const [query, setQuery] = useState(reopenQuery || '');
-  const queryRef = useRef(query);
-  const editorViewRef = useRef(editorView);
-  const items = useLoadItems(triggerHandler, editorView, query);
-  useLayoutEffect(() => {
-    queryRef.current = query;
-  }, [query]);
-  const [onItemInsert, onTextInsert] = useItemInsert(triggerHandler, editorView, items);
-  const selectNextItem = useMemo(() => moveSelectedIndex({
-    editorView,
-    direction: 'next'
-  }), [editorView]);
-  const selectPreviousItem = useMemo(() => moveSelectedIndex({
-    editorView,
-    direction: 'previous'
-  }), [editorView]);
-  const cancel = useCallback(({
-    setSelectionAt,
-    addPrefixTrigger,
-    text,
-    forceFocusOnEditor
-  }) => {
-    setClosed(true);
-    const fullquery = addPrefixTrigger ? `${triggerHandler.trigger}${text}` : text;
-    onTextInsert({
-      forceFocusOnEditor,
-      setSelectionAt,
-      text: fullquery
-    });
-  }, [triggerHandler, onTextInsert]);
-  const insertSelectedItem = useCallback((mode = SelectItemMode.SELECTED) => {
-    const {
-      current: view
-    } = editorViewRef;
-    const {
-      selectedIndex
-    } = getPluginState(view.state);
-    setClosed(true);
-    queueMicrotask(() => {
-      onItemInsert({
-        mode,
-        index: selectedIndex,
-        query: queryRef.current
-      });
-    });
-  }, [onItemInsert]);
-  const showTypeAheadPopupList = useCallback(() => {}, []);
-  const closePopup = useCallback(() => {
-    setClosed(true);
-  }, []);
-  useEffect(() => {
-    const {
-      current: view
-    } = editorViewRef;
-    const pluginState = getPluginState(view.state);
-    if (query.length === 0 || query === (pluginState === null || pluginState === void 0 ? void 0 : pluginState.query) || !(pluginState !== null && pluginState !== void 0 && pluginState.triggerHandler)) {
-      return;
-    }
-    updateQuery(query)(view.state, view.dispatch);
-  }, [query, reopenQuery]);
-  useOnForceSelect({
-    triggerHandler,
-    items,
-    query,
-    editorView,
-    closePopup
-  });
-  if (closed) {
-    return null;
-  }
-  return /*#__PURE__*/React.createElement(InputQuery, {
-    triggerQueryPrefix: triggerHandler.trigger,
-    onQueryChange: setQuery,
-    onItemSelect: insertSelectedItem,
-    selectNextItem: selectNextItem,
-    selectPreviousItem: selectPreviousItem,
-    onQueryFocus: showTypeAheadPopupList,
-    cancel: cancel,
-    forceFocus: shouldFocusCursorInsideQuery,
-    onUndoRedo: onUndoRedo,
-    reopenQuery: reopenQuery,
-    editorView: editorView,
-    items: items
-  });
-});
-WrapperTypeAhead.displayName = 'WrapperTypeAhead';

package/dist/es2019/plugins/type-ahead/ui/hooks/use-item-insert.js

@@ -1,112 +0,0 @@
-import { useLayoutEffect, useCallback, useRef } from 'react';
-import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
-import { closeTypeAhead } from '../../transforms/close-type-ahead';
-import { setSelectionBeforeQuery } from '../../transforms/set-selection-before-query';
-import { insertTypeAheadItem } from '../../commands/insert-type-ahead-item';
-import { CloseSelectionOptions } from '../../constants';
-const insertRawQuery = ({
-  view,
-  setSelectionAt,
-  text,
-  forceFocusOnEditor
-}) => {
-  const {
-    tr,
-    schema
-  } = view.state;
-  closeTypeAhead(tr);
-  if (text.length > 0) {
-    tr.replaceSelectionWith(schema.text(text));
-    if (setSelectionAt === CloseSelectionOptions.BEFORE_TEXT_INSERTED) {
-      setSelectionBeforeQuery(text)(tr);
-    }
-  }
-  view.dispatch(tr);
-  if (forceFocusOnEditor) {
-    view.focus();
-  }
-};
-export const useItemInsert = (triggerHandler, editorView, items) => {
-  const editorViewRef = useRef(editorView);
-  const itemsRef = useRef(items);
-  const onTextInsert = useCallback(({
-    setSelectionAt,
-    text,
-    forceFocusOnEditor
-  }) => {
-    if (!triggerHandler) {
-      return;
-    }
-    const {
-      current: view
-    } = editorViewRef;
-    insertRawQuery({
-      view,
-      setSelectionAt,
-      text,
-      forceFocusOnEditor
-    });
-  }, [triggerHandler]);
-  const onItemInsert = useCallback(({
-    mode,
-    index,
-    query
-  }) => {
-    const sourceListItem = itemsRef.current;
-    if (sourceListItem.length === 0 || !triggerHandler) {
-      const text = `${triggerHandler.trigger}${query}`;
-      onTextInsert({
-        forceFocusOnEditor: true,
-        setSelectionAt: CloseSelectionOptions.AFTER_TEXT_INSERTED,
-        text
-      });
-      return;
-    }
-    const itemToInsert = sourceListItem[index];
-    if (!itemToInsert) {
-      return;
-    }
-    const {
-      current: view
-    } = editorViewRef;
-    insertTypeAheadItem(view)({
-      item: itemToInsert,
-      handler: triggerHandler,
-      mode,
-      query,
-      sourceListItem
-    });
-  }, [triggerHandler, onTextInsert]);
-  const onItemMatch = useCallback(({
-    mode,
-    query
-  }) => {
-    const _items = itemsRef.current;
-    if (_items && _items.length > 1) {
-      return false;
-    }
-    if (_items.length === 1) {
-      queueMicrotask(() => {
-        onItemInsert({
-          mode,
-          query,
-          index: 0
-        });
-      });
-    } else {
-      const text = `${triggerHandler.trigger}${query}`;
-      queueMicrotask(() => {
-        onTextInsert({
-          forceFocusOnEditor: true,
-          setSelectionAt: CloseSelectionOptions.AFTER_TEXT_INSERTED,
-          text: mode === SelectItemMode.SPACE ? text.concat(' ') : text
-        });
-      });
-    }
-    return true;
-  }, [onItemInsert, triggerHandler, onTextInsert]);
-  useLayoutEffect(() => {
-    itemsRef.current = items;
-  }, [items]);
-  return [onItemInsert, onTextInsert, onItemMatch];
-};

package/dist/es2019/plugins/type-ahead/ui/hooks/use-load-items.js

@@ -1,41 +0,0 @@
-import { useRef, useState, useEffect } from 'react';
-import { updateListItem } from '../../commands/update-list-items';
-const EMPTY_LIST_ITEM = [];
-export const useLoadItems = (triggerHandler, editorView, query) => {
-  const [items, setItems] = useState(EMPTY_LIST_ITEM);
-  const componentIsMounted = useRef(true);
-  const editorViewRef = useRef(editorView);
-  useEffect(() => {
-    const getItems = triggerHandler === null || triggerHandler === void 0 ? void 0 : triggerHandler.getItems;
-    if (!getItems) {
-      setItems(EMPTY_LIST_ITEM);
-      return;
-    }
-    const options = {
-      query: query || '',
-      editorState: editorView.state
-    };
-    const {
-      current: view
-    } = editorViewRef;
-    getItems(options).then(result => {
-      const list = result.length > 0 ? result : EMPTY_LIST_ITEM;
-      if (componentIsMounted.current) {
-        setItems(list);
-      }
-      queueMicrotask(() => {
-        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]);
-  useEffect(() => {
-    return () => {
-      componentIsMounted.current = false;
-    };
-  }, []);
-  return items;
-};

package/dist/es2019/plugins/type-ahead/ui/hooks/use-on-force-select.js

@@ -1,38 +0,0 @@
-import { useLayoutEffect, useRef } from 'react';
-import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
-import { insertTypeAheadItem } from '../../commands/insert-type-ahead-item';
-export const useOnForceSelect = ({
-  triggerHandler,
-  items,
-  query,
-  editorView,
-  closePopup
-}) => {
-  const editorViewRef = useRef(editorView);
-  useLayoutEffect(() => {
-    if (!query || typeof triggerHandler.forceSelect !== 'function') {
-      return;
-    }
-    const item = triggerHandler.forceSelect({
-      items,
-      query,
-      editorState: editorViewRef.current.state
-    });
-    if (!item) {
-      return;
-    }
-    const {
-      current: view
-    } = editorViewRef;
-    closePopup();
-    queueMicrotask(() => {
-      insertTypeAheadItem(view)({
-        item,
-        mode: SelectItemMode.SPACE,
-        query,
-        handler: triggerHandler,
-        sourceListItem: items
-      });
-    });
-  }, [triggerHandler, closePopup, query, items]);
-};

package/dist/es2019/plugins/type-ahead/utils.js

@@ -1,126 +0,0 @@
-import { TypeAheadAvailableNodes } from '@atlaskit/editor-common/type-ahead';
-import { pluginKey as typeAheadPluginKey } from './pm-plugins/key';
-import { updateSelectedIndex } from './commands/update-selected-index';
-import { StatsModifier } from './stats-modifier';
-import { typeAheadListMessages } from './messages';
-export const isTypeAheadHandler = handler => {
-  return handler && Object.values(TypeAheadAvailableNodes).includes(handler.id) && typeof handler.trigger === 'string' && typeof handler.selectItem === 'function' && typeof handler.getItems === 'function';
-};
-
-/** Is a typeahead plugin open? */
-export const isTypeAheadOpen = editorState => {
-  var _typeAheadPluginKey$g, _typeAheadPluginKey$g2;
-  return !!(typeAheadPluginKey !== null && typeAheadPluginKey !== void 0 && (_typeAheadPluginKey$g = typeAheadPluginKey.getState(editorState)) !== null && _typeAheadPluginKey$g !== void 0 && (_typeAheadPluginKey$g2 = _typeAheadPluginKey$g.decorationSet) !== null && _typeAheadPluginKey$g2 !== void 0 && _typeAheadPluginKey$g2.find().length);
-};
-export const getPluginState = editorState => {
-  return typeAheadPluginKey.getState(editorState);
-};
-export const getTypeAheadHandler = editorState => {
-  var _typeAheadPluginKey$g3;
-  return (_typeAheadPluginKey$g3 = typeAheadPluginKey.getState(editorState)) === null || _typeAheadPluginKey$g3 === void 0 ? void 0 : _typeAheadPluginKey$g3.triggerHandler;
-};
-export const getTypeAheadQuery = editorState => {
-  var _typeAheadPluginKey$g4;
-  return (_typeAheadPluginKey$g4 = typeAheadPluginKey.getState(editorState)) === null || _typeAheadPluginKey$g4 === void 0 ? void 0 : _typeAheadPluginKey$g4.query;
-};
-export const isTypeAheadAllowed = state => {
-  const isOpen = isTypeAheadOpen(state);
-  // if the TypeAhead is open
-  // we should not allow it
-  return !isOpen;
-};
-export const findHandler = (id, state) => {
-  const pluginState = typeAheadPluginKey.getState(state);
-  if (!pluginState || !pluginState.typeAheadHandlers || pluginState.typeAheadHandlers.length === 0) {
-    return null;
-  }
-  const {
-    typeAheadHandlers
-  } = pluginState;
-  return typeAheadHandlers.find(h => h.id === id) || null;
-};
-export const findHandlerByTrigger = ({
-  trigger,
-  editorState
-}) => {
-  const pluginState = typeAheadPluginKey.getState(editorState);
-  if (!pluginState || !pluginState.typeAheadHandlers || pluginState.typeAheadHandlers.length === 0) {
-    return null;
-  }
-  const {
-    typeAheadHandlers
-  } = pluginState;
-  return typeAheadHandlers.find(h => h.trigger === trigger) || null;
-};
-export const moveSelectedIndex = ({
-  editorView,
-  direction
-}) => () => {
-  const typeAheadState = getPluginState(editorView.state);
-  if (!typeAheadState) {
-    return;
-  }
-  const {
-    selectedIndex,
-    items
-  } = typeAheadState;
-  const stats = typeAheadState.stats instanceof StatsModifier ? typeAheadState.stats : new StatsModifier();
-  let 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;
-  }
-  updateSelectedIndex(nextIndex)(editorView.state, editorView.dispatch);
-};
-export const getTypeAheadListAriaLabels = (trigger, intl, item) => {
-  var _item$mention, _item$mention2, _item$emoji, _item$emoji2, _item$emoji3;
-  switch (trigger) {
-    case '@':
-      return {
-        popupAriaLabel: intl.formatMessage(typeAheadListMessages.mentionPopupLabel),
-        listItemAriaLabel: intl.formatMessage(typeAheadListMessages.metionListItemLabel, {
-          name: (item === null || item === void 0 ? void 0 : (_item$mention = item.mention) === null || _item$mention === void 0 ? void 0 : _item$mention.name) || '',
-          shortName: (item === null || item === void 0 ? void 0 : (_item$mention2 = item.mention) === null || _item$mention2 === void 0 ? void 0 : _item$mention2.mentionName) || ''
-        })
-      };
-    case '/':
-      return {
-        popupAriaLabel: intl.formatMessage(typeAheadListMessages.quickInsertPopupLabel),
-        listItemAriaLabel: intl.formatMessage(typeAheadListMessages.emojiListItemLabel, {
-          name: (item === null || item === void 0 ? void 0 : item.title) || '',
-          shortcut: (item === null || item === void 0 ? void 0 : (_item$emoji = item.emoji) === null || _item$emoji === void 0 ? void 0 : _item$emoji.shortName) || ''
-        })
-      };
-    case ':':
-      return {
-        popupAriaLabel: intl.formatMessage(typeAheadListMessages.emojiPopupLabel),
-        listItemAriaLabel: intl.formatMessage(typeAheadListMessages.emojiListItemLabel, {
-          name: (item === null || item === void 0 ? void 0 : (_item$emoji2 = item.emoji) === null || _item$emoji2 === void 0 ? void 0 : _item$emoji2.name) || '',
-          shortcut: (item === null || item === void 0 ? void 0 : (_item$emoji3 = item.emoji) === null || _item$emoji3 === void 0 ? void 0 : _item$emoji3.shortName) || ''
-        })
-      };
-    default:
-      return {
-        popupAriaLabel: intl.formatMessage(typeAheadListMessages.typeAheadPopupLabel)
-      };
-  }
-};