@atlaskit/editor-core 188.8.0 → 188.9.2

package/dist/esm/plugins/type-ahead/plugin.js

@@ -1,374 +0,0 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-/**
- *
- * Revamped typeahead using decorations instead of the `typeAheadQuery` mark
- *
- * https://product-fabric.atlassian.net/wiki/spaces/E/pages/2992177582/Technical+TypeAhead+Data+Flow
- *
- *
- */
-import React from 'react';
-import { typeAheadQuery } from '@atlaskit/adf-schema';
-import { ACTION, ACTION_SUBJECT, EVENT_TYPE, fireAnalyticsEvent, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { SelectItemMode } from '@atlaskit/editor-common/type-ahead';
-import { WithPluginState } from '@atlaskit/editor-common/with-plugin-state';
-import { insertTypeAheadItem } from './commands/insert-type-ahead-item';
-import { updateSelectedIndex } from './commands/update-selected-index';
-import { inputRulePlugin } from './pm-plugins/input-rules';
-import { createPlugin as createInsertItemPlugin } from './pm-plugins/insert-item-plugin';
-import { pluginKey as typeAheadPluginKey } from './pm-plugins/key';
-import { createPlugin } from './pm-plugins/main';
-import { StatsModifier } from './stats-modifier';
-import { closeTypeAhead } from './transforms/close-type-ahead';
-import { openTypeAheadAtCursor } from './transforms/open-typeahead-at-cursor';
-import { useItemInsert } from './ui/hooks/use-item-insert';
-import { TypeAheadPopup } from './ui/TypeAheadPopup';
-import { findHandler, getPluginState, getTypeAheadHandler, getTypeAheadQuery, isTypeAheadAllowed, isTypeAheadOpen } from './utils';
-var TypeAheadMenu = /*#__PURE__*/React.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 = useItemInsert(triggerHandler, editorView, items),
-    _useItemInsert2 = _slicedToArray(_useItemInsert, 3),
-    onItemInsert = _useItemInsert2[0],
-    onTextInsert = _useItemInsert2[1],
-    onItemMatch = _useItemInsert2[2];
-  var setSelectedItem = React.useCallback(function (_ref2) {
-    var nextIndex = _ref2.index;
-    queueMicrotask(function () {
-      updateSelectedIndex(nextIndex)(editorView.state, editorView.dispatch);
-    });
-  }, [editorView]);
-  var insertItem = React.useCallback(function () {
-    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SelectItemMode.SELECTED;
-    var index = arguments.length > 1 ? arguments[1] : undefined;
-    queueMicrotask(function () {
-      onItemInsert({
-        mode: mode,
-        index: index,
-        query: query
-      });
-    });
-  }, [onItemInsert, query]);
-  var cancel = React.useCallback(function (_ref3) {
-    var setSelectionAt = _ref3.setSelectionAt,
-      addPrefixTrigger = _ref3.addPrefixTrigger,
-      forceFocusOnEditor = _ref3.forceFocusOnEditor;
-    var fullQuery = addPrefixTrigger ? "".concat(triggerHandler === null || triggerHandler === void 0 ? void 0 : triggerHandler.trigger).concat(query) : query;
-    onTextInsert({
-      forceFocusOnEditor: forceFocusOnEditor,
-      setSelectionAt: setSelectionAt,
-      text: fullQuery
-    });
-  }, [triggerHandler, onTextInsert, query]);
-  React.useEffect(function () {
-    if (!isOpen || !query) {
-      return;
-    }
-    var isLastCharSpace = query[query.length - 1] === ' ';
-    if (!isLastCharSpace) {
-      return;
-    }
-    var result = onItemMatch({
-      mode: 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.createElement(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,
-    cancel: cancel
-  });
-});
-var createOpenAtTransaction = function createOpenAtTransaction(editorAnalyticsAPI) {
-  return function (props) {
-    return function (tr) {
-      var triggerHandler = props.triggerHandler,
-        inputMethod = props.inputMethod;
-      openTypeAheadAtCursor({
-        triggerHandler: triggerHandler,
-        inputMethod: inputMethod
-      })({
-        tr: tr
-      });
-      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
-        action: ACTION.INVOKED,
-        actionSubject: ACTION_SUBJECT.TYPEAHEAD,
-        actionSubjectId: triggerHandler.id,
-        attributes: {
-          inputMethod: inputMethod
-        },
-        eventType: EVENT_TYPE.UI
-      })(tr);
-      return true;
-    };
-  };
-};
-var createOpenTypeAhead = function createOpenTypeAhead(editorViewRef, editorAnalyticsAPI) {
-  return function (props) {
-    if (!editorViewRef.current) {
-      return false;
-    }
-    var view = editorViewRef.current;
-    var tr = view.state.tr;
-    createOpenAtTransaction(editorAnalyticsAPI)(props)(tr);
-    view.dispatch(tr);
-    return true;
-  };
-};
-var createInsertTypeAheadItem = function createInsertTypeAheadItem(editorViewRef) {
-  return function (props) {
-    if (!editorViewRef.current) {
-      return false;
-    }
-    var view = editorViewRef.current;
-    var triggerHandler = props.triggerHandler,
-      contentItem = props.contentItem,
-      query = props.query,
-      sourceListItem = props.sourceListItem,
-      mode = props.mode;
-    insertTypeAheadItem(view)({
-      handler: triggerHandler,
-      item: contentItem,
-      mode: mode || SelectItemMode.SELECTED,
-      query: query,
-      sourceListItem: sourceListItem
-    });
-    return true;
-  };
-};
-var createFindHandlerByTrigger = function createFindHandlerByTrigger(editorViewRef) {
-  return function (trigger) {
-    if (!editorViewRef.current) {
-      return null;
-    }
-    var view = editorViewRef.current;
-    return findHandler(trigger, view.state);
-  };
-};
-var createCloseTypeAhead = function createCloseTypeAhead(editorViewRef) {
-  return function (options) {
-    if (!editorViewRef.current) {
-      return false;
-    }
-    var view = editorViewRef.current;
-    var currentQuery = getTypeAheadQuery(view.state) || '';
-    var state = view.state;
-    var tr = state.tr;
-    if (options.attachCommand) {
-      var fakeDispatch = function fakeDispatch(customTr) {
-        tr = customTr;
-      };
-      options.attachCommand(state, fakeDispatch);
-    }
-    closeTypeAhead(tr);
-    if (options.insertCurrentQueryAsRawText && currentQuery && currentQuery.length > 0) {
-      var handler = getTypeAheadHandler(state);
-      if (!handler) {
-        return false;
-      }
-      var text = handler.trigger.concat(currentQuery);
-      tr.replaceSelectionWith(state.schema.text(text));
-    }
-    view.dispatch(tr);
-    if (!view.hasFocus()) {
-      view.focus();
-    }
-    return true;
-  };
-};
-
-/**
- *
- * Revamped typeahead using decorations instead of the `typeAheadQuery` mark
- *
- * https://product-fabric.atlassian.net/wiki/spaces/E/pages/2992177582/Technical+TypeAhead+Data+Flow
- *
- *
- */
-export var typeAheadPlugin = function typeAheadPlugin(_ref4) {
-  var _api$analytics, _api$analytics2;
-  var options = _ref4.config,
-    api = _ref4.api;
-  var fireAnalyticsCallback = fireAnalyticsEvent(options === null || options === void 0 ? void 0 : options.createAnalyticsEvent);
-  var popupMountRef = {
-    current: null
-  };
-  var editorViewRef = {
-    current: null
-  };
-  return {
-    name: 'typeAhead',
-    marks: function marks() {
-      // We need to keep this to make sure
-      // All documents with typeahead marks will be loaded normally
-      return [{
-        name: 'typeAheadQuery',
-        mark: typeAheadQuery
-      }];
-    },
-    pmPlugins: function pmPlugins() {
-      var typeAhead = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-      return [{
-        name: 'typeAhead',
-        plugin: function plugin(_ref5) {
-          var dispatch = _ref5.dispatch,
-            getIntl = _ref5.getIntl;
-          return createPlugin({
-            getIntl: getIntl,
-            popupMountRef: popupMountRef,
-            reactDispatch: dispatch,
-            typeAheadHandlers: typeAhead,
-            createAnalyticsEvent: options === null || options === void 0 ? void 0 : options.createAnalyticsEvent
-          });
-        }
-      }, {
-        name: 'typeAheadEditorViewRef',
-        plugin: function plugin() {
-          return new SafePlugin({
-            view: function view(_view) {
-              editorViewRef.current = _view;
-              return {
-                destroy: function destroy() {
-                  editorViewRef.current = null;
-                }
-              };
-            }
-          });
-        }
-      }, {
-        name: 'typeAheadInsertItem',
-        plugin: createInsertItemPlugin
-      }, {
-        name: 'typeAheadInputRule',
-        plugin: function plugin(_ref6) {
-          var schema = _ref6.schema,
-            featureFlags = _ref6.featureFlags;
-          return inputRulePlugin(schema, typeAhead, featureFlags);
-        }
-      }];
-    },
-    getSharedState: function getSharedState(editorState) {
-      if (!editorState) {
-        return {
-          query: '',
-          isOpen: false,
-          isAllowed: false,
-          currentHandler: undefined
-        };
-      }
-      var isOpen = isTypeAheadOpen(editorState);
-      return {
-        query: getTypeAheadQuery(editorState) || '',
-        currentHandler: getTypeAheadHandler(editorState),
-        isOpen: isOpen,
-        isAllowed: !isOpen
-      };
-    },
-    actions: {
-      isOpen: isTypeAheadOpen,
-      isAllowed: isTypeAheadAllowed,
-      open: createOpenTypeAhead(editorViewRef, api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions),
-      openAtTransaction: createOpenAtTransaction(api === null || api === void 0 || (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 ? void 0 : _api$analytics2.actions),
-      findHandlerByTrigger: createFindHandlerByTrigger(editorViewRef),
-      insert: createInsertTypeAheadItem(editorViewRef),
-      close: createCloseTypeAhead(editorViewRef)
-    },
-    contentComponent: function contentComponent(_ref7) {
-      var editorView = _ref7.editorView,
-        containerElement = _ref7.containerElement,
-        popupsMountPoint = _ref7.popupsMountPoint,
-        popupsBoundariesElement = _ref7.popupsBoundariesElement,
-        popupsScrollableElement = _ref7.popupsScrollableElement,
-        wrapperElement = _ref7.wrapperElement;
-      popupMountRef.current = {
-        popupsMountPoint: popupsMountPoint || wrapperElement || undefined,
-        popupsBoundariesElement: popupsBoundariesElement,
-        popupsScrollableElement: popupsScrollableElement || containerElement || undefined
-      };
-      return /*#__PURE__*/React.createElement(WithPluginState, {
-        plugins: {
-          typeAheadState: typeAheadPluginKey
-        },
-        render: function render(_ref8) {
-          var typeAheadState = _ref8.typeAheadState;
-          if (!typeAheadState) {
-            return null;
-          }
-          return /*#__PURE__*/React.createElement(TypeAheadMenu, {
-            editorView: editorView,
-            popupMountRef: popupMountRef,
-            typeAheadState: typeAheadState,
-            fireAnalyticsCallback: fireAnalyticsCallback
-          });
-        }
-      });
-    },
-    onEditorViewStateUpdated: function onEditorViewStateUpdated(_ref9) {
-      var originalTransaction = _ref9.originalTransaction,
-        oldEditorState = _ref9.oldEditorState,
-        newEditorState = _ref9.newEditorState;
-      var oldPluginState = getPluginState(oldEditorState);
-      var newPluginState = 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) {
-        var typeAheadMessage = originalTransaction.getMeta(typeAheadPluginKey);
-        var wasItemInserted = typeAheadMessage && typeAheadMessage.action === 'INSERT_RAW_QUERY';
-        oldTriggerHandler.dismiss({
-          editorState: newEditorState,
-          query: oldPluginState.query,
-          stats: (oldPluginState.stats || new StatsModifier()).serialize(),
-          wasItemInserted: wasItemInserted
-        });
-      }
-      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: ACTION.INVOKED,
-            actionSubject: ACTION_SUBJECT.TYPEAHEAD,
-            actionSubjectId: newTriggerHandler.id || 'not_set',
-            attributes: {
-              inputMethod: newPluginState.inputMethod || INPUT_METHOD.KEYBOARD
-            },
-            eventType: EVENT_TYPE.UI
-          }
-        });
-      }
-    }
-  };
-};

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

