@atlaskit/editor-core 178.1.0 → 178.1.2

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

@@ -38,7 +38,6 @@ export const isTable = node => {
   if (!node) {
     return false;
   }
-
   const {
     table,
     tableHeader,
@@ -47,31 +46,31 @@ export const isTable = node => {
   } = node.type.schema.nodes;
   return [table, tableHeader, tableCell, tableRow].includes(node.type);
 };
+
 /**
  * Creates a NodeRange around the given taskItem and the following
  * ("nested") taskList, if one exists.
  */
-
 export const getBlockRange = ($from, $to) => {
   const {
     taskList
   } = $from.doc.type.schema.nodes;
   let end = $to.end();
   const $after = $to.doc.resolve(end + 1);
-  const after = $after.nodeAfter; // ensure the node after is actually just a sibling
-  // $to will be inside the text, so subtract one to get the taskItem it contains in
+  const after = $after.nodeAfter;
 
+  // ensure the node after is actually just a sibling
+  // $to will be inside the text, so subtract one to get the taskItem it contains in
   if (after && after.type === taskList && $after.depth === $to.depth - 1) {
     // it was! include it in our blockRange
     end += after.nodeSize;
   }
-
   return $from.blockRange($to.doc.resolve(end));
 };
+
 /**
  * Finds the distance between the current $from and the root of the taskList.
  */
-
 export const getCurrentIndentLevel = selection => {
   const {
     $from
@@ -80,43 +79,40 @@ export const getCurrentIndentLevel = selection => {
     taskList
   } = $from.doc.type.schema.nodes;
   const furthestParent = findFarthestParentNode(node => node.type === taskList)($from);
-
   if (!furthestParent) {
     return null;
   }
-
   return $from.depth - furthestParent.depth;
 };
+
 /**
  * Finds the index of the current task item in relation to the closest taskList
  */
-
 export const getTaskItemIndex = state => {
   const $pos = state.selection.$from;
-
   const isTaskList = node => (node === null || node === void 0 ? void 0 : node.type.name) === 'taskList';
-
   const itemAtPos = findParentNodeClosestToPos($pos, isTaskList);
   return $pos.index(itemAtPos ? itemAtPos.depth : undefined);
 };
+
 /**
  * Walk outwards from a position until we encounter the (inside) start of
  * the next node, or reach the end of the document.
  *
  * @param $startPos Position to start walking from.
  */
-
 export const walkOut = $startPos => {
-  let $pos = $startPos; // invariant 1: don't walk past the end of the document
+  let $pos = $startPos;
+
+  // invariant 1: don't walk past the end of the document
   // invariant 2: we haven't walked to the start of *any* node
   //              parentOffset includes textOffset.
-
   while ($pos.pos < $pos.doc.nodeSize - 2 && $pos.parentOffset > 0) {
     $pos = $pos.doc.resolve($pos.pos + 1);
   }
-
   return $pos;
 };
+
 /**
  * Finds the height of a tree-like structure, given any position inside it.
  *
@@ -129,43 +125,42 @@ export const walkOut = $startPos => {
  * @param $pos Any position inside the tree.
  * @param types The node types to consider traversable
  */
-
 export const subtreeHeight = ($from, $to, types) => {
   const root = findFarthestParentNode(node => types.indexOf(node.type) > -1)($from);
-
   if (!root) {
     return -1;
-  } // get the height between the root and the current position
+  }
 
+  // get the height between the root and the current position
+  const distToParent = $from.depth - root.depth;
 
-  const distToParent = $from.depth - root.depth; // include any following taskList since nested lists appear
+  // include any following taskList since nested lists appear
   // as siblings
   //
   // this is unlike regular bullet lists where the orderedList
   // appears as descendent of listItem
-
   const blockRange = getBlockRange($from, $to);
-
   if (!blockRange) {
     return -1;
-  } // and get the max height from the current position to the
-  // deepest leaf node
-
+  }
 
+  // and get the max height from the current position to the
+  // deepest leaf node
   let maxChildDepth = $from.depth;
   $from.doc.nodesBetween(blockRange.start, blockRange.end, (descendent, relPos, parent) => {
-    maxChildDepth = Math.max($from.doc.resolve(relPos).depth, maxChildDepth); // keep descending down the tree if we can
+    maxChildDepth = Math.max($from.doc.resolve(relPos).depth, maxChildDepth);
 
+    // keep descending down the tree if we can
     if (types.indexOf(descendent.type) > -1) {
       return true;
     }
   });
   return distToParent + (maxChildDepth - $from.depth);
 };
+
 /**
  * Returns `true` if the taskItem or decisionItem has no text.
  */
