@atlaskit/editor-core 189.3.29 → 189.3.30

package/dist/es2019/plugins/tasks-and-decisions/pm-plugins/keymaps.js

@@ -1,370 +0,0 @@
-import { autoJoin, chainCommands } from '@atlaskit/editor-prosemirror/commands';
-import { keymap } from '@atlaskit/editor-prosemirror/keymap';
-import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
-import { TextSelection } from '@atlaskit/editor-prosemirror/state';
-import { SetAttrsStep } from '@atlaskit/adf-schema/steps';
-import { findParentNodeOfType, findParentNodeOfTypeClosestToPos } from '@atlaskit/editor-prosemirror/utils';
-import { uuid } from '@atlaskit/adf-schema';
-import { filterCommand as filter, isEmptySelectionAtStart, isEmptySelectionAtEnd, deleteEmptyParagraphAndMoveBlockUp } from '@atlaskit/editor-common/utils';
-import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INDENT_DIRECTION, INDENT_TYPE, INPUT_METHOD } from '@atlaskit/editor-common/analytics';
-import { withAnalytics } from '@atlaskit/editor-common/editor-analytics';
-import { insertTaskDecisionWithAnalytics } from '../commands';
-import { joinAtCut, liftSelection, wrapSelectionInTaskList } from './commands';
-import { getBlockRange, getCurrentIndentLevel, isActionOrDecisionItem, isActionOrDecisionList, isEmptyTaskDecision, isInsideTask, isInsideTaskOrDecisionItem, liftBlock, walkOut, getTaskItemIndex, isInsideDecision, isTable } from './helpers';
-import { normalizeTaskItemsSelection } from '../utils';
-import { toggleTaskItemCheckbox } from '../../../keymaps';
-const indentationAnalytics = (curIndentLevel, direction, inputMethod) => ({
-  action: ACTION.FORMATTED,
-  actionSubject: ACTION_SUBJECT.TEXT,
-  actionSubjectId: ACTION_SUBJECT_ID.FORMAT_INDENT,
-  eventType: EVENT_TYPE.TRACK,
-  attributes: {
-    inputMethod,
-    previousIndentationLevel: curIndentLevel,
-    newIndentLevel: direction === INDENT_DIRECTION.OUTDENT ? curIndentLevel - 1 : curIndentLevel + 1,
-    direction,
-    indentType: INDENT_TYPE.TASK_LIST
-  }
-});
-const nodeAfter = $pos => $pos.doc.resolve($pos.end()).nodeAfter;
-const actionDecisionFollowsOrNothing = $pos => {
-  const after = nodeAfter($pos);
-  return !after || isActionOrDecisionItem(after);
-};
-const joinTaskDecisionFollowing = (state, dispatch) => {
-  // only run if selection is at end of text, and inside a task or decision item
-  if (!isEmptySelectionAtEnd(state) || !isInsideTaskOrDecisionItem(state) || !dispatch) {
-    return false;
-  }
-  // look for the node after this current one
-  const $next = walkOut(state.selection.$from);
-
-  // if there's no taskItem or taskList following, then
-  // we just do the normal behaviour
-  const {
-    taskList,
-    taskItem,
-    decisionList,
-    decisionItem,
-    paragraph,
-    bulletList,
-    orderedList,
-    listItem
-  } = state.schema.nodes;
-  const parentList = findParentNodeOfTypeClosestToPos($next, [taskList, taskItem, decisionList, decisionItem]);
-  if (!parentList) {
-    if ($next.parent.type === paragraph) {
-      // try to join paragraph and taskList when backspacing
-      return joinAtCut($next.doc.resolve($next.pos))(state, dispatch);
-    }
-    // If the item we are joining is a list
-    if ($next.parent.type === bulletList || $next.parent.type === orderedList) {
-      // If the list has an item
-      if ($next.parent.firstChild && $next.parent.firstChild.type === listItem) {
-        // Place the cursor at the first listItem
-        const resolvedStartPos = state.doc.resolve($next.pos + 1);
-        // Unindent the first listItem.
-        // As if placing your cursor just after the first dot of the list (before the text)
-        // and pressing Shift-Tab.
-        const tr = liftBlock(state.tr, resolvedStartPos, resolvedStartPos);
-
-        // If autoJoin not used, two ul/ol elements appear rather than one with multiple li elements
-        return autoJoin((state, dispatch) => {
-          if (tr) {
-            if (dispatch) {
-              dispatch(tr);
-            }
-            return true;
-          }
-          return false;
-        }, ['bulletList', 'orderedList'])(state, dispatch);
-      }
-    }
-  }
-  return false;
-};
-export const getUnindentCommand = editorAnalyticsAPI => (inputMethod = INPUT_METHOD.KEYBOARD) => filter(isInsideTask, (state, dispatch) => {
-  const normalizedSelection = normalizeTaskItemsSelection(state.selection);
-  const curIndentLevel = getCurrentIndentLevel(normalizedSelection);
-  if (!curIndentLevel || curIndentLevel === 1) {
-    return false;
-  }
-  return withAnalytics(editorAnalyticsAPI, indentationAnalytics(curIndentLevel, INDENT_DIRECTION.OUTDENT, inputMethod))(autoJoin(liftSelection, ['taskList']))(state, dispatch);
-});
-
-// if selection is decision item or first action item in table cell
-// then dont consume the Tab, as table-keymap should tab to the next cell
-const shouldLetTabThroughInTable = state => {
-  const curIndentLevel = getCurrentIndentLevel(state.selection);
-  const curIndex = getTaskItemIndex(state);
-  const {
-    tableCell,
-    tableHeader
-  } = state.schema.nodes;
-  const cell = findParentNodeOfType([tableCell, tableHeader])(state.selection);
-  if ((curIndentLevel === 1 && curIndex === 0 || isInsideDecision(state)) && cell) {
-    return true;
-  }
-  return false;
-};
-export const getIndentCommand = editorAnalyticsAPI => (inputMethod = INPUT_METHOD.KEYBOARD) => filter(isInsideTask, (state, dispatch) => {
-  const normalizedSelection = normalizeTaskItemsSelection(state.selection);
-  const curIndentLevel = getCurrentIndentLevel(normalizedSelection);
-  if (!curIndentLevel || curIndentLevel >= 6) {
-    return true;
-  }
-  return withAnalytics(editorAnalyticsAPI, indentationAnalytics(curIndentLevel, INDENT_DIRECTION.INDENT, inputMethod))(autoJoin(wrapSelectionInTaskList, ['taskList']))(state, dispatch);
-});
-const backspaceFrom = editorAnalyticsAPI => $from => (state, dispatch) => {
-  // previous was empty, just delete backwards
-  const taskBefore = $from.doc.resolve($from.before());
-  if (taskBefore.nodeBefore && isActionOrDecisionItem(taskBefore.nodeBefore) && taskBefore.nodeBefore.nodeSize === 2) {
-    return false;
-  }
-
-  // if nested, just unindent
-  const {
-    taskList,
-    paragraph
-  } = state.schema.nodes;
-  if ($from.node($from.depth - 2).type === taskList) {
-    return getUnindentCommand(editorAnalyticsAPI)()(state, dispatch);
-  }
-
-  // bottom level, should "unwrap" taskItem contents into paragraph
-  // we achieve this by slicing the content out, and replacing
-  if (actionDecisionFollowsOrNothing($from)) {
-    if (dispatch) {
-      const taskContent = state.doc.slice($from.start(), $from.end()).content;
-
-      // might be end of document after
-      const slice = taskContent.size ? paragraph.createChecked(undefined, taskContent) : paragraph.createChecked();
-      dispatch(splitListItemWith(state.tr, slice, $from, true));
-    }
-    return true;
-  }
-  return false;
-};
-const backspace = editorAnalyticsAPI => filter(isEmptySelectionAtStart, autoJoin(chainCommands((state, dispatch) => joinAtCut(state.selection.$from)(state, dispatch), filter(isInsideTaskOrDecisionItem, (state, dispatch) => backspaceFrom(editorAnalyticsAPI)(state.selection.$from)(state, dispatch))), ['taskList', 'decisionList']));
-const unindentTaskOrUnwrapTaskDecisionFollowing = (state, dispatch) => {
-  const {
-    selection: {
-      $from
-    },
-    schema: {
-      nodes: {
-        taskList,
-        doc,
-        paragraph
-      }
-    },
-    tr
-  } = state;
-
-  // only run if cursor is at the end of the node
-  if (!isEmptySelectionAtEnd(state) || !dispatch) {
-    return false;
-  }
-
-  // look for the node after this current one
-  const $next = walkOut($from);
-
-  // this is a top-level node it wont have $next.before()
-  if (!$next.parent || $next.parent.type === doc) {
-    return false;
-  }
-
-  // if nested, just unindent
-  if ($next.node($next.depth - 2).type === taskList ||
-  // this is for the case when we are on a non-nested item and next one is nested
-  $next.node($next.depth - 1).type === taskList && $next.parent.type === taskList) {
-    liftBlock(tr, $next, $next);
-    dispatch(tr);
-    return true;
-  }
-
-  // if next node is of same type, remove the node wrapping and create paragraph
-  if (!isTable($next.nodeAfter) && isActionOrDecisionItem($from.parent) && actionDecisionFollowsOrNothing($from) &&
-  // only forward delete if the node is same type
-  $next.node().type.name === $from.node().type.name) {
-    const taskContent = state.doc.slice($next.start(), $next.end()).content;
-
-    // might be end of document after
-    const slice = taskContent.size ? paragraph.createChecked(undefined, taskContent) : [];
-    dispatch(splitListItemWith(tr, slice, $next, false));
-    return true;
-  }
-  return false;
-};
-const deleteForwards = autoJoin(chainCommands(deleteEmptyParagraphAndMoveBlockUp(isActionOrDecisionList), joinTaskDecisionFollowing, unindentTaskOrUnwrapTaskDecisionFollowing), ['taskList', 'decisionList']);
-const splitListItemWith = (tr, content, $from, setSelection) => {
-  const origDoc = tr.doc;
-
-  // split just before the current item
-  // we can only split if there was a list item before us
-  const container = $from.node($from.depth - 2);
-  const posInList = $from.index($from.depth - 1);
-  const shouldSplit = !(!isActionOrDecisionList(container) && posInList === 0);
-  if (shouldSplit) {
-    // this only splits a node to delete it, so we probably don't need a random uuid
-    // but generate one anyway for correctness
-    tr = tr.split($from.pos, 1, [{
-      type: $from.parent.type,
-      attrs: {
-        localId: uuid.generate()
-      }
-    }]);
-  }
-  // and delete the action at the current pos
-  // we can do this because we know either first new child will be taskItem or nothing at all
-  const frag = Fragment.from(content);
-  tr = tr.replace(tr.mapping.map($from.start() - 2), tr.mapping.map($from.end() + 2), frag.size ? new Slice(frag, 0, 0) : Slice.empty);
-
-  // put cursor inside paragraph
-  if (setSelection) {
-    tr = tr.setSelection(new TextSelection(tr.doc.resolve($from.pos + 1 - (shouldSplit ? 0 : 2))));
-  }
-
-  // lift list up if the node after the initial one was a taskList
-  // which means it would have empty placeholder content if we just immediately delete it
-  //
-  // if it's a taskItem then it can stand alone, so it's fine
-  const $oldAfter = origDoc.resolve($from.after());
-
-  // if different levels then we shouldn't lift
-  if ($oldAfter.depth === $from.depth - 1) {
-    if ($oldAfter.nodeAfter && isActionOrDecisionList($oldAfter.nodeAfter)) {
-      // getBlockRange expects to be inside the taskItem
-      const pos = tr.mapping.map($oldAfter.pos + 2);
-      const $after = tr.doc.resolve(pos);
-      const blockRange = getBlockRange($after, tr.doc.resolve($after.after($after.depth - 1) - 1));
-      if (blockRange) {
-        tr = tr.lift(blockRange, blockRange.depth - 1).scrollIntoView();
-      }
-
-      // we delete 1 past the range of the empty taskItem
-      // otherwise we hit a bug in prosemirror-transform:
-      // Cannot read property 'content' of undefined
-      tr = tr.deleteRange(pos - 3, pos - 1);
-    }
-  }
-  return tr;
-};
-const splitListItem = (state, dispatch) => {
-  let {
-    tr,
-    selection: {
-      $from
-    }
-  } = state;
-  const {
-    schema: {
-      nodes: {
-        paragraph
-      }
-    }
-  } = state;
-  if (actionDecisionFollowsOrNothing($from)) {
-    if (dispatch) {
-      dispatch(splitListItemWith(tr, paragraph.createChecked(), $from, true));
-    }
-    return true;
-  }
-  return false;
-};
-const enter = editorAnalyticsAPI => filter(isInsideTaskOrDecisionItem, chainCommands(filter(isEmptyTaskDecision, chainCommands(getUnindentCommand(editorAnalyticsAPI)(), splitListItem)), (state, dispatch) => {
-  const {
-    selection,
-    schema
-  } = state;
-  const {
-    taskItem
-  } = schema.nodes;
-  const {
-    $from,
-    $to
-  } = selection;
-  const node = $from.node($from.depth);
-  const nodeType = node && node.type;
-  const listType = nodeType === taskItem ? 'taskList' : 'decisionList';
-  const addItem = ({
-    tr,
-    itemLocalId
-  }) => {
-    // ED-8932: When cursor is at the beginning of a task item, instead of split, we insert above.
-    if ($from.pos === $to.pos && $from.parentOffset === 0) {
-      const newTask = nodeType.createAndFill({
-        localId: itemLocalId
-      });
-      if (newTask) {
-        // Current position will point to text node, but we want to insert above the taskItem node
-        return tr.insert($from.pos - 1, newTask);
-      }
-    }
-    return tr.split($from.pos, 1, [{
-      type: nodeType,
-      attrs: {
-        localId: itemLocalId
-      }
-    }]);
-  };
-  const insertTr = insertTaskDecisionWithAnalytics(editorAnalyticsAPI)(state, listType, INPUT_METHOD.KEYBOARD, addItem);
-  if (insertTr && dispatch) {
-    insertTr.scrollIntoView();
-    dispatch(insertTr);
-  }
-  return true;
-}));
-const cmdOptEnter = filter(isInsideTaskOrDecisionItem, (state, dispatch) => {
-  const {
-    selection,
-    schema
-  } = state;
-  const {
-    taskItem
-  } = schema.nodes;
-  const {
-    $from
-  } = selection;
-  const node = $from.node($from.depth);
-  const nodeType = node && node.type;
-  const nodePos = $from.before($from.depth);
-  if (nodeType === taskItem) {
-    const tr = state.tr;
-    tr.step(new SetAttrsStep(nodePos, {
-      state: node.attrs.state === 'TODO' ? 'DONE' : 'TODO',
-      localId: node.attrs.localId
-    }));
-    if (tr && dispatch) {
-      dispatch(tr);
-    }
-  }
-  return true;
-});
-export function keymapPlugin(schema, api, allowNestedTasks, consumeTabs) {
-  var _api$analytics3, _api$analytics4;
-  const indentHandlers = {
-    'Shift-Tab': filter([isInsideTaskOrDecisionItem, state => !shouldLetTabThroughInTable(state)], (state, dispatch) => {
-      var _api$analytics;
-      return getUnindentCommand(api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions)(INPUT_METHOD.KEYBOARD)(state, dispatch) || !!consumeTabs;
-    }),
-    Tab: filter([isInsideTaskOrDecisionItem, state => !shouldLetTabThroughInTable(state)], (state, dispatch) => {
-      var _api$analytics2;
-      return getIndentCommand(api === null || api === void 0 ? void 0 : (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 ? void 0 : _api$analytics2.actions)(INPUT_METHOD.KEYBOARD)(state, dispatch) || !!consumeTabs;
-    })
-  };
-  const defaultHandlers = consumeTabs ? {
-    'Shift-Tab': isInsideTaskOrDecisionItem,
-    Tab: isInsideTaskOrDecisionItem
-  } : {};
-  const keymaps = {
-    Backspace: backspace(api === null || api === void 0 ? void 0 : (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 ? void 0 : _api$analytics3.actions),
-    Delete: deleteForwards,
-    'Ctrl-d': deleteForwards,
-    Enter: enter(api === null || api === void 0 ? void 0 : (_api$analytics4 = api.analytics) === null || _api$analytics4 === void 0 ? void 0 : _api$analytics4.actions),
-    [toggleTaskItemCheckbox.common]: cmdOptEnter,
-    ...(allowNestedTasks ? indentHandlers : defaultHandlers)
-  };
-  return keymap(keymaps);
-}
-export default keymapPlugin;

package/dist/es2019/plugins/tasks-and-decisions/pm-plugins/main.js

@@ -1,262 +0,0 @@
-import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
-import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
-import { uuid } from '@atlaskit/adf-schema';
-import { getStepRange } from '@atlaskit/editor-common/utils';
-import { SetAttrsStep } from '@atlaskit/adf-schema/steps';
-import { createSelectionClickHandler, GapCursorSelection } from '@atlaskit/editor-common/selection';
-import { decisionItemNodeView } from '../nodeviews/decisionItem';
-import { taskItemNodeViewFactory } from '../nodeviews/taskItem';
-import { stateKey } from './plugin-key';
-import { getTaskItemDataToFocus, getTaskItemDataAtPos, focusCheckboxAndUpdateSelection, removeCheckboxFocus } from './helpers';
-import { ACTIONS } from './types';
-function nodesBetweenChanged(tr, f, startPos) {
-  const stepRange = getStepRange(tr);
-  if (!stepRange) {
-    return;
-  }
-  tr.doc.nodesBetween(stepRange.from, stepRange.to, f, startPos);
-}
-const setContextIdentifierProvider = provider => (state, dispatch) => {
-  if (dispatch) {
-    dispatch(state.tr.setMeta(stateKey, {
-      action: ACTIONS.SET_CONTEXT_PROVIDER,
-      data: provider
-    }));
-  }
-  return true;
-};
-export function createPlugin(portalProviderAPI, eventDispatcher, providerFactory, dispatch, api, useLongPressSelection = false) {
-  return new SafePlugin({
-    props: {
-      nodeViews: {
-        taskItem: taskItemNodeViewFactory(portalProviderAPI, eventDispatcher, providerFactory, api),
-        decisionItem: decisionItemNodeView(portalProviderAPI, eventDispatcher, api)
-      },
-      handleTextInput(view, from, to, text) {
-        // When a decision item is selected and the user starts typing, the entire node
-        // should be replaced with what was just typed. This custom text input handler
-        // is needed to implement that behaviour.
-
-        // TODO: ProseMirror should already do this by default
-        // Tech debt to investigate why we need a custom handler here:
-        // https://product-fabric.atlassian.net/browse/ED-9278
-
-        const {
-          state,
-          dispatch
-        } = view;
-        const {
-          tr
-        } = state;
-        if (state.selection instanceof NodeSelection && state.selection.node.type === view.state.schema.nodes.decisionItem) {
-          state.selection.replace(tr);
-          tr.insertText(text);
-          if (dispatch) {
-            dispatch(tr);
-          }
-          return true;
-        }
-        return false;
-      },
-      handleClickOn: createSelectionClickHandler(['decisionItem'], target => target.hasAttribute('data-decision-wrapper') || target.getAttribute('aria-label') === 'Decision', {
-        useLongPressSelection
-      }),
-      handleKeyDown: (view, event) => {
-        const {
-          state,
-          dispatch
-        } = view;
-        const {
-          selection,
-          schema
-        } = state;
-        const {
-          $from,
-          $to
-        } = selection;
-        const parentOffset = $from.parentOffset;
-        const isInTaskItem = $from.node().type === schema.nodes.taskItem;
-        const focusedTaskItemLocalId = stateKey.getState(state).focusedTaskItemLocalId;
-        const currentTaskItemData = getTaskItemDataAtPos(view);
-        const currentTaskItemFocused = focusedTaskItemLocalId === (currentTaskItemData === null || currentTaskItemData === void 0 ? void 0 : currentTaskItemData.localId);
-
-        // if task item checkbox not focused and arrow key is not pressed
-        //  then we don't want to handle event.
-        if (!['ArrowUp', 'ArrowDown', 'ArrowRight', 'ArrowLeft'].includes(event.key)) {
-          return false;
-        }
-
-        // We want to handle arrow up, down and left key only
-        //  when selection is inside task item and no text is selected.
-        if (['ArrowUp', 'ArrowDown', 'ArrowLeft'].includes(event.key) && (!isInTaskItem || $from.pos !== $to.pos)) {
-          return false;
-        }
-
-        // Arrow keys are pressed and shift, ctrl or meta is pressed as well.
-        //  along with arrow keys and task item checkbox is focused
-        //  then first move focus to view and proceed with default event handling.
-        if (event.shiftKey || event.ctrlKey || event.metaKey) {
-          currentTaskItemFocused && removeCheckboxFocus(view);
-          return false;
-        }
-
-        // task item checkbox is already focused
-        if (focusedTaskItemLocalId) {
-          if (event.key === 'ArrowLeft') {
-            // Move focus to view and proceed with default keyboard handler.
-            // Which will move cursor to previous position.
-            removeCheckboxFocus(view);
-            return false;
-          }
-          if (event.key === 'ArrowRight') {
-            // Move focus to view and DON'T proceed with default handler.
-            // We have assumed that selection is already before first character of task item.
-            removeCheckboxFocus(view);
-            return true;
-          }
-          if (event.key === 'ArrowUp' || event.key === 'ArrowDown') {
-            const taskItemData = getTaskItemDataToFocus(view, event.key === 'ArrowUp' ? 'previous' : 'next');
-            if (taskItemData) {
-              focusCheckboxAndUpdateSelection(view, taskItemData);
-              return true;
-            } else {
-              // If any how checkbox input not found, then move focus to view
-              //  and proceed with default keyboard handler.
-              removeCheckboxFocus(view);
-              return false;
-            }
-          }
-        }
-
-        // If left arrow key is pressed and cursor is at first position in task-item
-        //  then focus checkbox and DON'T proceed with default keyboard handler
-        if (event.key === 'ArrowLeft' && parentOffset === 0) {
-          // here we are not using focusCheckboxAndUpdateSelection() method
-          // because it is working incorretly when we are placing is inside the nested items
-          dispatch(state.tr.setMeta(stateKey, {
-            action: ACTIONS.FOCUS_BY_LOCALID,
-            data: currentTaskItemData === null || currentTaskItemData === void 0 ? void 0 : currentTaskItemData.localId
-          }));
-          return true;
-        }
-        if (event.key === 'ArrowRight') {
-          var _$from$nodeAfter;
-          // If gap cursor is just before task list then focus first task item in list.
-          if (selection instanceof GapCursorSelection && selection.side === 'left' && ((_$from$nodeAfter = $from.nodeAfter) === null || _$from$nodeAfter === void 0 ? void 0 : _$from$nodeAfter.type) === schema.nodes.taskList) {
-            const taskList = $from.nodeAfter;
-            const firstTaskItemNode = taskList.child(0);
-            const taskItemPos = $from.pos + 1;
-            focusCheckboxAndUpdateSelection(view, {
-              pos: taskItemPos,
-              localId: firstTaskItemNode.attrs.localId
-            });
-            return true;
-          }
-          // if cursor is at then end of task item text then focus next task item checkbox
-          else if (isInTaskItem && $from.node().content.size === parentOffset) {
-            const nextTaskItemData = getTaskItemDataToFocus(view, 'next');
-            if (nextTaskItemData) {
-              focusCheckboxAndUpdateSelection(view, nextTaskItemData);
-              return true;
-            }
-          } else {
-            return false;
-          }
-        }
-      }
-    },
-    state: {
-      init() {
-        return {
-          insideTaskDecisionItem: false
-        };
-      },
-      apply(tr, pluginState) {
-        const {
-          action,
-          data
-        } = tr.getMeta(stateKey) || {
-          action: null,
-          data: null
-        };
-        let newPluginState = pluginState;
-        switch (action) {
-          case ACTIONS.SET_CONTEXT_PROVIDER:
-            newPluginState = {
-              ...pluginState,
-              contextIdentifierProvider: data
-            };
-            break;
-          case ACTIONS.FOCUS_BY_LOCALID:
-            newPluginState = {
-              ...pluginState,
-              focusedTaskItemLocalId: data
-            };
-            break;
-        }
-        dispatch(stateKey, newPluginState);
-        return newPluginState;
-      }
-    },
-    view(editorView) {
-      const providerHandler = (name, providerPromise) => {
-        if (name === 'contextIdentifierProvider') {
-          if (!providerPromise) {
-            setContextIdentifierProvider(undefined)(editorView.state, editorView.dispatch);
-          } else {
-            providerPromise.then(provider => {
-              setContextIdentifierProvider(provider)(editorView.state, editorView.dispatch);
-            });
-          }
-        }
-      };
-      providerFactory.subscribe('contextIdentifierProvider', providerHandler);
-      return {};
-    },
-    key: stateKey,
-    /*
-     * After each transaction, we search through the document for any decisionList/Item & taskList/Item nodes
-     * that do not have the localId attribute set and generate a random UUID to use. This is to replace a previous
-     * Prosemirror capabibility where node attributes could be generated dynamically.
-     * See https://discuss.prosemirror.net/t/release-0-23-0-possibly-to-be-1-0-0/959/17 for a discussion of this approach.
-     *
-     * Note: we currently do not handle the edge case where two nodes may have the same localId
-     */
-    appendTransaction: (transactions, _oldState, newState) => {
-      const tr = newState.tr;
-      let modified = false;
-      transactions.forEach(transaction => {
-        if (!transaction.docChanged) {
-          return;
-        }
-
-        // Adds a unique id to a node
-        nodesBetweenChanged(transaction, (node, pos) => {
-          const {
-            decisionList,
-            decisionItem,
-            taskList,
-            taskItem
-          } = newState.schema.nodes;
-          if (!!node.type && (node.type === decisionList || node.type === decisionItem || node.type === taskList || node.type === taskItem)) {
-            const {
-              localId,
-              ...rest
-            } = node.attrs;
-            if (localId === undefined || localId === null || localId === '') {
-              tr.step(new SetAttrsStep(pos, {
-                localId: uuid.generate(),
-                ...rest
-              }));
-              modified = true;
-            }
-          }
-        });
-      });
-      if (modified) {
-        return tr.setMeta('addToHistory', false);
-      }
-      return;
-    }
-  });
-}

package/dist/es2019/plugins/tasks-and-decisions/pm-plugins/plugin-key.js

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

package/dist/es2019/plugins/tasks-and-decisions/pm-plugins/types.js

@@ -1,5 +0,0 @@
-export let ACTIONS = /*#__PURE__*/function (ACTIONS) {
-  ACTIONS[ACTIONS["SET_CONTEXT_PROVIDER"] = 0] = "SET_CONTEXT_PROVIDER";
-  ACTIONS[ACTIONS["FOCUS_BY_LOCALID"] = 1] = "FOCUS_BY_LOCALID";
-  return ACTIONS;
-}({});

package/dist/es2019/plugins/tasks-and-decisions/types.js

@@ -1 +0,0 @@
-export {};

package/dist/es2019/plugins/tasks-and-decisions/ui/Decision/index.js

@@ -1,30 +0,0 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import React from 'react';
-import { defineMessages, injectIntl } from 'react-intl-next';
-import { DecisionItem } from '@atlaskit/task-decision';
-const messages = defineMessages({
-  placeholder: {
-    id: 'fabric.editor.decisionPlaceholder',
-    defaultMessage: 'Add a decision…',
-    description: 'Placeholder description for an empty decision in the editor'
-  }
-});
-export class Decision extends React.Component {
-  render() {
-    const {
-      contentRef,
-      showPlaceholder,
-      intl: {
-        formatMessage
-      }
-    } = this.props;
-    const placeholder = formatMessage(messages.placeholder);
-    return /*#__PURE__*/React.createElement(DecisionItem, {
-      contentRef: contentRef,
-      placeholder: placeholder,
-      showPlaceholder: showPlaceholder
-    });
-  }
-}
-_defineProperty(Decision, "displayName", 'Decision');
-export default injectIntl(Decision);