@atlaskit/editor-plugin-tasks-and-decisions 0.1.0 → 0.2.0

package/dist/cjs/pm-plugins/helpers.js

@@ -0,0 +1,299 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.focusCheckboxAndUpdateSelection = focusCheckboxAndUpdateSelection;
+exports.getAllTaskItemsDataInRootTaskList = getAllTaskItemsDataInRootTaskList;
+exports.getCurrentIndentLevel = exports.getBlockRange = void 0;
+exports.getCurrentTaskItemIndex = getCurrentTaskItemIndex;
+exports.getTaskItemDataAtPos = getTaskItemDataAtPos;
+exports.getTaskItemDataToFocus = getTaskItemDataToFocus;
+exports.liftBlock = exports.isTable = exports.isInsideTaskOrDecisionItem = exports.isInsideTask = exports.isInsideDecision = exports.isEmptyTaskDecision = exports.isActionOrDecisionList = exports.isActionOrDecisionItem = exports.getTaskItemIndex = void 0;
+exports.removeCheckboxFocus = removeCheckboxFocus;
+exports.walkOut = exports.subtreeHeight = void 0;
+var _utils = require("@atlaskit/editor-common/utils");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _utils2 = require("@atlaskit/editor-prosemirror/utils");
+var _pluginKey = require("./plugin-key");
+var _types = require("./types");
+var isInsideTaskOrDecisionItem = exports.isInsideTaskOrDecisionItem = function isInsideTaskOrDecisionItem(state) {
+  var _state$schema$nodes = state.schema.nodes,
+    decisionItem = _state$schema$nodes.decisionItem,
+    taskItem = _state$schema$nodes.taskItem;
+  return (0, _utils2.hasParentNodeOfType)([decisionItem, taskItem])(state.selection);
+};
+var isActionOrDecisionList = exports.isActionOrDecisionList = function isActionOrDecisionList(node) {
+  var _node$type$schema$nod = node.type.schema.nodes,
+    taskList = _node$type$schema$nod.taskList,
+    decisionList = _node$type$schema$nod.decisionList;
+  return [taskList, decisionList].indexOf(node.type) > -1;
+};
+var isActionOrDecisionItem = exports.isActionOrDecisionItem = function isActionOrDecisionItem(node) {
+  var _node$type$schema$nod2 = node.type.schema.nodes,
+    taskItem = _node$type$schema$nod2.taskItem,
+    decisionItem = _node$type$schema$nod2.decisionItem;
+  return [taskItem, decisionItem].indexOf(node.type) > -1;
+};
+var isInsideTask = exports.isInsideTask = function isInsideTask(state) {
+  var taskItem = state.schema.nodes.taskItem;
+  return (0, _utils2.hasParentNodeOfType)([taskItem])(state.selection);
+};
+var isInsideDecision = exports.isInsideDecision = function isInsideDecision(state) {
+  var decisionItem = state.schema.nodes.decisionItem;
+  return (0, _utils2.hasParentNodeOfType)([decisionItem])(state.selection);
+};
+var isTable = exports.isTable = function isTable(node) {
+  if (!node) {
+    return false;
+  }
+  var _node$type$schema$nod3 = node.type.schema.nodes,
+    table = _node$type$schema$nod3.table,
+    tableHeader = _node$type$schema$nod3.tableHeader,
+    tableCell = _node$type$schema$nod3.tableCell,
+    tableRow = _node$type$schema$nod3.tableRow;
+  return [table, tableHeader, tableCell, tableRow].includes(node.type);
+};
+
+/**
+ * Creates a NodeRange around the given taskItem and the following
+ * ("nested") taskList, if one exists.
+ */
+var getBlockRange = exports.getBlockRange = function getBlockRange($from, $to) {
+  var taskList = $from.doc.type.schema.nodes.taskList;
+  var end = $to.end();
+  var $after = $to.doc.resolve(end + 1);
+  var 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.
+ */
+var getCurrentIndentLevel = exports.getCurrentIndentLevel = function getCurrentIndentLevel(selection) {
+  var $from = selection.$from;
+  var taskList = $from.doc.type.schema.nodes.taskList;
+  var furthestParent = (0, _utils.findFarthestParentNode)(function (node) {
+    return 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
+ */
+var getTaskItemIndex = exports.getTaskItemIndex = function getTaskItemIndex(state) {
+  var $pos = state.selection.$from;
+  var isTaskList = function isTaskList(node) {
+    return (node === null || node === void 0 ? void 0 : node.type.name) === 'taskList';
+  };
+  var itemAtPos = (0, _utils2.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.
+ */
+var walkOut = exports.walkOut = function walkOut($startPos) {
+  var $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.
+ *
+ * Traverses from the top of the tree to all leaf nodes, and returns the length
+ * of the longest path.
+ *
+ * This means you can use it with things like taskList, which
+ * do not nest themselves inside taskItems but rather as adjacent children.
+ *
+ * @param $pos Any position inside the tree.
+ * @param types The node types to consider traversable
+ */
+var subtreeHeight = exports.subtreeHeight = function subtreeHeight($from, $to, types) {
+  var root = (0, _utils.findFarthestParentNode)(function (node) {
+    return types.indexOf(node.type) > -1;
+  })($from);
+  if (!root) {
+    return -1;
+  }
+
+  // get the height between the root and the current position
+  var distToParent = $from.depth - root.depth;
+
+  // include any following taskList since nested lists appear
+  // as siblings
+  //
+  // this is unlike regular bullet lists where the orderedList
+  // appears as descendent of listItem
+  var blockRange = getBlockRange($from, $to);
+  if (!blockRange) {
+    return -1;
+  }
+
+  // and get the max height from the current position to the
+  // deepest leaf node
+  var maxChildDepth = $from.depth;
+  $from.doc.nodesBetween(blockRange.start, blockRange.end, function (descendent, relPos, parent) {
+    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.
+ */
+var isEmptyTaskDecision = exports.isEmptyTaskDecision = function isEmptyTaskDecision(state) {
+  var selection = state.selection,
+    schema = state.schema;
+  var $from = selection.$from;
+  var 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.
+ *
+ * @param tr Transaction to base steps on
+ * @param $from Start of range you want to lift
+ * @param $to End of range you want to lift (can be same as `$from`)
+ */
+var liftBlock = exports.liftBlock = function liftBlock(tr, $from, $to) {
+  var blockRange = getBlockRange($from, $to);
+  if (!blockRange) {
+    return null;
+  }
+
+  // ensure we can actually lift
+  var target = (0, _transform.liftTarget)(blockRange);
+  if (typeof target !== 'number') {
+    return null;
+  }
+  return tr.lift(blockRange, target).scrollIntoView();
+};
+function getTaskItemDataAtPos(view) {
+  var state = view.state;
+  var selection = state.selection,
+    schema = state.schema;
+  var $from = selection.$from;
+  var isInTaskItem = $from.node().type === schema.nodes.taskItem;
+
+  // current selection has to be inside taskitem
+  if (isInTaskItem) {
+    var taskItemPos = $from.before();
+    return {
+      pos: taskItemPos,
+      localId: $from.node().attrs.localId
+    };
+  }
+}
+function getAllTaskItemsDataInRootTaskList(view) {
+  var state = view.state;
+  var schema = state.schema;
+  var $fromPos = state.selection.$from;
+  var isInTaskItem = $fromPos.node().type === schema.nodes.taskItem;
+  // if not inside task item then return undefined;
+  if (!isInTaskItem) {
+    return;
+  }
+  var _schema$nodes = schema.nodes,
+    taskList = _schema$nodes.taskList,
+    taskItem = _schema$nodes.taskItem;
+  var rootTaskListData = (0, _utils.findFarthestParentNode)(function (node) {
+    return node.type === taskList;
+  })($fromPos);
+  if (rootTaskListData) {
+    var rootTaskList = rootTaskListData.node;
+    var rootTaskListStartPos = rootTaskListData.start;
+    var allTaskItems = [];
+    rootTaskList.descendants(function (node, pos, parent, index) {
+      if (node.type === taskItem) {
+        allTaskItems.push({
+          node: node,
+          pos: pos + rootTaskListStartPos,
+          index: index
+        });
+      }
+    });
+    return allTaskItems;
+  }
+}
+function getCurrentTaskItemIndex(view, allTaskItems) {
+  var state = view.state;
+  var $fromPos = state.selection.$from;
+  var allTaskItemNodes = allTaskItems.map(function (nodeData) {
+    return nodeData.node;
+  });
+  var currentTaskItem = $fromPos.node($fromPos.depth);
+  var currentTaskItemIndex = allTaskItemNodes.indexOf(currentTaskItem);
+  return currentTaskItemIndex;
+}
+function getTaskItemDataToFocus(view, direction) {
+  var allTaskItems = getAllTaskItemsDataInRootTaskList(view);
+  // if not inside task item then allTaskItems will be undefined;
+  if (!allTaskItems) {
+    return;
+  }
+  var currentTaskItemIndex = getCurrentTaskItemIndex(view, allTaskItems);
+  if (direction === 'next' ? currentTaskItemIndex === allTaskItems.length - 1 : currentTaskItemIndex === 0) {
+    // checkbox of first or last task item is already focused based on direction.
+    return;
+  }
+  var indexOfTaskItemToFocus = direction === 'next' ? currentTaskItemIndex + 1 : currentTaskItemIndex - 1;
+  var taskItemToFocus = allTaskItems[indexOfTaskItemToFocus];
+  return {
+    pos: taskItemToFocus.pos,
+    localId: taskItemToFocus.node.attrs.localId
+  };
+}
+function focusCheckboxAndUpdateSelection(view, taskItemData) {
+  var pos = taskItemData.pos,
+    localId = taskItemData.localId;
+  var state = view.state,
+    dispatch = view.dispatch;
+  var doc = state.doc,
+    tr = state.tr;
+  tr.setSelection(new _state.TextSelection(doc.resolve(pos + 1)));
+  tr.setMeta(_pluginKey.stateKey, {
+    action: _types.ACTIONS.FOCUS_BY_LOCALID,
+    data: localId
+  });
+  dispatch(tr);
+}
+function removeCheckboxFocus(view) {
+  var state = view.state,
+    dispatch = view.dispatch;
+  var tr = state.tr;
+  view.focus();
+  dispatch(tr.setMeta(_pluginKey.stateKey, {
+    action: _types.ACTIONS.FOCUS_BY_LOCALID
+  }));
+}

package/dist/cjs/pm-plugins/input-rules.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.inputRulePlugin = exports.default = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _utils = require("@atlaskit/editor-prosemirror/utils");
+var _prosemirrorInputRules = require("@atlaskit/prosemirror-input-rules");
+var _commands = require("../commands");
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var createListRule = function createListRule(editorAnalyticsAPI) {
+  return function (regex, listType, itemAttrs) {
+    return (0, _prosemirrorInputRules.createRule)(regex, function (state, _match, start, end) {
+      var paragraph = state.schema.nodes.paragraph;
+      var _getListTypes = (0, _commands.getListTypes)(listType, state.schema),
+        list = _getListTypes.list;
+      var $end = state.doc.resolve(end);
+      var $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 || !(0, _utils.canInsert)($endOfParent, list.createAndFill())) {
+        return null;
+      }
+      var insertTr = (0, _commands.insertTaskDecisionAction)(editorAnalyticsAPI)(state, listType, _analytics.INPUT_METHOD.FORMATTING, addItem(start, end), undefined, undefined, itemAttrs);
+      return insertTr;
+    });
+  };
+};
+var addItem = function addItem(start, end) {
+  return function (_ref) {
+    var tr = _ref.tr,
+      state = _ref.state,
+      list = _ref.list,
+      item = _ref.item,
+      listLocalId = _ref.listLocalId,
+      itemLocalId = _ref.itemLocalId,
+      itemAttrs = _ref.itemAttrs;
+    var $from = state.selection.$from,
+      schema = state.schema;
+    var hardBreak = schema.nodes.hardBreak;
+    var content = $from.node($from.depth).content;
+    var shouldBreakNode = false;
+    content.forEach(function (node, offset) {
+      if (node.type === hardBreak && offset < start) {
+        shouldBreakNode = true;
+      }
+    });
+    if (!shouldBreakNode) {
+      tr.replaceRangeWith($from.before(), $from.after(), list.create({
+        localId: listLocalId
+      }, [item.create(_objectSpread({
+        localId: itemLocalId
+      }, itemAttrs), content)])).delete(start + 1, end + 1).setSelection(new _state.TextSelection(tr.doc.resolve(start + 1)));
+    } else {
+      var depthAdjustment = (0, _commands.changeInDepth)($from, tr.selection.$from);
+      tr.split($from.pos).setSelection(new _state.NodeSelection(tr.doc.resolve($from.pos + 1))).replaceSelectionWith(list.create({
+        localId: listLocalId
+      }, [item.create(_objectSpread({
+        localId: itemLocalId
+      }, itemAttrs),
+      // TODO: [ts30] handle void and null properly
+      tr.doc.nodeAt($from.pos + 1).content)])).setSelection(new _state.TextSelection(tr.doc.resolve($from.pos + depthAdjustment))).delete(start, end + 1);
+    }
+    return tr;
+  };
+};
+var inputRulePlugin = exports.inputRulePlugin = function inputRulePlugin(editorAnalyticsAPI) {
+  return function (schema, featureFlags) {
+    var rules = [];
+    var _schema$nodes = schema.nodes,
+      decisionList = _schema$nodes.decisionList,
+      decisionItem = _schema$nodes.decisionItem,
+      taskList = _schema$nodes.taskList,
+      taskItem = _schema$nodes.taskItem;
+    if (decisionList && decisionItem) {
+      rules.push(createListRule(editorAnalyticsAPI)(new RegExp("(^|".concat(_prosemirrorInputRules.leafNodeReplacementCharacter, ")\\<\\>\\s$")), 'decisionList'));
+    }
+    if (taskList && taskItem) {
+      rules.push(createListRule(editorAnalyticsAPI)(new RegExp("(^|".concat(_prosemirrorInputRules.leafNodeReplacementCharacter, ")\\[\\]\\s$")), 'taskList'));
+      rules.push(createListRule(editorAnalyticsAPI)(new RegExp("(^|".concat(_prosemirrorInputRules.leafNodeReplacementCharacter, ")\\[x\\]\\s$")), 'taskList', {
+        state: 'DONE'
+      }));
+    }
+    return (0, _prosemirrorInputRules.createPlugin)('tasks-and-decisions', rules, {
+      isBlockNodeRule: true
+    });
+  };
+};
+var _default = exports.default = inputRulePlugin;