@atlaskit/editor-plugin-list 9.0.26 → 9.0.28

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

@@ -0,0 +1,298 @@
+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 { GapCursorSelection } from '@atlaskit/editor-common/selection';
+import { isListItemNode, isListNode } from '@atlaskit/editor-common/utils';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import { NodeSelection, Selection, TextSelection } from '@atlaskit/editor-prosemirror/state';
+
+/**
+ * A single content-bearing list element extracted from the PM tree.
+ * Wrapper `listItem` nodes (those with no non-list children) are discarded;
+ * only items the user can actually see and select are represented.
+ */
+
+/**
+ * Returns true if a listItem has at least one non-list child (paragraph, etc.).
+ */
+function hasContentChildren(listItem) {
+  return listItem.children.some(function (child) {
+    return !isListNode(child);
+  });
+}
+
+/**
+ * Compute the size of non-list (content) children of a listItem, which
+ * represents the "visible" bounds of the item for selection purposes.
+ */
+function contentSize(listItem) {
+  return listItem.children.reduce(function (size, child) {
+    return size + (isListNode(child) ? 0 : child.nodeSize);
+  }, 0);
+}
+/**
+ * Flatten a root list into a flat array of content-bearing `ListElement`
+ * objects and simultaneously determine which elements intersect the user's
+ * selection.
+ * Selection intersection is checked against each item's content-only
+ * span (excluding nested lists).
+ */
+export function flattenList(_ref) {
+  var doc = _ref.doc,
+    rootListStart = _ref.rootListStart,
+    rootListEnd = _ref.rootListEnd,
+    selectionFrom = _ref.selectionFrom,
+    selectionTo = _ref.selectionTo,
+    delta = _ref.delta;
+  var elements = [];
+  var startIndex = -1;
+  var endIndex = -1;
+  var maxDepth = 0;
+  var rootDepth = doc.resolve(rootListStart).depth;
+  doc.nodesBetween(rootListStart, rootListEnd, function (node, pos, parent) {
+    if (!isListItemNode(node) || !hasContentChildren(node) || !isListNode(parent)) {
+      return true;
+    }
+
+    // Check selection intersection using content-only bounds
+    var cStart = pos + 1;
+    var cEnd = cStart + contentSize(node);
+    var isSelected = cStart < selectionTo && cEnd > selectionFrom;
+    var depth = (doc.resolve(pos).depth - rootDepth - 1) / 2 + (isSelected ? delta : 0);
+    elements.push({
+      node: node,
+      pos: pos,
+      depth: depth,
+      listType: parent.type.name
+    });
+    if (isSelected) {
+      var index = elements.length - 1;
+      if (startIndex === -1) {
+        startIndex = index;
+      }
+      endIndex = index;
+      maxDepth = Math.max(maxDepth, depth);
+    }
+    return true;
+  });
+  if (elements.length === 0 || startIndex === -1) {
+    return null;
+  }
+  return {
+    elements: elements,
+    startIndex: startIndex,
+    endIndex: endIndex,
+    maxDepth: maxDepth
+  };
+}
+
+/**
+ * Extract non-list (content) children from a listItem node.
+ */
+function extractContentChildren(listItem) {
+  var children = [];
+  for (var i = 0; i < listItem.childCount; i++) {
+    var child = listItem.child(i);
+    if (!isListNode(child)) {
+      children.push(child);
+    }
+  }
+  return children;
+}
+
+/**
+ * Rebuild a ProseMirror list tree from a flat array of `ListElement` objects
+ * using a bottom-up stack approach.
+ *
+ * The algorithm tracks open list/listItem wrappers on a stack. As depth
+ * transitions occur between consecutive elements, wrapper nodes are opened
+ * (depth increase) or closed (depth decrease).
+ */
+function rebuildPMList(elements, schema) {
+  if (elements.length === 0) {
+    return null;
+  }
+
+  // Each stack frame represents an open list at a given depth.
+  // items[] accumulates the PMNode children (listItem nodes) for that list.
+
+  var stack = [];
+  function openList(listType) {
+    stack.push({
+      listType: listType,
+      items: []
+    });
+  }
+
+  /**
+   * Close lists on the stack down to `targetDepth`, wrapping each closed
+   * list into the last listItem of its parent.
+   */
+  function closeToDepth(targetDepth) {
+    var _loop = function _loop() {
+      var closed = stack.pop();
+      if (!closed) {
+        return 1; // break
+      }
+      var listNode = schema.nodes[closed.listType].create(null, closed.items);
+
+      // Attach the closed list to the last listItem on the parent frame
+      var parentFrame = stack[stack.length - 1];
+      var lastItem = parentFrame.items[parentFrame.items.length - 1];
+      if (lastItem) {
+        // Append the nested list to this listItem's children
+        var newContent = [];
+        lastItem.forEach(function (child) {
+          return newContent.push(child);
+        });
+        newContent.push(listNode);
+        parentFrame.items[parentFrame.items.length - 1] = schema.nodes.listItem.create(lastItem.attrs, newContent);
+      } else {
+        // Edge case: no listItem to attach to. Create a wrapper.
+        var wrapperItem = schema.nodes.listItem.create(null, [listNode]);
+        parentFrame.items.push(wrapperItem);
+      }
+    };
+    while (stack.length > targetDepth + 1) {
+      if (_loop()) break;
+    }
+  }
+
+  // Seed the root list
+  openList(elements[0].listType);
+  var _iterator = _createForOfIteratorHelper(elements),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var el = _step.value;
+      var targetDepth = el.depth;
+
+      // Close lists if we're going shallower
+      if (stack.length > targetDepth + 1) {
+        closeToDepth(targetDepth);
+      }
+
+      // Open lists if we need to go deeper.
+      // We do NOT create wrapper listItems here — closeToDepth handles
+      // creating wrappers that contain only the nested list (no empty paragraph).
+      while (stack.length < targetDepth + 1) {
+        openList(el.listType);
+      }
+
+      // Build the listItem for this element using its content children
+      var contentChildren = extractContentChildren(el.node);
+      var listItem = schema.nodes.listItem.create(el.node.attrs, contentChildren);
+      stack[stack.length - 1].items.push(listItem);
+    }
+
+    // Close all remaining open lists
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  closeToDepth(0);
+  var root = stack[0];
+  return schema.nodes[root.listType].create(null, root.items);
+}
+/**
+ * Build a replacement Fragment from a flat array of `ListElement` objects.
+ *
+ * Elements with depth >= 0 are grouped into consecutive list segments
+ * and rebuilt via `rebuildPMList`. Elements with depth < 0 (extracted
+ * past the root) are converted to their content children (paragraphs).
+ * The result interleaves list nodes and extracted content in document order.
+ */
+export function buildReplacementFragment(elements, schema) {
+  var fragment = Fragment.empty;
+  var pendingListSegment = [];
+  var pendingStartIdx = 0;
+  var contentStartOffsets = new Array(elements.length);
+  var flushListSegment = function flushListSegment() {
+    if (pendingListSegment.length > 0) {
+      var fragmentOffset = fragment.size;
+      var rebuilt = rebuildPMList(pendingListSegment, schema);
+      if (rebuilt) {
+        // Walk the rebuilt tree to find content-bearing listItem positions.
+        // descendants() visits in document order matching the element order.
+        var segIdx = 0;
+        rebuilt.descendants(function (node, pos) {
+          if (isListItemNode(node) && hasContentChildren(node)) {
+            // pos is relative to rebuilt's content start;
+            // +1 for rebuilt's opening tag, +1 for listItem's opening tag
+            contentStartOffsets[pendingStartIdx + segIdx] = fragmentOffset + 1 + pos + 1;
+            segIdx++;
+          }
+          return true;
+        });
+        fragment = fragment.addToEnd(rebuilt);
+      }
+      pendingListSegment = [];
+    }
+  };
+  var elIdx = 0;
+  var _iterator2 = _createForOfIteratorHelper(elements),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var el = _step2.value;
+      if (el.depth < 0) {
+        flushListSegment();
+        // Extracted element — content children become top-level nodes.
+        // Record offset of first content child.
+        contentStartOffsets[elIdx] = fragment.size;
+        var _iterator3 = _createForOfIteratorHelper(extractContentChildren(el.node)),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var node = _step3.value;
+            fragment = fragment.addToEnd(node);
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      } else {
+        if (pendingListSegment.length === 0) {
+          pendingStartIdx = elIdx;
+        }
+        pendingListSegment.push(el);
+      }
+      elIdx++;
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  flushListSegment();
+  return {
+    fragment: fragment,
+    contentStartOffsets: contentStartOffsets
+  };
+}
+/**
+ * Restore the transaction's selection after a list structural change.
+ *
+ * Uses the content start offsets computed during fragment rebuild to
+ * map each selection endpoint to its new absolute position.
+ */
+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/types/pm-plugins/actions/move-selected-list-items.d.ts

