@atlaskit/editor-plugin-tasks-and-decisions 13.0.1 → 13.0.3

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @atlaskit/editor-plugin-tasks-and-decisions
 
+## 13.0.3
+
+### Patch Changes
+
+- Updated dependencies
+
+## 13.0.2
+
+### Patch Changes
+
+- [`402738b592e0b`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/402738b592e0b) -
+  Fix invalid flexible list structures caused by delete, paste, and typing operations.
+
+  Under platform_editor_flexible_list_schema, operations that remove content spanning list or task
+  list items could leave nodes with a nested list as their first child instead of a required
+  paragraph/item. Normalisation now runs efficiently on all relevant transactions in
+  appendTransaction.
+
+- Updated dependencies
+
 ## 13.0.1
 
 ### Patch Changes

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

@@ -15,12 +15,14 @@ var _utils = require("@atlaskit/editor-common/utils");
 var _state = require("@atlaskit/editor-prosemirror/state");
 var _view = require("@atlaskit/editor-prosemirror/view");
 var _expValEquals = require("@atlaskit/tmp-editor-statsig/exp-val-equals");
+var _expValEqualsNoExposure = require("@atlaskit/tmp-editor-statsig/exp-val-equals-no-exposure");
 var _DecisionItemNodeView = require("../nodeviews/DecisionItemNodeView");
 var _taskNodeView = require("../nodeviews/task-node-view");
 var _actions = require("./actions");
 var _helpers = require("./helpers");
 var _pluginKey = require("./plugin-key");
 var _taskItemOnChange = require("./taskItemOnChange");
+var _transforms = require("./transforms");
 var _types = require("./types");
 var _paste = require("./utils/paste");
 var _excluded = ["localId"];
