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

package/dist/esm/pm-plugins/decorations.js

@@ -0,0 +1,141 @@
+import React from 'react';
+import ReactDOM from 'react-dom';
+import { IntlProvider } from 'react-intl-next';
+import uuid from 'uuid';
+import { keyName as keyNameNormalized } from 'w3c-keyname';
+import { redo, undo } from '@atlaskit/editor-prosemirror/history';
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { B400 } from '@atlaskit/theme/colors';
+import { TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE, TYPE_AHEAD_DECORATION_KEY } from '../constants';
+import { StatsModifier } from '../stats-modifier';
+import { closeTypeAhead } from '../transforms/close-type-ahead';
+import { WrapperTypeAhead } from '../ui/WrapperTypeAhead';
+import { getTypeAheadQuery } from '../utils';
+export 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 TextSelection) || !selection.$cursor) {
+      return {
+        decorationSet: DecorationSet.empty,
+        stats: null,
+        decorationElement: null
+      };
+    }
+    var decorationId = "decoration_id_".concat(TYPE_AHEAD_DECORATION_KEY, "_").concat(uuid());
+    var $cursor = selection.$cursor;
+    var typeaheadComponent = document.createElement('mark');
+    var stats = new StatsModifier();
+    var shouldFocusCursorInsideQuery = true;
+    var deco = Decoration.widget($cursor.pos, function (editorView, getDecorationPosition) {
+      var _popupMountRef$curren, _popupMountRef$curren2, _popupMountRef$curren3;
+      typeaheadComponent.setAttribute('id', decorationId);
+      typeaheadComponent.setAttribute('role', 'search');
+      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 = TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE;
+      typeaheadComponent.style.color = "var(--ds-text-accent-blue, ".concat(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 = getTypeAheadQuery(editorView.state);
+        if (hasReopenQuery || (currentQuery === null || currentQuery === void 0 ? void 0 : currentQuery.length) === 0) {
+          var command = inputType === 'historyUndo' ? undo : redo;
+          var _tr = editorView.state.tr;
+          var fakeDispatch = function fakeDispatch(customTr) {
+            _tr = customTr;
+          };
+          var result = command(editorView.state, fakeDispatch);
+          if (result) {
+            closeTypeAhead(_tr);
+            editorView.dispatch(_tr);
+            editorView.focus();
+          }
+          return result;
+        }
+        return false;
+      };
+      ReactDOM.render( /*#__PURE__*/React.createElement(IntlProvider, {
+        locale: intl.locale || 'en',
+        messages: intl.messages,
+        formats: intl.formats
+      }, /*#__PURE__*/React.createElement(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 = keyNameNormalized(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: DecorationSet.create(tr.doc, [deco]),
+      decorationElement: typeaheadComponent,
+      stats: stats
+    };
+  };
+  var removeDecorations = function removeDecorations(decorationSet) {
+    if (!decorationSet || decorationSet === 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.unmountComponentAtNode(decoElement);
+    });
+    return true;
+  };
+  return {
+    createDecorations: createDecorations,
+    removeDecorations: removeDecorations
+  };
+};

package/dist/esm/pm-plugins/input-rules.js

@@ -0,0 +1,29 @@
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { createPlugin, createRule, leafNodeReplacementCharacter } from '@atlaskit/prosemirror-input-rules';
+import { openTypeAheadAtCursor } from '../transforms/open-typeahead-at-cursor';
+export function inputRulePlugin(schema, typeAheads, featureFlags) {
+  if (!typeAheads || typeAheads.length === 0) {
+    return;
+  }
+  var rules = typeAheads.reduce(function (acc, typeAhead) {
+    var trigger = typeAhead.customRegex || typeAhead.trigger;
+    if (!trigger) {
+      return acc;
+    }
+    var regex = new RegExp("(^|[.!?\\s".concat(leafNodeReplacementCharacter, "])(").concat(trigger, ")$"));
+    acc.push(createRule(regex, function (state, match) {
+      return openTypeAheadAtCursor({
+        triggerHandler: typeAhead,
+        inputMethod: INPUT_METHOD.KEYBOARD
+      })({
+        tr: state.tr
+      });
+    }));
+    return acc;
+  }, []);
+  var plugin = createPlugin('type-ahead', rules, {
+    allowInsertTextOnDocument: false
+  });
+  return plugin;
+}
+export default inputRulePlugin;

package/dist/esm/pm-plugins/insert-item-plugin.js

@@ -0,0 +1,16 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { ACTIONS } from './actions';
+import { isInsertionTransaction } from './utils';
+export function createPlugin() {
+  return new SafePlugin({
+    appendTransaction: function appendTransaction(transactions, _oldState, newState) {
+      var insertItemCallback = isInsertionTransaction(transactions, ACTIONS.INSERT_ITEM);
+      if (insertItemCallback) {
+        var tr = insertItemCallback(newState);
+        if (tr) {
+          return tr;
+        }
+      }
+    }
+  });
+}

package/dist/esm/pm-plugins/key.js

@@ -0,0 +1,2 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export var pluginKey = new PluginKey('typeAheadPlugin');

package/dist/esm/pm-plugins/main.js

@@ -0,0 +1,104 @@
+import { InsertTypeAheadStep } from '@atlaskit/adf-schema/steps';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { closest } from '@atlaskit/editor-common/utils';
+import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE } from '../constants';
+import { ACTIONS } from './actions';
+import { factoryDecorations } from './decorations';
+import { pluginKey } from './key';
+import { createReducer } from './reducer';
+import { isInsertionTransaction } from './utils';
+var hasValidTypeAheadStep = function hasValidTypeAheadStep(tr) {
+  var steps = tr.steps.filter(function (step) {
+    return step instanceof InsertTypeAheadStep;
+  });
+
+  // There are some cases, like collab rebase, where the steps are re-applied
+  // We should not re open the type-ahead for those cases
+  if (steps.length === 1) {
+    return steps[0];
+  }
+  return null;
+};
+export function createPlugin(_ref) {
+  var reactDispatch = _ref.reactDispatch,
+    popupMountRef = _ref.popupMountRef,
+    createAnalyticsEvent = _ref.createAnalyticsEvent,
+    typeAheadHandlers = _ref.typeAheadHandlers,
+    getIntl = _ref.getIntl;
+  var intl = getIntl();
+  var _factoryDecorations = factoryDecorations({
+      intl: intl,
+      popupMountRef: popupMountRef,
+      createAnalyticsEvent: createAnalyticsEvent
+    }),
+    createDecorations = _factoryDecorations.createDecorations,
+    removeDecorations = _factoryDecorations.removeDecorations;
+  var reducer = createReducer({
+    createDecorations: createDecorations,
+    removeDecorations: removeDecorations,
+    typeAheadHandlers: typeAheadHandlers,
+    popupMountRef: popupMountRef
+  });
+  return new SafePlugin({
+    key: pluginKey,
+    state: {
+      init: function init() {
+        return {
+          typeAheadHandlers: typeAheadHandlers,
+          query: '',
+          decorationSet: DecorationSet.empty,
+          decorationElement: null,
+          items: [],
+          selectedIndex: -1,
+          stats: null,
+          inputMethod: null
+        };
+      },
+      apply: function apply(tr, currentPluginState, oldEditorState, state) {
+        var customStep = hasValidTypeAheadStep(tr);
+        var nextPluginState = reducer(tr, currentPluginState, customStep);
+        if (currentPluginState !== nextPluginState) {
+          reactDispatch(pluginKey, nextPluginState);
+        }
+        return nextPluginState;
+      }
+    },
+    appendTransaction: function appendTransaction(transactions, _oldState, newState) {
+      var insertItemCallback = isInsertionTransaction(transactions, ACTIONS.INSERT_RAW_QUERY);
+      if (insertItemCallback) {
+        var tr = insertItemCallback(newState);
+        if (tr) {
+          return tr;
+        }
+      }
+    },
+    view: function view() {
+      return {
+        update: function update(editorView) {}
+      };
+    },
+    props: {
+      decorations: function decorations(state) {
+        var _pluginKey$getState;
+        return (_pluginKey$getState = pluginKey.getState(state)) === null || _pluginKey$getState === void 0 ? void 0 : _pluginKey$getState.decorationSet;
+      },
+      handleDOMEvents: {
+        compositionend: function compositionend(view, event) {
+          return false;
+        },
+        click: function click(view, event) {
+          var target = event.target;
+          // ProseMirror view listen to any click event inside of it
+          // When this event is coming from the typeahead
+          // we should tell to ProseMirror to sit down and relax
+          // cuz we know what we are doing (I hope)
+          if (target instanceof HTMLElement && closest(target, "[data-type-ahead=".concat(TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE, "]"))) {
+            return true;
+          }
+          return false;
+        }
+      }
+    }
+  });
+}

package/dist/esm/pm-plugins/reducer.js

@@ -0,0 +1,151 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { InsertTypeAheadStages, InsertTypeAheadStep } from '@atlaskit/adf-schema/steps';
+import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { isTypeAheadHandler } from '../utils';
+import { ACTIONS } from './actions';
+import { pluginKey } from './key';
+var shouldForceOpen = function shouldForceOpen(step) {
+  if (!(step instanceof InsertTypeAheadStep)) {
+    return false;
+  }
+  var isDeletionRawQueryOperation = step.isInsertionStep() && step.stage === InsertTypeAheadStages.DELETING_RAW_QUERY;
+  var isUndoingInsertionItem = step.isUndoingStep() && step.stage === InsertTypeAheadStages.INSERTING_ITEM;
+  return isDeletionRawQueryOperation || isUndoingInsertionItem;
+};
+var shouldForceClose = function shouldForceClose(step) {
+  if (!(step instanceof InsertTypeAheadStep)) {
+    return false;
+  }
+  var isInsertingItem = step.isInsertionStep() && step.stage === InsertTypeAheadStages.INSERTING_ITEM;
+  var isUndoingDeletionRawQuery = step.isUndoingStep() && step.stage === InsertTypeAheadStages.DELETING_RAW_QUERY;
+  return isInsertingItem || isUndoingDeletionRawQuery;
+};
+var createFindHandler = function createFindHandler(typeAheadHandlers) {
+  return function (step) {
+    if (!(step instanceof InsertTypeAheadStep)) {
+      return null;
+    }
+    var handler = typeAheadHandlers.find(function (h) {
+      return h.trigger === step.trigger;
+    });
+    return handler || null;
+  };
+};
+export var createReducer = function createReducer(_ref) {
+  var typeAheadHandlers = _ref.typeAheadHandlers,
+    removeDecorations = _ref.removeDecorations,
+    createDecorations = _ref.createDecorations;
+  var findHandler = createFindHandler(typeAheadHandlers);
+  var openMenu = function openMenu(currentPluginState, _ref2) {
+    var tr = _ref2.tr,
+      triggerHandler = _ref2.triggerHandler,
+      inputMethod = _ref2.inputMethod,
+      reopenQuery = _ref2.reopenQuery,
+      selectedIndex = _ref2.selectedIndex;
+    removeDecorations(currentPluginState.decorationSet);
+    var _createDecorations = createDecorations(tr, {
+        triggerHandler: triggerHandler,
+        inputMethod: inputMethod,
+        reopenQuery: reopenQuery
+      }),
+      decorationSet = _createDecorations.decorationSet,
+      decorationElement = _createDecorations.decorationElement,
+      stats = _createDecorations.stats;
+    return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+      stats: stats,
+      decorationSet: decorationSet,
+      triggerHandler: triggerHandler,
+      decorationElement: decorationElement,
+      inputMethod: inputMethod,
+      selectedIndex: typeof selectedIndex === 'number' ? selectedIndex : -1,
+      items: [],
+      query: reopenQuery || ''
+    });
+  };
+  var closeMenu = function closeMenu(currentPluginState) {
+    removeDecorations(currentPluginState.decorationSet);
+    return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+      inputMethod: null,
+      query: '',
+      decorationElement: null,
+      decorationSet: DecorationSet.empty,
+      stats: null,
+      triggerHandler: undefined,
+      items: []
+    });
+  };
+  return function (tr, currentPluginState, typeAheadStepOverride) {
+    var meta = tr.getMeta(pluginKey) || {};
+
+    // This code below controls when we should force
+    // the menu to open or close during undo/redo operations
+    var overrideHandler = findHandler(typeAheadStepOverride);
+    if (typeAheadStepOverride && overrideHandler && shouldForceOpen(typeAheadStepOverride)) {
+      return openMenu(currentPluginState, {
+        tr: tr,
+        triggerHandler: overrideHandler,
+        inputMethod: INPUT_METHOD.KEYBOARD,
+        reopenQuery: typeAheadStepOverride.query,
+        selectedIndex: typeAheadStepOverride.selectedIndex
+      });
+    } else if (shouldForceClose(typeAheadStepOverride)) {
+      return closeMenu(currentPluginState);
+    }
+    var _ref3 = meta || {},
+      action = _ref3.action,
+      params = _ref3.params;
+    var shouldOpenMenu = action === ACTIONS.OPEN_TYPEAHEAD_AT_CURSOR && isTypeAheadHandler(params === null || params === void 0 ? void 0 : params.triggerHandler);
+    var selectionChanged = tr.selectionSet && (tr.isGeneric || Boolean(tr.getMeta('pointer')));
+    var shouldCloseMenu = [ACTIONS.CLOSE_TYPE_AHEAD, ACTIONS.INSERT_ITEM].includes(action) || selectionChanged;
+    var shouldUpdateQuery = action === ACTIONS.CHANGE_QUERY;
+    var shouldUpdateListItems = action === ACTIONS.UPDATE_LIST_ITEMS;
+    var shouldUpdateSelectedIndex = action === ACTIONS.UPDATE_SELECTED_INDEX;
+    if (shouldOpenMenu) {
+      return openMenu(currentPluginState, {
+        tr: tr,
+        triggerHandler: params.triggerHandler,
+        inputMethod: params.inputMethod
+      });
+    } else if (shouldCloseMenu) {
+      return closeMenu(currentPluginState);
+    } else if (shouldUpdateQuery) {
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        query: params.query
+      });
+    } else if (shouldUpdateListItems) {
+      var items = params.items;
+      var selectedIndex = currentPluginState.selectedIndex;
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        items: items,
+        selectedIndex: Math.max(selectedIndex >= items.length ? items.length - 1 : selectedIndex, -1)
+      });
+    } else if (shouldUpdateSelectedIndex) {
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        selectedIndex: params.selectedIndex
+      });
+    }
+    if (tr.docChanged) {
+      var decorationSet = currentPluginState.decorationSet;
+      var onRemove = function onRemove() {
+        // Make sure we are unmounting the component
+        // from the react tree when this decoration is removed
+        removeDecorations(currentPluginState.decorationSet);
+      };
+      var mappedDecorationSet = decorationSet.map(tr.mapping, tr.doc, {
+        onRemove: onRemove
+      });
+
+      // return same pluginState if decorationSet did not change
+      if (mappedDecorationSet === currentPluginState.decorationSet) {
+        return currentPluginState;
+      }
+      return _objectSpread(_objectSpread({}, currentPluginState), {}, {
+        decorationSet: mappedDecorationSet
+      });
+    }
+    return currentPluginState;
+  };
+};