@@ -0,0 +1,5 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+/**
+ * Moves the selected list items n levels up (negative delta) or down (positive delta).
+ */
+export declare function moveSelectedListItems(tr: Transaction, delta: number): void;

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

@@ -0,0 +1,72 @@
+import type { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+/**
+ * A single content-bearing list element extracted from the PM tree.
+ * Wrapper `listItem` nodes (those with no non-list children) are discarded;
+ * only items the user can actually see and select are represented.
+ */
+export interface ListElement {
+    node: PMNode;
+    pos: number;
+    depth: number;
+    listType: 'bulletList' | 'orderedList';
+}
+export interface FlattenListResult {
+    elements: ListElement[];
+    startIndex: number;
+    endIndex: number;
+    maxDepth: number;
+}
+export interface FlattenListOptions {
+    doc: PMNode;
+    rootListStart: number;
+    rootListEnd: number;
+    selectionFrom: number;
+    selectionTo: number;
+    delta: number;
+}
+/**
+ * Flatten a root list into a flat array of content-bearing `ListElement`
+ * objects and simultaneously determine which elements intersect the user's
+ * selection.
+ * Selection intersection is checked against each item's content-only
+ * span (excluding nested lists).
+ */
+export declare function flattenList({ doc, rootListStart, rootListEnd, selectionFrom, selectionTo, delta, }: FlattenListOptions): FlattenListResult | null;
+export interface BuildResult {
+    fragment: Fragment;
+    /**
+     * For each element (by index), the offset within the fragment where the
+     * element's content begins. For list elements this is the position just
+     * inside the listItem (pos + 1); for extracted elements it is the position
+     * of the first extracted content child.
+     *
+     * To get the absolute document position after `tr.replaceWith(rangeStart, …)`,
+     * add `rangeStart` to the offset.
+     */
+    contentStartOffsets: number[];
+}
+/**
+ * Build a replacement Fragment from a flat array of `ListElement` objects.
+ *
+ * Elements with depth >= 0 are grouped into consecutive list segments
+ * and rebuilt via `rebuildPMList`. Elements with depth < 0 (extracted
+ * past the root) are converted to their content children (paragraphs).
+ * The result interleaves list nodes and extracted content in document order.
+ */
+export declare function buildReplacementFragment(elements: ListElement[], schema: Schema): BuildResult;
+export interface RestoreSelectionOptions {
+    tr: Transaction;
+    originalSelection: Selection;
+    from: number;
+    to: number;
+}
+/**
+ * Restore the transaction's selection after a list structural change.
+ *
+ * Uses the content start offsets computed during fragment rebuild to
+ * map each selection endpoint to its new absolute position.
+ */
+export declare function restoreSelection({ tr, originalSelection, from, to, }: RestoreSelectionOptions): void;

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

@@ -0,0 +1,5 @@
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+/**
+ * Moves the selected list items n levels up (negative delta) or down (positive delta).
+ */
+export declare function moveSelectedListItems(tr: Transaction, delta: number): void;

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

@@ -0,0 +1,72 @@
+import type { Node as PMNode, Schema } from '@atlaskit/editor-prosemirror/model';
+import { Fragment } from '@atlaskit/editor-prosemirror/model';
+import type { Transaction } from '@atlaskit/editor-prosemirror/state';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+/**
+ * A single content-bearing list element extracted from the PM tree.
+ * Wrapper `listItem` nodes (those with no non-list children) are discarded;
+ * only items the user can actually see and select are represented.
+ */
+export interface ListElement {
+    node: PMNode;
+    pos: number;
+    depth: number;
+    listType: 'bulletList' | 'orderedList';
+}
+export interface FlattenListResult {
+    elements: ListElement[];
+    startIndex: number;
+    endIndex: number;
+    maxDepth: number;
+}
+export interface FlattenListOptions {
+    doc: PMNode;
+    rootListStart: number;
+    rootListEnd: number;
+    selectionFrom: number;
+    selectionTo: number;
+    delta: number;
+}
+/**
+ * Flatten a root list into a flat array of content-bearing `ListElement`
+ * objects and simultaneously determine which elements intersect the user's
+ * selection.
+ * Selection intersection is checked against each item's content-only
+ * span (excluding nested lists).
+ */
+export declare function flattenList({ doc, rootListStart, rootListEnd, selectionFrom, selectionTo, delta, }: FlattenListOptions): FlattenListResult | null;
+export interface BuildResult {
+    fragment: Fragment;
+    /**
+     * For each element (by index), the offset within the fragment where the
+     * element's content begins. For list elements this is the position just
+     * inside the listItem (pos + 1); for extracted elements it is the position
+     * of the first extracted content child.
+     *
+     * To get the absolute document position after `tr.replaceWith(rangeStart, …)`,
+     * add `rangeStart` to the offset.
+     */
+    contentStartOffsets: number[];
+}
+/**
+ * Build a replacement Fragment from a flat array of `ListElement` objects.
+ *
+ * Elements with depth >= 0 are grouped into consecutive list segments
+ * and rebuilt via `rebuildPMList`. Elements with depth < 0 (extracted
+ * past the root) are converted to their content children (paragraphs).
+ * The result interleaves list nodes and extracted content in document order.
+ */
+export declare function buildReplacementFragment(elements: ListElement[], schema: Schema): BuildResult;
+export interface RestoreSelectionOptions {
+    tr: Transaction;
+    originalSelection: Selection;
+    from: number;
+    to: number;
+}
+/**
+ * Restore the transaction's selection after a list structural change.
+ *
+ * Uses the content start offsets computed during fragment rebuild to
+ * map each selection endpoint to its new absolute position.
+ */
+export declare function restoreSelection({ tr, originalSelection, from, to, }: RestoreSelectionOptions): void;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-list",
-	"version": "9.0.26",
+	"version": "9.0.28",
 	"description": "List plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -38,11 +38,11 @@
 		"@atlaskit/platform-feature-flags": "^1.1.0",
 		"@atlaskit/prosemirror-history": "^0.2.0",
 		"@atlaskit/prosemirror-input-rules": "^3.6.0",
-		"@atlaskit/tmp-editor-statsig": "^34.0.0",
+		"@atlaskit/tmp-editor-statsig": "^35.7.0",
 		"@babel/runtime": "^7.0.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^111.28.0",
+		"@atlaskit/editor-common": "^111.34.0",
 		"react": "^18.2.0",
 		"react-intl-next": "npm:react-intl@^5.18.1"
 	},