-
 export const isEmptyTaskDecision = state => {
   const {
     selection,
@@ -177,6 +172,7 @@ export const isEmptyTaskDecision = state => {
   const node = $from.node($from.depth);
   return node && (node.type === schema.nodes.taskItem || node.type === schema.nodes.decisionItem) && node.content.size === 0;
 };
+
 /**
  * Lifts a taskItem and any directly following taskList
  * (taskItem and its "nested children") out one level.
@@ -185,20 +181,16 @@ export const isEmptyTaskDecision = state => {
  * @param $from Start of range you want to lift
  * @param $to End of range you want to lift (can be same as `$from`)
  */
-
 export const liftBlock = (tr, $from, $to) => {
   const blockRange = getBlockRange($from, $to);
-
   if (!blockRange) {
     return null;
-  } // ensure we can actually lift
-
+  }
 
+  // ensure we can actually lift
   const target = liftTarget(blockRange);
-
   if (typeof target !== 'number') {
     return null;
   }
-
   return tr.lift(blockRange, target).scrollIntoView();
 };

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

@@ -4,7 +4,6 @@ import { createRule, createPlugin } from '../../../utils/input-rules';
 import { leafNodeReplacementCharacter } from '@atlaskit/prosemirror-input-rules';
 import { INPUT_METHOD } from '../../analytics';
 import { changeInDepth, insertTaskDecisionAction, getListTypes } from '../commands';
-
 const createListRule = (regex, listType) => {
   return createRule(regex, (state, _match, start, end) => {
     const {
@@ -14,18 +13,16 @@ const createListRule = (regex, listType) => {
       list
     } = getListTypes(listType, state.schema);
     const $end = state.doc.resolve(end);
-    const $endOfParent = state.doc.resolve($end.after()); // Only allow creating list in nodes that support them.
+    const $endOfParent = state.doc.resolve($end.after());
+    // Only allow creating list in nodes that support them.
     // Parent must be a paragraph as we don't want this applying to headings
-
     if ($end.parent.type !== paragraph || !canInsert($endOfParent, list.createAndFill())) {
       return null;
     }
-
     const insertTr = insertTaskDecisionAction(state, listType, INPUT_METHOD.FORMATTING, addItem(start, end));
     return insertTr;
   });
 };
-
 const addItem = (start, end) => ({
   tr,
   state,
@@ -50,7 +47,6 @@ const addItem = (start, end) => ({
       shouldBreakNode = true;
     }
   });
-
   if (!shouldBreakNode) {
     tr.replaceRangeWith($from.before(), $from.after(), list.create({
       localId: listLocalId
@@ -63,13 +59,12 @@ const addItem = (start, end) => ({
       localId: listLocalId
     }, [item.create({
       localId: itemLocalId
-    }, // TODO: [ts30] handle void and null properly
+    },
+    // TODO: [ts30] handle void and null properly
     tr.doc.nodeAt($from.pos + 1).content)])).setSelection(new TextSelection(tr.doc.resolve($from.pos + depthAdjustment))).delete(start, end + 1);
   }
-
   return tr;
 };
-
 export function inputRulePlugin(schema, featureFlags) {
   const rules = [];
   const {
@@ -78,15 +73,12 @@ export function inputRulePlugin(schema, featureFlags) {
     taskList,
     taskItem
   } = schema.nodes;
-
   if (decisionList && decisionItem) {
     rules.push(createListRule(new RegExp(`(^|${leafNodeReplacementCharacter})\\<\\>\\s$`), 'decisionList'));
   }
-
   if (taskList && taskItem) {
     rules.push(createListRule(new RegExp(`(^|${leafNodeReplacementCharacter})\\[\\]\\s$`), 'taskList'));
   }
-
   return createPlugin('tasks-and-decisions', rules, {
     isBlockNodeRule: true
   });

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

@@ -9,7 +9,6 @@ import { ACTION, ACTION_SUBJECT, ACTION_SUBJECT_ID, EVENT_TYPE, INDENT_DIRECTION
 import { insertTaskDecisionWithAnalytics } from '../commands';
 import { joinAtCut, liftSelection, wrapSelectionInTaskList } from './commands';
 import { getBlockRange, getCurrentIndentLevel, isActionOrDecisionItem, isActionOrDecisionList, isEmptyTaskDecision, isInsideTask, isInsideTaskOrDecisionItem, liftBlock, subtreeHeight, walkOut, getTaskItemIndex, isInsideDecision, isTable } from './helpers';
-
 const indentationAnalytics = (curIndentLevel, direction, inputMethod) => ({
   action: ACTION.FORMATTED,
   actionSubject: ACTION_SUBJECT.TEXT,
@@ -23,24 +22,21 @@ const indentationAnalytics = (curIndentLevel, direction, inputMethod) => ({
     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
-
+  }
+  // look for the node after this current one
+  const $next = walkOut(state.selection.$from);
 
-  const $next = walkOut(state.selection.$from); // if there's no taskItem or taskList following, then
+  // if there's no taskItem or taskList following, then
   // we just do the normal behaviour
-
   const {
     taskList,
     taskItem,
@@ -52,53 +48,47 @@ const joinTaskDecisionFollowing = (state, dispatch) => {
     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 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.
+        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);
 
-        const tr = liftBlock(state.tr, resolvedStartPos, resolvedStartPos); // If autoJoin not used, two ul/ol elements appear rather than one with multiple li elements
-
+        // 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 = (inputMethod = INPUT_METHOD.KEYBOARD) => filter(isInsideTask, (state, dispatch) => {
   const curIndentLevel = getCurrentIndentLevel(state.selection);
-
   if (!curIndentLevel || curIndentLevel === 1) {
     return false;
   }
-
   return withAnalytics(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
+});
 
+// 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);
@@ -107,22 +97,17 @@ const shouldLetTabThroughInTable = state => {
     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 = (inputMethod = INPUT_METHOD.KEYBOARD) => filter(isInsideTask, (state, dispatch) => {
   // limit ui indentation to 6 levels
   const curIndentLevel = getCurrentIndentLevel(state.selection);
-
   if (!curIndentLevel || curIndentLevel >= 6) {
     return true;
   }
-
   const {
     taskList,
     taskItem
@@ -132,50 +117,42 @@ export const getIndentCommand = (inputMethod = INPUT_METHOD.KEYBOARD) => filter(
     $to
   } = state.selection;
   const maxDepth = subtreeHeight($from, $to, [taskList, taskItem]);
-
   if (maxDepth >= 6) {
     return true;
   }
-
   return withAnalytics(indentationAnalytics(curIndentLevel, INDENT_DIRECTION.INDENT, inputMethod))(autoJoin(wrapSelectionInTaskList, ['taskList']))(state, dispatch);
 });
-
 const backspaceFrom = $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
-
+  }
 
+  // if nested, just unindent
   const {
     taskList,
     paragraph
   } = state.schema.nodes;
-
   if ($from.node($from.depth - 2).type === taskList) {
     return getUnindentCommand()(state, dispatch);
-  } // bottom level, should "unwrap" taskItem contents into paragraph
-  // we achieve this by slicing the content out, and replacing
-
+  }
 
+  // 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 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 = filter(isEmptySelectionAtStart, autoJoin(chainCommands((state, dispatch) => joinAtCut(state.selection.$from)(state, dispatch), filter(isInsideTaskOrDecisionItem, (state, dispatch) => backspaceFrom(state.selection.$from)(state, dispatch))), ['taskList', 'decisionList']));
-
 const unindentTaskOrUnwrapTaskDecisionFollowing = (state, dispatch) => {
   const {
     selection: {
@@ -189,50 +166,52 @@ const unindentTaskOrUnwrapTaskDecisionFollowing = (state, dispatch) => {
       }
     },
     tr
-  } = state; // only run if cursor is at the end of the node
+  } = 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()
+  // 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
+  // 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
+  // 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 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 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
@@ -242,44 +221,42 @@ const splitListItemWith = (tr, content, $from, setSelection) => {
         localId: uuid.generate()
       }
     }]);
-  } // and delete the action at the current pos
+  }
+  // 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
+  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
+  }
+
+  // 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());
 
-
-  const $oldAfter = origDoc.resolve($from.after()); // if different levels then we shouldn't lift
-
+  // 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
+      }
+
+      // 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,
@@ -294,18 +271,14 @@ const splitListItem = (state, dispatch) => {
       }
     }
   } = state;
