@atlaskit/editor-core 148.0.0 → 149.0.3

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

@@ -0,0 +1,243 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTypeAheadTools = void 0;
+
+var _typeAhead = require("@atlaskit/editor-common/type-ahead");
+
+var _utils = require("./utils");
+
+var _enums = require("../analytics/types/enums");
+
+var _openTypeaheadAtCursor = require("./transforms/open-typeahead-at-cursor");
+
+var _closeTypeAhead = require("./transforms/close-type-ahead");
+
+var _updateQuery = require("./commands/update-query");
+
+var _insertTypeAheadItem = require("./commands/insert-type-ahead-item");
+
+var open = function open(_ref) {
+  var editorView = _ref.editorView;
+  return function (itemType) {
+    return function (inputMethod) {
+      var state = editorView.state;
+      var handler = (0, _utils.findHandler)(itemType, state);
+
+      if (!handler) {
+        return false;
+      }
+
+      var tr = state.tr;
+      (0, _openTypeaheadAtCursor.openTypeAheadAtCursor)({
+        triggerHandler: handler,
+        inputMethod: inputMethod
+      })(tr);
+      editorView.dispatch(tr);
+      return true;
+    };
+  };
+};
+
+var defaultCloseOptions = {
+  insertCurrentQueryAsRawText: false
+};
+
+var close = function close(_ref2) {
+  var editorView = _ref2.editorView;
+  return function () {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultCloseOptions;
+    var state = editorView.state;
+    var currentQuery = (0, _utils.getTypeAheadQuery)(editorView.state);
+    var tr = state.tr;
+
+    if (options.attachCommand) {
+      var fakeDispatch = function fakeDispatch(customTr) {
+        tr = customTr;
+      };
+
+      options.attachCommand(state, fakeDispatch);
+    }
+
+    (0, _closeTypeAhead.closeTypeAhead)(tr);
+
+    if (options.insertCurrentQueryAsRawText && currentQuery && currentQuery.length > 0) {
+      var handler = (0, _utils.getTypeAheadHandler)(state);
+      var text = handler.trigger.concat(currentQuery);
+      tr.replaceSelectionWith(state.schema.text(text));
+    }
+
+    editorView.dispatch(tr);
+
+    if (!editorView.hasFocus()) {
+      editorView.focus();
+    }
+
+    return true;
+  };
+};
+
+var search = function search(_ref3) {
+  var editorView = _ref3.editorView;
+  return function (itemType) {
+    return function () {
+      var query = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      var state = editorView.state;
+      var handler = (0, _utils.findHandler)(itemType, state);
+
+      if (!handler) {
+        throw new Error("Handler not found, did you load the ".concat(itemType, " plugin properly"));
+      }
+
+      open({
+        editorView: editorView
+      })(itemType)(_enums.INPUT_METHOD.KEYBOARD);
+      (0, _updateQuery.updateQuery)(query)(editorView.state, editorView.dispatch);
+      var lastQuery = {
+        current: query
+      };
+      var last = handler.getItems({
+        query: query,
+        editorState: state
+      }).then(function (items) {
+        if (!handler.forceSelect) {
+          return items;
+        }
+
+        var forceSelectedItem = handler.forceSelect({
+          items: items,
+          query: query,
+          editorState: state
+        });
+
+        if (!forceSelectedItem) {
+          return items;
+        }
+
+        (0, _insertTypeAheadItem.insertTypeAheadItem)(editorView)({
+          handler: handler,
+          item: forceSelectedItem,
+          query: query,
+          mode: _typeAhead.SelectItemMode.SELECTED,
+          sourceListItem: items
+        });
+      });
+      var results = {
+        last: last
+      };
+      return {
+        type: function type(appendValue) {
+          if (!appendValue) {
+            return;
+          }
+
+          lastQuery.current += appendValue;
+          (0, _updateQuery.updateQuery)(lastQuery.current)(editorView.state, editorView.dispatch);
+          var promise = handler.getItems({
+            query: lastQuery.current,
+            editorState: state
+          });
+          results.last = promise;
+          return promise;
+        },
+        result: function result() {
+          return results.last;
+        },
+        close: close({
+          editorView: editorView
+        }),
+        insert: function insert(_ref4) {
+          var index = _ref4.index,
+              mode = _ref4.mode;
+          return results.last.then(function (result) {
+            var item = result ? result[index] : null;
+
+            if (result && item) {
+              (0, _insertTypeAheadItem.insertTypeAheadItem)(editorView)({
+                handler: handler,
+                item: item,
+                query: query,
+                mode: mode || _typeAhead.SelectItemMode.SELECTED,
+                sourceListItem: result
+              });
+            }
+          });
+        }
+      };
+    };
+  };
+};
+
+var insertItem = function insertItem(_ref5) {
+  var editorView = _ref5.editorView;
+  return function (itemType) {
+    return function (_ref6) {
+      var contentItem = _ref6.contentItem,
+          query = _ref6.query,
+          sourceListItem = _ref6.sourceListItem;
+      var state = editorView.state;
+      var handler = (0, _utils.findHandler)(itemType, state);
+
+      if (!handler) {
+        return false;
+      }
+
+      (0, _insertTypeAheadItem.insertTypeAheadItem)(editorView)({
+        handler: handler,
+        item: contentItem,
+        mode: _typeAhead.SelectItemMode.SELECTED,
+        query: query,
+        sourceListItem: sourceListItem
+      });
+      return true;
+    };
+  };
+};
+
+var isOpen = function isOpen(_ref7) {
+  var editorView = _ref7.editorView;
+  return function () {
+    if (!(0, _utils.isTypeAheadOpen)(editorView.state)) {
+      return false;
+    }
+
+    var handler = (0, _utils.getTypeAheadHandler)(editorView.state);
+
+    if (!handler) {
+      return false;
+    }
+
+    return handler;
+  };
+};
+
+var currentQuery = function currentQuery(_ref8) {
+  var editorView = _ref8.editorView;
+  return function () {
+    return (0, _utils.getTypeAheadQuery)(editorView.state);
+  };
+};
+
+var createTypeAheadTools = function createTypeAheadTools(editorView) {
+  var props = {
+    editorView: editorView
+  };
+  return {
+    isOpen: isOpen(props),
+    currentQuery: currentQuery(props),
+    close: close(props),
+    openMention: open(props)(_typeAhead.TypeAheadAvailableNodes.MENTION),
+    searchMention: search(props)(_typeAhead.TypeAheadAvailableNodes.MENTION),
+    openQuickInsert: open(props)(_typeAhead.TypeAheadAvailableNodes.QUICK_INSERT),
+    searchQuickInsert: search(props)(_typeAhead.TypeAheadAvailableNodes.QUICK_INSERT),
+    openEmoji: open(props)(_typeAhead.TypeAheadAvailableNodes.EMOJI),
+    searchEmoji: search(props)(_typeAhead.TypeAheadAvailableNodes.EMOJI),
+    insertItemMention: insertItem(props)(_typeAhead.TypeAheadAvailableNodes.MENTION),
+    insertItemEmoji: insertItem(props)(_typeAhead.TypeAheadAvailableNodes.EMOJI),
+    insertItemQuickInsert: insertItem(props)(_typeAhead.TypeAheadAvailableNodes.QUICK_INSERT)
+  };
+};
+
+exports.createTypeAheadTools = createTypeAheadTools;

