@atlaskit/editor-core 148.0.0 → 149.0.3

package/dist/cjs/plugins/type-ahead/index.js

@@ -8,29 +8,132 @@ Object.defineProperty(exports, "__esModule", {
 Object.defineProperty(exports, "typeAheadPluginKey", {
   enumerable: true,
   get: function get() {
-    return _main.pluginKey;
+    return _key.pluginKey;
   }
 });
 exports.default = void 0;
 
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
 var _react = _interopRequireDefault(require("react"));
 
-var _adfSchema = require("@atlaskit/adf-schema");
+var _typeAhead = require("@atlaskit/editor-common/type-ahead");
+
+var _main = require("./pm-plugins/main");
+
+var _insertItemPlugin = require("./pm-plugins/insert-item-plugin");
 
 var _WithPluginState = _interopRequireDefault(require("../../ui/WithPluginState"));
 
+var _adfSchema = require("@atlaskit/adf-schema");
+
+var _key = require("./pm-plugins/key");
+
 var _inputRules = require("./pm-plugins/input-rules");
 
-var _keymap = require("./pm-plugins/keymap");
+var _TypeAheadPopup = require("./ui/TypeAheadPopup");
 
-var _main = require("./pm-plugins/main");
+var _utils = require("./utils");
+
+var _useItemInsert3 = require("./ui/hooks/use-item-insert");
+
+var _updateSelectedIndex = require("./commands/update-selected-index");
+
+var _statsModifier = require("./stats-modifier");
 
-var _TypeAhead = require("./ui/TypeAhead");
+var _analytics = require("../analytics");
+
+var TypeAheadMenu = /*#__PURE__*/_react.default.memo(function (_ref) {
+  var _popupMountRef$curren, _popupMountRef$curren2, _popupMountRef$curren3;
+
+  var editorView = _ref.editorView,
+      popupMountRef = _ref.popupMountRef,
+      typeAheadState = _ref.typeAheadState,
+      fireAnalyticsCallback = _ref.fireAnalyticsCallback;
+  var isOpen = typeAheadState.decorationSet.find().length > 0;
+  var triggerHandler = typeAheadState.triggerHandler,
+      items = typeAheadState.items,
+      selectedIndex = typeAheadState.selectedIndex,
+      decorationElement = typeAheadState.decorationElement,
+      decorationSet = typeAheadState.decorationSet,
+      query = typeAheadState.query;
+
+  var _useItemInsert = (0, _useItemInsert3.useItemInsert)(triggerHandler, editorView, items),
+      _useItemInsert2 = (0, _slicedToArray2.default)(_useItemInsert, 3),
+      onItemInsert = _useItemInsert2[0],
+      onItemMatch = _useItemInsert2[2];
+
+  var setSelectedItem = _react.default.useCallback(function (_ref2) {
+    var nextIndex = _ref2.index;
+    queueMicrotask(function () {
+      (0, _updateSelectedIndex.updateSelectedIndex)(nextIndex)(editorView.state, editorView.dispatch);
+    });
+  }, [editorView]);
+
+  var insertItem = _react.default.useCallback(function () {
+    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _typeAhead.SelectItemMode.SELECTED;
+    var index = arguments.length > 1 ? arguments[1] : undefined;
+    queueMicrotask(function () {
+      onItemInsert({
+        mode: mode,
+        index: index,
+        query: query
+      });
+    });
+  }, [onItemInsert, query]);
+
+  _react.default.useEffect(function () {
+    if (!isOpen || !query) {
+      return;
+    }
+
+    var isLastCharSpace = query[query.length - 1] === ' ';
+
+    if (!isLastCharSpace) {
+      return;
+    }
+
+    var result = onItemMatch({
+      mode: _typeAhead.SelectItemMode.SPACE,
+      query: query.trim()
+    });
+
+    if (!result) {
+      return;
+    }
+  }, [isOpen, query, onItemMatch]);
+
+  if (!isOpen || !triggerHandler || !(decorationElement instanceof HTMLElement) || items.length === 0) {
+    return null;
+  }
+
+  return /*#__PURE__*/_react.default.createElement(_TypeAheadPopup.TypeAheadPopup, {
+    editorView: editorView,
+    popupsMountPoint: (_popupMountRef$curren = popupMountRef.current) === null || _popupMountRef$curren === void 0 ? void 0 : _popupMountRef$curren.popupsMountPoint,
+    popupsBoundariesElement: (_popupMountRef$curren2 = popupMountRef.current) === null || _popupMountRef$curren2 === void 0 ? void 0 : _popupMountRef$curren2.popupsBoundariesElement,
+    popupsScrollableElement: (_popupMountRef$curren3 = popupMountRef.current) === null || _popupMountRef$curren3 === void 0 ? void 0 : _popupMountRef$curren3.popupsScrollableElement,
+    anchorElement: decorationElement,
+    triggerHandler: triggerHandler,
+    fireAnalyticsCallback: fireAnalyticsCallback,
+    items: items,
+    selectedIndex: selectedIndex,
+    setSelectedItem: setSelectedItem,
+    onItemInsert: insertItem,
+    decorationSet: decorationSet,
+    isEmptyQuery: !query
+  });
+});
 
 var typeAheadPlugin = function typeAheadPlugin(options) {
+  var fireAnalyticsCallback = (0, _analytics.fireAnalyticsEvent)(options === null || options === void 0 ? void 0 : options.createAnalyticsEvent);
+  var popupMountRef = {
+    current: null
+  };
   return {
     name: 'typeAhead',
     marks: function marks() {
+      // We need to keep this to make sure
+      // All documents with typeahead marks will be loaded normaly
       return [{
         name: 'typeAheadQuery',
         mark: _adfSchema.typeAheadQuery
@@ -40,71 +143,99 @@ var typeAheadPlugin = function typeAheadPlugin(options) {
       var typeAhead = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
       return [{
         name: 'typeAhead',
-        plugin: function plugin(_ref) {
-          var dispatch = _ref.dispatch,
-              reactContext = _ref.reactContext;
-          return (0, _main.createPlugin)(dispatch, reactContext, typeAhead);
+        plugin: function plugin(_ref3) {
+          var dispatch = _ref3.dispatch,
+              reactContext = _ref3.reactContext;
+          return (0, _main.createPlugin)({
+            reactContext: reactContext,
+            popupMountRef: popupMountRef,
+            reactDispatch: dispatch,
+            typeAheadHandlers: typeAhead,
+            createAnalyticsEvent: options === null || options === void 0 ? void 0 : options.createAnalyticsEvent
+          });
         }
+      }, {
+        name: 'typeAheadInsertItem',
+        plugin: _insertItemPlugin.createPlugin
       }, {
         name: 'typeAheadInputRule',
-        plugin: function plugin(_ref2) {
-          var schema = _ref2.schema,
-              featureFlags = _ref2.featureFlags;
+        plugin: function plugin(_ref4) {
+          var schema = _ref4.schema,
+              featureFlags = _ref4.featureFlags;
           return (0, _inputRules.inputRulePlugin)(schema, typeAhead, featureFlags);
         }
-      }, {
-        name: 'typeAheadKeymap',
-        plugin: function plugin() {
-          return (0, _keymap.keymapPlugin)();
-        }
       }];
     },
-    contentComponent: function contentComponent(_ref3) {
-      var editorView = _ref3.editorView,
-          popupsMountPoint = _ref3.popupsMountPoint,
-          popupsBoundariesElement = _ref3.popupsBoundariesElement,
-          popupsScrollableElement = _ref3.popupsScrollableElement;
+    contentComponent: function contentComponent(_ref5) {
+      var editorView = _ref5.editorView,
+          containerElement = _ref5.containerElement,
+          popupsMountPoint = _ref5.popupsMountPoint,
+          popupsBoundariesElement = _ref5.popupsBoundariesElement,
+          popupsScrollableElement = _ref5.popupsScrollableElement;
+      popupMountRef.current = {
+        popupsMountPoint: popupsMountPoint || containerElement || undefined,
+        popupsBoundariesElement: popupsBoundariesElement,
+        popupsScrollableElement: popupsScrollableElement
+      };
       return /*#__PURE__*/_react.default.createElement(_WithPluginState.default, {
         plugins: {
-          typeAhead: _main.pluginKey
+          typeAheadState: _key.pluginKey
         },
-        render: function render(_ref4) {
-          var _ref4$typeAhead = _ref4.typeAhead,
-              typeAhead = _ref4$typeAhead === void 0 ? (0, _main.createInitialPluginState)() : _ref4$typeAhead;
+        render: function render(_ref6) {
+          var typeAheadState = _ref6.typeAheadState;
 
-          if (typeAhead.typeAheadHandler && typeAhead.typeAheadHandler.headless) {
+          if (!typeAheadState) {
             return null;
           }
 
-          var queryMarkPos = typeAhead.queryMarkPos;
-          var domRef = null;
-
-          if (queryMarkPos !== null) {
-            // temporary fix to avoid page crash until it is fixed properly
-            try {
-              domRef = editorView.domAtPos(queryMarkPos);
-            } catch (ex) {
-              return null;
-            }
-          }
-
-          var anchorElement = domRef ? domRef.node.childNodes[domRef.offset] : undefined;
-          return /*#__PURE__*/_react.default.createElement(_TypeAhead.TypeAhead, {
+          return /*#__PURE__*/_react.default.createElement(TypeAheadMenu, {
             editorView: editorView,
-            popupsMountPoint: popupsMountPoint,
-            popupsBoundariesElement: popupsBoundariesElement,
-            popupsScrollableElement: popupsScrollableElement,
-            anchorElement: anchorElement,
-            active: typeAhead.active,
-            isLoading: !!typeAhead.itemsLoader,
-            items: typeAhead.items,
-            currentIndex: typeAhead.currentIndex,
-            highlight: typeAhead.highlight,
-            createAnalyticsEvent: options === null || options === void 0 ? void 0 : options.createAnalyticsEvent,
-            query: typeAhead.query
+            popupMountRef: popupMountRef,
+            typeAheadState: typeAheadState,
+            fireAnalyticsCallback: fireAnalyticsCallback
           });
         }
       });
+    },
+    onEditorViewStateUpdated: function onEditorViewStateUpdated(_ref7) {
+      var oldEditorState = _ref7.oldEditorState,
+          newEditorState = _ref7.newEditorState;
+      var oldPluginState = (0, _utils.getPluginState)(oldEditorState);
+      var newPluginState = (0, _utils.getPluginState)(newEditorState);
+
+      if (!oldPluginState || !newPluginState) {
+        return;
+      }
+
+      var oldTriggerHandler = oldPluginState.triggerHandler;
+      var newTriggerHandler = newPluginState.triggerHandler;
+      var isANewHandler = oldTriggerHandler !== newTriggerHandler;
+
+      if (oldTriggerHandler !== null && oldTriggerHandler !== void 0 && oldTriggerHandler.dismiss && isANewHandler) {
+        oldTriggerHandler.dismiss({
+          editorState: newEditorState,
+          query: oldPluginState.query,
+          stats: (oldPluginState.stats || new _statsModifier.StatsModifier()).serialize()
+        });
+      }
+
+      if (newTriggerHandler !== null && newTriggerHandler !== void 0 && newTriggerHandler.onOpen && isANewHandler) {
+        newTriggerHandler.onOpen(newEditorState);
+      }
+
+      if (newTriggerHandler && isANewHandler && options !== null && options !== void 0 && options.createAnalyticsEvent) {
+        fireAnalyticsCallback({
+          payload: {
+            action: _analytics.ACTION.INVOKED,
+            actionSubject: _analytics.ACTION_SUBJECT.TYPEAHEAD,
+            actionSubjectId: newTriggerHandler.id || 'not_set',
+            attributes: {
+              inputMethod: newPluginState.inputMethod || _analytics.INPUT_METHOD.KEYBOARD
+            },
+            eventType: _analytics.EVENT_TYPE.UI
+          }
+        });
+      }
     }
   };
 };

package/dist/cjs/plugins/type-ahead/insert-utils.js

@@ -0,0 +1,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertInlineNodeOrFragment = exports.insertBlockNode = void 0;
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _prosemirrorModel = require("prosemirror-model");
+
+var _selection = require("../../utils/selection");
+
+var _insert = require("../../utils/insert");
+
+function findInsertPoint(doc, pos, nodeToInsert) {
+  var $pos = doc.resolve(pos);
+
+  var createInsertPosition = function createInsertPosition(from, to) {
+    return {
+      from: from,
+      to: to || from
+    };
+  }; // Search for a valid position for nodeToInsert in progressively higher levels
+
+
+  for (var level = $pos.depth; level >= 0; level--) {
+    var nodeAtLevel = $pos.node(level); // Try to replace the empty paragraph in the level above
+    // Scenario:
+    //   doc(
+    //     table(
+    //       row(
+    //         cell(
+    //           p('{<>}'),
+    //         ),
+    //       )
+    //     )
+    //   )
+
+    var levelAbove = Math.max(level - 1, 0);
+    var parentNode = $pos.node(levelAbove); // Special case: when this is true, the 'to' position should be the end
+    // of the empty paragraph
+
+    var isNodeAtLevelEmptyParagraph = nodeAtLevel.type.name === 'paragraph' && nodeAtLevel.content.size === 0;
+    var indexAtLevelAbove = $pos.index(levelAbove);
+    var canReplaceNodeAtLevelAbove = parentNode.canReplaceWith(indexAtLevelAbove, indexAtLevelAbove, nodeToInsert.type);
+
+    if (isNodeAtLevelEmptyParagraph && canReplaceNodeAtLevelAbove) {
+      var from = $pos.posAtIndex(indexAtLevelAbove, levelAbove);
+      return createInsertPosition(from, from + nodeAtLevel.nodeSize);
+    } // Try to insert this node right after the node in the level above
+    // Scenario:
+    //   doc(
+    //     panel(
+    //       p('{<>}'),
+    //     )
+    //   )
+
+
+    var indexAfterAtLevelAbove = $pos.indexAfter(levelAbove);
+    var canInsertNodeAtLevelAbove = parentNode.canReplaceWith(indexAfterAtLevelAbove, indexAfterAtLevelAbove, nodeToInsert.type);
+
+    if (canInsertNodeAtLevelAbove) {
+      return createInsertPosition($pos.posAtIndex(indexAfterAtLevelAbove, levelAbove));
+    }
+  }
+
+  return createInsertPosition(0);
+}
+
+var insertBlockNode = function insertBlockNode(_ref) {
+  var node = _ref.node,
+      tr = _ref.tr,
+      position = _ref.position;
+  var start = position.start,
+      end = position.end;
+
+  if (node.isText) {
+    return tr.replaceWith(start, end, node);
+  }
+
+  if (node.isBlock) {
+    tr.delete(start, end);
+    var mappedStart = tr.mapping.map(start);
+    var nodeNormalized = (0, _selection.normaliseNestedLayout)(tr, node); // Handle edge cases for hr and mediaSingle
+
+    var inserted = (0, _insert.safeInsert)(nodeNormalized, mappedStart)(tr);
+
+    if (inserted) {
+      return tr;
+    }
+
+    var sliceInserted = _prosemirrorModel.Slice.maxOpen(_prosemirrorModel.Fragment.from(nodeNormalized));
+
+    var _findInsertPoint = findInsertPoint(tr.doc, mappedStart, nodeNormalized),
+        from = _findInsertPoint.from,
+        to = _findInsertPoint.to;
+
+    tr.replaceWith(from, to, node);
+    var openPosition = Math.min(from + (node.isAtom ? node.nodeSize : sliceInserted.openStart), tr.doc.content.size);
+    var FORWARD_DIRECTION = 1;
+
+    var nextSelection = _prosemirrorState.TextSelection.findFrom(tr.doc.resolve(openPosition), FORWARD_DIRECTION, true);
+
+    if (nextSelection) {
+      return tr.setSelection(nextSelection);
+    }
+  }
+
+  return tr;
+};
+
+exports.insertBlockNode = insertBlockNode;
+
+var insertInlineNodeOrFragment = function insertInlineNodeOrFragment(_ref2) {
+  var maybeFragment = _ref2.maybeFragment,
+      tr = _ref2.tr,
+      position = _ref2.position,
+      selectInlineNode = _ref2.selectInlineNode;
+  var start = position.start,
+      end = position.end;
+  var fragment = maybeFragment instanceof _prosemirrorModel.Node ? _prosemirrorModel.Fragment.from(maybeFragment) : maybeFragment;
+  tr.replaceWith(start, end, fragment);
+
+  if (selectInlineNode) {
+    return tr.setSelection(_prosemirrorState.NodeSelection.create(tr.doc, start));
+  }
+
+  return tr.setSelection(_prosemirrorState.TextSelection.near(tr.doc.resolve(start + fragment.size)));
+};
+
+exports.insertInlineNodeOrFragment = insertInlineNodeOrFragment;

package/dist/cjs/plugins/type-ahead/pm-plugins/actions.js

@@ -4,12 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ACTIONS = void 0;
-var ACTIONS = {
-  SELECT_PREV: 'SELECT_PREV',
-  SELECT_NEXT: 'SELECT_NEXT',
-  SELECT_CURRENT: 'SELECT_CURRENT',
-  SET_CURRENT_INDEX: 'SET_CURRENT_INDEX',
-  SET_QUERY: 'SET_QUERY',
-  ITEMS_LIST_UPDATED: 'ITEMS_LIST_UPDATED'
-};
-exports.ACTIONS = ACTIONS;
+var ACTIONS;
+exports.ACTIONS = ACTIONS;
+
+(function (ACTIONS) {
+  ACTIONS["OPEN_TYPEAHEAD_AT_CURSOR"] = "OPEN_TYPEAHEAD_AT_CURSOR";
+  ACTIONS["CLOSE_TYPE_AHEAD"] = "CLOSE_TYPE_AHEAD";
+  ACTIONS["CHANGE_QUERY"] = "CHANGE_QUERY";
+  ACTIONS["INSERT_ITEM"] = "INSERT_ITEM";
+  ACTIONS["INSERT_RAW_QUERY"] = "INSERT_RAW_QUERY";
+  ACTIONS["UPDATE_LIST_ITEMS"] = "UPDATE_LIST_ITEMS";
+  ACTIONS["UPDATE_SELECTED_INDEX"] = "UPDATE_SELECTED_INDEX";
+})(ACTIONS || (exports.ACTIONS = ACTIONS = {}));

package/dist/cjs/plugins/type-ahead/pm-plugins/decorations.js

@@ -0,0 +1,238 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findDecorationElement = exports.isSelectionInsideTypeAhead = exports.factoryDecorations = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactDom = _interopRequireDefault(require("react-dom"));
+
+var _uuid = _interopRequireDefault(require("uuid"));
+
+var _prosemirrorState = require("prosemirror-state");
+
+var _prosemirrorView = require("prosemirror-view");
+
+var _colors = require("@atlaskit/theme/colors");
+
+var _w3cKeyname = require("w3c-keyname");
+
+var _reactIntl = require("react-intl");
+
+var _prosemirrorHistory = require("prosemirror-history");
+
+var _constants = require("../constants");
+
+var _WrapperTypeAhead = require("../ui/WrapperTypeAhead");
+
+var _statsModifier = require("../stats-modifier");
+
+var _utils = require("../utils");
+
+var _closeTypeAhead = require("../transforms/close-type-ahead");
+
+var factoryDecorations = function factoryDecorations(_ref) {
+  var intl = _ref.intl,
+      popupMountRef = _ref.popupMountRef,
+      createAnalyticsEvent = _ref.createAnalyticsEvent;
+
+  var createDecorations = function createDecorations(tr, _ref2) {
+    var triggerHandler = _ref2.triggerHandler,
+        inputMethod = _ref2.inputMethod,
+        reopenQuery = _ref2.reopenQuery;
+    var selection = tr.selection;
+
+    if (!(selection instanceof _prosemirrorState.TextSelection) || !selection.$cursor) {
+      return {
+        decorationSet: _prosemirrorView.DecorationSet.empty,
+        stats: null,
+        decorationElement: null
+      };
+    }
+
+    var decorationId = "decoration_id_".concat(_constants.TYPE_AHEAD_DECORATION_KEY, "_").concat((0, _uuid.default)());
+    var $cursor = selection.$cursor;
+    var typeaheadComponent = document.createElement('mark');
+    var stats = new _statsModifier.StatsModifier();
+    var shouldFocusCursorInsideQuery = true;
+
+    var deco = _prosemirrorView.Decoration.widget($cursor.pos, function (editorView, getDecorationPosition) {
+      var _popupMountRef$curren, _popupMountRef$curren2, _popupMountRef$curren3;
+
+      typeaheadComponent.setAttribute('id', decorationId);
+      typeaheadComponent.setAttribute('role', 'search');
+      typeaheadComponent.setAttribute('aria-label', "On ".concat(triggerHandler.id));
+      typeaheadComponent.dataset.typeAheadQuery = 'true';
+      typeaheadComponent.dataset.trigger = triggerHandler.trigger; // This line below seems weird,
+      // we need that cuz the clickAreaHelper
+      // will try to hijack any click event coming
+      // from the inside of the Editor
+      // packages/editor/editor-core/src/ui/Addon/click-area-helper.ts
+
+      typeaheadComponent.dataset.editorPopup = 'true';
+      typeaheadComponent.dataset.typeAhead = _constants.TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE;
+      typeaheadComponent.style.color = _colors.B400;
+      typeaheadComponent.style.backgroundColor = 'transparent';
+
+      var onUndoRedo = function onUndoRedo(inputType) {
+        if (!['historyUndo', 'historyRedo'].includes(inputType)) {
+          return false;
+        }
+
+        var hasReopenQuery = typeof reopenQuery === 'string' && reopenQuery.trim().length > 0;
+        var currentQuery = (0, _utils.getTypeAheadQuery)(editorView.state);
+
+        if (hasReopenQuery || currentQuery.length === 0) {
+          var command = inputType === 'historyUndo' ? _prosemirrorHistory.undo : _prosemirrorHistory.redo;
+          var _tr = editorView.state.tr;
+
+          var fakeDispatch = function fakeDispatch(customTr) {
+            _tr = customTr;
+          };
+
+          var result = command(editorView.state, fakeDispatch);
+
+          if (result) {
+            (0, _closeTypeAhead.closeTypeAhead)(_tr);
+            editorView.dispatch(_tr);
+            editorView.focus();
+          }
+
+          return result;
+        }
+
+        return false;
+      };
+
+      _reactDom.default.render( /*#__PURE__*/_react.default.createElement(_reactIntl.IntlProvider, {
+        locale: intl.locale || 'en',
+        messages: intl.messages,
+        formats: intl.formats
+      }, /*#__PURE__*/_react.default.createElement(_WrapperTypeAhead.WrapperTypeAhead, {
+        triggerHandler: triggerHandler,
+        editorView: editorView,
+        anchorElement: typeaheadComponent,
+        createAnalyticsEvent: createAnalyticsEvent,
+        inputMethod: inputMethod,
+        getDecorationPosition: getDecorationPosition,
+        shouldFocusCursorInsideQuery: shouldFocusCursorInsideQuery,
+        popupsMountPoint: (_popupMountRef$curren = popupMountRef.current) === null || _popupMountRef$curren === void 0 ? void 0 : _popupMountRef$curren.popupsMountPoint,
+        popupsBoundariesElement: (_popupMountRef$curren2 = popupMountRef.current) === null || _popupMountRef$curren2 === void 0 ? void 0 : _popupMountRef$curren2.popupsBoundariesElement,
+        popupsScrollableElement: (_popupMountRef$curren3 = popupMountRef.current) === null || _popupMountRef$curren3 === void 0 ? void 0 : _popupMountRef$curren3.popupsScrollableElement,
+        onUndoRedo: onUndoRedo,
+        reopenQuery: reopenQuery
+      })), typeaheadComponent);
+
+      shouldFocusCursorInsideQuery = false;
+      return typeaheadComponent;
+    }, {
+      isTypeAheadDecoration: true,
+      key: decorationId,
+      side: 0,
+      stopEvent: function stopEvent(e) {
+        var key = (0, _w3cKeyname.keyName)(e);
+        var sel = document.getSelection();
+
+        if ('ArrowLeft' === key && (sel === null || sel === void 0 ? void 0 : sel.anchorOffset) === 0) {
+          return false;
+        }
+
+        return true;
+      },
+      ignoreSelection: false
+    });
+
+    return {
+      decorationSet: _prosemirrorView.DecorationSet.create(tr.doc, [deco]),
+      decorationElement: typeaheadComponent,
+      stats: stats
+    };
+  };
+
+  var removeDecorations = function removeDecorations(decorationSet) {
+    if (!decorationSet || decorationSet === _prosemirrorView.DecorationSet.empty) {
+      return false;
+    }
+
+    var typeAheadDecorations = decorationSet.find(undefined, undefined, function (spec) {
+      return spec.isTypeAheadDecoration;
+    });
+
+    if (!typeAheadDecorations || typeAheadDecorations.length === 0) {
+      return false;
+    }
+
+    typeAheadDecorations.forEach(function (_ref3) {
+      var spec = _ref3.spec;
+
+      if (!spec.key) {
+        return;
+      }
+
+      var decoElement = document.querySelector("#".concat(spec.key));
+
+      if (!decoElement) {
+        return;
+      }
+
+      _reactDom.default.unmountComponentAtNode(decoElement);
+    });
+    return true;
+  };
+
+  return {
+    createDecorations: createDecorations,
+    removeDecorations: removeDecorations
+  };
+};
+
+exports.factoryDecorations = factoryDecorations;
+
+var isSelectionInsideTypeAhead = function isSelectionInsideTypeAhead(_ref4) {
+  var decorationSet = _ref4.decorationSet,
+      selection = _ref4.selection;
+
+  if (!decorationSet || decorationSet === _prosemirrorView.DecorationSet.empty) {
+    return false;
+  }
+
+  var typeAheadDecorations = decorationSet.find(undefined, undefined, function (spec) {
+    return spec.isTypeAheadDecoration;
+  });
+
+  if (!typeAheadDecorations || typeAheadDecorations.length === 0) {
+    return false;
+  }
+
+  return typeAheadDecorations.some(function (dec) {
+    return dec.from === selection.from && dec.to === selection.to;
+  });
+};
+
+exports.isSelectionInsideTypeAhead = isSelectionInsideTypeAhead;
+
+var findDecorationElement = function findDecorationElement(_ref5) {
+  var selection = _ref5.selection,
+      decorationSet = _ref5.decorationSet;
+
+  if (!decorationSet || decorationSet === _prosemirrorView.DecorationSet.empty || !(selection instanceof _prosemirrorState.TextSelection) || !selection.$cursor) {
+    return null;
+  }
+
+  var pos = selection.$cursor.pos;
+  var decoration = decorationSet.find(pos, pos, function (spec) {
+    return spec === null || spec === void 0 ? void 0 : spec.isTypeAheadDecoration;
+  });
+
+  if (!decoration || decoration.length !== 1) {
+    return null;
+  }
+
+  return document.querySelector("#".concat(decoration[0].spec.key));
+};
+
+exports.findDecorationElement = findDecorationElement;