@atlaskit/editor-core 188.7.5 → 188.8.0

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

@@ -0,0 +1,382 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typeAheadPlugin = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _react = _interopRequireDefault(require("react"));
+var _adfSchema = require("@atlaskit/adf-schema");
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
+var _typeAhead = require("@atlaskit/editor-common/type-ahead");
+var _withPluginState = require("@atlaskit/editor-common/with-plugin-state");
+var _insertTypeAheadItem = require("./commands/insert-type-ahead-item");
+var _updateSelectedIndex = require("./commands/update-selected-index");
+var _inputRules = require("./pm-plugins/input-rules");
+var _insertItemPlugin = require("./pm-plugins/insert-item-plugin");
+var _key = require("./pm-plugins/key");
+var _main = require("./pm-plugins/main");
+var _statsModifier = require("./stats-modifier");
+var _closeTypeAhead = require("./transforms/close-type-ahead");
+var _openTypeaheadAtCursor = require("./transforms/open-typeahead-at-cursor");
+var _useItemInsert3 = require("./ui/hooks/use-item-insert");
+var _TypeAheadPopup = require("./ui/TypeAheadPopup");
+var _utils = require("./utils");
+/**
+ *
+ * Revamped typeahead using decorations instead of the `typeAheadQuery` mark
+ *
+ * https://product-fabric.atlassian.net/wiki/spaces/E/pages/2992177582/Technical+TypeAhead+Data+Flow
+ *
+ *
+ */
+
+var TypeAheadMenu = /*#__PURE__*/_react.default.memo(function (_ref) {
+  var _popupMountRef$curren, _popupMountRef$curren2, _popupMountRef$curren3;
+  var editorView = _ref.editorView,
+    popupMountRef = _ref.popupMountRef,
+    typeAheadState = _ref.typeAheadState,
+    fireAnalyticsCallback = _ref.fireAnalyticsCallback;
+  var isOpen = typeAheadState.decorationSet.find().length > 0;
+  var triggerHandler = typeAheadState.triggerHandler,
+    items = typeAheadState.items,
+    selectedIndex = typeAheadState.selectedIndex,
+    decorationElement = typeAheadState.decorationElement,
+    decorationSet = typeAheadState.decorationSet,
+    query = typeAheadState.query;
+  var _useItemInsert = (0, _useItemInsert3.useItemInsert)(triggerHandler, editorView, items),
+    _useItemInsert2 = (0, _slicedToArray2.default)(_useItemInsert, 3),
+    onItemInsert = _useItemInsert2[0],
+    onTextInsert = _useItemInsert2[1],
+    onItemMatch = _useItemInsert2[2];
+  var setSelectedItem = _react.default.useCallback(function (_ref2) {
+    var nextIndex = _ref2.index;
+    queueMicrotask(function () {
+      (0, _updateSelectedIndex.updateSelectedIndex)(nextIndex)(editorView.state, editorView.dispatch);
+    });
+  }, [editorView]);
+  var insertItem = _react.default.useCallback(function () {
+    var mode = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _typeAhead.SelectItemMode.SELECTED;
+    var index = arguments.length > 1 ? arguments[1] : undefined;
+    queueMicrotask(function () {
+      onItemInsert({
+        mode: mode,
+        index: index,
+        query: query
+      });
+    });
+  }, [onItemInsert, query]);
+  var cancel = _react.default.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.default.useEffect(function () {
+    if (!isOpen || !query) {
+      return;
+    }
+    var isLastCharSpace = query[query.length - 1] === ' ';
+    if (!isLastCharSpace) {
+      return;
+    }
+    var result = onItemMatch({
+      mode: _typeAhead.SelectItemMode.SPACE,
+      query: query.trim()
+    });
+    if (!result) {
+      return;
+    }
+  }, [isOpen, query, onItemMatch]);
+  if (!isOpen || !triggerHandler || !(decorationElement instanceof HTMLElement) || items.length === 0) {
+    return null;
+  }
+  return /*#__PURE__*/_react.default.createElement(_TypeAheadPopup.TypeAheadPopup, {
+    editorView: editorView,
+    popupsMountPoint: (_popupMountRef$curren = popupMountRef.current) === null || _popupMountRef$curren === void 0 ? void 0 : _popupMountRef$curren.popupsMountPoint,
+    popupsBoundariesElement: (_popupMountRef$curren2 = popupMountRef.current) === null || _popupMountRef$curren2 === void 0 ? void 0 : _popupMountRef$curren2.popupsBoundariesElement,
+    popupsScrollableElement: (_popupMountRef$curren3 = popupMountRef.current) === null || _popupMountRef$curren3 === void 0 ? void 0 : _popupMountRef$curren3.popupsScrollableElement,
+    anchorElement: decorationElement,
+    triggerHandler: triggerHandler,
+    fireAnalyticsCallback: fireAnalyticsCallback,
+    items: items,
+    selectedIndex: selectedIndex,
+    setSelectedItem: setSelectedItem,
+    onItemInsert: insertItem,
+    decorationSet: decorationSet,
+    isEmptyQuery: !query,
+    cancel: cancel
+  });
+});
+var createOpenAtTransaction = function createOpenAtTransaction(editorAnalyticsAPI) {
+  return function (props) {
+    return function (tr) {
+      var triggerHandler = props.triggerHandler,
+        inputMethod = props.inputMethod;
+      (0, _openTypeaheadAtCursor.openTypeAheadAtCursor)({
+        triggerHandler: triggerHandler,
+        inputMethod: inputMethod
+      })({
+        tr: tr
+      });
+      editorAnalyticsAPI === null || editorAnalyticsAPI === void 0 || editorAnalyticsAPI.attachAnalyticsEvent({
+        action: _analytics.ACTION.INVOKED,
+        actionSubject: _analytics.ACTION_SUBJECT.TYPEAHEAD,
+        actionSubjectId: triggerHandler.id,
+        attributes: {
+          inputMethod: inputMethod
+        },
+        eventType: _analytics.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;
+    (0, _insertTypeAheadItem.insertTypeAheadItem)(view)({
+      handler: triggerHandler,
+      item: contentItem,
+      mode: mode || _typeAhead.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 (0, _utils.findHandler)(trigger, view.state);
+  };
+};
+var createCloseTypeAhead = function createCloseTypeAhead(editorViewRef) {
+  return function (options) {
+    if (!editorViewRef.current) {
+      return false;
+    }
+    var view = editorViewRef.current;
+    var currentQuery = (0, _utils.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);
+    }
+    (0, _closeTypeAhead.closeTypeAhead)(tr);
+    if (options.insertCurrentQueryAsRawText && currentQuery && currentQuery.length > 0) {
+      var handler = (0, _utils.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
+ *
+ *
+ */
+var typeAheadPlugin = exports.typeAheadPlugin = function typeAheadPlugin(_ref4) {
+  var _api$analytics, _api$analytics2;
+  var options = _ref4.config,
+    api = _ref4.api;
+  var fireAnalyticsCallback = (0, _analytics.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: _adfSchema.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 (0, _main.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.SafePlugin({
+            view: function view(_view) {
+              editorViewRef.current = _view;
+              return {
+                destroy: function destroy() {
+                  editorViewRef.current = null;
+                }
+              };
+            }
+          });
+        }
+      }, {
+        name: 'typeAheadInsertItem',
+        plugin: _insertItemPlugin.createPlugin
+      }, {
+        name: 'typeAheadInputRule',
+        plugin: function plugin(_ref6) {
+          var schema = _ref6.schema,
+            featureFlags = _ref6.featureFlags;
+          return (0, _inputRules.inputRulePlugin)(schema, typeAhead, featureFlags);
+        }
+      }];
+    },
+    getSharedState: function getSharedState(editorState) {
+      if (!editorState) {
+        return {
+          query: '',
+          isOpen: false,
+          isAllowed: false,
+          currentHandler: undefined
+        };
+      }
+      var isOpen = (0, _utils.isTypeAheadOpen)(editorState);
+      return {
+        query: (0, _utils.getTypeAheadQuery)(editorState) || '',
+        currentHandler: (0, _utils.getTypeAheadHandler)(editorState),
+        isOpen: isOpen,
+        isAllowed: !isOpen
+      };
+    },
+    actions: {
+      isOpen: _utils.isTypeAheadOpen,
+      isAllowed: _utils.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.default.createElement(_withPluginState.WithPluginState, {
+        plugins: {
+          typeAheadState: _key.pluginKey
+        },
+        render: function render(_ref8) {
+          var typeAheadState = _ref8.typeAheadState;
+          if (!typeAheadState) {
+            return null;
+          }
+          return /*#__PURE__*/_react.default.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 = (0, _utils.getPluginState)(oldEditorState);
+      var newPluginState = (0, _utils.getPluginState)(newEditorState);
+      if (!oldPluginState || !newPluginState) {
+        return;
+      }
+      var oldTriggerHandler = oldPluginState.triggerHandler;
+      var newTriggerHandler = newPluginState.triggerHandler;
+      var isANewHandler = oldTriggerHandler !== newTriggerHandler;
+      if (oldTriggerHandler !== null && oldTriggerHandler !== void 0 && oldTriggerHandler.dismiss && isANewHandler) {
+        var typeAheadMessage = originalTransaction.getMeta(_key.pluginKey);
+        var wasItemInserted = typeAheadMessage && typeAheadMessage.action === 'INSERT_RAW_QUERY';
+        oldTriggerHandler.dismiss({
+          editorState: newEditorState,
+          query: oldPluginState.query,
+          stats: (oldPluginState.stats || new _statsModifier.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: _analytics.ACTION.INVOKED,
+            actionSubject: _analytics.ACTION_SUBJECT.TYPEAHEAD,
+            actionSubjectId: newTriggerHandler.id || 'not_set',
+            attributes: {
+              inputMethod: newPluginState.inputMethod || _analytics.INPUT_METHOD.KEYBOARD
+            },
+            eventType: _analytics.EVENT_TYPE.UI
+          }
+        });
+      }
+    }
+  };
+};

package/dist/cjs/plugins/view-update-subscription/subscribe/toolbarAndPickerUpdates.js

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.subscribeToToolbarAndPickerUpdates = void 0;
 var _floatingToolbar = require("@atlaskit/editor-common/floating-toolbar");
-var _utils = require("../../type-ahead/utils");
 var _ = require("..");
 var areToolbarsSame = function areToolbarsSame(left, right) {
   if (!left && !right) {
@@ -30,14 +29,13 @@ var subscribeToToolbarAndPickerUpdates = exports.subscribeToToolbarAndPickerUpda
   var lastUpdatedState = null;
   var subscription = function subscription(_ref) {
     var newEditorState = _ref.newEditorState;
-    // TypeAhead has priority in the mobile-bridge
-    // In case it is open we don't need to send
-    // any toolbar updates don't need to be send
-    if ((0, _utils.isTypeAheadOpen)(newEditorState)) {
-      return;
-    }
-
     // Creating fake plugin keys for these plugins for the mean time until all these plugins are extracted.
+    var typeAheadPluginKey = {
+      key: 'typeAheadPlugin$',
+      getState: function getState(state) {
+        return state['typeAheadPlugin$'];
+      }
+    };
     var datePluginKey = {
       key: 'datePlugin$',
       getState: function getState(state) {
@@ -56,6 +54,17 @@ var subscribeToToolbarAndPickerUpdates = exports.subscribeToToolbarAndPickerUpda
         return state['floatingToolbarPluginKey$'];
       }
     };
+    var isTypeAheadOpen = function isTypeAheadOpen(editorState) {
+      var _typeAheadState$decor;
+      var typeAheadState = typeAheadPluginKey.getState(newEditorState);
+      return !!((_typeAheadState$decor = typeAheadState.decorationSet) !== null && _typeAheadState$decor !== void 0 && _typeAheadState$decor.find().length);
+    };
+    // TypeAhead has priority in the mobile-bridge
+    // In case it is open we don't need to send
+    // any toolbar updates don't need to be send
+    if (isTypeAheadOpen(newEditorState)) {
+      return;
+    }
     var dateState = datePluginKey.getState(newEditorState);
     var statusState = statusPluginKey.getState(newEditorState);
     var _ref2 = floatingToolbarPluginKey.getState(newEditorState),

package/dist/cjs/version-wrapper.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.version = exports.nextMajorVersion = exports.name = void 0;
 var name = exports.name = "@atlaskit/editor-core";
-var version = exports.version = "188.7.5";
+var version = exports.version = "188.8.0";
 var nextMajorVersion = exports.nextMajorVersion = function nextMajorVersion() {
   return [Number(version.split('.')[0]) + 1, 0, 0].join('.');
 };

package/dist/es2019/plugins/date/actions.js

@@ -2,9 +2,8 @@ import { NodeSelection, Selection } from '@atlaskit/editor-prosemirror/state';
 import { Fragment } from '@atlaskit/editor-prosemirror/model';
 import { todayTimestampInUTC } from '@atlaskit/editor-common/utils';
 import { pluginKey } from './pm-plugins/plugin-key';
-import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
 import { isToday } from './utils/internal';
-import { canInsert } from '@atlaskit/editor-prosemirror/utils';
 export const createDate = isQuickInsertAction => (insert, state) => {
   const dateNode = state.schema.nodes.date.createChecked({
     timestamp: todayTimestampInUTC()
@@ -23,25 +22,6 @@ export const createDate = isQuickInsertAction => (insert, state) => {
   return tr.setMeta(pluginKey, newPluginState);
 };
 
-/** Delete the date and close the datepicker */
-export const deleteDate = () => (state, dispatch) => {
-  const pluginState = pluginKey.getState(state);
-  if (!pluginState || pluginState.showDatePickerAt === null) {
-    return false;
-  }
-  const {
-    showDatePickerAt
-  } = pluginState;
-  const tr = state.tr.delete(showDatePickerAt, showDatePickerAt + 1).setMeta(pluginKey, {
-    showDatePickerAt: null,
-    isNew: false
-  });
-  if (dispatch) {
-    dispatch(tr);
-  }
-  return true;
-};
-
 /** Focus input */
 export const focusDateInput = () => (state, dispatch) => {
   const pluginState = pluginKey.getState(state);
@@ -57,92 +37,6 @@ export const focusDateInput = () => (state, dispatch) => {
   dispatch(tr);
   return true;
 };
-export const insertDate = (date, inputMethod, commitMethod, enterPressed = true, pluginInjectionApi) => (state, dispatch) => {
-  const {
-    schema
-  } = state;
-  let timestamp;
-  if (date) {
-    timestamp = Date.UTC(date.year, date.month - 1, date.day).toString();
-  } else {
-    timestamp = todayTimestampInUTC();
-  }
-  let tr = state.tr;
-  if (inputMethod) {
-    var _pluginInjectionApi$a, _pluginInjectionApi$a2;
-    pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a === void 0 ? void 0 : (_pluginInjectionApi$a2 = _pluginInjectionApi$a.actions) === null || _pluginInjectionApi$a2 === void 0 ? void 0 : _pluginInjectionApi$a2.attachAnalyticsEvent({
-      action: ACTION.INSERTED,
-      actionSubject: ACTION_SUBJECT.DOCUMENT,
-      actionSubjectId: ACTION_SUBJECT_ID.DATE,
-      eventType: EVENT_TYPE.TRACK,
-      attributes: {
-        inputMethod
-      }
-    })(tr);
-  }
-  if (commitMethod) {
-    var _pluginInjectionApi$a3, _pluginInjectionApi$a4;
-    pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a3 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a3 === void 0 ? void 0 : (_pluginInjectionApi$a4 = _pluginInjectionApi$a3.actions) === null || _pluginInjectionApi$a4 === void 0 ? void 0 : _pluginInjectionApi$a4.attachAnalyticsEvent({
-      eventType: EVENT_TYPE.TRACK,
-      action: ACTION.COMMITTED,
-      actionSubject: ACTION_SUBJECT.DATE,
-      attributes: {
-        commitMethod,
-        isValid: date !== undefined,
-        isToday: isToday(date)
-      }
-    })(tr);
-  }
-  const {
-    showDatePickerAt
-  } = pluginKey.getState(state) || {};
-  if (!showDatePickerAt) {
-    const dateNode = schema.nodes.date.createChecked({
-      timestamp
-    });
-    const textNode = state.schema.text(' ');
-    const fragment = Fragment.fromArray([dateNode, textNode]);
-    const {
-      from,
-      to
-    } = state.selection;
-    const insertable = canInsert(tr.selection.$from, fragment);
-    if (!insertable) {
-      const parentSelection = NodeSelection.create(tr.doc, tr.selection.from - tr.selection.$anchor.parentOffset - 1);
-      tr.insert(parentSelection.to, fragment).setSelection(NodeSelection.create(tr.doc, parentSelection.to + 1));
-    } else {
-      tr.replaceWith(from, to, fragment).setSelection(NodeSelection.create(tr.doc, from));
-    }
-    if (dispatch) {
-      dispatch(tr.scrollIntoView().setMeta(pluginKey, {
-        isNew: true
-      }));
-    }
-    return true;
-  }
-  if (state.doc.nodeAt(showDatePickerAt)) {
-    if (enterPressed) {
-      // Setting selection to outside the date node causes showDatePickerAt
-      // to be set to null by the PM plugin (onSelectionChanged), which will
-      // immediately close the datepicker once a valid date is typed in.
-      // Adding this check forces it to stay open until the user presses Enter.
-      tr = tr.setSelection(Selection.near(tr.doc.resolve(showDatePickerAt + 2)));
-    }
-    tr = tr.setNodeMarkup(showDatePickerAt, schema.nodes.date, {
-      timestamp
-    }).setMeta(pluginKey, {
-      isNew: false
-    }).scrollIntoView();
-    if (!enterPressed) {
-      tr = tr.setSelection(NodeSelection.create(tr.doc, showDatePickerAt));
-    }
-    if (dispatch) {
-      dispatch(tr);
-    }
-    return true;
-  }
-  return false;
-};
 export const setDatePickerAt = showDatePickerAt => (state, dispatch) => {
   dispatch(state.tr.setMeta(pluginKey, {
     showDatePickerAt
@@ -169,8 +63,8 @@ export const closeDatePickerWithAnalytics = ({
   date,
   pluginInjectionApi
 }) => {
-  var _pluginInjectionApi$a5, _pluginInjectionApi$a6;
-  pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a5 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a5 === void 0 ? void 0 : (_pluginInjectionApi$a6 = _pluginInjectionApi$a5.actions) === null || _pluginInjectionApi$a6 === void 0 ? void 0 : _pluginInjectionApi$a6.attachAnalyticsEvent({
+  var _pluginInjectionApi$a, _pluginInjectionApi$a2;
+  pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a === void 0 ? void 0 : (_pluginInjectionApi$a2 = _pluginInjectionApi$a.actions) === null || _pluginInjectionApi$a2 === void 0 ? void 0 : _pluginInjectionApi$a2.attachAnalyticsEvent({
     eventType: EVENT_TYPE.TRACK,
     action: ACTION.COMMITTED,
     actionSubject: ACTION_SUBJECT.DATE,

package/dist/es2019/plugins/date/commands.js

@@ -0,0 +1,113 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { NodeSelection, Selection } from '@atlaskit/editor-prosemirror/state';
+import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { canInsert } from '@atlaskit/editor-prosemirror/utils';
+import { todayTimestampInUTC } from '@atlaskit/editor-common/utils';
+import { pluginKey } from './pm-plugins/plugin-key';
+import { isToday } from './utils/internal';
+/** Delete the date and close the datepicker */
+export const deleteDateCommand = pluginInjectionApi => ({
+  tr
+}) => {
+  var _pluginInjectionApi$d, _pluginInjectionApi$d2;
+  const {
+    showDatePickerAt
+  } = (_pluginInjectionApi$d = pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$d2 = pluginInjectionApi.date) === null || _pluginInjectionApi$d2 === void 0 ? void 0 : _pluginInjectionApi$d2.sharedState.currentState()) !== null && _pluginInjectionApi$d !== void 0 ? _pluginInjectionApi$d : {};
+  if (!showDatePickerAt) {
+    return tr;
+  }
+  tr.delete(showDatePickerAt, showDatePickerAt + 1).setMeta(pluginKey, {
+    showDatePickerAt: null,
+    isNew: false
+  });
+  return tr;
+};
+export const insertDateCommand = pluginInjectionApi => ({
+  date,
+  inputMethod,
+  commitMethod,
+  enterPressed = true
+}) => ({
+  tr
+}) => {
+  var _pluginInjectionApi$d3, _pluginInjectionApi$d4;
+  const {
+    schema
+  } = tr.doc.type;
+  let timestamp;
+  if (date) {
+    timestamp = Date.UTC(date.year, date.month - 1, date.day).toString();
+  } else {
+    timestamp = todayTimestampInUTC();
+  }
+  if (inputMethod) {
+    var _pluginInjectionApi$a, _pluginInjectionApi$a2;
+    pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a === void 0 ? void 0 : (_pluginInjectionApi$a2 = _pluginInjectionApi$a.actions) === null || _pluginInjectionApi$a2 === void 0 ? void 0 : _pluginInjectionApi$a2.attachAnalyticsEvent({
+      action: ACTION.INSERTED,
+      actionSubject: ACTION_SUBJECT.DOCUMENT,
+      actionSubjectId: ACTION_SUBJECT_ID.DATE,
+      eventType: EVENT_TYPE.TRACK,
+      attributes: {
+        inputMethod
+      }
+    })(tr);
+  }
+  if (commitMethod) {
+    var _pluginInjectionApi$a3, _pluginInjectionApi$a4;
+    pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$a3 = pluginInjectionApi.analytics) === null || _pluginInjectionApi$a3 === void 0 ? void 0 : (_pluginInjectionApi$a4 = _pluginInjectionApi$a3.actions) === null || _pluginInjectionApi$a4 === void 0 ? void 0 : _pluginInjectionApi$a4.attachAnalyticsEvent({
+      eventType: EVENT_TYPE.TRACK,
+      action: ACTION.COMMITTED,
+      actionSubject: ACTION_SUBJECT.DATE,
+      attributes: {
+        commitMethod,
+        isValid: date !== undefined,
+        isToday: isToday(date)
+      }
+    })(tr);
+  }
+  const {
+    showDatePickerAt
+  } = (_pluginInjectionApi$d3 = pluginInjectionApi === null || pluginInjectionApi === void 0 ? void 0 : (_pluginInjectionApi$d4 = pluginInjectionApi.date) === null || _pluginInjectionApi$d4 === void 0 ? void 0 : _pluginInjectionApi$d4.sharedState.currentState()) !== null && _pluginInjectionApi$d3 !== void 0 ? _pluginInjectionApi$d3 : {};
+  if (!showDatePickerAt) {
+    const dateNode = schema.nodes.date.createChecked({
+      timestamp
+    });
+    const textNode = schema.text(' ');
+    const fragment = Fragment.fromArray([dateNode, textNode]);
+    const {
+      from,
+      to
+    } = tr.selection;
+    const insertable = canInsert(tr.selection.$from, fragment);
+    if (!insertable) {
+      const parentSelection = NodeSelection.create(tr.doc, tr.selection.from - tr.selection.$anchor.parentOffset - 1);
+      tr.insert(parentSelection.to, fragment).setSelection(NodeSelection.create(tr.doc, parentSelection.to + 1));
+    } else {
+      tr.replaceWith(from, to, fragment).setSelection(NodeSelection.create(tr.doc, from));
+    }
+    if (tr.docChanged) {
+      tr.scrollIntoView().setMeta(pluginKey, {
+        isNew: true
+      });
+    }
+    return tr;
+  }
+  if (tr.doc.nodeAt(showDatePickerAt)) {
+    if (enterPressed) {
+      // Setting selection to outside the date node causes showDatePickerAt
+      // to be set to null by the PM plugin (onSelectionChanged), which will
+      // immediately close the datepicker once a valid date is typed in.
+      // Adding this check forces it to stay open until the user presses Enter.
+      tr = tr.setSelection(Selection.near(tr.doc.resolve(showDatePickerAt + 2)));
+    }
+    tr = tr.setNodeMarkup(showDatePickerAt, schema.nodes.date, {
+      timestamp
+    }).setMeta(pluginKey, {
+      isNew: false
+    }).scrollIntoView();
+    if (!enterPressed) {
+      tr = tr.setSelection(NodeSelection.create(tr.doc, showDatePickerAt));
+    }
+  }
+  return tr;
+};