@@ -1,10 +0,0 @@
-export var ACTIONS = /*#__PURE__*/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";
-  return ACTIONS;
-}({});

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

@@ -1,141 +0,0 @@
-import React from 'react';
-import ReactDOM from 'react-dom';
-import uuid from 'uuid';
-import { TextSelection } from '@atlaskit/editor-prosemirror/state';
-import { DecorationSet, Decoration } from '@atlaskit/editor-prosemirror/view';
-import { B400 } from '@atlaskit/theme/colors';
-import { keyName as keyNameNormalized } from 'w3c-keyname';
-import { IntlProvider } from 'react-intl-next';
-import { redo, undo } from '@atlaskit/editor-prosemirror/history';
-import { TYPE_AHEAD_DECORATION_KEY, TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE } from '../constants';
-import { WrapperTypeAhead } from '../ui/WrapperTypeAhead';
-import { StatsModifier } from '../stats-modifier';
-import { getTypeAheadQuery } from '../utils';
-import { closeTypeAhead } from '../transforms/close-type-ahead';
-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/plugins/type-ahead/pm-plugins/input-rules.js

@@ -1,29 +0,0 @@
-import { createRule, createPlugin, leafNodeReplacementCharacter } from '@atlaskit/prosemirror-input-rules';
-import { openTypeAheadAtCursor } from '../transforms/open-typeahead-at-cursor';
-import { INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-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/plugins/type-ahead/pm-plugins/insert-item-plugin.js

@@ -1,16 +0,0 @@
-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/plugins/type-ahead/pm-plugins/key.js

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

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

@@ -1,104 +0,0 @@
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
-import { InsertTypeAheadStep } from '@atlaskit/adf-schema/steps';
-import { TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE } from '../constants';
-import { ACTIONS } from './actions';
-import { pluginKey } from './key';
-import { closest } from '@atlaskit/editor-common/utils';
-import { createReducer } from './reducer';
-import { factoryDecorations } from './decorations';
-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;
-        }
-      }
-    }
-  });
-}