package/dist/cjs/plugins/type-ahead/commands/insert-type-ahead-item.js

@@ -0,0 +1,238 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertTypeAheadItem = void 0;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _prosemirrorModel = require("prosemirror-model");
+
+var _steps = require("@atlaskit/adf-schema/steps");
+
+var _prosemirrorHistory = require("prosemirror-history");
+
+var _key = require("../pm-plugins/key");
+
+var _insertUtils = require("../insert-utils");
+
+var _statsModifier = require("../stats-modifier");
+
+var _typeAhead = require("@atlaskit/editor-common/type-ahead");
+
+var _actions = require("../pm-plugins/actions");
+
+var _closeTypeAhead = require("../transforms/close-type-ahead");
+
+var _utils = require("../utils");
+
+var validateNode = function validateNode(_ref) {
+  var schema = _ref.schema,
+      maybeNode = _ref.maybeNode;
+
+  if (!maybeNode) {
+    return null;
+  }
+
+  if (maybeNode instanceof _prosemirrorModel.Node || maybeNode instanceof _prosemirrorModel.Fragment) {
+    return maybeNode;
+  }
+
+  if (typeof maybeNode === 'string') {
+    return schema.text(maybeNode);
+  }
+
+  try {
+    return _prosemirrorModel.Node.fromJSON(schema, maybeNode);
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    return null;
+  }
+};
+
+var createInsertCallback = function createInsertCallback(_ref2) {
+  var state = _ref2.editorState,
+      handler = _ref2.handler,
+      query = _ref2.query,
+      mode = _ref2.mode,
+      wasInsertedBySpace = _ref2.wasInsertedBySpace,
+      selectedIndex = _ref2.selectedIndex,
+      textStartPosition = _ref2.textStartPosition,
+      textInserted = _ref2.textInserted;
+  return function (maybeNode) {
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var tr = state.tr;
+    var position = {
+      start: textStartPosition,
+      end: textStartPosition + (wasInsertedBySpace ? textInserted.length : 0)
+    };
+    var node = validateNode({
+      schema: state.schema,
+      maybeNode: maybeNode
+    });
+
+    if (!node) {
+      (0, _closeTypeAhead.closeTypeAhead)(tr); // In this kind of situation we need to
+      // delete the raw text query
+
+      tr.delete(position.start, position.end);
+      return tr;
+    }
+
+    node instanceof _prosemirrorModel.Node && node.isBlock ? (0, _insertUtils.insertBlockNode)({
+      node: node,
+      tr: tr,
+      position: position
+    }) : (0, _insertUtils.insertInlineNodeOrFragment)({
+      maybeFragment: node,
+      tr: tr,
+      position: position,
+      selectInlineNode: Boolean(opts.selectInlineNode)
+    });
+    (0, _prosemirrorHistory.closeHistory)(tr);
+
+    if (wasInsertedBySpace) {
+      return tr;
+    }
+
+    var config = {
+      stage: _steps.InsertTypeAheadStages.INSERTING_ITEM,
+      query: query,
+      selectedIndex: selectedIndex,
+      trigger: handler.trigger
+    };
+    tr.step(new _steps.InsertTypeAheadStep(config));
+    return tr;
+  };
+};
+
+var createDeleteRawTextCallback = function createDeleteRawTextCallback(_ref3) {
+  var trigger = _ref3.trigger,
+      selectedIndex = _ref3.selectedIndex,
+      position = _ref3.position,
+      query = _ref3.query,
+      wasInsertedBySpace = _ref3.wasInsertedBySpace,
+      insertItem = _ref3.insertItem;
+  return function (newState) {
+    var tr = newState.tr;
+    (0, _prosemirrorHistory.closeHistory)(tr);
+
+    if (!wasInsertedBySpace) {
+      tr.delete(position.start, position.end);
+      var config = {
+        stage: _steps.InsertTypeAheadStages.DELETING_RAW_QUERY,
+        selectedIndex: selectedIndex,
+        query: query,
+        trigger: trigger
+      };
+      tr.step(new _steps.InsertTypeAheadStep(config));
+    }
+
+    tr.setMeta(_key.pluginKey, {
+      action: _actions.ACTIONS.INSERT_ITEM,
+      params: insertItem
+    });
+    return tr;
+  };
+};
+
+var insertTypeAheadItem = function insertTypeAheadItem(view) {
+  return function (_ref4) {
+    var item = _ref4.item,
+        handler = _ref4.handler,
+        mode = _ref4.mode,
+        query = _ref4.query,
+        sourceListItem = _ref4.sourceListItem;
+    var pluginState = (0, _utils.getPluginState)(view.state);
+
+    if (!pluginState) {
+      return;
+    }
+
+    var stats = (pluginState.stats || new _statsModifier.StatsModifier()).serialize();
+    var meta = {
+      mode: mode,
+      query: query,
+      stats: stats,
+      sourceListItem: sourceListItem
+    };
+    var tr = view.state.tr;
+    var trigger = handler.trigger;
+    var text = "".concat(trigger).concat(query);
+
+    if (mode === _typeAhead.SelectItemMode.SPACE) {
+      text = text.trim().concat(' ');
+    }
+
+    var selectedIndex = Math.max(sourceListItem.indexOf(item), 0);
+    var wasInsertedBySpace = mode === _typeAhead.SelectItemMode.SPACE;
+    var textStartPosition = tr.selection.from;
+
+    var insertItem = function insertItem(newEditorSate) {
+      var insertCallback = createInsertCallback({
+        editorState: newEditorSate,
+        query: query,
+        mode: mode,
+        handler: handler,
+        wasInsertedBySpace: wasInsertedBySpace,
+        selectedIndex: selectedIndex,
+        textInserted: text,
+        textStartPosition: textStartPosition
+      });
+      var wasInsertCallbackCalled = false; // Some wierd plugins doesn't call the insert item callback
+      // For example, the link quick insert item
+      // For those cases we need to make sure we are closing the typeahead
+
+      var proxyHandler = {
+        apply: function apply(target, _thisContext, argumentsList) {
+          wasInsertCallbackCalled = true;
+          return target.apply(void 0, (0, _toConsumableArray2.default)(argumentsList));
+        }
+      };
+      var insertCallbackProxy = new Proxy(insertCallback, proxyHandler);
+      var nextTr = handler.selectItem(newEditorSate, item, insertCallbackProxy, meta);
+
+      if (!wasInsertCallbackCalled && nextTr) {
+        (0, _prosemirrorHistory.closeHistory)(nextTr); // In some cases we need to re-open the typeahead
+        // e.g.: addign mentions from the quick insert
+        //
+        // Today, the QuickInsert API doesn't have a tool
+        // to help on this. So the code below will close the typeahead
+        // only if there is no previous metadata about typeahead in the
+        // next transaction
+
+        if (!nextTr.getMeta(_key.pluginKey)) {
+          (0, _closeTypeAhead.closeTypeAhead)(nextTr);
+        }
+      }
+
+      return nextTr;
+    };
+
+    var position = {
+      start: tr.selection.from,
+      end: tr.selection.from + text.length
+    };
+    tr.setMeta(_key.pluginKey, {
+      action: _actions.ACTIONS.INSERT_RAW_QUERY,
+      params: createDeleteRawTextCallback({
+        wasInsertedBySpace: wasInsertedBySpace,
+        selectedIndex: selectedIndex,
+        insertItem: insertItem,
+        position: position,
+        query: query,
+        trigger: trigger
+      })
+    });
+    tr.insertText(text);
+    (0, _prosemirrorHistory.closeHistory)(tr);
+    view.dispatch(tr);
+    view.focus();
+  };
+};
+
+exports.insertTypeAheadItem = insertTypeAheadItem;