package/dist/esm/pm-plugins/utils.js

@@ -0,0 +1,12 @@
+import { pluginKey } from './key';
+export var isInsertionTransaction = function isInsertionTransaction(transactions, action) {
+  var _tr$getMeta2;
+  var tr = transactions.find(function (tr) {
+    var _tr$getMeta;
+    return ((_tr$getMeta = tr.getMeta(pluginKey)) === null || _tr$getMeta === void 0 ? void 0 : _tr$getMeta.action) === action;
+  });
+  if (!tr) {
+    return null;
+  }
+  return (_tr$getMeta2 = tr.getMeta(pluginKey)) === null || _tr$getMeta2 === void 0 ? void 0 : _tr$getMeta2.params;
+};

package/dist/esm/stats-modifier.js

@@ -0,0 +1,35 @@
+import _createClass from "@babel/runtime/helpers/createClass";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+export var StatsModifier = /*#__PURE__*/_createClass(function StatsModifier() {
+  var _this = this;
+  _classCallCheck(this, StatsModifier);
+  _defineProperty(this, "startedAt", 0);
+  _defineProperty(this, "endedAt", 0);
+  _defineProperty(this, "keyCount", {
+    arrowUp: 0,
+    arrowDown: 0
+  });
+  _defineProperty(this, "increaseArrowUp", function () {
+    _this.keyCount.arrowUp += 1;
+  });
+  _defineProperty(this, "increaseArrowDown", function () {
+    _this.keyCount.arrowDown += 1;
+  });
+  _defineProperty(this, "serialize", function () {
+    var _this$keyCount, _this$keyCount2;
+    return {
+      startedAt: _this.startedAt,
+      endedAt: performance.now(),
+      keyCount: {
+        arrowUp: ((_this$keyCount = _this.keyCount) === null || _this$keyCount === void 0 ? void 0 : _this$keyCount.arrowUp) || 0,
+        arrowDown: ((_this$keyCount2 = _this.keyCount) === null || _this$keyCount2 === void 0 ? void 0 : _this$keyCount2.arrowDown) || 0
+      }
+    };
+  });
+  this.startedAt = performance.now();
+  this.keyCount = {
+    arrowUp: 0,
+    arrowDown: 0
+  };
+});

