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

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @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

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

@@ -42,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;
@@ -81,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/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

@@ -28,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 {
@@ -73,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/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

@@ -24,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;
@@ -63,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/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.3",
+	"version": "6.2.4",
 	"description": "Tasks and decisions plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",