@atlaskit/editor-common 112.7.5 → 112.8.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @atlaskit/editor-common
 
+## 112.8.0
+
+### Minor Changes
+
+- [`65cb641586cc0`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/65cb641586cc0) -
+  Extract shared list indentation utilities: restoreSelection, computeSelectionOffsets,
+  buildReplacementFragment, flattenList, and FlattenedItem
+
+### Patch Changes
+
+- Updated dependencies
+
 ## 112.7.5
 
 ### Patch Changes

package/dist/cjs/lists/build-replacement-fragment.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildReplacementFragment = buildReplacementFragment;
+var _model = require("@atlaskit/editor-prosemirror/model");
+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; }
+/** Rebuilds a list-like PM node from a flat array of items. */
+
+/** Extracts top-level content nodes from an item being broken out past the root list. */
+
+/**
+ * Build a replacement Fragment from a flat array of items.
+ *
+ * Items with depth >= 0 are grouped and rebuilt via `rebuildFn`.
+ * Items with depth < 0 are extracted via `extractContentFn`.
+ */
+function buildReplacementFragment(_ref) {
+  var items = _ref.items,
+    schema = _ref.schema,
+    rebuildFn = _ref.rebuildFn,
+    extractContentFn = _ref.extractContentFn;
+  var fragment = _model.Fragment.empty;
+  var pendingListSegment = [];
+  var pendingStartIdx = 0;
+  var contentStartOffsets = new Array(items.length);
+  var flushListSegment = function flushListSegment() {
+    if (pendingListSegment.length > 0) {
+      var fragmentOffset = fragment.size;
+      var result = rebuildFn(pendingListSegment, schema);
+      if (result) {
+        // Map the rebuild's content start offsets into the overall fragment.
+        for (var i = 0; i < pendingListSegment.length; i++) {
+          contentStartOffsets[pendingStartIdx + i] = fragmentOffset + result.contentStartOffsets[i];
+        }
+        fragment = fragment.addToEnd(result.node);
+      }
+      pendingListSegment = [];
+    }
+  };
+  var elIdx = 0;
+  var _iterator = _createForOfIteratorHelper(items),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _item = _step.value;
+      if (_item.depth < 0) {
+        flushListSegment();
+        // Extracted element — content children become top-level nodes.
+        // Record offset of first content child.
+        contentStartOffsets[elIdx] = fragment.size;
+        var _iterator2 = _createForOfIteratorHelper(extractContentFn(_item, schema)),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var node = _step2.value;
+            fragment = fragment.addToEnd(node);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      } else {
+        if (pendingListSegment.length === 0) {
+          pendingStartIdx = elIdx;
+        }
+        pendingListSegment.push(_item);
+      }
+      elIdx++;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  flushListSegment();
+  return {
+    fragment: fragment,
+    contentStartOffsets: contentStartOffsets
+  };
+}

package/dist/cjs/lists/flatten-list.js

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.flattenList = flattenList;
+/**
+ * Type-specific predicates that vary between regular lists and task lists.
+ */
+
+/**
+ * Flattens a list-like PM structure (regular list or task list) into an
+ * array of content-bearing items with computed depths.
+ *
+ * Uses `doc.nodesBetween` to walk the tree and delegates type-specific
+ * decisions to the provided predicates. The core algorithm — selection
+ * intersection, depth adjustment, index tracking — is shared.
+ */
+function flattenList(options, predicates) {
+  var doc = options.doc,
+    rootListStart = options.rootListStart,
+    rootListEnd = options.rootListEnd,
+    selectionFrom = options.selectionFrom,
+    selectionTo = options.selectionTo,
+    indentDelta = options.indentDelta,
+    maxDepth = options.maxDepth;
+  var isContentNode = predicates.isContentNode,
+    getSelectionBounds = predicates.getSelectionBounds,
+    getDepth = predicates.getDepth;
+  var items = [];
+  var startIndex = -1;
+  var endIndex = -1;
+  var exceedsMaxDepth = false;
+  var rootDepth = doc.resolve(rootListStart).depth;
+  doc.nodesBetween(rootListStart, rootListEnd, function (node, pos, parent) {
+    if (!isContentNode(node, parent) || parent == null) {
+      return true;
+    }
+    var _getSelectionBounds = getSelectionBounds(node, pos),
+      start = _getSelectionBounds.start,
+      end = _getSelectionBounds.end;
+    var isSelected = selectionFrom === selectionTo ? selectionFrom >= start && selectionFrom <= end : start < selectionTo && end > selectionFrom;
+    var resolvedDepth = doc.resolve(pos).depth;
+    var depth = getDepth(resolvedDepth, rootDepth) + (isSelected ? indentDelta : 0);
+    items.push({
+      node: node,
+      pos: pos,
+      depth: depth,
+      isSelected: isSelected,
+      listType: parent.type.name,
+      parentListAttrs: parent.attrs
+    });
+    if (isSelected) {
+      var index = items.length - 1;
+      if (startIndex === -1) {
+        startIndex = index;
+      }
+      endIndex = index;
+      if (maxDepth != null && depth >= maxDepth) {
+        exceedsMaxDepth = true;
+      }
+    }
+    return true;
+  });
+  if (items.length === 0 || startIndex === -1 || exceedsMaxDepth) {
+    return null;
+  }
+  return {
+    items: items,
+    startIndex: startIndex,
+    endIndex: endIndex
+  };
+}