package/dist/esm/transforms/close-type-ahead.js

@@ -0,0 +1,7 @@
+import { ACTIONS } from '../pm-plugins/actions';
+import { pluginKey } from '../pm-plugins/key';
+export var closeTypeAhead = function closeTypeAhead(tr) {
+  return tr.setMeta(pluginKey, {
+    action: ACTIONS.CLOSE_TYPE_AHEAD
+  });
+};

package/dist/esm/transforms/open-typeahead-at-cursor.js

@@ -0,0 +1,69 @@
+import { GapCursorSelection } from '@atlaskit/editor-common/selection';
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { ACTIONS } from '../pm-plugins/actions';
+import { pluginKey } from '../pm-plugins/key';
+export var openTypeAhead = function openTypeAhead(props) {
+  return function (tr) {
+    var triggerHandler = props.triggerHandler,
+      inputMethod = props.inputMethod,
+      query = props.query;
+    tr.setMeta(pluginKey, {
+      action: ACTIONS.OPEN_TYPEAHEAD_AT_CURSOR,
+      params: {
+        triggerHandler: triggerHandler,
+        inputMethod: inputMethod,
+        query: query
+      }
+    });
+  };
+};
+export var openTypeAheadAtCursor = function openTypeAheadAtCursor(_ref) {
+  var triggerHandler = _ref.triggerHandler,
+    inputMethod = _ref.inputMethod,
+    query = _ref.query;
+  return function (_ref2) {
+    var tr = _ref2.tr;
+    openTypeAhead({
+      triggerHandler: triggerHandler,
+      inputMethod: inputMethod,
+      query: query
+    })(tr);
+    var selection = tr.selection;
+    if (!(selection instanceof TextSelection || selection instanceof GapCursorSelection)) {
+      return tr;
+    }
+    if (selection instanceof GapCursorSelection) {
+      // Create space for the typeahead menu in gap cursor
+      tr.insertText(' ');
+      // delete 1 pos before wherever selection is now - that will delete the empty space
+      tr.delete(tr.selection.from - 1, tr.selection.from);
+    } else {
+      var _selection$$head, _selection$$head$pare, _selection$$head$pare2;
+      if (!selection.$cursor) {
+        tr.deleteSelection();
+        return tr;
+      }
+
+      // Search & Destroy placeholder
+      var cursorPos = selection.$cursor.pos;
+      var nodeAtCursor = tr.doc.nodeAt(cursorPos);
+      var isPlaceholderAtCursorPosition = nodeAtCursor && nodeAtCursor.type.name === 'placeholder';
+      if (nodeAtCursor && isPlaceholderAtCursorPosition) {
+        tr.delete(cursorPos, cursorPos + nodeAtCursor.nodeSize);
+      }
+
+      // ME-2375 remove the superfluous '@' inserted before decoration
+      // by composition (https://github.com/ProseMirror/prosemirror/issues/903)
+      //
+      // Update:
+      // Now also handles any use case with superfluous typeahead triggers (ie. '@', ':', '/')
+      // being inserted due to composition by checking if we have the trigger
+      // directly before the typeahead. This should not happen unless it has
+      // been eroneously added because we require whitespace/newline for typeahead.
+      if (cursorPos >= 2 && !!(selection !== null && selection !== void 0 && (_selection$$head = selection.$head) !== null && _selection$$head !== void 0 && (_selection$$head = _selection$$head.parent) !== null && _selection$$head !== void 0 && _selection$$head.textContent) && (_selection$$head$pare = (_selection$$head$pare2 = selection.$head.parent.textContent).endsWith) !== null && _selection$$head$pare !== void 0 && _selection$$head$pare.call(_selection$$head$pare2, triggerHandler.trigger)) {
+        tr.delete(cursorPos - 1, cursorPos);
+      }
+    }
+    return tr;
+  };
+};

package/dist/esm/transforms/set-selection-before-query.js

@@ -0,0 +1,12 @@
+import { TextSelection } from '@atlaskit/editor-prosemirror/state';
+export var setSelectionBeforeQuery = function setSelectionBeforeQuery(rawText) {
+  return function (tr) {
+    var currentPosition = tr.selection.$from.pos;
+    var positionBeforeRawText = Math.max(currentPosition - rawText.length, 0);
+    var resolvedPositionBeforeText = tr.doc.resolve(positionBeforeRawText);
+    var nextSelection = TextSelection.findFrom(resolvedPositionBeforeText, -1, true);
+    if (nextSelection) {
+      tr.setSelection(nextSelection);
+    }
+  };
+};