@atlaskit/editor-plugin-tasks-and-decisions 11.2.1 → 11.3.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/editor-plugin-tasks-and-decisions
 
+## 11.3.0
+
+### Minor Changes
+
+- [`65cb641586cc0`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/65cb641586cc0) -
+  Add flexible per-item task list indentation with breakout support behind
+  platform_editor_flexible_list_indentation experiment
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 11.2.1
 
 ### Patch Changes

package/dist/cjs/pm-plugins/actions/move-selected-task-list-items.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.moveSelectedTaskListItems = moveSelectedTaskListItems;
+var _lists = require("@atlaskit/editor-common/lists");
+var _utils = require("@atlaskit/editor-common/utils");
+var _taskListIndentation = require("../task-list-indentation");
+var MAX_TASK_LIST_DEPTH = 6;
+function moveSelectedTaskListItems(tr, indentDelta) {
+  var doc = tr.doc,
+    selection = tr.selection;
+  var schema = doc.type.schema;
+  var taskList = schema.nodes.taskList;
+  var $from = selection.$from,
+    $to = selection.$to;
+  var rootListResult = (0, _utils.findFarthestParentNode)(function (node) {
+    return node.type === taskList;
+  })($from);
+  if (!rootListResult) {
+    return null;
+  }
+  var rootListStart = rootListResult.pos;
+  var rootListEnd = rootListStart + rootListResult.node.nodeSize;
+  var flattenResult = (0, _taskListIndentation.flattenTaskList)({
+    doc: doc,
+    rootListStart: rootListStart,
+    rootListEnd: rootListEnd,
+    selectionFrom: $from.pos,
+    selectionTo: $to.pos,
+    indentDelta: indentDelta,
+    maxDepth: MAX_TASK_LIST_DEPTH
+  });
+  if (!flattenResult) {
+    return null;
+  }
+  var flattenedItems = flattenResult.items,
+    startIndex = flattenResult.startIndex,
+    endIndex = flattenResult.endIndex;
+  var _buildReplacementFrag = (0, _lists.buildReplacementFragment)({
+      items: flattenedItems,
+      schema: schema,
+      rebuildFn: _taskListIndentation.rebuildTaskList,
+      extractContentFn: function extractContentFn(item, s) {
+        // Extract task item content for breakout.
+        // taskItem has inline content, so wrap in a paragraph.
+        // blockTaskItem already has paragraph children.
+        var blockTaskItem = s.nodes.blockTaskItem;
+        if (blockTaskItem != null && item.node.type === blockTaskItem) {
+          // blockTaskItem children are already paragraphs/extensions
+          var children = [];
+          item.node.forEach(function (child) {
+            return children.push(child);
+          });
+          return children;
+        }
+        // Regular taskItem — wrap inline content in a paragraph
+        return [s.nodes.paragraph.create(null, item.node.content)];
+      }
+    }),
+    fragment = _buildReplacementFrag.fragment,
+    contentStartOffsets = _buildReplacementFrag.contentStartOffsets;
+  if (fragment.size === 0) {
+    return null;
+  }
+  tr.replaceWith(rootListStart, rootListEnd, fragment);
+  var _computeSelectionOffs = (0, _lists.computeSelectionOffsets)({
+      items: flattenedItems,
+      startIndex: startIndex,
+      endIndex: endIndex,
+      originalFrom: $from.pos,
+      originalTo: $to.pos,
+      contentStartOffsets: contentStartOffsets,
+      rootListStart: rootListStart,
+      docSize: tr.doc.content.size
+    }),
+    from = _computeSelectionOffs.from,
+    to = _computeSelectionOffs.to;
+  (0, _lists.restoreSelection)({
+    tr: tr,
+    originalSelection: selection,
+    from: from,
+    to: to
+  });
+  tr.scrollIntoView();
+  return tr;
+}

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

@@ -17,9 +17,11 @@ var _utils = require("@atlaskit/editor-common/utils");
 var _commands = require("@atlaskit/editor-prosemirror/commands");
 var _keymap = require("@atlaskit/editor-prosemirror/keymap");
 var _model = require("@atlaskit/editor-prosemirror/model");
-var _state = require("@atlaskit/editor-prosemirror/state");
+var _state2 = require("@atlaskit/editor-prosemirror/state");
 var _utils2 = require("@atlaskit/editor-prosemirror/utils");
 var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
+var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
+var _moveSelectedTaskListItems = require("./actions/move-selected-task-list-items");
 var _commands2 = require("./commands");
 var _helpers = require("./helpers");
 var _insertCommands = require("./insert-commands");
