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

package/dist/esm/insert-utils.js

@@ -0,0 +1,101 @@
+import { normaliseNestedLayout, safeInsert } from '@atlaskit/editor-common/insert';
+import { Fragment, Node as PMNode, Slice } from '@atlaskit/editor-prosemirror/model';
+import { NodeSelection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+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);
+}
+export 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 = normaliseNestedLayout(tr, node);
+
+    // Handle edge cases for hr and mediaSingle
+    var inserted = safeInsert(nodeNormalized, mappedStart)(tr);
+    if (inserted) {
+      return tr;
+    }
+    var sliceInserted = Slice.maxOpen(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 = TextSelection.findFrom(tr.doc.resolve(openPosition), FORWARD_DIRECTION, true);
+    if (nextSelection) {
+      return tr.setSelection(nextSelection);
+    }
+  }
+  return tr;
+};
+export 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 PMNode ? Fragment.from(maybeFragment) : maybeFragment;
+  tr.replaceWith(start, end, fragment);
+  if (selectInlineNode) {
+    return tr.setSelection(NodeSelection.create(tr.doc, start));
+  }
+  return tr.setSelection(TextSelection.near(tr.doc.resolve(start + fragment.size)));
+};

package/dist/esm/messages.js

@@ -0,0 +1,73 @@
+import { defineMessages } from 'react-intl-next';
+export var typeAheadListMessages = defineMessages({
+  typeAheadPopupLabel: {
+    id: 'fabric.editor.typeAhead.popupLabel',
+    defaultMessage: 'Typeahead results',
+    description: 'the result of a typeahead, similar to autocomplete results+'
+  },
+  quickInsertPopupLabel: {
+    id: 'fabric.editor.typeAhead.quickInsertPopupLabel',
+    defaultMessage: 'Shortcuts for inserts and formatting',
+    description: 'the result of a quick insert typeahead, similar to autocomplete results+'
+  },
+  quickInsertInputLabel: {
+    id: 'fabric.editor.typeAhead.quickInsertInputLabel',
+    defaultMessage: 'Begin typing to search or filter shortcut options',
+    description: 'assisitve text for typeahed input field'
+  },
+  emojiPopupLabel: {
+    id: 'fabric.editor.typeahead.emojiPopupLabel',
+    defaultMessage: 'Emoji shortcuts',
+    description: 'the result of a emoji typeahead, similar to autocomplete results+'
+  },
+  emojiInputLabel: {
+    id: 'fabric.editor.typeahead.emojiInputLabel',
+    defaultMessage: 'Begin typing to search or filter emoji options',
+    description: 'assisitve text for typeahed input field'
+  },
+  mentionPopupLabel: {
+    id: 'fabric.editor.typeahead.mentionPopupLabel',
+    defaultMessage: 'Users you can tag',
+    description: 'the aria label of a mention typeahead popup'
+  },
+  mentionInputLabel: {
+    id: 'fabric.editor.typeahead.mentionInputLabel',
+    defaultMessage: 'Begin typing to search for users to tag',
+    description: 'assisitve text for typeahed input field'
+  },
+  metionListItemLabel: {
+    id: 'fabric.editor.typeahead.metionListItemLabel',
+    defaultMessage: 'User {name} @{shortName}',
+    description: 'assistive text for user mention items username and nickname'
+  },
+  emojiListItemLabel: {
+    id: 'fabric.editor.typeahead.emojiListItemLabel',
+    defaultMessage: 'Emoji {name} Text Shortcut {shortcut}',
+    description: 'assistive text for emoji name and shortcut'
+  },
+  inputQueryAssistiveLabel: {
+    id: 'fabric.editor.inputQueryAssistiveTxt',
+    defaultMessage: 'When autocomplete results are available use up and down arrows to review and enter to select. Touch device users, explore by touch or with swipe gestures.',
+    description: 'Assistive text to the user when using typeahead shortcut'
+  },
+  searchResultsLabel: {
+    id: 'fabric.editor.searchResults',
+    defaultMessage: '{itemsLength, plural, one {# search result} other {# search results}} available',
+    description: 'Assistive text to the user when using typeahead shortcut and it preceeds with a number - Ex: 10 search results available'
+  },
+  noSearchResultsLabel: {
+    id: 'fabric.editor.noSearchResults',
+    defaultMessage: 'No search results',
+    description: 'Assistive text to the user when using typeahead shortcut'
+  },
+  descriptionLabel: {
+    id: 'fabric.editor.description',
+    defaultMessage: 'Description',
+    description: 'Description'
+  },
+  shortcutLabel: {
+    id: 'fabric.editor.shortcut',
+    defaultMessage: 'Text shortcut',
+    description: 'Text shortcut'
+  }
+});

package/dist/esm/plugin.js

@@ -0,0 +1,374 @@
+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/pm-plugins/actions.js

@@ -0,0 +1,10 @@
+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;
+}({});