@atlaskit/editor-plugin-tasks-and-decisions 6.2.2 → 6.2.4

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @atlaskit/editor-plugin-tasks-and-decisions
 
+## 6.2.4
+
+### Patch Changes
+
+- [`af3ebe7fda754`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/af3ebe7fda754) -
+  [EDITOR-1153] Handle when user presses "Tab" in a blockTaskItem
+
+## 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

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

@@ -5,11 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.wrapSelectionInTaskList = exports.liftSelection = exports.joinAtCut = void 0;
 var _commands = require("@atlaskit/editor-common/commands");
+var _utils = require("@atlaskit/editor-common/utils");
+var _model = require("@atlaskit/editor-prosemirror/model");
 var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _utils2 = require("@atlaskit/editor-prosemirror/utils");
 var _helpers = require("./helpers");
-var _utils = require("./utils");
+var _utils3 = require("./utils");
 var liftSelection = exports.liftSelection = function liftSelection(state, dispatch) {
-  var normalizedSelection = (0, _utils.normalizeTaskItemsSelection)(state.selection);
+  var normalizedSelection = (0, _utils3.normalizeTaskItemsSelection)(state.selection);
   var $from = normalizedSelection.$from,
     $to = normalizedSelection.$to;
   var tr = (0, _helpers.liftBlock)(state.tr, $from, $to);
@@ -18,20 +21,60 @@ var liftSelection = exports.liftSelection = function liftSelection(state, dispat
   }
   return !!tr;
 };