@@ -106,6 +108,20 @@ var getUnindentCommand = exports.getUnindentCommand = function getUnindentComman
     return (0, _utils.filterCommand)(_helpers.isInsideTask, function (state, dispatch) {
       var normalizedSelection = (0, _utils3.normalizeTaskItemsSelection)(state.selection);
       var curIndentLevel = (0, _helpers.getCurrentIndentLevel)(normalizedSelection);
+      if ((0, _expValEquals.expValEquals)('platform_editor_flexible_list_indentation', 'isEnabled', true)) {
+        if (!curIndentLevel) {
+          return true;
+        }
+        var outdentTr = (0, _moveSelectedTaskListItems.moveSelectedTaskListItems)(state.tr, -1);
+        if (outdentTr) {
+          (0, _editorAnalytics.withAnalytics)(editorAnalyticsAPI, indentationAnalytics(curIndentLevel, _analytics.INDENT_DIRECTION.OUTDENT, inputMethod))(function (_state, d) {
+            d === null || d === void 0 || d(outdentTr);
+            return true;
+          })(state, dispatch);
+          return true;
+        }
+        return false;
+      }
       if (!curIndentLevel || curIndentLevel === 1) {
         return false;
       }
@@ -136,6 +152,20 @@ var getIndentCommand = exports.getIndentCommand = function getIndentCommand(edit
     return (0, _utils.filterCommand)(_helpers.isInsideTask, function (state, dispatch) {
       var normalizedSelection = (0, _utils3.normalizeTaskItemsSelection)(state.selection);
       var curIndentLevel = (0, _helpers.getCurrentIndentLevel)(normalizedSelection);
+      if ((0, _expValEquals.expValEquals)('platform_editor_flexible_list_indentation', 'isEnabled', true)) {
+        if (!curIndentLevel) {
+          return true;
+        }
+        var indentTr = (0, _moveSelectedTaskListItems.moveSelectedTaskListItems)(state.tr, 1);
+        if (indentTr) {
+          (0, _editorAnalytics.withAnalytics)(editorAnalyticsAPI, indentationAnalytics(curIndentLevel, _analytics.INDENT_DIRECTION.INDENT, inputMethod))(function (_state, d) {
+            d === null || d === void 0 || d(indentTr);
+            return true;
+          })(state, dispatch);
+          return true;
+        }
+        return false;
+      }
       if (!curIndentLevel || curIndentLevel >= 6) {
         return true;
       }
@@ -379,7 +409,7 @@ var processNestedActionItem = function processNestedActionItem(tr, $from, previo
 
   // Set custom selection for nested action inside lists using previosuly calculated previousListItem position
   var stableResolvedPos = tr.doc.resolve(previousListItemPos);
-  tr.setSelection(_state.TextSelection.create(tr.doc, stableResolvedPos.after() + 2));
+  tr.setSelection(_state2.TextSelection.create(tr.doc, stableResolvedPos.after() + 2));
 };
 var splitListItemWith = function splitListItemWith(tr, content, $from, setSelection) {
   var _frag$firstChild;
@@ -469,7 +499,7 @@ var splitListItemWith = function splitListItemWith(tr, content, $from, setSelect
     if (isGapCursorSelection) {
       tr = tr.setSelection(new _selection.GapCursorSelection(tr.doc.resolve(newPos), _selection.Side.LEFT));
     } else {
-      tr = tr.setSelection(new _state.TextSelection(tr.doc.resolve(newPos)));
+      tr = tr.setSelection(new _state2.TextSelection(tr.doc.resolve(newPos)));
     }
   }
 
@@ -608,7 +638,7 @@ var enter = function enter(editorAnalyticsAPI, getContextIdentifier) {
             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));
+            tr.setSelection(_state2.TextSelection.create(tr.doc, _blockTaskItemNode.pos + _blockTaskItemNode.node.nodeSize + 1));
             return tr;
           }
         }

package/dist/cjs/pm-plugins/task-list-indentation.js

@@ -0,0 +1,213 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flattenTaskList = flattenTaskList;
+exports.rebuildTaskList = rebuildTaskList;
+var _adfSchema = require("@atlaskit/adf-schema");
+var _lists = require("@atlaskit/editor-common/lists");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+/**
+ * Flattens a taskList tree into an array of task items with computed depths.
+ * Only selected items have their depth adjusted by indentDelta.
+ *
+ * Delegates to the shared `flattenList` with task-list-specific callbacks.
+ */
+function flattenTaskList(options) {
+  var _options$doc$type$sch = options.doc.type.schema.nodes,
+    taskList = _options$doc$type$sch.taskList,
+    taskItem = _options$doc$type$sch.taskItem,
+    blockTaskItem = _options$doc$type$sch.blockTaskItem;
+  return (0, _lists.flattenList)(options, {
+    isContentNode: function isContentNode(node, parent) {
+      var isTaskItemType = node.type === taskItem || blockTaskItem != null && node.type === blockTaskItem;
+      return isTaskItemType && parent != null && parent.type === taskList;
+    },
+    getSelectionBounds: function getSelectionBounds(node, pos) {
+      return {
+        start: pos,
+        end: pos + node.nodeSize
+      };
+    },
+    getDepth: function getDepth(resolvedDepth, rootDepth) {
+      return resolvedDepth - rootDepth - 1;
+    }
+  });
+}
+
+/**
+ * Rebuilds a taskList tree from a flattened array of task items.
+ * Uses a stack-based approach to create proper nesting.
+ *
+ * Preserves original taskList attributes (e.g. localId) for wrappers
+ * of unselected items. Only generates fresh UUIDs for newly-created
+ * nesting levels (i.e. when items were moved via indent/outdent).
+ *
+ * Given items with depths [A:0, B:1, C:2, D:1, E:0], produces:
+ *
+ * taskList
+ *   taskItem 'A'
+ *   taskList
+ *     taskItem 'B'
+ *     taskList
+ *       taskItem 'C'
+ *     taskItem 'D'
+ *   taskItem 'E'
+ *
+ * Also computes `contentStartOffsets`: for each item (by index),
+ * the offset within the returned fragment where the item's content
+ * begins. This is used for accurate selection restoration.
+ */
+function rebuildTaskList(items, schema) {
+  var _stack$0$listAttrs;
+  var taskList = schema.nodes.taskList;
+  var contentStartOffsets = new Array(items.length);
+  if (items.length === 0) {
+    return null;
+  }
+
+  // Each stack entry collects children for a taskList at a given depth.
+  // The root entry (depth -1) is special: its children become the content
+  // of the outermost taskList directly (not wrapped in another taskList).
+  // Entries at depth >= 0 each produce a nested taskList when popped.
+  // listAttrs preserves the original parent's attributes when available.
+  // sourceParentAttrs tracks the original parent taskList attrs of the items
+  // in this entry, used to decide whether consecutive same-depth items
+  // should share a wrapper or be separated.
+
+  // Start with the root level (depth -1 represents the root taskList wrapper)
+  var stack = [{
+    depth: -1,
+    children: [],
+    listAttrs: items[0].parentListAttrs,
+    sourceParentAttrs: items[0].parentListAttrs
+  }];
+  var _iterator = _createForOfIteratorHelper(items),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      var targetDepth = item.depth;
+
+      // Pop stack entries strictly deeper than target, wrapping them into taskLists
+      while (stack.length > 1 && stack[stack.length - 1].depth > targetDepth) {
+        var _popped$listAttrs2;
+        var _popped = stack.pop();
+        if (!_popped) {
+          break;
+        }
+        var _attrs = (_popped$listAttrs2 = _popped.listAttrs) !== null && _popped$listAttrs2 !== void 0 ? _popped$listAttrs2 : {
+          localId: _adfSchema.uuid.generate()
+        };
+        var _wrappedList = taskList.create(_attrs, _popped.children);
+        stack[stack.length - 1].children.push(_wrappedList);
+      }
+
+      // If the stack top is at the same depth as the target, decide whether
+      // to merge into the existing entry or close it and start a new one.
+      // Unselected items from different original parent taskLists get
+      // separate wrappers (preserving original nesting). Selected (moved)
+      // items always merge with whatever is already at the target depth,
+      // since they're being placed into a new structural context.
+      if (stack.length > 1 && stack[stack.length - 1].depth === targetDepth && !item.isSelected) {
+        var top = stack[stack.length - 1];
+        if (top.sourceParentAttrs !== item.parentListAttrs) {
+          var _popped2$listAttrs;
+          var _popped2 = stack.pop();
+          if (!_popped2) {
+            break;
+          }
+          var _attrs2 = (_popped2$listAttrs = _popped2.listAttrs) !== null && _popped2$listAttrs !== void 0 ? _popped2$listAttrs : {
+            localId: _adfSchema.uuid.generate()
+          };
+          var _wrappedList2 = taskList.create(_attrs2, _popped2.children);
+          stack[stack.length - 1].children.push(_wrappedList2);
+        }
+      }
+
+      // Push new stack entries to reach the target depth.
+      // Skip intermediate entries at depth 0 — depth-0 items belong
+      // directly in the root entry (depth -1), so we only need
+      // intermediates for depths > 1.
+      while (stack[stack.length - 1].depth < targetDepth - 1) {
+        var nextDepth = Math.max(stack[stack.length - 1].depth + 1, 1);
+        stack.push({
+          depth: nextDepth,
+          children: [],
+          listAttrs: item.isSelected ? null : item.parentListAttrs,
+          sourceParentAttrs: item.parentListAttrs
+        });
+      }
+
+      // Add the item at the target depth
+      if (targetDepth === 0) {
+        // Depth 0 items go directly into the root taskList
+        stack[0].children.push(item.node);
+      } else {
+        // Ensure there's a stack entry at depth targetDepth to hold this item
+        if (stack[stack.length - 1].depth < targetDepth) {
+          stack.push({
+            depth: targetDepth,
+            children: [],
+            listAttrs: item.isSelected ? null : item.parentListAttrs,
+            sourceParentAttrs: item.parentListAttrs
+          });
+        }
+        stack[stack.length - 1].children.push(item.node);
+      }
+    }
+
+    // Close remaining stack entries
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  while (stack.length > 1) {
+    var _popped$listAttrs;
+    var popped = stack.pop();
+    if (!popped) {
+      break;
+    }
+    var attrs = (_popped$listAttrs = popped.listAttrs) !== null && _popped$listAttrs !== void 0 ? _popped$listAttrs : {
+      localId: _adfSchema.uuid.generate()
+    };
+    var wrappedList = taskList.create(attrs, popped.children);
+    stack[stack.length - 1].children.push(wrappedList);
+  }
+
+  // The root entry's children form the root taskList.
+  // Preserve the root's original attrs when available.
+  var rootChildren = stack[0].children;
+  var rootAttrs = (_stack$0$listAttrs = stack[0].listAttrs) !== null && _stack$0$listAttrs !== void 0 ? _stack$0$listAttrs : {
+    localId: _adfSchema.uuid.generate()
+  };
+  var rootList = taskList.create(rootAttrs, rootChildren);
+
+  // Compute contentStartOffsets by walking the rebuilt tree.
+  // Each taskItem's content starts at (pos_within_root + 1) for the taskItem opening tag.
+  // We add +1 for the root taskList's opening tag.
+  var isTaskItemType = function isTaskItemType(node) {
+    var _schema$nodes = schema.nodes,
+      taskItem = _schema$nodes.taskItem,
+      blockTaskItem = _schema$nodes.blockTaskItem;
+    return node.type === taskItem || blockTaskItem != null && node.type === blockTaskItem;
+  };
+  var itemIdx = 0;
+  rootList.descendants(function (node, pos) {
+    if (isTaskItemType(node) && itemIdx < items.length) {
+      // pos is relative to rootList content start;
+      // +1 for rootList's opening tag, +1 for taskItem's opening tag
+      contentStartOffsets[itemIdx] = 1 + pos + 1;
+      itemIdx++;
+    }
+    return true;
+  });
+  return {
+    node: rootList,
+    contentStartOffsets: contentStartOffsets
+  };
+}

package/dist/es2019/pm-plugins/actions/move-selected-task-list-items.js

@@ -0,0 +1,92 @@
+import { buildReplacementFragment, computeSelectionOffsets, restoreSelection } from '@atlaskit/editor-common/lists';
+import { findFarthestParentNode } from '@atlaskit/editor-common/utils';
+import { flattenTaskList, rebuildTaskList } from '../task-list-indentation';
+const MAX_TASK_LIST_DEPTH = 6;
+export function moveSelectedTaskListItems(tr, indentDelta) {
+  const {
+    doc,
+    selection
+  } = tr;
+  const {
+    schema
+  } = doc.type;
+  const {
+    taskList
+  } = schema.nodes;
+  const {
+    $from,
+    $to
+  } = selection;
+  const rootListResult = findFarthestParentNode(node => node.type === taskList)($from);
+  if (!rootListResult) {
+    return null;
+  }
+  const rootListStart = rootListResult.pos;
+  const rootListEnd = rootListStart + rootListResult.node.nodeSize;
+  const flattenResult = flattenTaskList({
+    doc,
+    rootListStart,
+    rootListEnd,
+    selectionFrom: $from.pos,
+    selectionTo: $to.pos,
+    indentDelta,
+    maxDepth: MAX_TASK_LIST_DEPTH
+  });
+  if (!flattenResult) {
+    return null;
+  }
+  const {
+    items: flattenedItems,
+    startIndex,
+    endIndex
+  } = flattenResult;
+  const {
+    fragment,
+    contentStartOffsets
+  } = buildReplacementFragment({
+    items: flattenedItems,
+    schema,
+    rebuildFn: rebuildTaskList,
+    extractContentFn: (item, s) => {
+      // Extract task item content for breakout.
+      // taskItem has inline content, so wrap in a paragraph.
+      // blockTaskItem already has paragraph children.
+      const {
+        blockTaskItem
+      } = s.nodes;
+      if (blockTaskItem != null && item.node.type === blockTaskItem) {
+        // blockTaskItem children are already paragraphs/extensions
+        const children = [];
+        item.node.forEach(child => children.push(child));
+        return children;
+      }
+      // Regular taskItem — wrap inline content in a paragraph
+      return [s.nodes.paragraph.create(null, item.node.content)];
+    }
+  });
+  if (fragment.size === 0) {
+    return null;
+  }
+  tr.replaceWith(rootListStart, rootListEnd, fragment);
+  const {
+    from,
+    to
+  } = computeSelectionOffsets({
+    items: flattenedItems,
+    startIndex,
+    endIndex,
+    originalFrom: $from.pos,
+    originalTo: $to.pos,
+    contentStartOffsets,
+    rootListStart,
+    docSize: tr.doc.content.size
+  });
+  restoreSelection({
+    tr,
+    originalSelection: selection,
+    from,
+    to
+  });
+  tr.scrollIntoView();
+  return tr;
+}

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

@@ -11,6 +11,8 @@ import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
 import { TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { findParentNodeOfType, findParentNodeOfTypeClosestToPos, hasParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
 import { fg } from '@atlaskit/platform-feature-flags';
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { moveSelectedTaskListItems } from './actions/move-selected-task-list-items';
 import { joinAtCut, liftSelection, wrapSelectionInTaskList } from './commands';
 import { findFirstParentListNode, getBlockRange, getCurrentIndentLevel, getTaskItemIndex, isActionOrDecisionItem, isActionOrDecisionList, isEmptyTaskDecision, isInFirstTextblockOfBlockTaskItem, isInLastTextblockOfBlockTaskItem, isInsideDecision, isInsideTask, isInsideTaskOrDecisionItem, isTable, liftBlock, walkOut } from './helpers';
 import { insertTaskDecisionWithAnalytics } from './insert-commands';
@@ -89,6 +91,20 @@ const joinTaskDecisionFollowing = (state, dispatch) => {
 export const getUnindentCommand = editorAnalyticsAPI => (inputMethod = INPUT_METHOD.KEYBOARD) => filter(isInsideTask, (state, dispatch) => {
   const normalizedSelection = normalizeTaskItemsSelection(state.selection);
   const curIndentLevel = getCurrentIndentLevel(normalizedSelection);
+  if (expValEquals('platform_editor_flexible_list_indentation', 'isEnabled', true)) {
+    if (!curIndentLevel) {
+      return true;
+    }
+    const outdentTr = moveSelectedTaskListItems(state.tr, -1);
+    if (outdentTr) {
+      withAnalytics(editorAnalyticsAPI, indentationAnalytics(curIndentLevel, INDENT_DIRECTION.OUTDENT, inputMethod))((_state, d) => {
+        d === null || d === void 0 ? void 0 : d(outdentTr);
+        return true;
+      })(state, dispatch);
+      return true;
+    }
+    return false;
+  }
   if (!curIndentLevel || curIndentLevel === 1) {
     return false;
   }
@@ -115,6 +131,20 @@ const shouldLetTabThroughInTable = state => {
 export const getIndentCommand = editorAnalyticsAPI => (inputMethod = INPUT_METHOD.KEYBOARD) => filter(isInsideTask, (state, dispatch) => {
   const normalizedSelection = normalizeTaskItemsSelection(state.selection);
   const curIndentLevel = getCurrentIndentLevel(normalizedSelection);
+  if (expValEquals('platform_editor_flexible_list_indentation', 'isEnabled', true)) {
+    if (!curIndentLevel) {
+      return true;
+    }
+    const indentTr = moveSelectedTaskListItems(state.tr, 1);
+    if (indentTr) {
+      withAnalytics(editorAnalyticsAPI, indentationAnalytics(curIndentLevel, INDENT_DIRECTION.INDENT, inputMethod))((_state, d) => {
+        d === null || d === void 0 ? void 0 : d(indentTr);
+        return true;
+      })(state, dispatch);
+      return true;
+    }
+    return false;
+  }
   if (!curIndentLevel || curIndentLevel >= 6) {
     return true;
   }

package/dist/es2019/pm-plugins/task-list-indentation.js

@@ -0,0 +1,194 @@
+import { uuid } from '@atlaskit/adf-schema';
+import { flattenList as flattenListBase } from '@atlaskit/editor-common/lists';
+/**
+ * Flattens a taskList tree into an array of task items with computed depths.
+ * Only selected items have their depth adjusted by indentDelta.
+ *
+ * Delegates to the shared `flattenList` with task-list-specific callbacks.
+ */
+export function flattenTaskList(options) {
+  const {
+    taskList,
+    taskItem,
+    blockTaskItem
+  } = options.doc.type.schema.nodes;
+  return flattenListBase(options, {
+    isContentNode: (node, parent) => {
+      const isTaskItemType = node.type === taskItem || blockTaskItem != null && node.type === blockTaskItem;
+      return isTaskItemType && parent != null && parent.type === taskList;
+    },
+    getSelectionBounds: (node, pos) => ({
+      start: pos,
+      end: pos + node.nodeSize
+    }),
+    getDepth: (resolvedDepth, rootDepth) => resolvedDepth - rootDepth - 1
+  });
+}
+
+/**
+ * Rebuilds a taskList tree from a flattened array of task items.
+ * Uses a stack-based approach to create proper nesting.
+ *
+ * Preserves original taskList attributes (e.g. localId) for wrappers
+ * of unselected items. Only generates fresh UUIDs for newly-created
+ * nesting levels (i.e. when items were moved via indent/outdent).
+ *
+ * Given items with depths [A:0, B:1, C:2, D:1, E:0], produces:
+ *
+ * taskList
+ *   taskItem 'A'
+ *   taskList
+ *     taskItem 'B'
+ *     taskList
+ *       taskItem 'C'
+ *     taskItem 'D'
+ *   taskItem 'E'
+ *
+ * Also computes `contentStartOffsets`: for each item (by index),
+ * the offset within the returned fragment where the item's content
+ * begins. This is used for accurate selection restoration.
+ */
+export function rebuildTaskList(items, schema) {
+  var _stack$0$listAttrs;
+  const {
+    taskList
+  } = schema.nodes;
+  const contentStartOffsets = new Array(items.length);
+  if (items.length === 0) {
+    return null;
+  }
+
+  // Each stack entry collects children for a taskList at a given depth.
+  // The root entry (depth -1) is special: its children become the content
+  // of the outermost taskList directly (not wrapped in another taskList).
+  // Entries at depth >= 0 each produce a nested taskList when popped.
+  // listAttrs preserves the original parent's attributes when available.
+  // sourceParentAttrs tracks the original parent taskList attrs of the items
+  // in this entry, used to decide whether consecutive same-depth items
+  // should share a wrapper or be separated.
+
+  // Start with the root level (depth -1 represents the root taskList wrapper)
+  const stack = [{
+    depth: -1,
+    children: [],
+    listAttrs: items[0].parentListAttrs,
+    sourceParentAttrs: items[0].parentListAttrs
+  }];
+  for (const item of items) {
+    const targetDepth = item.depth;
+
+    // Pop stack entries strictly deeper than target, wrapping them into taskLists
+    while (stack.length > 1 && stack[stack.length - 1].depth > targetDepth) {
+      var _popped$listAttrs;
+      const popped = stack.pop();
+      if (!popped) {
+        break;
+      }
+      const attrs = (_popped$listAttrs = popped.listAttrs) !== null && _popped$listAttrs !== void 0 ? _popped$listAttrs : {
+        localId: uuid.generate()
+      };
+      const wrappedList = taskList.create(attrs, popped.children);
+      stack[stack.length - 1].children.push(wrappedList);
+    }
+
+    // If the stack top is at the same depth as the target, decide whether
+    // to merge into the existing entry or close it and start a new one.
+    // Unselected items from different original parent taskLists get
+    // separate wrappers (preserving original nesting). Selected (moved)
+    // items always merge with whatever is already at the target depth,
+    // since they're being placed into a new structural context.
+    if (stack.length > 1 && stack[stack.length - 1].depth === targetDepth && !item.isSelected) {
+      const top = stack[stack.length - 1];
+      if (top.sourceParentAttrs !== item.parentListAttrs) {
+        var _popped$listAttrs2;
+        const popped = stack.pop();
+        if (!popped) {
+          break;
+        }
+        const attrs = (_popped$listAttrs2 = popped.listAttrs) !== null && _popped$listAttrs2 !== void 0 ? _popped$listAttrs2 : {
+          localId: uuid.generate()
+        };
+        const wrappedList = taskList.create(attrs, popped.children);
+        stack[stack.length - 1].children.push(wrappedList);
+      }
+    }
+
+    // Push new stack entries to reach the target depth.
+    // Skip intermediate entries at depth 0 — depth-0 items belong
+    // directly in the root entry (depth -1), so we only need
+    // intermediates for depths > 1.
+    while (stack[stack.length - 1].depth < targetDepth - 1) {
+      const nextDepth = Math.max(stack[stack.length - 1].depth + 1, 1);
+      stack.push({
+        depth: nextDepth,
+        children: [],
+        listAttrs: item.isSelected ? null : item.parentListAttrs,
+        sourceParentAttrs: item.parentListAttrs
+      });
+    }
+
+    // Add the item at the target depth
+    if (targetDepth === 0) {
+      // Depth 0 items go directly into the root taskList
+      stack[0].children.push(item.node);
+    } else {
+      // Ensure there's a stack entry at depth targetDepth to hold this item
+      if (stack[stack.length - 1].depth < targetDepth) {
+        stack.push({
+          depth: targetDepth,
+          children: [],
+          listAttrs: item.isSelected ? null : item.parentListAttrs,
+          sourceParentAttrs: item.parentListAttrs
+        });
+      }
+      stack[stack.length - 1].children.push(item.node);
+    }
+  }
+
+  // Close remaining stack entries
+  while (stack.length > 1) {
+    var _popped$listAttrs3;
+    const popped = stack.pop();
+    if (!popped) {
+      break;
+    }
+    const attrs = (_popped$listAttrs3 = popped.listAttrs) !== null && _popped$listAttrs3 !== void 0 ? _popped$listAttrs3 : {
+      localId: uuid.generate()
+    };
+    const wrappedList = taskList.create(attrs, popped.children);
+    stack[stack.length - 1].children.push(wrappedList);
+  }
+
+  // The root entry's children form the root taskList.
+  // Preserve the root's original attrs when available.
+  const rootChildren = stack[0].children;
+  const rootAttrs = (_stack$0$listAttrs = stack[0].listAttrs) !== null && _stack$0$listAttrs !== void 0 ? _stack$0$listAttrs : {
+    localId: uuid.generate()
+  };
+  const rootList = taskList.create(rootAttrs, rootChildren);
+
+  // Compute contentStartOffsets by walking the rebuilt tree.
+  // Each taskItem's content starts at (pos_within_root + 1) for the taskItem opening tag.
+  // We add +1 for the root taskList's opening tag.
+  const isTaskItemType = node => {
+    const {
+      taskItem,
+      blockTaskItem
+    } = schema.nodes;
+    return node.type === taskItem || blockTaskItem != null && node.type === blockTaskItem;
+  };
+  let itemIdx = 0;
+  rootList.descendants((node, pos) => {
+    if (isTaskItemType(node) && itemIdx < items.length) {
+      // pos is relative to rootList content start;
+      // +1 for rootList's opening tag, +1 for taskItem's opening tag
+      contentStartOffsets[itemIdx] = 1 + pos + 1;
+      itemIdx++;
+    }
+    return true;
+  });
+  return {
+    node: rootList,
+    contentStartOffsets
+  };
+}

package/dist/esm/pm-plugins/actions/move-selected-task-list-items.js

@@ -0,0 +1,82 @@
+import { buildReplacementFragment, computeSelectionOffsets, restoreSelection } from '@atlaskit/editor-common/lists';
+import { findFarthestParentNode } from '@atlaskit/editor-common/utils';
+import { flattenTaskList, rebuildTaskList } from '../task-list-indentation';
+var MAX_TASK_LIST_DEPTH = 6;
+export function moveSelectedTaskListItems(tr, indentDelta) {
+  var doc = tr.doc,
+    selection = tr.selection;
+  var schema = doc.type.schema;
+  var taskList = schema.nodes.taskList;
+  var $from = selection.$from,
+    $to = selection.$to;
+  var rootListResult = findFarthestParentNode(function (node) {
+    return node.type === taskList;
+  })($from);
+  if (!rootListResult) {
+    return null;
+  }
+  var rootListStart = rootListResult.pos;
+  var rootListEnd = rootListStart + rootListResult.node.nodeSize;
+  var flattenResult = flattenTaskList({
+    doc: doc,
+    rootListStart: rootListStart,
+    rootListEnd: rootListEnd,
+    selectionFrom: $from.pos,
+    selectionTo: $to.pos,
+    indentDelta: indentDelta,
+    maxDepth: MAX_TASK_LIST_DEPTH
+  });
+  if (!flattenResult) {
+    return null;
+  }
+  var flattenedItems = flattenResult.items,
+    startIndex = flattenResult.startIndex,
+    endIndex = flattenResult.endIndex;
+  var _buildReplacementFrag = buildReplacementFragment({
+      items: flattenedItems,
+      schema: schema,
+      rebuildFn: rebuildTaskList,
+      extractContentFn: function extractContentFn(item, s) {
+        // Extract task item content for breakout.
+        // taskItem has inline content, so wrap in a paragraph.
+        // blockTaskItem already has paragraph children.
+        var blockTaskItem = s.nodes.blockTaskItem;
+        if (blockTaskItem != null && item.node.type === blockTaskItem) {
+          // blockTaskItem children are already paragraphs/extensions
+          var children = [];
+          item.node.forEach(function (child) {
+            return children.push(child);
+          });
+          return children;
+        }
+        // Regular taskItem — wrap inline content in a paragraph
+        return [s.nodes.paragraph.create(null, item.node.content)];
+      }
+    }),
+    fragment = _buildReplacementFrag.fragment,
+    contentStartOffsets = _buildReplacementFrag.contentStartOffsets;
+  if (fragment.size === 0) {
+    return null;
+  }
+  tr.replaceWith(rootListStart, rootListEnd, fragment);
+  var _computeSelectionOffs = computeSelectionOffsets({
+      items: flattenedItems,
+      startIndex: startIndex,
+      endIndex: endIndex,
+      originalFrom: $from.pos,
+      originalTo: $to.pos,
+      contentStartOffsets: contentStartOffsets,
+      rootListStart: rootListStart,
+      docSize: tr.doc.content.size
+    }),
+    from = _computeSelectionOffs.from,
+    to = _computeSelectionOffs.to;
+  restoreSelection({
+    tr: tr,
+    originalSelection: selection,
+    from: from,
+    to: to
+  });
+  tr.scrollIntoView();
+  return tr;
+}

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

@@ -14,6 +14,8 @@ import { Fragment, Slice } from '@atlaskit/editor-prosemirror/model';
 import { TextSelection } from '@atlaskit/editor-prosemirror/state';
 import { findParentNodeOfType, findParentNodeOfTypeClosestToPos, hasParentNodeOfType } from '@atlaskit/editor-prosemirror/utils';
 import { fg } from '@atlaskit/platform-feature-flags';
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { moveSelectedTaskListItems } from './actions/move-selected-task-list-items';
 import { joinAtCut, liftSelection, wrapSelectionInTaskList } from './commands';
 import { findFirstParentListNode, getBlockRange, getCurrentIndentLevel, getTaskItemIndex, isActionOrDecisionItem, isActionOrDecisionList, isEmptyTaskDecision, isInFirstTextblockOfBlockTaskItem, isInLastTextblockOfBlockTaskItem, isInsideDecision, isInsideTask, isInsideTaskOrDecisionItem, isTable, liftBlock, walkOut } from './helpers';
 import { insertTaskDecisionWithAnalytics } from './insert-commands';
@@ -98,6 +100,20 @@ export var getUnindentCommand = function getUnindentCommand(editorAnalyticsAPI)
     return filter(isInsideTask, function (state, dispatch) {
       var normalizedSelection = normalizeTaskItemsSelection(state.selection);
       var curIndentLevel = getCurrentIndentLevel(normalizedSelection);
+      if (expValEquals('platform_editor_flexible_list_indentation', 'isEnabled', true)) {
+        if (!curIndentLevel) {
+          return true;
+        }
+        var outdentTr = moveSelectedTaskListItems(state.tr, -1);
+        if (outdentTr) {
+          withAnalytics(editorAnalyticsAPI, indentationAnalytics(curIndentLevel, INDENT_DIRECTION.OUTDENT, inputMethod))(function (_state, d) {
+            d === null || d === void 0 || d(outdentTr);
+            return true;
+          })(state, dispatch);
+          return true;
+        }
+        return false;
+      }
       if (!curIndentLevel || curIndentLevel === 1) {
         return false;
       }
@@ -128,6 +144,20 @@ export var getIndentCommand = function getIndentCommand(editorAnalyticsAPI) {
     return filter(isInsideTask, function (state, dispatch) {
       var normalizedSelection = normalizeTaskItemsSelection(state.selection);
       var curIndentLevel = getCurrentIndentLevel(normalizedSelection);
+      if (expValEquals('platform_editor_flexible_list_indentation', 'isEnabled', true)) {
+        if (!curIndentLevel) {
+          return true;
+        }
+        var indentTr = moveSelectedTaskListItems(state.tr, 1);
+        if (indentTr) {
+          withAnalytics(editorAnalyticsAPI, indentationAnalytics(curIndentLevel, INDENT_DIRECTION.INDENT, inputMethod))(function (_state, d) {
+            d === null || d === void 0 || d(indentTr);
+            return true;
+          })(state, dispatch);
+          return true;
+        }
+        return false;
+      }
       if (!curIndentLevel || curIndentLevel >= 6) {
         return true;
       }

package/dist/esm/pm-plugins/task-list-indentation.js

@@ -0,0 +1,206 @@
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import { uuid } from '@atlaskit/adf-schema';
+import { flattenList as flattenListBase } from '@atlaskit/editor-common/lists';
+/**
+ * Flattens a taskList tree into an array of task items with computed depths.
+ * Only selected items have their depth adjusted by indentDelta.
+ *
+ * Delegates to the shared `flattenList` with task-list-specific callbacks.
+ */
+export function flattenTaskList(options) {
+  var _options$doc$type$sch = options.doc.type.schema.nodes,
+    taskList = _options$doc$type$sch.taskList,
+    taskItem = _options$doc$type$sch.taskItem,
+    blockTaskItem = _options$doc$type$sch.blockTaskItem;
+  return flattenListBase(options, {
+    isContentNode: function isContentNode(node, parent) {
+      var isTaskItemType = node.type === taskItem || blockTaskItem != null && node.type === blockTaskItem;
+      return isTaskItemType && parent != null && parent.type === taskList;
+    },
+    getSelectionBounds: function getSelectionBounds(node, pos) {
+      return {
+        start: pos,
+        end: pos + node.nodeSize
+      };
+    },
+    getDepth: function getDepth(resolvedDepth, rootDepth) {
+      return resolvedDepth - rootDepth - 1;
+    }
+  });
+}
+
+/**
+ * Rebuilds a taskList tree from a flattened array of task items.
+ * Uses a stack-based approach to create proper nesting.
+ *
+ * Preserves original taskList attributes (e.g. localId) for wrappers
+ * of unselected items. Only generates fresh UUIDs for newly-created
+ * nesting levels (i.e. when items were moved via indent/outdent).
+ *
+ * Given items with depths [A:0, B:1, C:2, D:1, E:0], produces:
+ *
+ * taskList
+ *   taskItem 'A'
+ *   taskList
+ *     taskItem 'B'
+ *     taskList
+ *       taskItem 'C'
+ *     taskItem 'D'
+ *   taskItem 'E'
+ *
+ * Also computes `contentStartOffsets`: for each item (by index),
+ * the offset within the returned fragment where the item's content
+ * begins. This is used for accurate selection restoration.
+ */
+export function rebuildTaskList(items, schema) {
+  var _stack$0$listAttrs;
+  var taskList = schema.nodes.taskList;
+  var contentStartOffsets = new Array(items.length);
+  if (items.length === 0) {
+    return null;
+  }
+
+  // Each stack entry collects children for a taskList at a given depth.
+  // The root entry (depth -1) is special: its children become the content
+  // of the outermost taskList directly (not wrapped in another taskList).
+  // Entries at depth >= 0 each produce a nested taskList when popped.
+  // listAttrs preserves the original parent's attributes when available.
+  // sourceParentAttrs tracks the original parent taskList attrs of the items
+  // in this entry, used to decide whether consecutive same-depth items
+  // should share a wrapper or be separated.
+
+  // Start with the root level (depth -1 represents the root taskList wrapper)
+  var stack = [{
+    depth: -1,
+    children: [],
+    listAttrs: items[0].parentListAttrs,
+    sourceParentAttrs: items[0].parentListAttrs
+  }];
+  var _iterator = _createForOfIteratorHelper(items),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var item = _step.value;
+      var targetDepth = item.depth;
+
+      // Pop stack entries strictly deeper than target, wrapping them into taskLists
+      while (stack.length > 1 && stack[stack.length - 1].depth > targetDepth) {
+        var _popped$listAttrs2;
+        var _popped = stack.pop();
+        if (!_popped) {
+          break;
+        }
+        var _attrs = (_popped$listAttrs2 = _popped.listAttrs) !== null && _popped$listAttrs2 !== void 0 ? _popped$listAttrs2 : {
+          localId: uuid.generate()
+        };
+        var _wrappedList = taskList.create(_attrs, _popped.children);
+        stack[stack.length - 1].children.push(_wrappedList);
+      }
+
+      // If the stack top is at the same depth as the target, decide whether
+      // to merge into the existing entry or close it and start a new one.
+      // Unselected items from different original parent taskLists get
+      // separate wrappers (preserving original nesting). Selected (moved)
+      // items always merge with whatever is already at the target depth,
+      // since they're being placed into a new structural context.
+      if (stack.length > 1 && stack[stack.length - 1].depth === targetDepth && !item.isSelected) {
+        var top = stack[stack.length - 1];
+        if (top.sourceParentAttrs !== item.parentListAttrs) {
+          var _popped2$listAttrs;
+          var _popped2 = stack.pop();
+          if (!_popped2) {
+            break;
+          }
+          var _attrs2 = (_popped2$listAttrs = _popped2.listAttrs) !== null && _popped2$listAttrs !== void 0 ? _popped2$listAttrs : {
+            localId: uuid.generate()
+          };
+          var _wrappedList2 = taskList.create(_attrs2, _popped2.children);
+          stack[stack.length - 1].children.push(_wrappedList2);
+        }
+      }
+
+      // Push new stack entries to reach the target depth.
+      // Skip intermediate entries at depth 0 — depth-0 items belong
+      // directly in the root entry (depth -1), so we only need
+      // intermediates for depths > 1.
+      while (stack[stack.length - 1].depth < targetDepth - 1) {
+        var nextDepth = Math.max(stack[stack.length - 1].depth + 1, 1);
+        stack.push({
+          depth: nextDepth,
+          children: [],
+          listAttrs: item.isSelected ? null : item.parentListAttrs,
+          sourceParentAttrs: item.parentListAttrs
+        });
+      }
+
+      // Add the item at the target depth
+      if (targetDepth === 0) {
+        // Depth 0 items go directly into the root taskList
+        stack[0].children.push(item.node);
+      } else {
+        // Ensure there's a stack entry at depth targetDepth to hold this item
+        if (stack[stack.length - 1].depth < targetDepth) {
+          stack.push({
+            depth: targetDepth,
+            children: [],
+            listAttrs: item.isSelected ? null : item.parentListAttrs,
+            sourceParentAttrs: item.parentListAttrs
+          });
+        }
+        stack[stack.length - 1].children.push(item.node);
+      }
+    }
+
+    // Close remaining stack entries
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  while (stack.length > 1) {
+    var _popped$listAttrs;
+    var popped = stack.pop();
+    if (!popped) {
+      break;
+    }
+    var attrs = (_popped$listAttrs = popped.listAttrs) !== null && _popped$listAttrs !== void 0 ? _popped$listAttrs : {
+      localId: uuid.generate()
+    };
+    var wrappedList = taskList.create(attrs, popped.children);
+    stack[stack.length - 1].children.push(wrappedList);
+  }
+
+  // The root entry's children form the root taskList.
+  // Preserve the root's original attrs when available.
+  var rootChildren = stack[0].children;
+  var rootAttrs = (_stack$0$listAttrs = stack[0].listAttrs) !== null && _stack$0$listAttrs !== void 0 ? _stack$0$listAttrs : {
+    localId: uuid.generate()
+  };
+  var rootList = taskList.create(rootAttrs, rootChildren);
+
+  // Compute contentStartOffsets by walking the rebuilt tree.
+  // Each taskItem's content starts at (pos_within_root + 1) for the taskItem opening tag.
+  // We add +1 for the root taskList's opening tag.
+  var isTaskItemType = function isTaskItemType(node) {
+    var _schema$nodes = schema.nodes,
+      taskItem = _schema$nodes.taskItem,
+      blockTaskItem = _schema$nodes.blockTaskItem;
+    return node.type === taskItem || blockTaskItem != null && node.type === blockTaskItem;
+  };
+  var itemIdx = 0;
+  rootList.descendants(function (node, pos) {
+    if (isTaskItemType(node) && itemIdx < items.length) {
+      // pos is relative to rootList content start;
+      // +1 for rootList's opening tag, +1 for taskItem's opening tag
+      contentStartOffsets[itemIdx] = 1 + pos + 1;
+      itemIdx++;
+    }
+    return true;
+  });
+  return {
+    node: rootList,
+    contentStartOffsets: contentStartOffsets
+  };
+}

package/dist/types/pm-plugins/actions/move-selected-task-list-items.d.ts

@@ -0,0 +1,2 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function moveSelectedTaskListItems(tr: Transaction, indentDelta: number): Transaction | null;

package/dist/types/pm-plugins/task-list-indentation.d.ts

@@ -0,0 +1,36 @@
+import { type FlattenedItem, type FlattenListOptions, type FlattenListResult } from '@atlaskit/editor-common/lists';
+import type { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Flattens a taskList tree into an array of task items with computed depths.
+ * Only selected items have their depth adjusted by indentDelta.
+ *
+ * Delegates to the shared `flattenList` with task-list-specific callbacks.
+ */
+export declare function flattenTaskList(options: FlattenListOptions): FlattenListResult | null;
+/**
+ * Rebuilds a taskList tree from a flattened array of task items.
+ * Uses a stack-based approach to create proper nesting.
+ *
+ * Preserves original taskList attributes (e.g. localId) for wrappers
+ * of unselected items. Only generates fresh UUIDs for newly-created
+ * nesting levels (i.e. when items were moved via indent/outdent).
+ *
+ * Given items with depths [A:0, B:1, C:2, D:1, E:0], produces:
+ *
+ * taskList
+ *   taskItem 'A'
+ *   taskList
+ *     taskItem 'B'
+ *     taskList
+ *       taskItem 'C'
+ *     taskItem 'D'
+ *   taskItem 'E'
+ *
+ * Also computes `contentStartOffsets`: for each item (by index),
+ * the offset within the returned fragment where the item's content
+ * begins. This is used for accurate selection restoration.
+ */
+export declare function rebuildTaskList(items: FlattenedItem[], schema: Schema): {
+    contentStartOffsets: number[];
+    node: PMNode;
+} | null;

package/dist/types-ts4.5/pm-plugins/actions/move-selected-task-list-items.d.ts

@@ -0,0 +1,2 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+export declare function moveSelectedTaskListItems(tr: Transaction, indentDelta: number): Transaction | null;

package/dist/types-ts4.5/pm-plugins/task-list-indentation.d.ts

@@ -0,0 +1,36 @@
+import { type FlattenedItem, type FlattenListOptions, type FlattenListResult } from '@atlaskit/editor-common/lists';
+import type { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+/**
+ * Flattens a taskList tree into an array of task items with computed depths.
+ * Only selected items have their depth adjusted by indentDelta.
+ *
+ * Delegates to the shared `flattenList` with task-list-specific callbacks.
+ */
+export declare function flattenTaskList(options: FlattenListOptions): FlattenListResult | null;
+/**
+ * Rebuilds a taskList tree from a flattened array of task items.
+ * Uses a stack-based approach to create proper nesting.
+ *
+ * Preserves original taskList attributes (e.g. localId) for wrappers
+ * of unselected items. Only generates fresh UUIDs for newly-created
+ * nesting levels (i.e. when items were moved via indent/outdent).
+ *
+ * Given items with depths [A:0, B:1, C:2, D:1, E:0], produces:
+ *
+ * taskList
+ *   taskItem 'A'
+ *   taskList
+ *     taskItem 'B'
+ *     taskList
+ *       taskItem 'C'
+ *     taskItem 'D'
+ *   taskItem 'E'
+ *
+ * Also computes `contentStartOffsets`: for each item (by index),
+ * the offset within the returned fragment where the item's content
+ * begins. This is used for accurate selection restoration.
+ */
+export declare function rebuildTaskList(items: FlattenedItem[], schema: Schema): {
+    contentStartOffsets: number[];
+    node: PMNode;
+} | null;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-tasks-and-decisions",
-	"version": "11.2.1",
+	"version": "11.3.0",
 	"description": "Tasks and decisions plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -49,14 +49,14 @@
 		"@atlaskit/primitives": "^18.0.0",
 		"@atlaskit/prosemirror-input-rules": "^3.6.0",
 		"@atlaskit/task-decision": "^19.3.0",
-		"@atlaskit/tmp-editor-statsig": "^44.0.0",
+		"@atlaskit/tmp-editor-statsig": "^44.1.0",
 		"@atlaskit/tokens": "^11.1.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^0.20.0",
 		"bind-event-listener": "^3.0.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^112.7.0",
+		"@atlaskit/editor-common": "^112.8.0",
 		"react": "^18.2.0",
 		"react-dom": "^18.2.0",
 		"react-intl-next": "npm:react-intl@^5.18.1"