package/dist/cjs/lists/index.js

@@ -9,12 +9,30 @@ Object.defineProperty(exports, "JoinDirection", {
     return _node.JoinDirection;
   }
 });
+Object.defineProperty(exports, "buildReplacementFragment", {
+  enumerable: true,
+  get: function get() {
+    return _buildReplacementFragment.buildReplacementFragment;
+  }
+});
+Object.defineProperty(exports, "computeSelectionOffsets", {
+  enumerable: true,
+  get: function get() {
+    return _restoreSelection.computeSelectionOffsets;
+  }
+});
 Object.defineProperty(exports, "countListItemsInSelection", {
   enumerable: true,
   get: function get() {
     return _analytics.countListItemsInSelection;
   }
 });
+Object.defineProperty(exports, "flattenList", {
+  enumerable: true,
+  get: function get() {
+    return _flattenList.flattenList;
+  }
+});
 Object.defineProperty(exports, "getCommonListAnalyticsAttributes", {
   enumerable: true,
   get: function get() {
@@ -93,10 +111,19 @@ Object.defineProperty(exports, "processNestedTaskListsInSameLevel", {
     return _node.processNestedTaskListsInSameLevel;
   }
 });
+Object.defineProperty(exports, "restoreSelection", {
+  enumerable: true,
+  get: function get() {
+    return _restoreSelection.restoreSelection;
+  }
+});
 var _selection = require("./selection");
 var _replaceContent = require("./replace-content");
 var _node = require("./node");
 var _analytics = require("./analytics");
 var _indentation = require("./indentation");
+var _restoreSelection = require("./restore-selection");
+var _buildReplacementFragment = require("./build-replacement-fragment");
+var _flattenList = require("./flatten-list");
 var _utils = require("../utils");
 var _messages = require("./messages");

package/dist/cjs/lists/restore-selection.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeSelectionOffsets = computeSelectionOffsets;
+exports.restoreSelection = restoreSelection;
+var _state = require("@atlaskit/editor-prosemirror/state");
+var _selection = require("../selection");
+/**
+ * Compute the new selection offsets after list items have been moved/indented/outdented.
+ *
+ * Uses the content start offsets computed during fragment rebuild to map each
+ * selection endpoint to its new absolute position, accounting for the change
+ * in the list structure.
+ */
+function computeSelectionOffsets(_ref) {
+  var items = _ref.items,
+    startIndex = _ref.startIndex,
+    endIndex = _ref.endIndex,
+    originalFrom = _ref.originalFrom,
+    originalTo = _ref.originalTo,
+    contentStartOffsets = _ref.contentStartOffsets,
+    rootListStart = _ref.rootListStart,
+    docSize = _ref.docSize;
+  // +1 shifts from the outer edge of the list item node to the start of the content within
+  var fromContentStart = items[startIndex].pos + 1;
+  var toContentStart = items[endIndex].pos + 1;
+  var fromOffset = originalFrom - fromContentStart;
+  var toOffset = originalTo - toContentStart;
+  var clamp = function clamp(pos) {
+    return Math.min(Math.max(0, pos), docSize);
+  };
+  return {
+    from: clamp(rootListStart + contentStartOffsets[startIndex] + fromOffset),
+    to: clamp(rootListStart + contentStartOffsets[endIndex] + toOffset)
+  };
+}
+
+/**
+ * Restore the transaction's selection after a list structural change
+ * (indent/outdent of list items or task list items).
+ *
+ * Uses the content start offsets computed during fragment rebuild to
+ * map each selection endpoint to its new absolute position.
+ *
+ * Handles NodeSelection, GapCursorSelection, and TextSelection.
+ */
+function restoreSelection(_ref2) {
+  var tr = _ref2.tr,
+    originalSelection = _ref2.originalSelection,
+    from = _ref2.from,
+    to = _ref2.to;
+  var maxPos = tr.doc.content.size;
+  if (originalSelection instanceof _state.NodeSelection) {
+    try {
+      tr.setSelection(_state.NodeSelection.create(tr.doc, Math.min(from, maxPos - 1)));
+    } catch (_unused) {
+      tr.setSelection(_state.Selection.near(tr.doc.resolve(from)));
+    }
+  } else if (originalSelection instanceof _selection.GapCursorSelection) {
+    tr.setSelection(new _selection.GapCursorSelection(tr.doc.resolve(from), originalSelection.side));
+  } else {
+    tr.setSelection(_state.TextSelection.create(tr.doc, from, to));
+  }
+}

package/dist/cjs/monitoring/error.js

@@ -19,7 +19,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
 var SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 var packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-var packageVersion = "112.7.4";
+var packageVersion = "0.0.0-development";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/cjs/ui/DropList/index.js

@@ -24,7 +24,7 @@ function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.
  * @jsx jsx
  */ // eslint-disable-next-line @atlaskit/ui-styling-standard/use-compiled -- Ignored via go/DSP-18766
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "112.7.4";
+var packageVersion = "0.0.0-development";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 var fadeIn = (0, _react2.keyframes)({

package/dist/es2019/lists/build-replacement-fragment.js

@@ -0,0 +1,60 @@
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+
+/** Rebuilds a list-like PM node from a flat array of items. */
+
+/** Extracts top-level content nodes from an item being broken out past the root list. */
+
+/**
+ * Build a replacement Fragment from a flat array of items.
+ *
+ * Items with depth >= 0 are grouped and rebuilt via `rebuildFn`.
+ * Items with depth < 0 are extracted via `extractContentFn`.
+ */
+export function buildReplacementFragment({
+  items,
+  schema,
+  rebuildFn,
+  extractContentFn
+}) {
+  let fragment = Fragment.empty;
+  let pendingListSegment = [];
+  let pendingStartIdx = 0;
+  const contentStartOffsets = new Array(items.length);
+  const flushListSegment = () => {
+    if (pendingListSegment.length > 0) {
+      const fragmentOffset = fragment.size;
+      const result = rebuildFn(pendingListSegment, schema);
+      if (result) {
+        // Map the rebuild's content start offsets into the overall fragment.
+        for (let i = 0; i < pendingListSegment.length; i++) {
+          contentStartOffsets[pendingStartIdx + i] = fragmentOffset + result.contentStartOffsets[i];
+        }
+        fragment = fragment.addToEnd(result.node);
+      }
+      pendingListSegment = [];
+    }
+  };
+  let elIdx = 0;
+  for (const item of items) {
+    if (item.depth < 0) {
+      flushListSegment();
+      // Extracted element — content children become top-level nodes.
+      // Record offset of first content child.
+      contentStartOffsets[elIdx] = fragment.size;
+      for (const node of extractContentFn(item, schema)) {
+        fragment = fragment.addToEnd(node);
+      }
+    } else {
+      if (pendingListSegment.length === 0) {
+        pendingStartIdx = elIdx;
+      }
+      pendingListSegment.push(item);
+    }
+    elIdx++;
+  }
+  flushListSegment();
+  return {
+    fragment,
+    contentStartOffsets
+  };
+}

package/dist/es2019/lists/flatten-list.js

@@ -0,0 +1,72 @@
+/**
+ * Type-specific predicates that vary between regular lists and task lists.
+ */
+
+/**
+ * Flattens a list-like PM structure (regular list or task list) into an
+ * array of content-bearing items with computed depths.
+ *
+ * Uses `doc.nodesBetween` to walk the tree and delegates type-specific
+ * decisions to the provided predicates. The core algorithm — selection
+ * intersection, depth adjustment, index tracking — is shared.
+ */
+export function flattenList(options, predicates) {
+  const {
+    doc,
+    rootListStart,
+    rootListEnd,
+    selectionFrom,
+    selectionTo,
+    indentDelta,
+    maxDepth
+  } = options;
+  const {
+    isContentNode,
+    getSelectionBounds,
+    getDepth
+  } = predicates;
+  const items = [];
+  let startIndex = -1;
+  let endIndex = -1;
+  let exceedsMaxDepth = false;
+  const rootDepth = doc.resolve(rootListStart).depth;
+  doc.nodesBetween(rootListStart, rootListEnd, (node, pos, parent) => {
+    if (!isContentNode(node, parent) || parent == null) {
+      return true;
+    }
+    const {
+      start,
+      end
+    } = getSelectionBounds(node, pos);
+    const isSelected = selectionFrom === selectionTo ? selectionFrom >= start && selectionFrom <= end : start < selectionTo && end > selectionFrom;
+    const resolvedDepth = doc.resolve(pos).depth;
+    const depth = getDepth(resolvedDepth, rootDepth) + (isSelected ? indentDelta : 0);
+    items.push({
+      node,
+      pos,
+      depth,
+      isSelected,
+      listType: parent.type.name,
+      parentListAttrs: parent.attrs
+    });
+    if (isSelected) {
+      const index = items.length - 1;
+      if (startIndex === -1) {
+        startIndex = index;
+      }
+      endIndex = index;
+      if (maxDepth != null && depth >= maxDepth) {
+        exceedsMaxDepth = true;
+      }
+    }
+    return true;
+  });
+  if (items.length === 0 || startIndex === -1 || exceedsMaxDepth) {
+    return null;
+  }
+  return {
+    items,
+    startIndex,
+    endIndex
+  };
+}

package/dist/es2019/lists/index.js

@@ -6,5 +6,8 @@ export { moveTargetIntoList } from './replace-content';
 export { JoinDirection, isListNodeValidContent, joinSiblingLists, processNestedTaskListsInSameLevel } from './node';
 export { getCommonListAnalyticsAttributes, countListItemsInSelection } from './analytics';
 export { hasValidListIndentationLevel } from './indentation';
+export { restoreSelection, computeSelectionOffsets } from './restore-selection';
+export { buildReplacementFragment } from './build-replacement-fragment';
+export { flattenList } from './flatten-list';
 export { isListNode, isListItemNode, isBulletList, isParagraphNode } from '../utils';
 export { messages } from './messages';

package/dist/es2019/lists/restore-selection.js

@@ -0,0 +1,59 @@
+import { NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { GapCursorSelection } from '../selection';
+/**
+ * Compute the new selection offsets after list items have been moved/indented/outdented.
+ *
+ * Uses the content start offsets computed during fragment rebuild to map each
+ * selection endpoint to its new absolute position, accounting for the change
+ * in the list structure.
+ */
+export function computeSelectionOffsets({
+  items,
+  startIndex,
+  endIndex,
+  originalFrom,
+  originalTo,
+  contentStartOffsets,
+  rootListStart,
+  docSize
+}) {
+  // +1 shifts from the outer edge of the list item node to the start of the content within
+  const fromContentStart = items[startIndex].pos + 1;
+  const toContentStart = items[endIndex].pos + 1;
+  const fromOffset = originalFrom - fromContentStart;
+  const toOffset = originalTo - toContentStart;
+  const clamp = pos => Math.min(Math.max(0, pos), docSize);
+  return {
+    from: clamp(rootListStart + contentStartOffsets[startIndex] + fromOffset),
+    to: clamp(rootListStart + contentStartOffsets[endIndex] + toOffset)
+  };
+}
+
+/**
+ * Restore the transaction's selection after a list structural change
+ * (indent/outdent of list items or task list items).
+ *
+ * Uses the content start offsets computed during fragment rebuild to
+ * map each selection endpoint to its new absolute position.
+ *
+ * Handles NodeSelection, GapCursorSelection, and TextSelection.
+ */
+export function restoreSelection({
+  tr,
+  originalSelection,
+  from,
+  to
+}) {
+  const maxPos = tr.doc.content.size;
+  if (originalSelection instanceof NodeSelection) {
+    try {
+      tr.setSelection(NodeSelection.create(tr.doc, Math.min(from, maxPos - 1)));
+    } catch {
+      tr.setSelection(Selection.near(tr.doc.resolve(from)));
+    }
+  } else if (originalSelection instanceof GapCursorSelection) {
+    tr.setSelection(new GapCursorSelection(tr.doc.resolve(from), originalSelection.side));
+  } else {
+    tr.setSelection(TextSelection.create(tr.doc, from, to));
+  }
+}

package/dist/es2019/monitoring/error.js

@@ -4,7 +4,7 @@ import { isFedRamp } from './environment';
 import { normaliseSentryBreadcrumbs, SERIALIZABLE_ATTRIBUTES } from './normalise-sentry-breadcrumbs';
 const SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 const packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-const packageVersion = "112.7.4";
+const packageVersion = "0.0.0-development";
 const sanitiseSentryEvents = (data, _hint) => {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/es2019/ui/DropList/index.js

@@ -14,7 +14,7 @@ import withAnalyticsEvents from '@atlaskit/analytics-next/withAnalyticsEvents';
 import { fg } from '@atlaskit/platform-feature-flags';
 import Layer from '../Layer';
 const packageName = "@atlaskit/editor-common";
-const packageVersion = "112.7.4";
+const packageVersion = "0.0.0-development";
 const halfFocusRing = 1;
 const dropOffset = '0, 8';
 const fadeIn = keyframes({

package/dist/esm/lists/build-replacement-fragment.js

@@ -0,0 +1,80 @@
+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 { Fragment } from '@atlaskit/editor-prosemirror/model';
+
+/** Rebuilds a list-like PM node from a flat array of items. */
+
+/** Extracts top-level content nodes from an item being broken out past the root list. */
+
+/**
+ * Build a replacement Fragment from a flat array of items.
+ *
+ * Items with depth >= 0 are grouped and rebuilt via `rebuildFn`.
+ * Items with depth < 0 are extracted via `extractContentFn`.
+ */
+export function buildReplacementFragment(_ref) {
+  var items = _ref.items,
+    schema = _ref.schema,
+    rebuildFn = _ref.rebuildFn,
+    extractContentFn = _ref.extractContentFn;
+  var fragment = Fragment.empty;
+  var pendingListSegment = [];
+  var pendingStartIdx = 0;
+  var contentStartOffsets = new Array(items.length);
+  var flushListSegment = function flushListSegment() {
+    if (pendingListSegment.length > 0) {
+      var fragmentOffset = fragment.size;
+      var result = rebuildFn(pendingListSegment, schema);
+      if (result) {
+        // Map the rebuild's content start offsets into the overall fragment.
+        for (var i = 0; i < pendingListSegment.length; i++) {
+          contentStartOffsets[pendingStartIdx + i] = fragmentOffset + result.contentStartOffsets[i];
+        }
+        fragment = fragment.addToEnd(result.node);
+      }
+      pendingListSegment = [];
+    }
+  };
+  var elIdx = 0;
+  var _iterator = _createForOfIteratorHelper(items),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _item = _step.value;
+      if (_item.depth < 0) {
+        flushListSegment();
+        // Extracted element — content children become top-level nodes.
+        // Record offset of first content child.
+        contentStartOffsets[elIdx] = fragment.size;
+        var _iterator2 = _createForOfIteratorHelper(extractContentFn(_item, schema)),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var node = _step2.value;
+            fragment = fragment.addToEnd(node);
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+      } else {
+        if (pendingListSegment.length === 0) {
+          pendingStartIdx = elIdx;
+        }
+        pendingListSegment.push(_item);
+      }
+      elIdx++;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  flushListSegment();
+  return {
+    fragment: fragment,
+    contentStartOffsets: contentStartOffsets
+  };
+}

package/dist/esm/lists/flatten-list.js

@@ -0,0 +1,67 @@
+/**
+ * Type-specific predicates that vary between regular lists and task lists.
+ */
+
+/**
+ * Flattens a list-like PM structure (regular list or task list) into an
+ * array of content-bearing items with computed depths.
+ *
+ * Uses `doc.nodesBetween` to walk the tree and delegates type-specific
+ * decisions to the provided predicates. The core algorithm — selection
+ * intersection, depth adjustment, index tracking — is shared.
+ */
+export function flattenList(options, predicates) {
+  var doc = options.doc,
+    rootListStart = options.rootListStart,
+    rootListEnd = options.rootListEnd,
+    selectionFrom = options.selectionFrom,
+    selectionTo = options.selectionTo,
+    indentDelta = options.indentDelta,
+    maxDepth = options.maxDepth;
+  var isContentNode = predicates.isContentNode,
+    getSelectionBounds = predicates.getSelectionBounds,
+    getDepth = predicates.getDepth;
+  var items = [];
+  var startIndex = -1;
+  var endIndex = -1;
+  var exceedsMaxDepth = false;
+  var rootDepth = doc.resolve(rootListStart).depth;
+  doc.nodesBetween(rootListStart, rootListEnd, function (node, pos, parent) {
+    if (!isContentNode(node, parent) || parent == null) {
+      return true;
+    }
+    var _getSelectionBounds = getSelectionBounds(node, pos),
+      start = _getSelectionBounds.start,
+      end = _getSelectionBounds.end;
+    var isSelected = selectionFrom === selectionTo ? selectionFrom >= start && selectionFrom <= end : start < selectionTo && end > selectionFrom;
+    var resolvedDepth = doc.resolve(pos).depth;
+    var depth = getDepth(resolvedDepth, rootDepth) + (isSelected ? indentDelta : 0);
+    items.push({
+      node: node,
+      pos: pos,
+      depth: depth,
+      isSelected: isSelected,
+      listType: parent.type.name,
+      parentListAttrs: parent.attrs
+    });
+    if (isSelected) {
+      var index = items.length - 1;
+      if (startIndex === -1) {
+        startIndex = index;
+      }
+      endIndex = index;
+      if (maxDepth != null && depth >= maxDepth) {
+        exceedsMaxDepth = true;
+      }
+    }
+    return true;
+  });
+  if (items.length === 0 || startIndex === -1 || exceedsMaxDepth) {
+    return null;
+  }
+  return {
+    items: items,
+    startIndex: startIndex,
+    endIndex: endIndex
+  };
+}

package/dist/esm/lists/index.js

@@ -6,5 +6,8 @@ export { moveTargetIntoList } from './replace-content';
 export { JoinDirection, isListNodeValidContent, joinSiblingLists, processNestedTaskListsInSameLevel } from './node';
 export { getCommonListAnalyticsAttributes, countListItemsInSelection } from './analytics';
 export { hasValidListIndentationLevel } from './indentation';
+export { restoreSelection, computeSelectionOffsets } from './restore-selection';
+export { buildReplacementFragment } from './build-replacement-fragment';
+export { flattenList } from './flatten-list';
 export { isListNode, isListItemNode, isBulletList, isParagraphNode } from '../utils';
 export { messages } from './messages';

package/dist/esm/lists/restore-selection.js

@@ -0,0 +1,59 @@
+import { NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+import { GapCursorSelection } from '../selection';
+/**
+ * Compute the new selection offsets after list items have been moved/indented/outdented.
+ *
+ * Uses the content start offsets computed during fragment rebuild to map each
+ * selection endpoint to its new absolute position, accounting for the change
+ * in the list structure.
+ */
+export function computeSelectionOffsets(_ref) {
+  var items = _ref.items,
+    startIndex = _ref.startIndex,
+    endIndex = _ref.endIndex,
+    originalFrom = _ref.originalFrom,
+    originalTo = _ref.originalTo,
+    contentStartOffsets = _ref.contentStartOffsets,
+    rootListStart = _ref.rootListStart,
+    docSize = _ref.docSize;
+  // +1 shifts from the outer edge of the list item node to the start of the content within
+  var fromContentStart = items[startIndex].pos + 1;
+  var toContentStart = items[endIndex].pos + 1;
+  var fromOffset = originalFrom - fromContentStart;
+  var toOffset = originalTo - toContentStart;
+  var clamp = function clamp(pos) {
+    return Math.min(Math.max(0, pos), docSize);
+  };
+  return {
+    from: clamp(rootListStart + contentStartOffsets[startIndex] + fromOffset),
+    to: clamp(rootListStart + contentStartOffsets[endIndex] + toOffset)
+  };
+}
+
+/**
+ * Restore the transaction's selection after a list structural change
+ * (indent/outdent of list items or task list items).
+ *
+ * Uses the content start offsets computed during fragment rebuild to
+ * map each selection endpoint to its new absolute position.
+ *
+ * Handles NodeSelection, GapCursorSelection, and TextSelection.
+ */
+export function restoreSelection(_ref2) {
+  var tr = _ref2.tr,
+    originalSelection = _ref2.originalSelection,
+    from = _ref2.from,
+    to = _ref2.to;
+  var maxPos = tr.doc.content.size;
+  if (originalSelection instanceof NodeSelection) {
+    try {
+      tr.setSelection(NodeSelection.create(tr.doc, Math.min(from, maxPos - 1)));
+    } catch (_unused) {
+      tr.setSelection(Selection.near(tr.doc.resolve(from)));
+    }
+  } else if (originalSelection instanceof GapCursorSelection) {
+    tr.setSelection(new GapCursorSelection(tr.doc.resolve(from), originalSelection.side));
+  } else {
+    tr.setSelection(TextSelection.create(tr.doc, from, to));
+  }
+}

package/dist/esm/monitoring/error.js

@@ -10,7 +10,7 @@ import { isFedRamp } from './environment';
 import { normaliseSentryBreadcrumbs, SERIALIZABLE_ATTRIBUTES } from './normalise-sentry-breadcrumbs';
 var SENTRY_DSN = 'https://0b10c8e02fb44d8796c047b102c9bee8@o55978.ingest.sentry.io/4505129224110080';
 var packageName = 'editor-common'; // Sentry doesn't accept '/' in its releases https://docs.sentry.io/platforms/javascript/configuration/releases/
-var packageVersion = "112.7.4";
+var packageVersion = "0.0.0-development";
 var sanitiseSentryEvents = function sanitiseSentryEvents(data, _hint) {
   // Remove URL as it has UGC
   // Ignored via go/ees007

package/dist/esm/ui/DropList/index.js

@@ -21,7 +21,7 @@ import withAnalyticsEvents from '@atlaskit/analytics-next/withAnalyticsEvents';
 import { fg } from '@atlaskit/platform-feature-flags';
 import Layer from '../Layer';
 var packageName = "@atlaskit/editor-common";
-var packageVersion = "112.7.4";
+var packageVersion = "0.0.0-development";
 var halfFocusRing = 1;
 var dropOffset = '0, 8';
 var fadeIn = keyframes({

package/dist/types/lists/build-replacement-fragment.d.ts

@@ -0,0 +1,35 @@
+import type { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import type { FlattenedItem } from './flatten-list';
+export interface BuildResult {
+    /**
+     * For each element (by index), the offset within the fragment where the
+     * element's content begins.
+     *
+     * To get the absolute document position after `tr.replaceWith(rangeStart, …)`,
+     * add `rangeStart` to the offset.
+     */
+    contentStartOffsets: number[];
+    fragment: Fragment;
+}
+/** Rebuilds a list-like PM node from a flat array of items. */
+type RebuildFn = (items: FlattenedItem[], schema: Schema) => {
+    contentStartOffsets: number[];
+    node: PMNode;
+} | null;
+/** Extracts top-level content nodes from an item being broken out past the root list. */
+type ExtractContentFn = (item: FlattenedItem, schema: Schema) => PMNode[];
+interface BuildReplacementFragmentOptions {
+    extractContentFn: ExtractContentFn;
+    items: FlattenedItem[];
+    rebuildFn: RebuildFn;
+    schema: Schema;
+}
+/**
+ * Build a replacement Fragment from a flat array of items.
+ *
+ * Items with depth >= 0 are grouped and rebuilt via `rebuildFn`.
+ * Items with depth < 0 are extracted via `extractContentFn`.
+ */
+export declare function buildReplacementFragment({ items, schema, rebuildFn, extractContentFn, }: BuildReplacementFragmentOptions): BuildResult;
+export {};

package/dist/types/lists/flatten-list.d.ts

@@ -0,0 +1,47 @@
+import type { Attrs, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+export interface FlattenedItem {
+    depth: number;
+    isSelected: boolean;
+    listType: string;
+    node: PMNode;
+    parentListAttrs: Attrs | null;
+    pos: number;
+}
+export interface FlattenListOptions {
+    doc: PMNode;
+    indentDelta: number;
+    maxDepth?: number;
+    rootListStart: number;
+    rootListEnd: number;
+    selectionFrom: number;
+    selectionTo: number;
+}
+/**
+ * Type-specific predicates that vary between regular lists and task lists.
+ */
+interface FlattenListPredicates {
+    /** Returns true if `node` is a content-bearing item to include in the flattened output. */
+    isContentNode: (node: PMNode, parent: PMNode | null) => boolean;
+    /** Returns the selection bounds for an item, used to check selection intersection. */
+    getSelectionBounds: (node: PMNode, pos: number) => {
+        start: number;
+        end: number;
+    };
+    /** Computes the nesting depth for a node given its resolved depth and the root's depth. */
+    getDepth: (resolvedDepth: number, rootDepth: number) => number;
+}
+export interface FlattenListResult {
+    items: FlattenedItem[];
+    startIndex: number;
+    endIndex: number;
+}
+/**
+ * Flattens a list-like PM structure (regular list or task list) into an
+ * array of content-bearing items with computed depths.
+ *
+ * Uses `doc.nodesBetween` to walk the tree and delegates type-specific
+ * decisions to the provided predicates. The core algorithm — selection
+ * intersection, depth adjustment, index tracking — is shared.
+ */
+export declare function flattenList(options: FlattenListOptions, predicates: FlattenListPredicates): FlattenListResult | null;
+export {};

package/dist/types/lists/index.d.ts

@@ -3,5 +3,11 @@ export { moveTargetIntoList } from './replace-content';
 export { JoinDirection, isListNodeValidContent, joinSiblingLists, processNestedTaskListsInSameLevel, } from './node';
 export { getCommonListAnalyticsAttributes, countListItemsInSelection } from './analytics';
 export { hasValidListIndentationLevel } from './indentation';
+export { restoreSelection, computeSelectionOffsets } from './restore-selection';
+export { buildReplacementFragment } from './build-replacement-fragment';
+export type { BuildResult } from './build-replacement-fragment';
+export type { FlattenedItem } from './flatten-list';
+export { flattenList } from './flatten-list';
+export type { FlattenListOptions, FlattenListResult } from './flatten-list';
 export { isListNode, isListItemNode, isBulletList, isParagraphNode } from '../utils';
 export { messages } from './messages';

package/dist/types/lists/restore-selection.d.ts

@@ -0,0 +1,41 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+import type { FlattenedItem } from './flatten-list';
+interface ComputeSelectionOffsetsOptions {
+    contentStartOffsets: number[];
+    docSize: number;
+    endIndex: number;
+    items: FlattenedItem[];
+    originalFrom: number;
+    originalTo: number;
+    rootListStart: number;
+    startIndex: number;
+}
+interface RestoreSelectionOptions {
+    from: number;
+    originalSelection: Selection;
+    to: number;
+    tr: Transaction;
+}
+/**
+ * Compute the new selection offsets after list items have been moved/indented/outdented.
+ *
+ * Uses the content start offsets computed during fragment rebuild to map each
+ * selection endpoint to its new absolute position, accounting for the change
+ * in the list structure.
+ */
+export declare function computeSelectionOffsets({ items, startIndex, endIndex, originalFrom, originalTo, contentStartOffsets, rootListStart, docSize, }: ComputeSelectionOffsetsOptions): {
+    from: number;
+    to: number;
+};
+/**
+ * Restore the transaction's selection after a list structural change
+ * (indent/outdent of list items or task list items).
+ *
+ * Uses the content start offsets computed during fragment rebuild to
+ * map each selection endpoint to its new absolute position.
+ *
+ * Handles NodeSelection, GapCursorSelection, and TextSelection.
+ */
+export declare function restoreSelection({ tr, originalSelection, from, to, }: RestoreSelectionOptions): void;
+export {};

package/dist/types-ts4.5/lists/build-replacement-fragment.d.ts

@@ -0,0 +1,35 @@
+import type { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import type { FlattenedItem } from './flatten-list';
+export interface BuildResult {
+    /**
+     * For each element (by index), the offset within the fragment where the
+     * element's content begins.
+     *
+     * To get the absolute document position after `tr.replaceWith(rangeStart, …)`,
+     * add `rangeStart` to the offset.
+     */
+    contentStartOffsets: number[];
+    fragment: Fragment;
+}
+/** Rebuilds a list-like PM node from a flat array of items. */
+type RebuildFn = (items: FlattenedItem[], schema: Schema) => {
+    contentStartOffsets: number[];
+    node: PMNode;
+} | null;
+/** Extracts top-level content nodes from an item being broken out past the root list. */
+type ExtractContentFn = (item: FlattenedItem, schema: Schema) => PMNode[];
+interface BuildReplacementFragmentOptions {
+    extractContentFn: ExtractContentFn;
+    items: FlattenedItem[];
+    rebuildFn: RebuildFn;
+    schema: Schema;
+}
+/**
+ * Build a replacement Fragment from a flat array of items.
+ *
+ * Items with depth >= 0 are grouped and rebuilt via `rebuildFn`.
+ * Items with depth < 0 are extracted via `extractContentFn`.
+ */
+export declare function buildReplacementFragment({ items, schema, rebuildFn, extractContentFn, }: BuildReplacementFragmentOptions): BuildResult;
+export {};

package/dist/types-ts4.5/lists/flatten-list.d.ts

@@ -0,0 +1,47 @@
+import type { Attrs, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+export interface FlattenedItem {
+    depth: number;
+    isSelected: boolean;
+    listType: string;
+    node: PMNode;
+    parentListAttrs: Attrs | null;
+    pos: number;
+}
+export interface FlattenListOptions {
+    doc: PMNode;
+    indentDelta: number;
+    maxDepth?: number;
+    rootListStart: number;
+    rootListEnd: number;
+    selectionFrom: number;
+    selectionTo: number;
+}
+/**
+ * Type-specific predicates that vary between regular lists and task lists.
+ */
+interface FlattenListPredicates {
+    /** Returns true if `node` is a content-bearing item to include in the flattened output. */
+    isContentNode: (node: PMNode, parent: PMNode | null) => boolean;
+    /** Returns the selection bounds for an item, used to check selection intersection. */
+    getSelectionBounds: (node: PMNode, pos: number) => {
+        start: number;
+        end: number;
+    };
+    /** Computes the nesting depth for a node given its resolved depth and the root's depth. */
+    getDepth: (resolvedDepth: number, rootDepth: number) => number;
+}
+export interface FlattenListResult {
+    items: FlattenedItem[];
+    startIndex: number;
+    endIndex: number;
+}
+/**
+ * Flattens a list-like PM structure (regular list or task list) into an
+ * array of content-bearing items with computed depths.
+ *
+ * Uses `doc.nodesBetween` to walk the tree and delegates type-specific
+ * decisions to the provided predicates. The core algorithm — selection
+ * intersection, depth adjustment, index tracking — is shared.
+ */
+export declare function flattenList(options: FlattenListOptions, predicates: FlattenListPredicates): FlattenListResult | null;
+export {};

package/dist/types-ts4.5/lists/index.d.ts

@@ -3,5 +3,11 @@ export { moveTargetIntoList } from './replace-content';
 export { JoinDirection, isListNodeValidContent, joinSiblingLists, processNestedTaskListsInSameLevel, } from './node';
 export { getCommonListAnalyticsAttributes, countListItemsInSelection } from './analytics';
 export { hasValidListIndentationLevel } from './indentation';
+export { restoreSelection, computeSelectionOffsets } from './restore-selection';
+export { buildReplacementFragment } from './build-replacement-fragment';
+export type { BuildResult } from './build-replacement-fragment';
+export type { FlattenedItem } from './flatten-list';
+export { flattenList } from './flatten-list';
+export type { FlattenListOptions, FlattenListResult } from './flatten-list';
 export { isListNode, isListItemNode, isBulletList, isParagraphNode } from '../utils';
 export { messages } from './messages';

package/dist/types-ts4.5/lists/restore-selection.d.ts

@@ -0,0 +1,41 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+import type { FlattenedItem } from './flatten-list';
+interface ComputeSelectionOffsetsOptions {
+    contentStartOffsets: number[];
+    docSize: number;
+    endIndex: number;
+    items: FlattenedItem[];
+    originalFrom: number;
+    originalTo: number;
+    rootListStart: number;
+    startIndex: number;
+}
+interface RestoreSelectionOptions {
+    from: number;
+    originalSelection: Selection;
+    to: number;
+    tr: Transaction;
+}
+/**
+ * Compute the new selection offsets after list items have been moved/indented/outdented.
+ *
+ * Uses the content start offsets computed during fragment rebuild to map each
+ * selection endpoint to its new absolute position, accounting for the change
+ * in the list structure.
+ */
+export declare function computeSelectionOffsets({ items, startIndex, endIndex, originalFrom, originalTo, contentStartOffsets, rootListStart, docSize, }: ComputeSelectionOffsetsOptions): {
+    from: number;
+    to: number;
+};
+/**
+ * Restore the transaction's selection after a list structural change
+ * (indent/outdent of list items or task list items).
+ *
+ * Uses the content start offsets computed during fragment rebuild to
+ * map each selection endpoint to its new absolute position.
+ *
+ * Handles NodeSelection, GapCursorSelection, and TextSelection.
+ */
+export declare function restoreSelection({ tr, originalSelection, from, to, }: RestoreSelectionOptions): void;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-common",
-	"version": "112.7.5",
+	"version": "112.8.0",
 	"description": "A package that contains common classes and components for editor and renderer",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.org/"
@@ -81,7 +81,7 @@
 		"@atlaskit/status": "^3.1.0",
 		"@atlaskit/task-decision": "^19.3.0",
 		"@atlaskit/textfield": "^8.2.0",
-		"@atlaskit/tmp-editor-statsig": "^44.0.0",
+		"@atlaskit/tmp-editor-statsig": "^44.1.0",
 		"@atlaskit/tokens": "^11.1.0",
 		"@atlaskit/tooltip": "^21.0.0",
 		"@atlaskit/width-detector": "^5.0.0",