package/dist/cjs/plugins/type-ahead/commands/update-list-items.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateListItem = void 0;
+
+var _key = require("../pm-plugins/key");
+
+var _actions = require("../pm-plugins/actions");
+
+var updateListItem = function updateListItem(items) {
+  return function (state, dispatch) {
+    var tr = state.tr;
+    tr.setMeta(_key.pluginKey, {
+      action: _actions.ACTIONS.UPDATE_LIST_ITEMS,
+      params: {
+        items: items
+      }
+    });
+
+    if (dispatch) {
+      dispatch(tr);
+    }
+
+    return true;
+  };
+};
+
+exports.updateListItem = updateListItem;

package/dist/cjs/plugins/type-ahead/commands/update-query.js

@@ -3,36 +3,34 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.updateQueryCommand = void 0;
+exports.updateQuery = void 0;
 
-var _actions = require("../pm-plugins/actions");
-
-var _pluginKey = require("../pm-plugins/plugin-key");
-
-var _findQueryMark = require("../utils/find-query-mark");
+var _key = require("../pm-plugins/key");
 
-var _isQueryActive = require("../utils/is-query-active");
+var _actions = require("../pm-plugins/actions");
 
-var updateQueryCommand = function updateQueryCommand(query) {
+var updateQuery = function updateQuery(query) {
   return function (state, dispatch) {
-    var queryMark = (0, _findQueryMark.findTypeAheadQuery)(state);
-    var activeQuery = (0, _isQueryActive.isQueryActive)(state.schema.marks.typeAheadQuery, state.doc, state.selection.from, state.selection.to);
+    var pluginState = _key.pluginKey.getState(state);
 
-    if (queryMark === null || activeQuery === false) {
+    if (pluginState.query === query) {
       return false;
     }
 
+    var tr = state.tr;
+    tr.setMeta(_key.pluginKey, {
+      action: _actions.ACTIONS.CHANGE_QUERY,
+      params: {
+        query: query
+      }
+    });
+
     if (dispatch) {
-      dispatch(state.tr.setMeta(_pluginKey.pluginKey, {
-        action: _actions.ACTIONS.SET_QUERY,
-        params: {
-          query: query
-        }
-      }));
+      dispatch(tr);
     }
 
     return true;
   };
 };
 
-exports.updateQueryCommand = updateQueryCommand;
+exports.updateQuery = updateQuery;

package/dist/cjs/plugins/type-ahead/commands/update-selected-index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateSelectedIndex = void 0;
+
+var _key = require("../pm-plugins/key");
+
+var _actions = require("../pm-plugins/actions");
+
+var updateSelectedIndex = function updateSelectedIndex(selectedIndex) {
+  return function (state, dispatch) {
+    var pluginState = _key.pluginKey.getState(state);
+
+    if (pluginState.selectedIndex === selectedIndex) {
+      return false;
+    }
+
+    var tr = state.tr;
+    tr.setMeta(_key.pluginKey, {
+      action: _actions.ACTIONS.UPDATE_SELECTED_INDEX,
+      params: {
+        selectedIndex: selectedIndex
+      }
+    });
+
+    if (dispatch) {
+      dispatch(tr);
+    }
+
+    return true;
+  };
+};
+
+exports.updateSelectedIndex = updateSelectedIndex;

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

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CloseSelectionOptions = exports.NavigationDirection = exports.TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE = exports.TYPE_AHEAD_DECORATION_KEY = void 0;
+var TYPE_AHEAD_DECORATION_KEY = 'typeahead_decoration_key';
+exports.TYPE_AHEAD_DECORATION_KEY = TYPE_AHEAD_DECORATION_KEY;
+var TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE = 'typeaheadDecoration';
+exports.TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE = TYPE_AHEAD_DECORATION_DATA_ATTRIBUTE;
+var NavigationDirection;
+exports.NavigationDirection = NavigationDirection;
+
+(function (NavigationDirection) {
+  NavigationDirection[NavigationDirection["LEFT"] = -1] = "LEFT";
+  NavigationDirection[NavigationDirection["RIGHT"] = 1] = "RIGHT";
+})(NavigationDirection || (exports.NavigationDirection = NavigationDirection = {}));
+
+var CloseSelectionOptions;
+exports.CloseSelectionOptions = CloseSelectionOptions;
+
+(function (CloseSelectionOptions) {
+  CloseSelectionOptions["BEFORE_TEXT_INSERTED"] = "BEFORE_TEXT_INSERTED";
+  CloseSelectionOptions["AFTER_TEXT_INSERTED"] = "AFTER_TEXT_INSERTED";
+})(CloseSelectionOptions || (exports.CloseSelectionOptions = CloseSelectionOptions = {}));