-
   if (actionDecisionFollowsOrNothing($from)) {
     if (dispatch) {
       dispatch(splitListItemWith(tr, paragraph.createChecked(), $from, true));
     }
-
     return true;
   }
-
   return false;
 };
-
 const enter = filter(isInsideTaskOrDecisionItem, chainCommands(filter(isEmptyTaskDecision, chainCommands(getUnindentCommand(), splitListItem)), (state, dispatch) => {
   const {
     selection,
@@ -321,7 +294,6 @@ const enter = filter(isInsideTaskOrDecisionItem, chainCommands(filter(isEmptyTas
   const node = $from.node($from.depth);
   const nodeType = node && node.type;
   const listType = nodeType === taskItem ? 'taskList' : 'decisionList';
-
   const addItem = ({
     tr,
     itemLocalId
@@ -331,13 +303,11 @@ const enter = filter(isInsideTaskOrDecisionItem, chainCommands(filter(isEmptyTas
       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: {
@@ -345,14 +315,11 @@ const enter = filter(isInsideTaskOrDecisionItem, chainCommands(filter(isEmptyTas
       }
     }]);
   };
-
   const insertTr = insertTaskDecisionWithAnalytics(state, listType, INPUT_METHOD.KEYBOARD, addItem);
-
   if (insertTr && dispatch) {
     insertTr.scrollIntoView();
     dispatch(insertTr);
   }
-
   return true;
 }));
 export function keymapPlugin(schema, allowNestedTasks, consumeTabs) {