+
+/**
+ * Wraps the current selection in a task list, respecting a maximum indentation depth of 6 levels.
+ *
+ * - Normalizes the selection to ensure it covers complete task items.
+ * - Determines the maximum depth of task list nesting within the selection.
+ * - If the selection is already nested at or beyond the maximum depth, the command does nothing.
+ * - Calculates the block range to wrap, handling both regular and block task items.
+ * - Wraps the block in a task list to increase indentation or create a new task list if necessary.
+ *
+ * @param state - The current editor state.
+ * @param dispatch - The dispatch function to apply the transaction.
+ * @returns `true` if the command was handled (even if no changes were made), otherwise `false`.
+ * @example
+ * ```typescript
+ * autoJoin(wrapSelectionInTaskList, ['taskList']))(state, dispatch);
+ * ```
+ */
 var wrapSelectionInTaskList = exports.wrapSelectionInTaskList = function wrapSelectionInTaskList(state, dispatch) {
-  var _normalizeTaskItemsSe = (0, _utils.normalizeTaskItemsSelection)(state.selection),
+  var _normalizeTaskItemsSe = (0, _utils3.normalizeTaskItemsSelection)(state.selection),
     $from = _normalizeTaskItemsSe.$from,
     $to = _normalizeTaskItemsSe.$to;
 
   // limit ui indentation to 6 levels
   var _state$schema$nodes = state.schema.nodes,
     taskList = _state$schema$nodes.taskList,
-    taskItem = _state$schema$nodes.taskItem;
+    taskItem = _state$schema$nodes.taskItem,
+    blockTaskItem = _state$schema$nodes.blockTaskItem;
   var maxDepth = (0, _helpers.subtreeHeight)($from, $to, [taskList, taskItem]);
+  var isBlockTaskItem = (0, _utils2.hasParentNodeOfType)([blockTaskItem])(state.selection);
+  var blockTaskItemNode = (0, _utils.findFarthestParentNode)(function (node) {
+    return node.type === blockTaskItem;
+  })($from);
+  if (blockTaskItem && isBlockTaskItem && blockTaskItemNode) {
+    // If the selection is inside a nested node inside the blockTaskItem
+    // Remove the difference in depth between the selection and the blockTaskItemNode
+    if ($from.depth > blockTaskItemNode.depth) {
+      maxDepth = (0, _helpers.subtreeHeight)($from, $to, [taskList, blockTaskItem]) - ($from.depth - blockTaskItemNode.depth);
+    } else {
+      maxDepth = (0, _helpers.subtreeHeight)($from, $to, [taskList, blockTaskItem]);
+    }
+  }
   if (maxDepth >= 6) {
     return true;
   }
   var blockRange = (0, _helpers.getBlockRange)($from, $to);
+  if (blockTaskItem) {
+    if (isBlockTaskItem && blockTaskItemNode) {
+      // Get the Resolved $from and $to of the node nested inside the blockTaskItem
+      var startOfNodeInBlockTaskItem = state.doc.resolve(blockTaskItemNode.start);
+      var endOfNodeInBlockTaskItem = state.doc.resolve(blockTaskItemNode.start + blockTaskItemNode.node.nodeSize - 1);
+      blockRange = new _model.NodeRange(startOfNodeInBlockTaskItem, endOfNodeInBlockTaskItem, blockTaskItemNode.depth - 1);
+    }
+  }
   if (!blockRange) {
     return true;
   }

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,
@@ -41,8 +42,10 @@ var isActionOrDecisionItem = exports.isActionOrDecisionItem = function isActionO
   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 _state$schema$nodes2 = state.schema.nodes,
+    taskItem = _state$schema$nodes2.taskItem,
+    blockTaskItem = _state$schema$nodes2.blockTaskItem;
+  return (0, _utils2.hasParentNodeOfType)([taskItem, blockTaskItem])(state.selection);
 };
 var isInsideDecision = exports.isInsideDecision = function isInsideDecision(state) {
   var decisionItem = state.schema.nodes.decisionItem;
@@ -80,17 +83,43 @@ var getBlockRange = exports.getBlockRange = function getBlockRange($from, $to) {
 };
 
 /**
- * Finds the distance between the current $from and the root of the taskList.
+ * Calculates the current indent level of the selection within a task list in the ProseMirror document.
+ *
+ * The indent level is determined by finding the depth difference between the selection and the furthest parent
+ * node of type `taskList`. If the selection is inside a `blockTaskItem`, the calculation is adjusted to avoid
+ * counting nested block items as additional indent levels.
+ *
+ * @param selection - The current ProseMirror selection.
+ * @returns The indent level as a number, or `null` if the selection is not inside a task list.
+ * @example
+ * ```typescript
+ * const indentLevel = getCurrentIndentLevel(editorState.selection);
+ * ```
  */
 var getCurrentIndentLevel = exports.getCurrentIndentLevel = function getCurrentIndentLevel(selection) {
   var $from = selection.$from;
-  var taskList = $from.doc.type.schema.nodes.taskList;
+  var _$from$doc$type$schem = $from.doc.type.schema.nodes,
+    taskList = _$from$doc$type$schem.taskList,
+    blockTaskItem = _$from$doc$type$schem.blockTaskItem;
   var furthestParent = (0, _utils.findFarthestParentNode)(function (node) {
     return node.type === taskList;
   })($from);
   if (!furthestParent) {
     return null;
   }
+  if ((0, _utils2.hasParentNodeOfType)([blockTaskItem])(selection)) {
+    var blockTaskItemNode = (0, _utils.findFarthestParentNode)(function (node) {
+      return node.type === blockTaskItem;
+    })($from);
+    if (blockTaskItemNode) {
+      /**
+       * If we are inside a blockTaskItem, calculate the indent level from the
+       * blockTaskItemNode instead of the selection, in case the selection is
+       * nested inside a blockTaskItem.
+       */
+      return blockTaskItemNode.depth - furthestParent.depth;
+    }
+  }
   return $from.depth - furthestParent.depth;
 };
 

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/es2019/pm-plugins/commands.js

@@ -1,5 +1,8 @@
 import { findCutBefore } from '@atlaskit/editor-common/commands';
+import { findFarthestParentNode } from '@atlaskit/editor-common/utils';
+import { NodeRange } from '@atlaskit/editor-prosemirror/model';
 import { findWrapping, ReplaceAroundStep } from '@atlaskit/editor-prosemirror/transform';
+import { hasParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
 import { getBlockRange, isActionOrDecisionItem, isActionOrDecisionList, liftBlock, subtreeHeight } from './helpers';
 import { normalizeTaskItemsSelection } from './utils';
 export const liftSelection = (state, dispatch) => {
@@ -14,6 +17,24 @@ export const liftSelection = (state, dispatch) => {
   }
   return !!tr;
 };
+
+/**
+ * Wraps the current selection in a task list, respecting a maximum indentation depth of 6 levels.
+ *
+ * - Normalizes the selection to ensure it covers complete task items.
+ * - Determines the maximum depth of task list nesting within the selection.
+ * - If the selection is already nested at or beyond the maximum depth, the command does nothing.
+ * - Calculates the block range to wrap, handling both regular and block task items.
+ * - Wraps the block in a task list to increase indentation or create a new task list if necessary.
+ *
+ * @param state - The current editor state.
+ * @param dispatch - The dispatch function to apply the transaction.
+ * @returns `true` if the command was handled (even if no changes were made), otherwise `false`.
+ * @example
+ * ```typescript
+ * autoJoin(wrapSelectionInTaskList, ['taskList']))(state, dispatch);
+ * ```
+ */
 export const wrapSelectionInTaskList = (state, dispatch) => {
   const {
     $from,
@@ -23,13 +44,33 @@ export const wrapSelectionInTaskList = (state, dispatch) => {
   // limit ui indentation to 6 levels
   const {
     taskList,
-    taskItem
+    taskItem,
+    blockTaskItem
   } = state.schema.nodes;
-  const maxDepth = subtreeHeight($from, $to, [taskList, taskItem]);
+  let maxDepth = subtreeHeight($from, $to, [taskList, taskItem]);
+  const isBlockTaskItem = hasParentNodeOfType([blockTaskItem])(state.selection);
+  const blockTaskItemNode = findFarthestParentNode(node => node.type === blockTaskItem)($from);
+  if (blockTaskItem && isBlockTaskItem && blockTaskItemNode) {
+    // If the selection is inside a nested node inside the blockTaskItem
+    // Remove the difference in depth between the selection and the blockTaskItemNode
+    if ($from.depth > blockTaskItemNode.depth) {
+      maxDepth = subtreeHeight($from, $to, [taskList, blockTaskItem]) - ($from.depth - blockTaskItemNode.depth);
+    } else {
+      maxDepth = subtreeHeight($from, $to, [taskList, blockTaskItem]);
+    }
+  }
   if (maxDepth >= 6) {
     return true;
   }
-  const blockRange = getBlockRange($from, $to);
+  let blockRange = getBlockRange($from, $to);
+  if (blockTaskItem) {
+    if (isBlockTaskItem && blockTaskItemNode) {
+      // Get the Resolved $from and $to of the node nested inside the blockTaskItem
+      const startOfNodeInBlockTaskItem = state.doc.resolve(blockTaskItemNode.start);
+      const endOfNodeInBlockTaskItem = state.doc.resolve(blockTaskItemNode.start + blockTaskItemNode.node.nodeSize - 1);
+      blockRange = new NodeRange(startOfNodeInBlockTaskItem, endOfNodeInBlockTaskItem, blockTaskItemNode.depth - 1);
+    }
+  }
   if (!blockRange) {
     return true;
   }

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 {
@@ -27,9 +28,10 @@ export const isActionOrDecisionItem = node => {
 };
 export const isInsideTask = state => {
   const {
-    taskItem
+    taskItem,
+    blockTaskItem
   } = state.schema.nodes;
-  return hasParentNodeOfType([taskItem])(state.selection);
+  return hasParentNodeOfType([taskItem, blockTaskItem])(state.selection);
 };
 export const isInsideDecision = state => {
   const {
@@ -72,19 +74,42 @@ export const getBlockRange = ($from, $to) => {
 };
 
 /**
- * Finds the distance between the current $from and the root of the taskList.
+ * Calculates the current indent level of the selection within a task list in the ProseMirror document.
+ *
+ * The indent level is determined by finding the depth difference between the selection and the furthest parent
+ * node of type `taskList`. If the selection is inside a `blockTaskItem`, the calculation is adjusted to avoid
+ * counting nested block items as additional indent levels.
+ *
+ * @param selection - The current ProseMirror selection.
+ * @returns The indent level as a number, or `null` if the selection is not inside a task list.
+ * @example
+ * ```typescript
+ * const indentLevel = getCurrentIndentLevel(editorState.selection);
+ * ```
  */
 export const getCurrentIndentLevel = selection => {
   const {
     $from
   } = selection;
   const {
-    taskList
+    taskList,
+    blockTaskItem
   } = $from.doc.type.schema.nodes;
   const furthestParent = findFarthestParentNode(node => node.type === taskList)($from);
   if (!furthestParent) {
     return null;
   }
+  if (hasParentNodeOfType([blockTaskItem])(selection)) {
+    const blockTaskItemNode = findFarthestParentNode(node => node.type === blockTaskItem)($from);
+    if (blockTaskItemNode) {
+      /**
+       * If we are inside a blockTaskItem, calculate the indent level from the
+       * blockTaskItemNode instead of the selection, in case the selection is
+       * nested inside a blockTaskItem.
+       */
+      return blockTaskItemNode.depth - furthestParent.depth;
+    }
+  }
   return $from.depth - furthestParent.depth;
 };
 

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/esm/pm-plugins/commands.js

@@ -1,5 +1,8 @@
 import { findCutBefore } from '@atlaskit/editor-common/commands';
+import { findFarthestParentNode } from '@atlaskit/editor-common/utils';
+import { NodeRange } from '@atlaskit/editor-prosemirror/model';
 import { findWrapping, ReplaceAroundStep } from '@atlaskit/editor-prosemirror/transform';
+import { hasParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
 import { getBlockRange, isActionOrDecisionItem, isActionOrDecisionList, liftBlock, subtreeHeight } from './helpers';
 import { normalizeTaskItemsSelection } from './utils';
 export var liftSelection = function liftSelection(state, dispatch) {
@@ -12,6 +15,24 @@ export var liftSelection = function liftSelection(state, dispatch) {
   }
   return !!tr;
 };
+
+/**
+ * Wraps the current selection in a task list, respecting a maximum indentation depth of 6 levels.
+ *
+ * - Normalizes the selection to ensure it covers complete task items.
+ * - Determines the maximum depth of task list nesting within the selection.
+ * - If the selection is already nested at or beyond the maximum depth, the command does nothing.
+ * - Calculates the block range to wrap, handling both regular and block task items.
+ * - Wraps the block in a task list to increase indentation or create a new task list if necessary.
+ *
+ * @param state - The current editor state.
+ * @param dispatch - The dispatch function to apply the transaction.
+ * @returns `true` if the command was handled (even if no changes were made), otherwise `false`.
+ * @example
+ * ```typescript
+ * autoJoin(wrapSelectionInTaskList, ['taskList']))(state, dispatch);
+ * ```
+ */
 export var wrapSelectionInTaskList = function wrapSelectionInTaskList(state, dispatch) {
   var _normalizeTaskItemsSe = normalizeTaskItemsSelection(state.selection),
     $from = _normalizeTaskItemsSe.$from,
@@ -20,12 +41,34 @@ export var wrapSelectionInTaskList = function wrapSelectionInTaskList(state, dis
   // limit ui indentation to 6 levels
   var _state$schema$nodes = state.schema.nodes,
     taskList = _state$schema$nodes.taskList,
-    taskItem = _state$schema$nodes.taskItem;
+    taskItem = _state$schema$nodes.taskItem,
+    blockTaskItem = _state$schema$nodes.blockTaskItem;
   var maxDepth = subtreeHeight($from, $to, [taskList, taskItem]);
+  var isBlockTaskItem = hasParentNodeOfType([blockTaskItem])(state.selection);
+  var blockTaskItemNode = findFarthestParentNode(function (node) {
+    return node.type === blockTaskItem;
+  })($from);
+  if (blockTaskItem && isBlockTaskItem && blockTaskItemNode) {
+    // If the selection is inside a nested node inside the blockTaskItem
+    // Remove the difference in depth between the selection and the blockTaskItemNode
+    if ($from.depth > blockTaskItemNode.depth) {
+      maxDepth = subtreeHeight($from, $to, [taskList, blockTaskItem]) - ($from.depth - blockTaskItemNode.depth);
+    } else {
+      maxDepth = subtreeHeight($from, $to, [taskList, blockTaskItem]);
+    }
+  }
   if (maxDepth >= 6) {
     return true;
   }
   var blockRange = getBlockRange($from, $to);
+  if (blockTaskItem) {
+    if (isBlockTaskItem && blockTaskItemNode) {
+      // Get the Resolved $from and $to of the node nested inside the blockTaskItem
+      var startOfNodeInBlockTaskItem = state.doc.resolve(blockTaskItemNode.start);
+      var endOfNodeInBlockTaskItem = state.doc.resolve(blockTaskItemNode.start + blockTaskItemNode.node.nodeSize - 1);
+      blockRange = new NodeRange(startOfNodeInBlockTaskItem, endOfNodeInBlockTaskItem, blockTaskItemNode.depth - 1);
+    }
+  }
   if (!blockRange) {
     return true;
   }

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,
@@ -23,8 +24,10 @@ export var isActionOrDecisionItem = function isActionOrDecisionItem(node) {
   return [taskItem, decisionItem].indexOf(node.type) > -1;
 };
 export var isInsideTask = function isInsideTask(state) {
-  var taskItem = state.schema.nodes.taskItem;
-  return hasParentNodeOfType([taskItem])(state.selection);
+  var _state$schema$nodes2 = state.schema.nodes,
+    taskItem = _state$schema$nodes2.taskItem,
+    blockTaskItem = _state$schema$nodes2.blockTaskItem;
+  return hasParentNodeOfType([taskItem, blockTaskItem])(state.selection);
 };
 export var isInsideDecision = function isInsideDecision(state) {
   var decisionItem = state.schema.nodes.decisionItem;
@@ -62,17 +65,43 @@ export var getBlockRange = function getBlockRange($from, $to) {
 };
 
 /**
- * Finds the distance between the current $from and the root of the taskList.
+ * Calculates the current indent level of the selection within a task list in the ProseMirror document.
+ *
+ * The indent level is determined by finding the depth difference between the selection and the furthest parent
+ * node of type `taskList`. If the selection is inside a `blockTaskItem`, the calculation is adjusted to avoid
+ * counting nested block items as additional indent levels.
+ *
+ * @param selection - The current ProseMirror selection.
+ * @returns The indent level as a number, or `null` if the selection is not inside a task list.
+ * @example
+ * ```typescript
+ * const indentLevel = getCurrentIndentLevel(editorState.selection);
+ * ```
  */
 export var getCurrentIndentLevel = function getCurrentIndentLevel(selection) {
   var $from = selection.$from;
-  var taskList = $from.doc.type.schema.nodes.taskList;
+  var _$from$doc$type$schem = $from.doc.type.schema.nodes,
+    taskList = _$from$doc$type$schem.taskList,
+    blockTaskItem = _$from$doc$type$schem.blockTaskItem;
   var furthestParent = findFarthestParentNode(function (node) {
     return node.type === taskList;
   })($from);
   if (!furthestParent) {
     return null;
   }
+  if (hasParentNodeOfType([blockTaskItem])(selection)) {
+    var blockTaskItemNode = findFarthestParentNode(function (node) {
+      return node.type === blockTaskItem;
+    })($from);
+    if (blockTaskItemNode) {
+      /**
+       * If we are inside a blockTaskItem, calculate the indent level from the
+       * blockTaskItemNode instead of the selection, in case the selection is
+       * nested inside a blockTaskItem.
+       */
+      return blockTaskItemNode.depth - furthestParent.depth;
+    }
+  }
   return $from.depth - furthestParent.depth;
 };
 

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/types/pm-plugins/commands.d.ts

@@ -1,6 +1,23 @@
 import type { Command } from '@atlaskit/editor-common/types';
-import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import { type ResolvedPos } from '@atlaskit/editor-prosemirror/model';
 export declare const liftSelection: Command;
+/**
+ * Wraps the current selection in a task list, respecting a maximum indentation depth of 6 levels.
+ *
+ * - Normalizes the selection to ensure it covers complete task items.
+ * - Determines the maximum depth of task list nesting within the selection.
+ * - If the selection is already nested at or beyond the maximum depth, the command does nothing.
+ * - Calculates the block range to wrap, handling both regular and block task items.
+ * - Wraps the block in a task list to increase indentation or create a new task list if necessary.
+ *
+ * @param state - The current editor state.
+ * @param dispatch - The dispatch function to apply the transaction.
+ * @returns `true` if the command was handled (even if no changes were made), otherwise `false`.
+ * @example
+ * ```typescript
+ * autoJoin(wrapSelectionInTaskList, ['taskList']))(state, dispatch);
+ * ```
+ */
 export declare const wrapSelectionInTaskList: Command;
 /**
  * Tries to move the paragraph content near the given position into the taskItem or decisionItem

package/dist/types/pm-plugins/helpers.d.ts

@@ -14,7 +14,18 @@ export declare const isTable: (node?: Node | null) => boolean;
  */
 export declare const getBlockRange: ($from: ResolvedPos, $to: ResolvedPos) => import("prosemirror-model").NodeRange | null;
 /**
- * Finds the distance between the current $from and the root of the taskList.
+ * Calculates the current indent level of the selection within a task list in the ProseMirror document.
+ *
+ * The indent level is determined by finding the depth difference between the selection and the furthest parent
+ * node of type `taskList`. If the selection is inside a `blockTaskItem`, the calculation is adjusted to avoid
+ * counting nested block items as additional indent levels.
+ *
+ * @param selection - The current ProseMirror selection.
+ * @returns The indent level as a number, or `null` if the selection is not inside a task list.
+ * @example
+ * ```typescript
+ * const indentLevel = getCurrentIndentLevel(editorState.selection);
+ * ```
  */
 export declare const getCurrentIndentLevel: (selection: Selection) => number | null;
 /**

package/dist/types-ts4.5/pm-plugins/commands.d.ts

@@ -1,6 +1,23 @@
 import type { Command } from '@atlaskit/editor-common/types';
-import type { ResolvedPos } from '@atlaskit/editor-prosemirror/model';
+import { type ResolvedPos } from '@atlaskit/editor-prosemirror/model';
 export declare const liftSelection: Command;
+/**
+ * Wraps the current selection in a task list, respecting a maximum indentation depth of 6 levels.
+ *
+ * - Normalizes the selection to ensure it covers complete task items.
+ * - Determines the maximum depth of task list nesting within the selection.
+ * - If the selection is already nested at or beyond the maximum depth, the command does nothing.
+ * - Calculates the block range to wrap, handling both regular and block task items.
+ * - Wraps the block in a task list to increase indentation or create a new task list if necessary.
+ *
+ * @param state - The current editor state.
+ * @param dispatch - The dispatch function to apply the transaction.
+ * @returns `true` if the command was handled (even if no changes were made), otherwise `false`.
+ * @example
+ * ```typescript
+ * autoJoin(wrapSelectionInTaskList, ['taskList']))(state, dispatch);
+ * ```
+ */
 export declare const wrapSelectionInTaskList: Command;
 /**
  * Tries to move the paragraph content near the given position into the taskItem or decisionItem

package/dist/types-ts4.5/pm-plugins/helpers.d.ts

@@ -14,7 +14,18 @@ export declare const isTable: (node?: Node | null) => boolean;
  */
 export declare const getBlockRange: ($from: ResolvedPos, $to: ResolvedPos) => import("prosemirror-model").NodeRange | null;
 /**
- * Finds the distance between the current $from and the root of the taskList.
+ * Calculates the current indent level of the selection within a task list in the ProseMirror document.
+ *
+ * The indent level is determined by finding the depth difference between the selection and the furthest parent
+ * node of type `taskList`. If the selection is inside a `blockTaskItem`, the calculation is adjusted to avoid
+ * counting nested block items as additional indent levels.
+ *
+ * @param selection - The current ProseMirror selection.
+ * @returns The indent level as a number, or `null` if the selection is not inside a task list.
+ * @example
+ * ```typescript
+ * const indentLevel = getCurrentIndentLevel(editorState.selection);
+ * ```
  */
 export declare const getCurrentIndentLevel: (selection: Selection) => number | null;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-tasks-and-decisions",
-	"version": "6.2.2",
+	"version": "6.2.4",
 	"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",