@@ -268,6 +270,26 @@ function createPlugin(portalProviderAPI, eventDispatcher, dispatch, api, getIntl
      * Note: we currently do not handle the edge case where two nodes may have the same localId
      */
     appendTransaction: function appendTransaction(transactions, _oldState, newState) {
+      // Normalise taskList structure first — runs on its own transaction (without addToHistory: false)
+      // so it is included in history and correctly undone with the triggering operation.
+      if ((0, _expValEqualsNoExposure.expValEqualsNoExposure)('platform_editor_flexible_list_schema', 'isEnabled', true) && transactions.some(function (t) {
+        return t.docChanged;
+      })) {
+        var normTr = (0, _transforms.applyTaskListNormalisationFixes)({
+          tr: newState.tr,
+          transactions: transactions,
+          doc: newState.doc,
+          schema: newState.schema
+        });
+        if (normTr.docChanged) {
+          // Return the normalisation transaction — the next appendTransaction call will
+          // assign any missing localIds to newly inserted nodes via the localId path below.
+          return normTr;
+        }
+      }
+
+      // Assign unique localIds to any new nodes that don't have one.
+      // Runs with addToHistory: false so localId assignment is not part of the undo history.
       var tr = newState.tr;
       var modified = false;
       transactions.forEach(function (transaction) {

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

@@ -0,0 +1,150 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyTaskListNormalisationFixes = applyTaskListNormalisationFixes;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _transform = require("@atlaskit/editor-prosemirror/transform");
+var _expValEqualsNoExposure = require("@atlaskit/tmp-editor-statsig/exp-val-equals-no-exposure");
+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; }
+function getAffectedTaskListsFromTransactions(transactions, doc, schema) {
+  var taskList = schema.nodes.taskList;
+  if (!taskList) {
+    return new Map();
+  }
+  var result = new Map();
+  var _iterator = _createForOfIteratorHelper(transactions),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var tr = _step.value;
+      var _iterator2 = _createForOfIteratorHelper(tr.steps),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var step = _step2.value;
+          // ReplaceStep and ReplaceAroundStep both have from/to — other step types are skipped.
+          if (!(step instanceof _transform.ReplaceStep) && !(step instanceof _transform.ReplaceAroundStep)) {
+            continue;
+          }
+          // Check both the start and end of each changed range, mapped to post-transaction positions.
+          for (var _i = 0, _arr = [step.from, step.to]; _i < _arr.length; _i++) {
+            var rawPos = _arr[_i];
+            var mappedPos = Math.min(tr.mapping.map(rawPos), doc.content.size - 1);
+            var $pos = doc.resolve(mappedPos);
+            // Walk ancestors from inner to outer, recording the outermost taskList node.
+            // Once we find a taskList and then exit list structure (hit a non-taskList ancestor),
+            // break early — prevents container nodes (e.g. panel) from causing us to
+            // return an outer taskList in a different structural context.
+            var rootTaskListPos = null;
+            var rootTaskListNode = null;
+            for (var depth = $pos.depth; depth >= 0; depth--) {
+              var node = $pos.node(depth);
+              if (node.type === taskList) {
+                rootTaskListPos = $pos.before(depth);
+                rootTaskListNode = node;
+              } else if (rootTaskListNode !== null && node.type !== schema.nodes.taskItem) {
+                // We've exited the taskList structure — stop walking.
+                break;
+              }
+            }
+            if (rootTaskListPos !== null && rootTaskListNode !== null) {
+              result.set(rootTaskListPos, rootTaskListNode);
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+function applyTaskListNormalisationFixes(_ref) {
+  var doc = _ref.doc,
+    schema = _ref.schema,
+    tr = _ref.tr,
+    transactions = _ref.transactions;
+  var _schema$nodes = schema.nodes,
+    taskList = _schema$nodes.taskList,
+    taskItem = _schema$nodes.taskItem;
+  if (!taskList || !taskItem) {
+    return tr;
+  }
+  var affectedTaskLists = getAffectedTaskListsFromTransactions(transactions, doc, schema);
+  if (affectedTaskLists.size === 0) {
+    return tr;
+  }
+
+  // Sort by position descending so we process deeper/later positions first,
+  // preventing earlier insertions from shifting later positions.
+  var sortedEntries = (0, _toConsumableArray2.default)(affectedTaskLists.entries()).sort(function (_ref2, _ref3) {
+    var _ref4 = (0, _slicedToArray2.default)(_ref2, 1),
+      a = _ref4[0];
+    var _ref5 = (0, _slicedToArray2.default)(_ref3, 1),
+      b = _ref5[0];
+    return b - a;
+  });
+  var _iterator3 = _createForOfIteratorHelper(sortedEntries),
+    _step3;
+  try {
+    var _loop = function _loop() {
+      var _step3$value = (0, _slicedToArray2.default)(_step3.value, 1),
+        taskListPos = _step3$value[0];
+      // Re-resolve the taskList node from the current transaction doc (post-operation state).
+      var mappedTaskListPos = tr.mapping.map(taskListPos);
+      var currentTaskListNode = tr.doc.nodeAt(mappedTaskListPos);
+      if (!currentTaskListNode) {
+        return 1; // continue
+      }
+      if (!(0, _expValEqualsNoExposure.expValEqualsNoExposure)('platform_editor_flexible_list_indentation', 'isEnabled', true)) {
+        // Collect positions of all taskList nodes (at any depth) whose direct children
+        // include a taskList — this is the invalid structure. The taskList schema requires
+        // taskItem as children, not nested taskLists directly.
+        // Process in reverse order so higher-position insertions don't shift lower positions.
+        var invalidTaskListPositions = [];
+        currentTaskListNode.descendants(function (node, offsetPos) {
+          if (node.type === taskList) {
+            // A taskList as the FIRST child of another taskList is invalid — it means a
+            // delete or paste removed the leading taskItem, leaving a bare nested list.
+            // A taskList that follows a taskItem is valid (that's normal indentation).
+            var firstChild = node.firstChild;
+            if (firstChild && firstChild.type === taskList) {
+              var pos = mappedTaskListPos + 1 + offsetPos + 1;
+              invalidTaskListPositions.push(pos);
+            }
+          }
+          return true;
+        });
+
+        // Process in reverse (highest positions first).
+        for (var i = invalidTaskListPositions.length - 1; i >= 0; i--) {
+          var remappedPos = tr.mapping.map(invalidTaskListPositions[i]);
+          var emptyTaskItem = taskItem.createAndFill();
+          if (emptyTaskItem) {
+            tr.insert(remappedPos, emptyTaskItem);
+          }
+        }
+      }
+    };
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      if (_loop()) continue;
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return tr;
+}

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

@@ -6,12 +6,14 @@ import { getStepRange } from '@atlaskit/editor-common/utils';
 import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
 import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { expValEqualsNoExposure } from '@atlaskit/tmp-editor-statsig/exp-val-equals-no-exposure';
 import { DecisionItemNodeView } from '../nodeviews/DecisionItemNodeView';
 import { taskView } from '../nodeviews/task-node-view';
-import { focusTaskDecision, setProvider, openRequestEditPopup } from './actions';
+import { focusTaskDecision, openRequestEditPopup, setProvider } from './actions';
 import { focusCheckbox, focusCheckboxAndUpdateSelection, getTaskItemDataAtPos, getTaskItemDataToFocus, isInsideTask, removeCheckboxFocus } from './helpers';
 import { stateKey } from './plugin-key';
 import { taskItemOnChange } from './taskItemOnChange';
+import { applyTaskListNormalisationFixes } from './transforms';
 import { ACTIONS } from './types';
 import { tempTransformSliceToRemoveBlockTaskItem } from './utils/paste';
 function nodesBetweenChanged(tr, f, startPos) {
@@ -264,6 +266,24 @@ export function createPlugin(portalProviderAPI, eventDispatcher, dispatch, api,
      * Note: we currently do not handle the edge case where two nodes may have the same localId
      */
     appendTransaction: (transactions, _oldState, newState) => {
+      // Normalise taskList structure first — runs on its own transaction (without addToHistory: false)
+      // so it is included in history and correctly undone with the triggering operation.
+      if (expValEqualsNoExposure('platform_editor_flexible_list_schema', 'isEnabled', true) && transactions.some(t => t.docChanged)) {
+        const normTr = applyTaskListNormalisationFixes({
+          tr: newState.tr,
+          transactions,
+          doc: newState.doc,
+          schema: newState.schema
+        });
+        if (normTr.docChanged) {
+          // Return the normalisation transaction — the next appendTransaction call will
+          // assign any missing localIds to newly inserted nodes via the localId path below.
+          return normTr;
+        }
+      }
+
+      // Assign unique localIds to any new nodes that don't have one.
+      // Runs with addToHistory: false so localId assignment is not part of the undo history.
       const tr = newState.tr;
       let modified = false;
       transactions.forEach(transaction => {

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

@@ -0,0 +1,104 @@
+import { ReplaceAroundStep, ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import { expValEqualsNoExposure } from '@atlaskit/tmp-editor-statsig/exp-val-equals-no-exposure';
+function getAffectedTaskListsFromTransactions(transactions, doc, schema) {
+  const {
+    taskList
+  } = schema.nodes;
+  if (!taskList) {
+    return new Map();
+  }
+  const result = new Map();
+  for (const tr of transactions) {
+    for (const step of tr.steps) {
+      // ReplaceStep and ReplaceAroundStep both have from/to — other step types are skipped.
+      if (!(step instanceof ReplaceStep) && !(step instanceof ReplaceAroundStep)) {
+        continue;
+      }
+      // Check both the start and end of each changed range, mapped to post-transaction positions.
+      for (const rawPos of [step.from, step.to]) {
+        const mappedPos = Math.min(tr.mapping.map(rawPos), doc.content.size - 1);
+        const $pos = doc.resolve(mappedPos);
+        // Walk ancestors from inner to outer, recording the outermost taskList node.
+        // Once we find a taskList and then exit list structure (hit a non-taskList ancestor),
+        // break early — prevents container nodes (e.g. panel) from causing us to
+        // return an outer taskList in a different structural context.
+        let rootTaskListPos = null;
+        let rootTaskListNode = null;
+        for (let depth = $pos.depth; depth >= 0; depth--) {
+          const node = $pos.node(depth);
+          if (node.type === taskList) {
+            rootTaskListPos = $pos.before(depth);
+            rootTaskListNode = node;
+          } else if (rootTaskListNode !== null && node.type !== schema.nodes.taskItem) {
+            // We've exited the taskList structure — stop walking.
+            break;
+          }
+        }
+        if (rootTaskListPos !== null && rootTaskListNode !== null) {
+          result.set(rootTaskListPos, rootTaskListNode);
+        }
+      }
+    }
+  }
+  return result;
+}
+export function applyTaskListNormalisationFixes({
+  doc,
+  schema,
+  tr,
+  transactions
+}) {
+  const {
+    taskList,
+    taskItem
+  } = schema.nodes;
+  if (!taskList || !taskItem) {
+    return tr;
+  }
+  const affectedTaskLists = getAffectedTaskListsFromTransactions(transactions, doc, schema);
+  if (affectedTaskLists.size === 0) {
+    return tr;
+  }
+
+  // Sort by position descending so we process deeper/later positions first,
+  // preventing earlier insertions from shifting later positions.
+  const sortedEntries = [...affectedTaskLists.entries()].sort(([a], [b]) => b - a);
+  for (const [taskListPos] of sortedEntries) {
+    // Re-resolve the taskList node from the current transaction doc (post-operation state).
+    const mappedTaskListPos = tr.mapping.map(taskListPos);
+    const currentTaskListNode = tr.doc.nodeAt(mappedTaskListPos);
+    if (!currentTaskListNode) {
+      continue;
+    }
+    if (!expValEqualsNoExposure('platform_editor_flexible_list_indentation', 'isEnabled', true)) {
+      // Collect positions of all taskList nodes (at any depth) whose direct children
+      // include a taskList — this is the invalid structure. The taskList schema requires
+      // taskItem as children, not nested taskLists directly.
+      // Process in reverse order so higher-position insertions don't shift lower positions.
+      const invalidTaskListPositions = [];
+      currentTaskListNode.descendants((node, offsetPos) => {
+        if (node.type === taskList) {
+          // A taskList as the FIRST child of another taskList is invalid — it means a
+          // delete or paste removed the leading taskItem, leaving a bare nested list.
+          // A taskList that follows a taskItem is valid (that's normal indentation).
+          const firstChild = node.firstChild;
+          if (firstChild && firstChild.type === taskList) {
+            const pos = mappedTaskListPos + 1 + offsetPos + 1;
+            invalidTaskListPositions.push(pos);
+          }
+        }
+        return true;
+      });
+
+      // Process in reverse (highest positions first).
+      for (let i = invalidTaskListPositions.length - 1; i >= 0; i--) {
+        const remappedPos = tr.mapping.map(invalidTaskListPositions[i]);
+        const emptyTaskItem = taskItem.createAndFill();
+        if (emptyTaskItem) {
+          tr.insert(remappedPos, emptyTaskItem);
+        }
+      }
+    }
+  }
+  return tr;
+}

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

@@ -11,12 +11,14 @@ import { getStepRange } from '@atlaskit/editor-common/utils';
 import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
 import { Decoration, DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { expValEqualsNoExposure } from '@atlaskit/tmp-editor-statsig/exp-val-equals-no-exposure';
 import { DecisionItemNodeView } from '../nodeviews/DecisionItemNodeView';
 import { taskView } from '../nodeviews/task-node-view';
-import { focusTaskDecision, setProvider, openRequestEditPopup } from './actions';
+import { focusTaskDecision, openRequestEditPopup, setProvider } from './actions';
 import { focusCheckbox, focusCheckboxAndUpdateSelection, getTaskItemDataAtPos, getTaskItemDataToFocus, isInsideTask, removeCheckboxFocus } from './helpers';
 import { stateKey } from './plugin-key';
 import { taskItemOnChange } from './taskItemOnChange';
+import { applyTaskListNormalisationFixes } from './transforms';
 import { ACTIONS } from './types';
 import { tempTransformSliceToRemoveBlockTaskItem } from './utils/paste';
 function nodesBetweenChanged(tr, f, startPos) {
@@ -261,6 +263,26 @@ export function createPlugin(portalProviderAPI, eventDispatcher, dispatch, api,
      * Note: we currently do not handle the edge case where two nodes may have the same localId
      */
     appendTransaction: function appendTransaction(transactions, _oldState, newState) {
+      // Normalise taskList structure first — runs on its own transaction (without addToHistory: false)
+      // so it is included in history and correctly undone with the triggering operation.
+      if (expValEqualsNoExposure('platform_editor_flexible_list_schema', 'isEnabled', true) && transactions.some(function (t) {
+        return t.docChanged;
+      })) {
+        var normTr = applyTaskListNormalisationFixes({
+          tr: newState.tr,
+          transactions: transactions,
+          doc: newState.doc,
+          schema: newState.schema
+        });
+        if (normTr.docChanged) {
+          // Return the normalisation transaction — the next appendTransaction call will
+          // assign any missing localIds to newly inserted nodes via the localId path below.
+          return normTr;
+        }
+      }
+
+      // Assign unique localIds to any new nodes that don't have one.
+      // Runs with addToHistory: false so localId assignment is not part of the undo history.
       var tr = newState.tr;
       var modified = false;
       transactions.forEach(function (transaction) {

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

@@ -0,0 +1,143 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+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 { ReplaceAroundStep, ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
+import { expValEqualsNoExposure } from '@atlaskit/tmp-editor-statsig/exp-val-equals-no-exposure';
+function getAffectedTaskListsFromTransactions(transactions, doc, schema) {
+  var taskList = schema.nodes.taskList;
+  if (!taskList) {
+    return new Map();
+  }
+  var result = new Map();
+  var _iterator = _createForOfIteratorHelper(transactions),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var tr = _step.value;
+      var _iterator2 = _createForOfIteratorHelper(tr.steps),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var step = _step2.value;
+          // ReplaceStep and ReplaceAroundStep both have from/to — other step types are skipped.
+          if (!(step instanceof ReplaceStep) && !(step instanceof ReplaceAroundStep)) {
+            continue;
+          }
+          // Check both the start and end of each changed range, mapped to post-transaction positions.
+          for (var _i = 0, _arr = [step.from, step.to]; _i < _arr.length; _i++) {
+            var rawPos = _arr[_i];
+            var mappedPos = Math.min(tr.mapping.map(rawPos), doc.content.size - 1);
+            var $pos = doc.resolve(mappedPos);
+            // Walk ancestors from inner to outer, recording the outermost taskList node.
+            // Once we find a taskList and then exit list structure (hit a non-taskList ancestor),
+            // break early — prevents container nodes (e.g. panel) from causing us to
+            // return an outer taskList in a different structural context.
+            var rootTaskListPos = null;
+            var rootTaskListNode = null;
+            for (var depth = $pos.depth; depth >= 0; depth--) {
+              var node = $pos.node(depth);
+              if (node.type === taskList) {
+                rootTaskListPos = $pos.before(depth);
+                rootTaskListNode = node;
+              } else if (rootTaskListNode !== null && node.type !== schema.nodes.taskItem) {
+                // We've exited the taskList structure — stop walking.
+                break;
+              }
+            }
+            if (rootTaskListPos !== null && rootTaskListNode !== null) {
+              result.set(rootTaskListPos, rootTaskListNode);
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return result;
+}
+export function applyTaskListNormalisationFixes(_ref) {
+  var doc = _ref.doc,
+    schema = _ref.schema,
+    tr = _ref.tr,
+    transactions = _ref.transactions;
+  var _schema$nodes = schema.nodes,
+    taskList = _schema$nodes.taskList,
+    taskItem = _schema$nodes.taskItem;
+  if (!taskList || !taskItem) {
+    return tr;
+  }
+  var affectedTaskLists = getAffectedTaskListsFromTransactions(transactions, doc, schema);
+  if (affectedTaskLists.size === 0) {
+    return tr;
+  }
+
+  // Sort by position descending so we process deeper/later positions first,
+  // preventing earlier insertions from shifting later positions.
+  var sortedEntries = _toConsumableArray(affectedTaskLists.entries()).sort(function (_ref2, _ref3) {
+    var _ref4 = _slicedToArray(_ref2, 1),
+      a = _ref4[0];
+    var _ref5 = _slicedToArray(_ref3, 1),
+      b = _ref5[0];
+    return b - a;
+  });
+  var _iterator3 = _createForOfIteratorHelper(sortedEntries),
+    _step3;
+  try {
+    var _loop = function _loop() {
+      var _step3$value = _slicedToArray(_step3.value, 1),
+        taskListPos = _step3$value[0];
+      // Re-resolve the taskList node from the current transaction doc (post-operation state).
+      var mappedTaskListPos = tr.mapping.map(taskListPos);
+      var currentTaskListNode = tr.doc.nodeAt(mappedTaskListPos);
+      if (!currentTaskListNode) {
+        return 1; // continue
+      }
+      if (!expValEqualsNoExposure('platform_editor_flexible_list_indentation', 'isEnabled', true)) {
+        // Collect positions of all taskList nodes (at any depth) whose direct children
+        // include a taskList — this is the invalid structure. The taskList schema requires
+        // taskItem as children, not nested taskLists directly.
+        // Process in reverse order so higher-position insertions don't shift lower positions.
+        var invalidTaskListPositions = [];
+        currentTaskListNode.descendants(function (node, offsetPos) {
+          if (node.type === taskList) {
+            // A taskList as the FIRST child of another taskList is invalid — it means a
+            // delete or paste removed the leading taskItem, leaving a bare nested list.
+            // A taskList that follows a taskItem is valid (that's normal indentation).
+            var firstChild = node.firstChild;
+            if (firstChild && firstChild.type === taskList) {
+              var pos = mappedTaskListPos + 1 + offsetPos + 1;
+              invalidTaskListPositions.push(pos);
+            }
+          }
+          return true;
+        });
+
+        // Process in reverse (highest positions first).
+        for (var i = invalidTaskListPositions.length - 1; i >= 0; i--) {
+          var remappedPos = tr.mapping.map(invalidTaskListPositions[i]);
+          var emptyTaskItem = taskItem.createAndFill();
+          if (emptyTaskItem) {
+            tr.insert(remappedPos, emptyTaskItem);
+          }
+        }
+      }
+    };
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      if (_loop()) continue;
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  return tr;
+}

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

@@ -0,0 +1,10 @@
+import type { Node, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+interface ApplyTaskListNormalisationFixesOptions {
+    doc: Node;
+    schema: Schema;
+    tr: Transaction;
+    transactions: readonly Transaction[];
+}
+export declare function applyTaskListNormalisationFixes({ doc, schema, tr, transactions, }: ApplyTaskListNormalisationFixesOptions): Transaction;
+export {};

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

@@ -0,0 +1,10 @@
+import type { Node, Schema } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+interface ApplyTaskListNormalisationFixesOptions {
+    doc: Node;
+    schema: Schema;
+    tr: Transaction;
+    transactions: readonly Transaction[];
+}
+export declare function applyTaskListNormalisationFixes({ doc, schema, tr, transactions, }: ApplyTaskListNormalisationFixesOptions): Transaction;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-tasks-and-decisions",
-	"version": "13.0.1",
+	"version": "13.0.3",
 	"description": "Tasks and decisions plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -49,14 +49,14 @@
 		"@atlaskit/primitives": "^19.0.0",
 		"@atlaskit/prosemirror-input-rules": "^3.6.0",
 		"@atlaskit/task-decision": "^20.0.0",
-		"@atlaskit/tmp-editor-statsig": "^63.0.0",
+		"@atlaskit/tmp-editor-statsig": "^64.0.0",
 		"@atlaskit/tokens": "^13.0.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^0.20.0",
 		"bind-event-listener": "^3.0.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^114.2.0",
+		"@atlaskit/editor-common": "^114.5.0",
 		"react": "^18.2.0",
 		"react-dom": "^18.2.0",
 		"react-intl": "^5.25.1 || ^6.0.0 || ^7.0.0"