@atlaskit/editor-plugin-tasks-and-decisions 6.2.1 → 6.2.3

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atlaskit/editor-plugin-tasks-and-decisions
 
+## 6.2.3
+
+### Patch Changes
+
+- [#201339](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/201339)
+  [`b734e816f63ba`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/b734e816f63ba) -
+  [EDITOR-1150] Handle pressing Enter in blockTaskItems
+
+## 6.2.2
+
+### Patch Changes
+
+- [#200845](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/pull-requests/200845)
+  [`4e3985a5a347d`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/4e3985a5a347d) -
+  EDITOR-1320 Ensure localID creation for blockTaskItem
+
 ## 6.2.1
 
 ### Patch Changes

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

@@ -25,8 +25,9 @@ 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);
+    taskItem = _state$schema$nodes.taskItem,
+    blockTaskItem = _state$schema$nodes.blockTaskItem;
+  return (0, _utils2.hasParentNodeOfType)([decisionItem, taskItem, blockTaskItem])(state.selection);
 };
 var isActionOrDecisionList = exports.isActionOrDecisionList = function isActionOrDecisionList(node) {
   var _node$type$schema$nod = node.type.schema.nodes,

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

@@ -348,12 +348,25 @@ var enter = function enter(editorAnalyticsAPI, getContextIdentifier) {
   return (0, _utils.filterCommand)(_helpers.isInsideTaskOrDecisionItem, (0, _commands.chainCommands)((0, _utils.filterCommand)(_helpers.isEmptyTaskDecision, (0, _commands.chainCommands)(getUnindentCommand(editorAnalyticsAPI)(), splitListItem)), function (state, dispatch) {
     var selection = state.selection,
       schema = state.schema;
-    var taskItem = schema.nodes.taskItem;
+    var _schema$nodes = schema.nodes,
+      decisionItem = _schema$nodes.decisionItem,
+      taskItem = _schema$nodes.taskItem,
+      blockTaskItem = _schema$nodes.blockTaskItem;
     var $from = selection.$from,
       $to = selection.$to;
     var node = $from.node($from.depth);
     var nodeType = node && node.type;
-    var listType = nodeType === taskItem ? 'taskList' : 'decisionList';
+
+    // Get the parent node type if the current node type is not one of the task or decision items
+    // This is required to handle blockTaskItem
+    if (![decisionItem, taskItem, blockTaskItem].includes(nodeType)) {
+      var _findParentNodeOfType;
+      var possibleNodeType = (_findParentNodeOfType = (0, _utils2.findParentNodeOfType)([decisionItem, taskItem, blockTaskItem])(selection)) === null || _findParentNodeOfType === void 0 || (_findParentNodeOfType = _findParentNodeOfType.node) === null || _findParentNodeOfType === void 0 ? void 0 : _findParentNodeOfType.type;
+      if (possibleNodeType) {
+        nodeType = possibleNodeType;
+      }
+    }
+    var listType = [taskItem, blockTaskItem].includes(nodeType) ? 'taskList' : 'decisionList';
     var addItem = function addItem(_ref) {
       var tr = _ref.tr,
         itemLocalId = _ref.itemLocalId;
@@ -363,10 +376,55 @@ var enter = function enter(editorAnalyticsAPI, getContextIdentifier) {
           localId: itemLocalId
         });
         if (newTask) {
+          if (nodeType === blockTaskItem) {
+            var blockTaskItemNode = (0, _utils2.findParentNodeOfType)([blockTaskItem])(selection);
+
+            // New task items for blockTaskItem should be taskItem
+            // We want to prevent creating new blockTaskItems as much as possible
+            var newTaskItem = taskItem.createAndFill({
+              localId: itemLocalId
+            });
+            if (!blockTaskItemNode || !newTaskItem) {
+              return tr;
+            }
+            return tr.insert(blockTaskItemNode.pos, newTaskItem);
+          }
           // Current position will point to text node, but we want to insert above the taskItem node
           return tr.insert($from.pos - 1, newTask);
         }
       }
+      /**
+       * For blockTaskItem, must handle it differently because it can have a different depth
+       */
+      if (nodeType === blockTaskItem) {
+        var _blockTaskItemNode = (0, _utils2.findParentNodeOfType)([blockTaskItem])(selection);
+        if (!_blockTaskItemNode) {
+          return tr;
+        }
+
+        // If the selection is a gap cursor at the end of the blockTaskItem,
+        // we should insert a new taskItem.
+        if ($from.parentOffset === $from.parent.nodeSize - 2) {
+          var _newTaskItem = taskItem.createAndFill({
+            localId: itemLocalId
+          });
+          if (_newTaskItem) {
+            tr.insert(_blockTaskItemNode.pos + _blockTaskItemNode.node.nodeSize, _newTaskItem);
+
+            // Move the cursor to the end of the newly inserted blockTaskItem
+            tr.setSelection(_state.TextSelection.create(tr.doc, _blockTaskItemNode.pos + _blockTaskItemNode.node.nodeSize + 1));
+            return tr;
+          }
+        }
+
+        // Split near the depth of the current selection
+        return tr.split($from.pos, $from.depth - 1, [{
+          type: blockTaskItem,
+          attrs: {
+            localId: itemLocalId
+          }
+        }]);
+      }
       return tr.split($from.pos, 1, [{
         type: nodeType,
         attrs: {

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

@@ -261,7 +261,7 @@ function createPlugin(portalProviderAPI, eventDispatcher, dispatch, api, getIntl
     /*
      * 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.
+     * Prosemirror capability 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
@@ -280,8 +280,9 @@ function createPlugin(portalProviderAPI, eventDispatcher, dispatch, api, getIntl
             decisionList = _newState$schema$node.decisionList,
             decisionItem = _newState$schema$node.decisionItem,
             taskList = _newState$schema$node.taskList,
-            taskItem = _newState$schema$node.taskItem;
-          if (!!node.type && (node.type === decisionList || node.type === decisionItem || node.type === taskList || node.type === taskItem)) {
+            taskItem = _newState$schema$node.taskItem,
+            blockTaskItem = _newState$schema$node.blockTaskItem;
+          if (!!node.type && (node.type === decisionList || node.type === decisionItem || node.type === taskList || node.type === taskItem || blockTaskItem && node.type === blockTaskItem)) {
             var _node$attrs = node.attrs,
               localId = _node$attrs.localId,
               rest = (0, _objectWithoutProperties2.default)(_node$attrs, _excluded);

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

@@ -7,9 +7,10 @@ import { ACTIONS } from './types';
 export const isInsideTaskOrDecisionItem = state => {
   const {
     decisionItem,
-    taskItem
+    taskItem,
+    blockTaskItem
   } = state.schema.nodes;
-  return hasParentNodeOfType([decisionItem, taskItem])(state.selection);
+  return hasParentNodeOfType([decisionItem, taskItem, blockTaskItem])(state.selection);
 };
 export const isActionOrDecisionList = node => {
   const {

package/dist/es2019/pm-plugins/keymaps.js

@@ -337,15 +337,27 @@ const enter = (editorAnalyticsAPI, getContextIdentifier) => filter(isInsideTaskO
     schema
   } = state;
   const {
-    taskItem
+    decisionItem,
+    taskItem,
+    blockTaskItem
   } = schema.nodes;
   const {
     $from,
     $to
   } = selection;
   const node = $from.node($from.depth);
-  const nodeType = node && node.type;
-  const listType = nodeType === taskItem ? 'taskList' : 'decisionList';
+  let nodeType = node && node.type;
+
+  // Get the parent node type if the current node type is not one of the task or decision items
+  // This is required to handle blockTaskItem
+  if (![decisionItem, taskItem, blockTaskItem].includes(nodeType)) {
+    var _findParentNodeOfType, _findParentNodeOfType2;
+    const possibleNodeType = (_findParentNodeOfType = findParentNodeOfType([decisionItem, taskItem, blockTaskItem])(selection)) === null || _findParentNodeOfType === void 0 ? void 0 : (_findParentNodeOfType2 = _findParentNodeOfType.node) === null || _findParentNodeOfType2 === void 0 ? void 0 : _findParentNodeOfType2.type;
+    if (possibleNodeType) {
+      nodeType = possibleNodeType;
+    }
+  }
+  const listType = [taskItem, blockTaskItem].includes(nodeType) ? 'taskList' : 'decisionList';
   const addItem = ({
     tr,
     itemLocalId
@@ -356,10 +368,55 @@ const enter = (editorAnalyticsAPI, getContextIdentifier) => filter(isInsideTaskO
         localId: itemLocalId
       });
       if (newTask) {
+        if (nodeType === blockTaskItem) {
+          const blockTaskItemNode = findParentNodeOfType([blockTaskItem])(selection);
+
+          // New task items for blockTaskItem should be taskItem
+          // We want to prevent creating new blockTaskItems as much as possible
+          const newTaskItem = taskItem.createAndFill({
+            localId: itemLocalId
+          });
+          if (!blockTaskItemNode || !newTaskItem) {
+            return tr;
+          }
+          return tr.insert(blockTaskItemNode.pos, newTaskItem);
+        }
         // Current position will point to text node, but we want to insert above the taskItem node
         return tr.insert($from.pos - 1, newTask);
       }
     }
+    /**
+     * For blockTaskItem, must handle it differently because it can have a different depth
+     */
+    if (nodeType === blockTaskItem) {
+      const blockTaskItemNode = findParentNodeOfType([blockTaskItem])(selection);
+      if (!blockTaskItemNode) {
+        return tr;
+      }
+
+      // If the selection is a gap cursor at the end of the blockTaskItem,
+      // we should insert a new taskItem.
+      if ($from.parentOffset === $from.parent.nodeSize - 2) {
+        const newTaskItem = taskItem.createAndFill({
+          localId: itemLocalId
+        });
+        if (newTaskItem) {
+          tr.insert(blockTaskItemNode.pos + blockTaskItemNode.node.nodeSize, newTaskItem);
+
+          // Move the cursor to the end of the newly inserted blockTaskItem
+          tr.setSelection(TextSelection.create(tr.doc, blockTaskItemNode.pos + blockTaskItemNode.node.nodeSize + 1));
+          return tr;
+        }
+      }
+
+      // Split near the depth of the current selection
+      return tr.split($from.pos, $from.depth - 1, [{
+        type: blockTaskItem,
+        attrs: {
+          localId: itemLocalId
+        }
+      }]);
+    }
     return tr.split($from.pos, 1, [{
       type: nodeType,
       attrs: {

package/dist/es2019/pm-plugins/main.js

@@ -257,7 +257,7 @@ export function createPlugin(portalProviderAPI, eventDispatcher, dispatch, api,
     /*
      * 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.
+     * Prosemirror capability 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
@@ -276,9 +276,10 @@ export function createPlugin(portalProviderAPI, eventDispatcher, dispatch, api,
             decisionList,
             decisionItem,
             taskList,
-            taskItem
+            taskItem,
+            blockTaskItem
           } = newState.schema.nodes;
-          if (!!node.type && (node.type === decisionList || node.type === decisionItem || node.type === taskList || node.type === taskItem)) {
+          if (!!node.type && (node.type === decisionList || node.type === decisionItem || node.type === taskList || node.type === taskItem || blockTaskItem && node.type === blockTaskItem)) {
             const {
               localId,
               ...rest

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

@@ -7,8 +7,9 @@ import { ACTIONS } from './types';
 export var isInsideTaskOrDecisionItem = function isInsideTaskOrDecisionItem(state) {
   var _state$schema$nodes = state.schema.nodes,
     decisionItem = _state$schema$nodes.decisionItem,
-    taskItem = _state$schema$nodes.taskItem;
-  return hasParentNodeOfType([decisionItem, taskItem])(state.selection);
+    taskItem = _state$schema$nodes.taskItem,
+    blockTaskItem = _state$schema$nodes.blockTaskItem;
+  return hasParentNodeOfType([decisionItem, taskItem, blockTaskItem])(state.selection);
 };
 export var isActionOrDecisionList = function isActionOrDecisionList(node) {
   var _node$type$schema$nod = node.type.schema.nodes,

package/dist/esm/pm-plugins/keymaps.js

@@ -340,12 +340,25 @@ var enter = function enter(editorAnalyticsAPI, getContextIdentifier) {
   return filter(isInsideTaskOrDecisionItem, chainCommands(filter(isEmptyTaskDecision, chainCommands(getUnindentCommand(editorAnalyticsAPI)(), splitListItem)), function (state, dispatch) {
     var selection = state.selection,
       schema = state.schema;
-    var taskItem = schema.nodes.taskItem;
+    var _schema$nodes = schema.nodes,
+      decisionItem = _schema$nodes.decisionItem,
+      taskItem = _schema$nodes.taskItem,
+      blockTaskItem = _schema$nodes.blockTaskItem;
     var $from = selection.$from,
       $to = selection.$to;
     var node = $from.node($from.depth);
     var nodeType = node && node.type;
-    var listType = nodeType === taskItem ? 'taskList' : 'decisionList';
+
+    // Get the parent node type if the current node type is not one of the task or decision items
+    // This is required to handle blockTaskItem
+    if (![decisionItem, taskItem, blockTaskItem].includes(nodeType)) {
+      var _findParentNodeOfType;
+      var possibleNodeType = (_findParentNodeOfType = findParentNodeOfType([decisionItem, taskItem, blockTaskItem])(selection)) === null || _findParentNodeOfType === void 0 || (_findParentNodeOfType = _findParentNodeOfType.node) === null || _findParentNodeOfType === void 0 ? void 0 : _findParentNodeOfType.type;
+      if (possibleNodeType) {
+        nodeType = possibleNodeType;
+      }
+    }
+    var listType = [taskItem, blockTaskItem].includes(nodeType) ? 'taskList' : 'decisionList';
     var addItem = function addItem(_ref) {
       var tr = _ref.tr,
         itemLocalId = _ref.itemLocalId;
@@ -355,10 +368,55 @@ var enter = function enter(editorAnalyticsAPI, getContextIdentifier) {
           localId: itemLocalId
         });
         if (newTask) {
+          if (nodeType === blockTaskItem) {
+            var blockTaskItemNode = findParentNodeOfType([blockTaskItem])(selection);
+
+            // New task items for blockTaskItem should be taskItem
+            // We want to prevent creating new blockTaskItems as much as possible
+            var newTaskItem = taskItem.createAndFill({
+              localId: itemLocalId
+            });
+            if (!blockTaskItemNode || !newTaskItem) {
+              return tr;
+            }
+            return tr.insert(blockTaskItemNode.pos, newTaskItem);
+          }
           // Current position will point to text node, but we want to insert above the taskItem node
           return tr.insert($from.pos - 1, newTask);
         }
       }
+      /**
+       * For blockTaskItem, must handle it differently because it can have a different depth
+       */
+      if (nodeType === blockTaskItem) {
+        var _blockTaskItemNode = findParentNodeOfType([blockTaskItem])(selection);
+        if (!_blockTaskItemNode) {
+          return tr;
+        }
+
+        // If the selection is a gap cursor at the end of the blockTaskItem,
+        // we should insert a new taskItem.
+        if ($from.parentOffset === $from.parent.nodeSize - 2) {
+          var _newTaskItem = taskItem.createAndFill({
+            localId: itemLocalId
+          });
+          if (_newTaskItem) {
+            tr.insert(_blockTaskItemNode.pos + _blockTaskItemNode.node.nodeSize, _newTaskItem);
+
+            // Move the cursor to the end of the newly inserted blockTaskItem
+            tr.setSelection(TextSelection.create(tr.doc, _blockTaskItemNode.pos + _blockTaskItemNode.node.nodeSize + 1));
+            return tr;
+          }
+        }
+
+        // Split near the depth of the current selection
+        return tr.split($from.pos, $from.depth - 1, [{
+          type: blockTaskItem,
+          attrs: {
+            localId: itemLocalId
+          }
+        }]);
+      }
       return tr.split($from.pos, 1, [{
         type: nodeType,
         attrs: {

package/dist/esm/pm-plugins/main.js

@@ -254,7 +254,7 @@ export function createPlugin(portalProviderAPI, eventDispatcher, dispatch, api,
     /*
      * 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.
+     * Prosemirror capability 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
@@ -273,8 +273,9 @@ export function createPlugin(portalProviderAPI, eventDispatcher, dispatch, api,
             decisionList = _newState$schema$node.decisionList,
             decisionItem = _newState$schema$node.decisionItem,
             taskList = _newState$schema$node.taskList,
-            taskItem = _newState$schema$node.taskItem;
-          if (!!node.type && (node.type === decisionList || node.type === decisionItem || node.type === taskList || node.type === taskItem)) {
+            taskItem = _newState$schema$node.taskItem,
+            blockTaskItem = _newState$schema$node.blockTaskItem;
+          if (!!node.type && (node.type === decisionList || node.type === decisionItem || node.type === taskList || node.type === taskItem || blockTaskItem && node.type === blockTaskItem)) {
             var _node$attrs = node.attrs,
               localId = _node$attrs.localId,
               rest = _objectWithoutProperties(_node$attrs, _excluded);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-tasks-and-decisions",
-	"version": "6.2.1",
+	"version": "6.2.3",
 	"description": "Tasks and decisions plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -49,7 +49,7 @@
 		"@atlaskit/primitives": "^14.11.0",
 		"@atlaskit/prosemirror-input-rules": "^3.4.0",
 		"@atlaskit/task-decision": "^19.2.0",
-		"@atlaskit/tmp-editor-statsig": "^9.27.0",
+		"@atlaskit/tmp-editor-statsig": "^9.28.0",
 		"@atlaskit/tokens": "^6.0.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^0.18.3",